Page MenuHomeFreeBSD
Files F156660482

D52308.id162980.diff
No OneTemporary
Actions

D52308.id162980.diff
View Options

This file is larger than 256 KB, so syntax highlighting was skipped.
diff --git a/etc/mtree/BSD.lib32.dist b/etc/mtree/BSD.lib32.dist
--- a/etc/mtree/BSD.lib32.dist
+++ b/etc/mtree/BSD.lib32.dist
@@ -21,5 +21,7 @@
..
pkgconfig
..
+ virtual_oss
+ ..
..
..
diff --git a/etc/mtree/BSD.usr.dist b/etc/mtree/BSD.usr.dist
--- a/etc/mtree/BSD.usr.dist
+++ b/etc/mtree/BSD.usr.dist
@@ -103,6 +103,8 @@
..
ossl-modules
..
+ virtual_oss
+ ..
..
libdata
ldscripts
diff --git a/lib/Makefile b/lib/Makefile
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -115,7 +115,8 @@
libz \
libzstd \
ncurses \
- nss_tacplus
+ nss_tacplus \
+ virtual_oss
# Inter-library dependencies. When the makefile for a library contains LDADD
# libraries, those libraries should be listed as build order dependencies here.
@@ -157,6 +158,7 @@
SUBDIR_DEPEND_libpcap= ofed
.endif
SUBDIR_DEPEND_nss_tacplus= libtacplus
+SUBDIR_DEPEND_virtual_oss= libsamplerate
# NB: keep these sorted by MK_* knobs
diff --git a/lib/virtual_oss/Makefile b/lib/virtual_oss/Makefile
new file mode 100644
--- /dev/null
+++ b/lib/virtual_oss/Makefile
@@ -0,0 +1,9 @@
+.include <src.opts.mk>
+
+SHLIBDIR?= ${LIBDIR}/virtual_oss
+
+SUBDIR+= null \
+ oss
+
+.include "Makefile.inc"
+.include <bsd.subdir.mk>
diff --git a/lib/virtual_oss/Makefile.inc b/lib/virtual_oss/Makefile.inc
new file mode 100644
--- /dev/null
+++ b/lib/virtual_oss/Makefile.inc
@@ -0,0 +1,3 @@
+.include "../Makefile.inc"
+
+LDFLAGS+= -L${.OBJDIR:H:H}/libsamplerate
diff --git a/lib/virtual_oss/bt/Makefile b/lib/virtual_oss/bt/Makefile
new file mode 100644
--- /dev/null
+++ b/lib/virtual_oss/bt/Makefile
@@ -0,0 +1,19 @@
+SHLIB_NAME= voss_bt.so
+SHLIBDIR= ${LIBDIR}/virtual_oss
+
+SRCS= bt.c \
+ avdtp.c \
+ sbc_encode.c
+
+CFLAGS+= -I${SRCTOP}/usr.sbin/virtual_oss/virtual_oss \
+ -I${SRCTOP}/contrib/libsamplerate
+LDFLAGS+= -lbluetooth -lsdp
+LIBADD= samplerate
+
+.if defined(HAVE_LIBAV)
+CFLAGS+= -I${LOCALBASE:U/usr/local}/include -DHAVE_LIBAV
+LDFLAGS+= -L${LOCALBASE:U/usr/local}/lib \
+ -lavdevice -lavutil -lavcodec -lavformat
+.endif
+
+.include <bsd.lib.mk>
diff --git a/lib/virtual_oss/bt/avdtp.c b/lib/virtual_oss/bt/avdtp.c
new file mode 100644
--- /dev/null
+++ b/lib/virtual_oss/bt/avdtp.c
@@ -0,0 +1,720 @@
+/* $NetBSD$ */
+
+/*-
+ * Copyright (c) 2015-2016 Nathanial Sloss <nathanialsloss@yahoo.com.au>
+ * Copyright (c) 2016-2019 Hans Petter Selasky <hps@selasky.org>
+ * Copyright (c) 2019 Google LLC, written by Richard Kralovic <riso@google.com>
+ *
+ * This software is dedicated to the memory of -
+ * Baron James Anlezark (Barry) - 1 Jan 1949 - 13 May 2012.
+ *
+ * Barry was a man who loved his music.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/uio.h>
+
+#include <stdio.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "avdtp_signal.h"
+#include "bt.h"
+
+#define DPRINTF(...) printf("backend_bt: " __VA_ARGS__)
+
+struct avdtpGetPacketInfo {
+ uint8_t buffer_data[512];
+ uint16_t buffer_len;
+ uint8_t trans;
+ uint8_t signalID;
+};
+
+static int avdtpAutoConfig(struct bt_config *);
+
+/* Return received message type if success, < 0 if failure. */
+static int
+avdtpGetPacket(int fd, struct avdtpGetPacketInfo *info)
+{
+ uint8_t *pos = info->buffer_data;
+ uint8_t *end = info->buffer_data + sizeof(info->buffer_data);
+ uint8_t message_type;
+ int len;
+
+ memset(info, 0, sizeof(*info));
+
+ /* Handle fragmented packets */
+ for (int remaining = 1; remaining > 0; --remaining) {
+ len = read(fd, pos, end - pos);
+
+ if (len < AVDTP_LEN_SUCCESS)
+ return (-1);
+ if (len == (int)(end - pos))
+ return (-1); /* buffer too small */
+
+ uint8_t trans = (pos[0] & TRANSACTIONLABEL) >> TRANSACTIONLABEL_S;
+ uint8_t packet_type = (pos[0] & PACKETTYPE) >> PACKETTYPE_S;
+ uint8_t current_message_type = (info->buffer_data[0] & MESSAGETYPE);
+ uint8_t shift;
+ if (pos == info->buffer_data) {
+ info->trans = trans;
+ message_type = current_message_type;
+ if (packet_type == singlePacket) {
+ info->signalID = (pos[1] & SIGNALID_MASK);
+ shift = 2;
+ } else {
+ if (packet_type != startPacket)
+ return (-1);
+ remaining = pos[1];
+ info->signalID = (pos[2] & SIGNALID_MASK);
+ shift = 3;
+ }
+ } else {
+ if (info->trans != trans ||
+ message_type != current_message_type ||
+ (remaining == 1 && packet_type != endPacket) ||
+ (remaining > 1 && packet_type != continuePacket)) {
+ return (-1);
+ }
+ shift = 1;
+ }
+ memmove(pos, pos + shift, len);
+ pos += len;
+ }
+ info->buffer_len = pos - info->buffer_data;
+ return (message_type);
+}
+
+/* Returns 0 on success, < 0 on failure. */
+static int
+avdtpSendPacket(int fd, uint8_t command, uint8_t trans, uint8_t type,
+ uint8_t * data0, int datasize0, uint8_t * data1,
+ int datasize1)
+{
+ struct iovec iov[3];
+ uint8_t header[2];
+ int retval;
+
+ /* fill out command header */
+ header[0] = (trans << 4) | (type & 3);
+ if (command != 0)
+ header[1] = command & 0x3f;
+ else
+ header[1] = 3;
+
+ iov[0].iov_base = header;
+ iov[0].iov_len = 2;
+ iov[1].iov_base = data0;
+ iov[1].iov_len = datasize0;
+ iov[2].iov_base = data1;
+ iov[2].iov_len = datasize1;
+
+ retval = writev(fd, iov, 3);
+ if (retval != (2 + datasize0 + datasize1))
+ return (-EINVAL);
+ else
+ return (0);
+}
+
+/* Returns 0 on success, < 0 on failure. */
+static int
+avdtpSendSyncCommand(int fd, struct avdtpGetPacketInfo *info,
+ uint8_t command, uint8_t type, uint8_t * data0,
+ int datasize0, uint8_t * data1, int datasize1)
+{
+ static uint8_t transLabel;
+ uint8_t trans;
+ int retval;
+
+ alarm(8); /* set timeout */
+
+ trans = (transLabel++) & 0xF;
+
+ retval = avdtpSendPacket(fd, command, trans, type,
+ data0, datasize0, data1, datasize1);
+ if (retval)
+ goto done;
+retry:
+ switch (avdtpGetPacket(fd, info)) {
+ case RESPONSEACCEPT:
+ if (info->trans != trans)
+ goto retry;
+ retval = 0;
+ break;
+ case RESPONSEREJECT:
+ if (info->trans != trans)
+ goto retry;
+ retval = -EINVAL;
+ break;
+ case COMMAND:
+ retval = avdtpSendReject(fd, info->trans, info->signalID);
+ if (retval == 0)
+ goto retry;
+ break;
+ default:
+ retval = -ENXIO;
+ break;
+ }
+done:
+ alarm(0); /* clear timeout */
+
+ return (retval);
+}
+
+/*
+ * Variant for acceptor role: We support any frequency, blocks, bands, and
+ * allocation. Returns 0 on success, < 0 on failure.
+ */
+static int
+avdtpSendCapabilitiesResponseSBCForACP(int fd, int trans)
+{
+ uint8_t data[10];
+
+ data[0] = mediaTransport;
+ data[1] = 0;
+ data[2] = mediaCodec;
+ data[3] = 0x6;
+ data[4] = mediaTypeAudio;
+ data[5] = SBC_CODEC_ID;
+ data[6] =
+ (1 << (3 - MODE_STEREO)) |
+ (1 << (3 - MODE_JOINT)) |
+ (1 << (3 - MODE_DUAL)) |
+ (1 << (3 - MODE_MONO)) |
+ (1 << (7 - FREQ_44_1K)) |
+ (1 << (7 - FREQ_48K)) |
+ (1 << (7 - FREQ_32K)) |
+ (1 << (7 - FREQ_16K));
+ data[7] =
+ (1 << (7 - BLOCKS_4)) |
+ (1 << (7 - BLOCKS_8)) |
+ (1 << (7 - BLOCKS_12)) |
+ (1 << (7 - BLOCKS_16)) |
+ (1 << (3 - BANDS_4)) |
+ (1 << (3 - BANDS_8)) | (1 << ALLOC_LOUDNESS) | (1 << ALLOC_SNR);
+ data[8] = MIN_BITPOOL;
+ data[9] = DEFAULT_MAXBPOOL;
+
+ return (avdtpSendPacket(fd, AVDTP_GET_CAPABILITIES, trans,
+ RESPONSEACCEPT, data, sizeof(data), NULL, 0));
+}
+
+/* Returns 0 on success, < 0 on failure. */
+int
+avdtpSendAccept(int fd, uint8_t trans, uint8_t myCommand)
+{
+ return (avdtpSendPacket(fd, myCommand, trans, RESPONSEACCEPT,
+ NULL, 0, NULL, 0));
+}
+
+/* Returns 0 on success, < 0 on failure. */
+int
+avdtpSendReject(int fd, uint8_t trans, uint8_t myCommand)
+{
+ uint8_t value = 0;
+
+ return (avdtpSendPacket(fd, myCommand, trans, RESPONSEREJECT,
+ &value, 1, NULL, 0));
+}
+
+/* Returns 0 on success, < 0 on failure. */
+int
+avdtpSendDiscResponseAudio(int fd, uint8_t trans,
+ uint8_t mySep, uint8_t is_sink)
+{
+ uint8_t data[2];
+
+ data[0] = mySep << 2;
+ data[1] = mediaTypeAudio << 4 | (is_sink ? (1 << 3) : 0);
+
+ return (avdtpSendPacket(fd, AVDTP_DISCOVER, trans, RESPONSEACCEPT,
+ data, 2, NULL, 0));
+}
+
+/* Returns 0 on success, < 0 on failure. */
+int
+avdtpDiscoverAndConfig(struct bt_config *cfg, bool isSink)
+{
+ struct avdtpGetPacketInfo info;
+ uint16_t offset;
+ uint8_t chmode = cfg->chmode;
+ uint8_t aacMode1 = cfg->aacMode1;
+ uint8_t aacMode2 = cfg->aacMode2;
+ int retval;
+
+ retval = avdtpSendSyncCommand(cfg->hc, &info, AVDTP_DISCOVER, 0,
+ NULL, 0, NULL, 0);
+ if (retval)
+ return (retval);
+
+ retval = -EBUSY;
+ for (offset = 0; offset + 2 <= info.buffer_len; offset += 2) {
+ cfg->sep = info.buffer_data[offset] >> 2;
+ cfg->media_Type = info.buffer_data[offset + 1] >> 4;
+ cfg->chmode = chmode;
+ cfg->aacMode1 = aacMode1;
+ cfg->aacMode2 = aacMode2;
+ if (info.buffer_data[offset] & DISCOVER_SEP_IN_USE)
+ continue;
+ if (info.buffer_data[offset + 1] & DISCOVER_IS_SINK) {
+ if (!isSink)
+ continue;
+ } else {
+ if (isSink)
+ continue;
+ }
+ /* try to configure SBC */
+ retval = avdtpAutoConfig(cfg);
+ if (retval == 0)
+ return (0);
+ }
+ return (retval);
+}
+
+/* Returns 0 on success, < 0 on failure. */
+static int
+avdtpGetCapabilities(int fd, uint8_t sep, struct avdtpGetPacketInfo *info)
+{
+ uint8_t address = (sep << 2);
+
+ return (avdtpSendSyncCommand(fd, info,
+ AVDTP_GET_CAPABILITIES, 0, &address, 1,
+ NULL, 0));
+}
+
+/* Returns 0 on success, < 0 on failure. */
+int
+avdtpSetConfiguration(int fd, uint8_t sep, uint8_t * data, int datasize)
+{
+ struct avdtpGetPacketInfo info;
+ uint8_t configAddresses[2];
+
+ configAddresses[0] = sep << 2;
+ configAddresses[1] = INTSEP << 2;
+
+ return (avdtpSendSyncCommand(fd, &info, AVDTP_SET_CONFIGURATION, 0,
+ configAddresses, 2, data, datasize));
+}
+
+/* Returns 0 on success, < 0 on failure. */
+int
+avdtpOpen(int fd, uint8_t sep)
+{
+ struct avdtpGetPacketInfo info;
+ uint8_t address = sep << 2;
+
+ return (avdtpSendSyncCommand(fd, &info, AVDTP_OPEN, 0,
+ &address, 1, NULL, 0));
+}
+
+/* Returns 0 on success, < 0 on failure. */
+int
+avdtpStart(int fd, uint8_t sep)
+{
+ struct avdtpGetPacketInfo info;
+ uint8_t address = sep << 2;
+
+ return (avdtpSendSyncCommand(fd, &info, AVDTP_START, 0,
+ &address, 1, NULL, 0));
+}
+
+/* Returns 0 on success, < 0 on failure. */
+int
+avdtpClose(int fd, uint8_t sep)
+{
+ struct avdtpGetPacketInfo info;
+ uint8_t address = sep << 2;
+
+ return (avdtpSendSyncCommand(fd, &info, AVDTP_CLOSE, 0,
+ &address, 1, NULL, 0));
+}
+
+/* Returns 0 on success, < 0 on failure. */
+int
+avdtpSuspend(int fd, uint8_t sep)
+{
+ struct avdtpGetPacketInfo info;
+ uint8_t address = sep << 2;
+
+ return (avdtpSendSyncCommand(fd, &info, AVDTP_SUSPEND, 0,
+ &address, 1, NULL, 0));
+}
+
+/* Returns 0 on success, < 0 on failure. */
+int
+avdtpAbort(int fd, uint8_t sep)
+{
+ struct avdtpGetPacketInfo info;
+ uint8_t address = sep << 2;
+
+ return (avdtpSendSyncCommand(fd, &info, AVDTP_ABORT, 0,
+ &address, 1, NULL, 0));
+}
+
+static int
+avdtpAutoConfig(struct bt_config *cfg)
+{
+ struct avdtpGetPacketInfo info;
+ uint8_t freqmode;
+ uint8_t blk_len_sb_alloc;
+ uint8_t availFreqMode = 0;
+ uint8_t availConfig = 0;
+ uint8_t supBitpoolMin = 0;
+ uint8_t supBitpoolMax = 0;
+ uint8_t aacMode1 = 0;
+ uint8_t aacMode2 = 0;
+#ifdef HAVE_LIBAV
+ uint8_t aacBitrate3 = 0;
+ uint8_t aacBitrate4 = 0;
+ uint8_t aacBitrate5 = 0;
+#endif
+ int retval;
+ int i;
+
+ retval = avdtpGetCapabilities(cfg->hc, cfg->sep, &info);
+ if (retval) {
+ DPRINTF("Cannot get capabilities\n");
+ return (retval);
+ }
+retry:
+ for (i = 0; (i + 1) < info.buffer_len;) {
+#if 0
+ DPRINTF("0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
+ info.buffer_data[i + 0],
+ info.buffer_data[i + 1],
+ info.buffer_data[i + 2],
+ info.buffer_data[i + 3],
+ info.buffer_data[i + 4], info.buffer_data[i + 5]);
+#endif
+ if (i + 2 + info.buffer_data[i + 1] > info.buffer_len)
+ break;
+ switch (info.buffer_data[i]) {
+ case mediaTransport:
+ break;
+ case mediaCodec:
+ if (info.buffer_data[i + 1] < 2)
+ break;
+ /* check codec */
+ switch (info.buffer_data[i + 3]) {
+ case 0: /* SBC */
+ if (info.buffer_data[i + 1] < 6)
+ break;
+ availFreqMode = info.buffer_data[i + 4];
+ availConfig = info.buffer_data[i + 5];
+ supBitpoolMin = info.buffer_data[i + 6];
+ supBitpoolMax = info.buffer_data[i + 7];
+ break;
+ case 2: /* MPEG2/4 AAC */
+ if (info.buffer_data[i + 1] < 8)
+ break;
+ aacMode1 = info.buffer_data[i + 5];
+ aacMode2 = info.buffer_data[i + 6];
+#ifdef HAVE_LIBAV
+ aacBitrate3 = info.buffer_data[i + 7];
+ aacBitrate4 = info.buffer_data[i + 8];
+ aacBitrate5 = info.buffer_data[i + 9];
+#endif
+ break;
+ default:
+ break;
+ }
+ }
+ /* jump to next information element */
+ i += 2 + info.buffer_data[i + 1];
+ }
+ aacMode1 &= cfg->aacMode1;
+ aacMode2 &= cfg->aacMode2;
+
+ /* Try AAC first */
+ if (aacMode1 == cfg->aacMode1 && aacMode2 == cfg->aacMode2) {
+#ifdef HAVE_LIBAV
+ uint8_t config[12] = { mediaTransport, 0x0, mediaCodec,
+ 0x8, 0x0, 0x02, 0x80, aacMode1, aacMode2, aacBitrate3,
+ aacBitrate4, aacBitrate5
+ };
+
+ if (avdtpSetConfiguration
+ (cfg->hc, cfg->sep, config, sizeof(config)) == 0) {
+ cfg->codec = CODEC_AAC;
+ return (0);
+ }
+#endif
+ }
+ /* Try SBC second */
+ if (cfg->freq == FREQ_UNDEFINED)
+ goto auto_config_failed;
+
+ freqmode = (1 << (3 - cfg->freq + 4)) | (1 << (3 - cfg->chmode));
+
+ if ((availFreqMode & freqmode) != freqmode) {
+ DPRINTF("No frequency and mode match\n");
+ goto auto_config_failed;
+ }
+ for (i = 0; i != 4; i++) {
+ blk_len_sb_alloc = (1 << (i + 4)) |
+ (1 << (1 - cfg->bands + 2)) | (1 << cfg->allocm);
+
+ if ((availConfig & blk_len_sb_alloc) == blk_len_sb_alloc)
+ break;
+ }
+ if (i == 4) {
+ DPRINTF("No bands available\n");
+ goto auto_config_failed;
+ }
+ cfg->blocks = (3 - i);
+
+ if (cfg->allocm == ALLOC_SNR)
+ supBitpoolMax &= ~1;
+
+ if (cfg->chmode == MODE_DUAL || cfg->chmode == MODE_MONO)
+ supBitpoolMax /= 2;
+
+ if (cfg->bands == BANDS_4)
+ supBitpoolMax /= 2;
+
+ if (supBitpoolMax > cfg->bitpool)
+ supBitpoolMax = cfg->bitpool;
+ else
+ cfg->bitpool = supBitpoolMax;
+
+ do {
+ uint8_t config[10] = { mediaTransport, 0x0, mediaCodec, 0x6,
+ 0x0, 0x0, freqmode, blk_len_sb_alloc, supBitpoolMin,
+ supBitpoolMax
+ };
+
+ if (avdtpSetConfiguration
+ (cfg->hc, cfg->sep, config, sizeof(config)) == 0) {
+ cfg->codec = CODEC_SBC;
+ return (0);
+ }
+ } while (0);
+
+auto_config_failed:
+ if (cfg->chmode == MODE_STEREO) {
+ cfg->chmode = MODE_MONO;
+ cfg->aacMode2 ^= 0x0C;
+ goto retry;
+ }
+ return (-EINVAL);
+}
+
+void
+avdtpACPFree(struct bt_config *cfg)
+{
+ if (cfg->handle.sbc_enc) {
+ free(cfg->handle.sbc_enc);
+ cfg->handle.sbc_enc = NULL;
+ }
+}
+
+/* Returns 0 on success, < 0 on failure. */
+static int
+avdtpParseSBCConfig(uint8_t * data, struct bt_config *cfg)
+{
+ if (data[0] & (1 << (7 - FREQ_48K))) {
+ cfg->freq = FREQ_48K;
+ } else if (data[0] & (1 << (7 - FREQ_44_1K))) {
+ cfg->freq = FREQ_44_1K;
+ } else if (data[0] & (1 << (7 - FREQ_32K))) {
+ cfg->freq = FREQ_32K;
+ } else if (data[0] & (1 << (7 - FREQ_16K))) {
+ cfg->freq = FREQ_16K;
+ } else {
+ return -EINVAL;
+ }
+
+ if (data[0] & (1 << (3 - MODE_STEREO))) {
+ cfg->chmode = MODE_STEREO;
+ } else if (data[0] & (1 << (3 - MODE_JOINT))) {
+ cfg->chmode = MODE_JOINT;
+ } else if (data[0] & (1 << (3 - MODE_DUAL))) {
+ cfg->chmode = MODE_DUAL;
+ } else if (data[0] & (1 << (3 - MODE_MONO))) {
+ cfg->chmode = MODE_MONO;
+ } else {
+ return -EINVAL;
+ }
+
+ if (data[1] & (1 << (7 - BLOCKS_16))) {
+ cfg->blocks = BLOCKS_16;
+ } else if (data[1] & (1 << (7 - BLOCKS_12))) {
+ cfg->blocks = BLOCKS_12;
+ } else if (data[1] & (1 << (7 - BLOCKS_8))) {
+ cfg->blocks = BLOCKS_8;
+ } else if (data[1] & (1 << (7 - BLOCKS_4))) {
+ cfg->blocks = BLOCKS_4;
+ } else {
+ return -EINVAL;
+ }
+
+ if (data[1] & (1 << (3 - BANDS_8))) {
+ cfg->bands = BANDS_8;
+ } else if (data[1] & (1 << (3 - BANDS_4))) {
+ cfg->bands = BANDS_4;
+ } else {
+ return -EINVAL;
+ }
+
+ if (data[1] & (1 << ALLOC_LOUDNESS)) {
+ cfg->allocm = ALLOC_LOUDNESS;
+ } else if (data[1] & (1 << ALLOC_SNR)) {
+ cfg->allocm = ALLOC_SNR;
+ } else {
+ return -EINVAL;
+ }
+ cfg->bitpool = data[3];
+ return 0;
+}
+
+int
+avdtpACPHandlePacket(struct bt_config *cfg)
+{
+ struct avdtpGetPacketInfo info;
+ int retval;
+
+ if (avdtpGetPacket(cfg->hc, &info) != COMMAND)
+ return (-ENXIO);
+
+ switch (info.signalID) {
+ case AVDTP_DISCOVER:
+ retval =
+ avdtpSendDiscResponseAudio(cfg->hc, info.trans, ACPSEP, 1);
+ if (!retval)
+ retval = AVDTP_DISCOVER;
+ break;
+ case AVDTP_GET_CAPABILITIES:
+ retval =
+ avdtpSendCapabilitiesResponseSBCForACP(cfg->hc, info.trans);
+ if (!retval)
+ retval = AVDTP_GET_CAPABILITIES;
+ break;
+ case AVDTP_SET_CONFIGURATION:
+ if (cfg->acceptor_state != acpInitial)
+ goto err;
+ cfg->sep = info.buffer_data[1] >> 2;
+ int is_configured = 0;
+ for (int i = 2; (i + 1) < info.buffer_len;) {
+ if (i + 2 + info.buffer_data[i + 1] > info.buffer_len)
+ break;
+ switch (info.buffer_data[i]) {
+ case mediaTransport:
+ break;
+ case mediaCodec:
+ if (info.buffer_data[i + 1] < 2)
+ break;
+ /* check codec */
+ switch (info.buffer_data[i + 3]) {
+ case 0: /* SBC */
+ if (info.buffer_data[i + 1] < 6)
+ break;
+ retval =
+ avdtpParseSBCConfig(info.buffer_data + i + 4, cfg);
+ if (retval)
+ return retval;
+ is_configured = 1;
+ break;
+ case 2: /* MPEG2/4 AAC */
+ /* TODO: Add support */
+ default:
+ break;
+ }
+ }
+ /* jump to next information element */
+ i += 2 + info.buffer_data[i + 1];
+ }
+ if (!is_configured)
+ goto err;
+
+ retval =
+ avdtpSendAccept(cfg->hc, info.trans, AVDTP_SET_CONFIGURATION);
+ if (retval)
+ return (retval);
+
+ /* TODO: Handle other codecs */
+ if (cfg->handle.sbc_enc == NULL) {
+ cfg->handle.sbc_enc = malloc(sizeof(*cfg->handle.sbc_enc));
+ if (cfg->handle.sbc_enc == NULL)
+ return (-ENOMEM);
+ }
+ memset(cfg->handle.sbc_enc, 0, sizeof(*cfg->handle.sbc_enc));
+
+ retval = AVDTP_SET_CONFIGURATION;
+ cfg->acceptor_state = acpConfigurationSet;
+ break;
+ case AVDTP_OPEN:
+ if (cfg->acceptor_state != acpConfigurationSet)
+ goto err;
+ retval = avdtpSendAccept(cfg->hc, info.trans, info.signalID);
+ if (retval)
+ return (retval);
+ retval = info.signalID;
+ cfg->acceptor_state = acpStreamOpened;
+ break;
+ case AVDTP_START:
+ if (cfg->acceptor_state != acpStreamOpened &&
+ cfg->acceptor_state != acpStreamSuspended) {
+ goto err;
+ }
+ retval = avdtpSendAccept(cfg->hc, info.trans, info.signalID);
+ if (retval)
+ return retval;
+ retval = info.signalID;
+ cfg->acceptor_state = acpStreamStarted;
+ break;
+ case AVDTP_CLOSE:
+ if (cfg->acceptor_state != acpStreamOpened &&
+ cfg->acceptor_state != acpStreamStarted &&
+ cfg->acceptor_state != acpStreamSuspended) {
+ goto err;
+ }
+ retval = avdtpSendAccept(cfg->hc, info.trans, info.signalID);
+ if (retval)
+ return (retval);
+ retval = info.signalID;
+ cfg->acceptor_state = acpStreamClosed;
+ break;
+ case AVDTP_SUSPEND:
+ if (cfg->acceptor_state != acpStreamOpened &&
+ cfg->acceptor_state != acpStreamStarted) {
+ goto err;
+ }
+ retval = avdtpSendAccept(cfg->hc, info.trans, info.signalID);
+ if (retval)
+ return (retval);
+ retval = info.signalID;
+ cfg->acceptor_state = acpStreamSuspended;
+ break;
+ case AVDTP_GET_CONFIGURATION:
+ case AVDTP_RECONFIGURE:
+ case AVDTP_ABORT:
+ /* TODO: Implement this. */
+ default:
+err:
+ avdtpSendReject(cfg->hc, info.trans, info.signalID);
+ return (-ENXIO);
+ }
+ return (retval);
+}
diff --git a/lib/virtual_oss/bt/avdtp_signal.h b/lib/virtual_oss/bt/avdtp_signal.h
new file mode 100644
--- /dev/null
+++ b/lib/virtual_oss/bt/avdtp_signal.h
@@ -0,0 +1,139 @@
+/* $NetBSD$ */
+
+/*-
+ * Copyright (c) 2015 Nathanial Sloss <nathanialsloss@yahoo.com.au>
+ *
+ * This software is dedicated to the memory of -
+ * Baron James Anlezark (Barry) - 1 Jan 1949 - 13 May 2012.
+ *
+ * Barry was a man who loved his music.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _AVDTP_SIGNAL_H_
+#define _AVDTP_SIGNAL_H_
+
+#include <stdint.h>
+#include <stdbool.h>
+
+/* Our endpoint. */
+#define INTSEP 8
+#define ACPSEP 8
+
+/* AVDTP signals. */
+
+#define AVDTP_DISCOVER 0x01
+#define AVDTP_GET_CAPABILITIES 0x02
+#define AVDTP_SET_CONFIGURATION 0x03
+#define AVDTP_GET_CONFIGURATION 0x04
+#define AVDTP_RECONFIGURE 0x05
+#define AVDTP_OPEN 0x06
+#define AVDTP_START 0x07
+#define AVDTP_CLOSE 0x08
+#define AVDTP_SUSPEND 0x09
+#define AVDTP_ABORT 0x0a
+#define AVDTP_SECUURITY_CONTROL 0x0b
+
+/* Signal Command & Response Header Masks. */
+
+#define TRANSACTIONLABEL 0xf0
+#define TRANSACTIONLABEL_S 4
+#define SIGNALID_MASK 0x3f
+#define PACKETTYPE 0x0c
+#define PACKETTYPE_S 0x02
+#define MESSAGETYPE 0x03
+#define SIGNALIDENTIFIER 0x3f
+#define DISCOVER_SEP_IN_USE 0x02
+#define DISCOVER_IS_SINK 0x08
+
+/* Packet Types */
+#define singlePacket 0x0
+#define startPacket 0x1
+#define continuePacket 0x2
+#define endPacket 0x3
+
+/* Message Types */
+#define COMMAND 0x0
+#define RESPONSEACCEPT 0x2
+#define RESPONSEREJECT 0x3
+
+/* Response general error/success lengths */
+#define AVDTP_LEN_SUCCESS 2
+#define AVDTP_LEN_ERROR 3
+
+/* Error codes */
+#define BAD_HEADER_FORMAT 0x01
+#define BAD_LENGTH 0x11
+#define BAD_ACP_SEID 0x12
+#define SEP_IN_USE 0x13
+#define SEP_NOT_IN_USE 0x14
+#define BAD_SERV_CATAGORY 0x17
+#define BAD_PAYLOAD_FORMAT 0x18
+#define NOT_SUPPORTED_COMMAND 0x19
+#define INVALID_CAPABILITIES 0x1a
+
+#define BAD_RECOVERY_TYPE 0x22
+#define BAD_MEDIA_TRANSPORT_FORMAT 0x23
+#define BAD_RECOVERY_FORMAT 0x25
+#define BAD_ROHC_FORMAT 0x26
+#define BAD_CP_FORMAT 0x27
+#define BAD_MULTIPLEXING_FORMAT 0x28
+#define UNSUPPORTED_CONFIGURATION 0x29
+#define BAD_STATE 0x31
+
+/* Service Capabilities Field. */
+#define mediaTransport 0x1
+#define reporting 0x2
+#define recovery 0x3
+#define contentProtection 0x4
+#define headerCompression 0x5
+#define multiplexing 0x6
+#define mediaCodec 0x7
+
+/* Media Codec Capabilities */
+#define mediaCodecSbc 0x00
+#define mediaCodecMpeg1 0x01
+#define mediaCodecMpeg2 0x02
+
+#define SBC_CODEC_ID 0x0
+#define mediaTypeAudio 0x0
+
+struct bt_config;
+
+int avdtpSendAccept(int, uint8_t, uint8_t);
+int avdtpSendReject(int, uint8_t, uint8_t);
+int avdtpSendDiscResponseAudio(int, uint8_t, uint8_t, uint8_t);
+int avdtpDiscoverAndConfig(struct bt_config *, bool);
+int avdtpSetConfiguration(int, uint8_t, uint8_t *, int);
+int avdtpOpen(int, uint8_t);
+int avdtpStart(int, uint8_t);
+int avdtpClose(int, uint8_t);
+int avdtpSuspend(int, uint8_t);
+int avdtpAbort(int, uint8_t);
+
+/* Return < 0 if error, processed signal otherwise. */
+int avdtpACPHandlePacket(struct bt_config *cfg);
+/* Free state allocated in avdtpACPHandlePacket(), if any. */
+void avdtpACPFree(struct bt_config *cfg);
+
+#endif /* _AVDTP_SIGNAL_H_ */
diff --git a/lib/virtual_oss/bt/bt.h b/lib/virtual_oss/bt/bt.h
new file mode 100644
--- /dev/null
+++ b/lib/virtual_oss/bt/bt.h
@@ -0,0 +1,116 @@
+/*-
+ * Copyright (c) 2015 Hans Petter Selasky
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef _BACKEND_BT_H_
+#define _BACKEND_BT_H_
+
+#ifdef HAVE_LIBAV
+#include <libavformat/avformat.h>
+#include <libavcodec/avcodec.h>
+#include <libavutil/opt.h>
+#endif
+
+#include "sbc_encode.h"
+
+struct bt_config {
+ uint8_t sep; /* SEID of the peer */
+ uint8_t media_Type;
+ uint8_t chmode;
+#define MODE_STEREO 2
+#define MODE_JOINT 3
+#define MODE_DUAL 1
+#define MODE_MONO 0
+ uint8_t allocm;
+#define ALLOC_LOUDNESS 0
+#define ALLOC_SNR 1
+ uint8_t bitpool;
+ uint8_t bands;
+#define BANDS_4 0
+#define BANDS_8 1
+ uint8_t blocks;
+#define BLOCKS_4 0
+#define BLOCKS_8 1
+#define BLOCKS_12 2
+#define BLOCKS_16 3
+ uint8_t freq;
+#define FREQ_UNDEFINED 255
+#define FREQ_16K 0
+#define FREQ_32K 1
+#define FREQ_44_1K 2
+#define FREQ_48K 3
+ uint16_t mtu;
+ uint8_t codec;
+#define CODEC_SBC 0x00
+#define CODEC_AAC 0x02
+ uint8_t aacMode1;
+ uint8_t aacMode2;
+
+ /* transcoding handle(s) */
+ union {
+#ifdef HAVE_LIBAV
+ struct {
+ AVCodec *codec;
+ AVCodecContext *context;
+ AVFormatContext *format;
+ AVFrame *frame;
+ AVStream *stream;
+ } av;
+#endif
+ struct sbc_encode *sbc_enc;
+ } handle;
+
+ /* audio input buffer */
+ uint32_t rem_in_len;
+ uint32_t rem_in_size;
+ uint8_t *rem_in_data;
+
+ /* data transport */
+ uint32_t mtu_seqnumber;
+ uint32_t mtu_timestamp;
+ uint32_t mtu_offset;
+
+ /* bluetooth file handles */
+ int fd;
+ int hc;
+
+ /* scratch buffer */
+ uint8_t mtu_data[65536];
+
+ /* acceptor state */
+ int8_t acceptor_state;
+#define acpInitial 1
+#define acpConfigurationSet 2
+#define acpStreamOpened 3
+#define acpStreamStarted 4
+#define acpStreamSuspended 5
+#define acpStreamClosed 6
+};
+
+size_t sbc_encode_frame(struct bt_config *);
+size_t sbc_decode_frame(struct bt_config *, int);
+
+int bt_receive(struct bt_config *cfg, void *ptr, int len, int use_delay);
+
+#endif /* _BACKEND_BT_H_ */
diff --git a/lib/virtual_oss/bt/bt.c b/lib/virtual_oss/bt/bt.c
new file mode 100644
--- /dev/null
+++ b/lib/virtual_oss/bt/bt.c
@@ -0,0 +1,1061 @@
+/*-
+ * Copyright (c) 2015-2019 Hans Petter Selasky
+ * Copyright (c) 2015 Nathanial Sloss <nathanialsloss@yahoo.com.au>
+ * Copyright (c) 2006 Itronix Inc
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/queue.h>
+#include <sys/filio.h>
+#include <sys/soundcard.h>
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <err.h>
+#define L2CAP_SOCKET_CHECKED
+#include <bluetooth.h>
+#include <sdp.h>
+
+#include "backend.h"
+#include "int.h"
+
+#include "avdtp_signal.h"
+#include "bt.h"
+
+#define DPRINTF(...) printf("backend_bt: " __VA_ARGS__)
+
+struct l2cap_info {
+ bdaddr_t laddr;
+ bdaddr_t raddr;
+};
+
+static struct bt_config bt_play_cfg;
+static struct bt_config bt_rec_cfg;
+
+int
+bt_receive(struct bt_config *cfg, void *ptr, int len, int use_delay)
+{
+ struct sbc_header *phdr = (struct sbc_header *)cfg->mtu_data;
+ struct sbc_encode *sbc = cfg->handle.sbc_enc;
+ uint8_t *tmp = ptr;
+ int old_len = len;
+ int delta;
+ int err;
+
+ /* wait for service interval, if any */
+ if (use_delay)
+ virtual_oss_wait();
+
+ switch (cfg->blocks) {
+ case BLOCKS_4:
+ sbc->blocks = 4;
+ break;
+ case BLOCKS_8:
+ sbc->blocks = 8;
+ break;
+ case BLOCKS_12:
+ sbc->blocks = 12;
+ break;
+ default:
+ sbc->blocks = 16;
+ break;
+ }
+
+ switch (cfg->bands) {
+ case BANDS_4:
+ sbc->bands = 4;
+ break;
+ default:
+ sbc->bands = 8;
+ break;
+ }
+
+ if (cfg->chmode != MODE_MONO) {
+ sbc->channels = 2;
+ } else {
+ sbc->channels = 1;
+ }
+
+ while (1) {
+ delta = len & ~1;
+ if (delta > (int)(2 * sbc->rem_len))
+ delta = (2 * sbc->rem_len);
+
+ /* copy out samples, if any */
+ memcpy(tmp, (char *)sbc->music_data + sbc->rem_off, delta);
+ tmp += delta;
+ len -= delta;
+ sbc->rem_off += delta / 2;
+ sbc->rem_len -= delta / 2;
+ if (len == 0)
+ break;
+
+ if (sbc->rem_len == 0 &&
+ sbc->rem_data_frames != 0) {
+ err = sbc_decode_frame(cfg, sbc->rem_data_len * 8);
+ sbc->rem_data_frames--;
+ sbc->rem_data_ptr += err;
+ sbc->rem_data_len -= err;
+ continue;
+ }
+ /* TODO: Support fragmented SBC frames */
+ err = read(cfg->fd, cfg->mtu_data, cfg->mtu);
+
+ if (err == 0) {
+ break;
+ } else if (err < 0) {
+ if (errno == EAGAIN || errno == EWOULDBLOCK)
+ break;
+ else
+ return (-1); /* disconnected */
+ }
+
+ /* verify RTP header */
+ if (err < (int)sizeof(*phdr) || phdr->id != 0x80)
+ continue;
+
+ sbc->rem_data_frames = phdr->numFrames;
+ sbc->rem_data_ptr = (uint8_t *)(phdr + 1);
+ sbc->rem_data_len = err - sizeof(*phdr);
+ }
+ return (old_len - len);
+}
+
+static int
+bt_set_format(int *format)
+{
+ int value;
+
+ value = *format & AFMT_S16_NE;
+ if (value != 0) {
+ *format = value;
+ return (0);
+ }
+ return (-1);
+}
+
+static void
+bt_close(struct voss_backend *pbe)
+{
+ struct bt_config *cfg = pbe->arg;
+
+ if (cfg->hc > 0) {
+ avdtpAbort(cfg->hc, cfg->sep);
+ avdtpClose(cfg->hc, cfg->sep);
+ close(cfg->hc);
+ cfg->hc = -1;
+ }
+ if (cfg->fd > 0) {
+ close(cfg->fd);
+ cfg->fd = -1;
+ }
+}
+
+static void
+bt_play_close(struct voss_backend *pbe)
+{
+ struct bt_config *cfg = pbe->arg;
+
+ switch (cfg->codec) {
+ case CODEC_SBC:
+ if (cfg->handle.sbc_enc == NULL)
+ break;
+ free(cfg->handle.sbc_enc);
+ cfg->handle.sbc_enc = NULL;
+ break;
+#ifdef HAVE_LIBAV
+ case CODEC_AAC:
+ if (cfg->handle.av.context == NULL)
+ break;
+ av_free(cfg->rem_in_data);
+ av_frame_free(&cfg->handle.av.frame);
+ avcodec_close(cfg->handle.av.context);
+ avformat_free_context(cfg->handle.av.format);
+ cfg->handle.av.context = NULL;
+ break;
+#endif
+ default:
+ break;
+ }
+ return (bt_close(pbe));
+}
+
+static void
+bt_rec_close(struct voss_backend *pbe)
+{
+ struct bt_config *cfg = pbe->arg;
+
+ switch (cfg->codec) {
+ case CODEC_SBC:
+ break;
+#ifdef HAVE_LIBAV
+ case CODEC_AAC:
+ break;
+#endif
+
+ default:
+ break;
+ }
+ return (bt_close(pbe));
+}
+
+static const uint32_t bt_attrs[] = {
+ SDP_ATTR_RANGE(SDP_ATTR_PROTOCOL_DESCRIPTOR_LIST,
+ SDP_ATTR_PROTOCOL_DESCRIPTOR_LIST),
+};
+
+#define BT_NUM_VALUES 32
+#define BT_BUF_SIZE 32
+
+static int
+bt_find_psm(const uint8_t *start, const uint8_t *end)
+{
+ uint32_t type;
+ uint32_t len;
+ int protover = 0;
+ int psm = -1;
+
+ if ((end - start) < 2)
+ return (-1);
+
+ SDP_GET8(type, start);
+ switch (type) {
+ case SDP_DATA_SEQ8:
+ SDP_GET8(len, start);
+ break;
+
+ case SDP_DATA_SEQ16:
+ SDP_GET16(len, start);
+ break;
+
+ case SDP_DATA_SEQ32:
+ SDP_GET32(len, start);
+ break;
+
+ default:
+ return (-1);
+ }
+
+ while (start < end) {
+ SDP_GET8(type, start);
+ switch (type) {
+ case SDP_DATA_SEQ8:
+ SDP_GET8(len, start);
+ break;
+
+ case SDP_DATA_SEQ16:
+ SDP_GET16(len, start);
+ break;
+
+ case SDP_DATA_SEQ32:
+ SDP_GET32(len, start);
+ break;
+
+ default:
+ return (-1);
+ }
+ /* check range */
+ if (len > (uint32_t)(end - start))
+ break;
+
+ if (len >= 6) {
+ const uint8_t *ptr = start;
+
+ SDP_GET8(type, ptr);
+ if (type == SDP_DATA_UUID16) {
+ uint16_t temp;
+
+ SDP_GET16(temp, ptr);
+ switch (temp) {
+ case SDP_UUID_PROTOCOL_L2CAP:
+ SDP_GET8(type, ptr);
+ SDP_GET16(psm, ptr);
+ break;
+ case SDP_UUID_PROTOCOL_AVDTP:
+ SDP_GET8(type, ptr);
+ SDP_GET16(protover, ptr);
+ break;
+ default:
+ break;
+ }
+ }
+ }
+ start += len;
+
+ if (protover >= 0x0100 && psm > -1)
+ return (htole16(psm));
+ }
+ return (-1);
+}
+
+static int
+bt_query(struct l2cap_info *info, uint16_t service_class)
+{
+ sdp_attr_t values[BT_NUM_VALUES];
+ uint8_t buffer[BT_NUM_VALUES][BT_BUF_SIZE];
+ void *ss;
+ int psm = -1;
+ int n;
+
+ memset(buffer, 0, sizeof(buffer));
+ memset(values, 0, sizeof(values));
+
+ ss = sdp_open(&info->laddr, &info->raddr);
+ if (ss == NULL || sdp_error(ss) != 0) {
+ DPRINTF("Could not open SDP\n");
+ sdp_close(ss);
+ return (psm);
+ }
+ /* Initialize attribute values array */
+ for (n = 0; n != BT_NUM_VALUES; n++) {
+ values[n].flags = SDP_ATTR_INVALID;
+ values[n].vlen = BT_BUF_SIZE;
+ values[n].value = buffer[n];
+ }
+
+ /* Do SDP Service Search Attribute Request */
+ n = sdp_search(ss, 1, &service_class, 1, bt_attrs, BT_NUM_VALUES, values);
+ if (n != 0) {
+ DPRINTF("SDP search failed\n");
+ goto done;
+ }
+ /* Print attributes values */
+ for (n = 0; n != BT_NUM_VALUES; n++) {
+ if (values[n].flags != SDP_ATTR_OK)
+ break;
+ if (values[n].attr != SDP_ATTR_PROTOCOL_DESCRIPTOR_LIST)
+ continue;
+ psm = bt_find_psm(values[n].value, values[n].value + values[n].vlen);
+ if (psm > -1)
+ break;
+ }
+done:
+ sdp_close(ss);
+ return (psm);
+}
+
+static int
+bt_open(struct voss_backend *pbe __unused, const char *devname, int samplerate,
+ int bufsize __unused, int *pchannels, int *pformat, struct bt_config *cfg,
+ int service_class, int isSink)
+{
+ struct sockaddr_l2cap addr;
+ struct l2cap_info info;
+ socklen_t mtusize = sizeof(uint16_t);
+ int tmpbitpool;
+ int l2cap_psm;
+ int temp;
+
+ memset(&info, 0, sizeof(info));
+
+ if (strstr(devname, "/dev/bluetooth/") != devname) {
+ printf("Invalid device name '%s'", devname);
+ goto error;
+ }
+ /* skip prefix */
+ devname += sizeof("/dev/bluetooth/") - 1;
+
+ if (!bt_aton(devname, &info.raddr)) {
+ struct hostent *he = NULL;
+
+ if ((he = bt_gethostbyname(devname)) == NULL) {
+ DPRINTF("Could not get host by name\n");
+ goto error;
+ }
+ bdaddr_copy(&info.raddr, (bdaddr_t *)he->h_addr);
+ }
+ switch (samplerate) {
+ case 8000:
+ cfg->freq = FREQ_UNDEFINED;
+ cfg->aacMode1 = 0x80;
+ cfg->aacMode2 = 0x0C;
+ break;
+ case 11025:
+ cfg->freq = FREQ_UNDEFINED;
+ cfg->aacMode1 = 0x40;
+ cfg->aacMode2 = 0x0C;
+ break;
+ case 12000:
+ cfg->freq = FREQ_UNDEFINED;
+ cfg->aacMode1 = 0x20;
+ cfg->aacMode2 = 0x0C;
+ break;
+ case 16000:
+ cfg->freq = FREQ_16K;
+ cfg->aacMode1 = 0x10;
+ cfg->aacMode2 = 0x0C;
+ break;
+ case 22050:
+ cfg->freq = FREQ_UNDEFINED;
+ cfg->aacMode1 = 0x08;
+ cfg->aacMode2 = 0x0C;
+ break;
+ case 24000:
+ cfg->freq = FREQ_UNDEFINED;
+ cfg->aacMode1 = 0x04;
+ cfg->aacMode2 = 0x0C;
+ break;
+ case 32000:
+ cfg->freq = FREQ_32K;
+ cfg->aacMode1 = 0x02;
+ cfg->aacMode2 = 0x0C;
+ break;
+ case 44100:
+ cfg->freq = FREQ_44_1K;
+ cfg->aacMode1 = 0x01;
+ cfg->aacMode2 = 0x0C;
+ break;
+ case 48000:
+ cfg->freq = FREQ_48K;
+ cfg->aacMode1 = 0;
+ cfg->aacMode2 = 0x8C;
+ break;
+ case 64000:
+ cfg->freq = FREQ_UNDEFINED;
+ cfg->aacMode1 = 0;
+ cfg->aacMode2 = 0x4C;
+ break;
+ case 88200:
+ cfg->freq = FREQ_UNDEFINED;
+ cfg->aacMode1 = 0;
+ cfg->aacMode2 = 0x2C;
+ break;
+ case 96000:
+ cfg->freq = FREQ_UNDEFINED;
+ cfg->aacMode1 = 0;
+ cfg->aacMode2 = 0x1C;
+ break;
+ default:
+ DPRINTF("Invalid samplerate %d", samplerate);
+ goto error;
+ }
+ cfg->bands = BANDS_8;
+ cfg->bitpool = 0;
+
+ switch (*pchannels) {
+ case 1:
+ cfg->aacMode2 &= 0xF8;
+ cfg->chmode = MODE_MONO;
+ break;
+ default:
+ cfg->aacMode2 &= 0xF4;
+ cfg->chmode = MODE_STEREO;
+ break;
+ }
+
+ cfg->allocm = ALLOC_LOUDNESS;
+
+ if (cfg->chmode == MODE_MONO || cfg->chmode == MODE_DUAL)
+ tmpbitpool = 16;
+ else
+ tmpbitpool = 32;
+
+ if (cfg->bands == BANDS_8)
+ tmpbitpool *= 8;
+ else
+ tmpbitpool *= 4;
+
+ if (tmpbitpool > DEFAULT_MAXBPOOL)
+ tmpbitpool = DEFAULT_MAXBPOOL;
+
+ cfg->bitpool = tmpbitpool;
+
+ if (bt_set_format(pformat)) {
+ DPRINTF("Unsupported sample format\n");
+ goto error;
+ }
+ l2cap_psm = bt_query(&info, service_class);
+ DPRINTF("PSM=0x%02x\n", l2cap_psm);
+ if (l2cap_psm < 0) {
+ DPRINTF("PSM not found\n");
+ goto error;
+ }
+ cfg->hc = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BLUETOOTH_PROTO_L2CAP);
+ if (cfg->hc < 0) {
+ DPRINTF("Could not create BT socket\n");
+ goto error;
+ }
+ memset(&addr, 0, sizeof(addr));
+ addr.l2cap_len = sizeof(addr);
+ addr.l2cap_family = AF_BLUETOOTH;
+ bdaddr_copy(&addr.l2cap_bdaddr, &info.laddr);
+
+ if (bind(cfg->hc, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+ DPRINTF("Could not bind to HC\n");
+ goto error;
+ }
+ bdaddr_copy(&addr.l2cap_bdaddr, &info.raddr);
+ addr.l2cap_psm = l2cap_psm;
+ if (connect(cfg->hc, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+ DPRINTF("Could not connect to HC: %d\n", errno);
+ goto error;
+ }
+ if (avdtpDiscoverAndConfig(cfg, isSink)) {
+ DPRINTF("DISCOVER FAILED\n");
+ goto error;
+ }
+ if (avdtpOpen(cfg->hc, cfg->sep)) {
+ DPRINTF("OPEN FAILED\n");
+ goto error;
+ }
+ cfg->fd = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BLUETOOTH_PROTO_L2CAP);
+ if (cfg->fd < 0) {
+ DPRINTF("Could not create BT socket\n");
+ goto error;
+ }
+ memset(&addr, 0, sizeof(addr));
+
+ addr.l2cap_len = sizeof(addr);
+ addr.l2cap_family = AF_BLUETOOTH;
+ bdaddr_copy(&addr.l2cap_bdaddr, &info.laddr);
+
+ if (bind(cfg->fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+ DPRINTF("Could not bind\n");
+ goto error;
+ }
+ bdaddr_copy(&addr.l2cap_bdaddr, &info.raddr);
+ addr.l2cap_psm = l2cap_psm;
+ if (connect(cfg->fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+ DPRINTF("Could not connect: %d\n", errno);
+ goto error;
+ }
+ if (isSink) {
+ if (getsockopt(cfg->fd, SOL_L2CAP, SO_L2CAP_OMTU, &cfg->mtu, &mtusize) == -1) {
+ DPRINTF("Could not get MTU\n");
+ goto error;
+ }
+ temp = cfg->mtu * 16;
+ if (setsockopt(cfg->fd, SOL_SOCKET, SO_SNDBUF, &temp, sizeof(temp)) == -1) {
+ DPRINTF("Could not set send buffer size\n");
+ goto error;
+ }
+ temp = cfg->mtu;
+ if (setsockopt(cfg->fd, SOL_SOCKET, SO_SNDLOWAT, &temp, sizeof(temp)) == -1) {
+ DPRINTF("Could not set low water mark\n");
+ goto error;
+ }
+ } else {
+ if (getsockopt(cfg->fd, SOL_L2CAP, SO_L2CAP_IMTU, &cfg->mtu, &mtusize) == -1) {
+ DPRINTF("Could not get MTU\n");
+ goto error;
+ }
+ temp = cfg->mtu * 16;
+ if (setsockopt(cfg->fd, SOL_SOCKET, SO_RCVBUF, &temp, sizeof(temp)) == -1) {
+ DPRINTF("Could not set receive buffer size\n");
+ goto error;
+ }
+ temp = 1;
+ if (setsockopt(cfg->fd, SOL_SOCKET, SO_RCVLOWAT, &temp, sizeof(temp)) == -1) {
+ DPRINTF("Could not set low water mark\n");
+ goto error;
+ }
+ temp = 1;
+ if (ioctl(cfg->fd, FIONBIO, &temp) == -1) {
+ DPRINTF("Could not set non-blocking I/O for receive direction\n");
+ goto error;
+ }
+ }
+
+ if (avdtpStart(cfg->hc, cfg->sep)) {
+ DPRINTF("START FAILED\n");
+ goto error;
+ }
+ switch (cfg->chmode) {
+ case MODE_MONO:
+ *pchannels = 1;
+ break;
+ default:
+ *pchannels = 2;
+ break;
+ }
+ return (0);
+
+error:
+ if (cfg->hc > 0) {
+ close(cfg->hc);
+ cfg->hc = -1;
+ }
+ if (cfg->fd > 0) {
+ close(cfg->fd);
+ cfg->fd = -1;
+ }
+ return (-1);
+}
+
+static void
+bt_init_cfg(struct bt_config *cfg)
+{
+ memset(cfg, 0, sizeof(*cfg));
+}
+
+static int
+bt_rec_open(struct voss_backend *pbe, const char *devname, int samplerate,
+ int bufsize, int *pchannels, int *pformat)
+{
+ struct bt_config *cfg = pbe->arg;
+ int retval;
+
+ bt_init_cfg(cfg);
+
+ retval = bt_open(pbe, devname, samplerate, bufsize, pchannels, pformat,
+ cfg, SDP_SERVICE_CLASS_AUDIO_SOURCE, 0);
+ if (retval != 0)
+ return (retval);
+ return (0);
+}
+
+static int
+bt_play_open(struct voss_backend *pbe, const char *devname, int samplerate,
+ int bufsize, int *pchannels, int *pformat)
+{
+ struct bt_config *cfg = pbe->arg;
+ int retval;
+
+ bt_init_cfg(cfg);
+
+ retval = bt_open(pbe, devname, samplerate, bufsize, pchannels, pformat,
+ cfg, SDP_SERVICE_CLASS_AUDIO_SINK, 1);
+ if (retval != 0)
+ return (retval);
+
+ /* setup codec */
+ switch (cfg->codec) {
+ case CODEC_SBC:
+ cfg->handle.sbc_enc =
+ malloc(sizeof(*cfg->handle.sbc_enc));
+ if (cfg->handle.sbc_enc == NULL)
+ return (-1);
+ memset(cfg->handle.sbc_enc, 0, sizeof(*cfg->handle.sbc_enc));
+ break;
+#ifdef HAVE_LIBAV
+ case CODEC_AAC:
+ cfg->handle.av.codec = __DECONST(AVCodec *,
+ avcodec_find_encoder_by_name("aac"));
+ if (cfg->handle.av.codec == NULL) {
+ DPRINTF("Codec AAC encoder not found\n");
+ goto av_error_0;
+ }
+ cfg->handle.av.format = avformat_alloc_context();
+ if (cfg->handle.av.format == NULL) {
+ DPRINTF("Could not allocate format context\n");
+ goto av_error_0;
+ }
+ cfg->handle.av.format->oformat =
+ av_guess_format("latm", NULL, NULL);
+ if (cfg->handle.av.format->oformat == NULL) {
+ DPRINTF("Could not guess output format\n");
+ goto av_error_1;
+ }
+ cfg->handle.av.stream = avformat_new_stream(
+ cfg->handle.av.format, cfg->handle.av.codec);
+
+ if (cfg->handle.av.stream == NULL) {
+ DPRINTF("Could not create new stream\n");
+ goto av_error_1;
+ }
+ cfg->handle.av.context = avcodec_alloc_context3(cfg->handle.av.codec);
+ if (cfg->handle.av.context == NULL) {
+ DPRINTF("Could not allocate audio context\n");
+ goto av_error_1;
+ }
+ /*avcodec_get_context_defaults3(cfg->handle.av.context,*/
+ /*cfg->handle.av.codec);*/
+
+ cfg->handle.av.context->bit_rate = 128000;
+ cfg->handle.av.context->sample_fmt = AV_SAMPLE_FMT_FLTP;
+ cfg->handle.av.context->sample_rate = samplerate;
+ switch (*pchannels) {
+ case 1:
+ cfg->handle.av.context->ch_layout = *(AVChannelLayout *)AV_CH_LAYOUT_MONO;
+ break;
+ default:
+ cfg->handle.av.context->ch_layout = *(AVChannelLayout *)AV_CH_LAYOUT_STEREO;
+ break;
+ }
+
+ cfg->handle.av.context->profile = FF_PROFILE_AAC_LOW;
+ if (1) {
+ AVDictionary *opts = NULL;
+
+ av_dict_set(&opts, "strict", "-2", 0);
+ av_dict_set_int(&opts, "latm", 1, 0);
+
+ if (avcodec_open2(cfg->handle.av.context,
+ cfg->handle.av.codec, &opts) < 0) {
+ av_dict_free(&opts);
+
+ DPRINTF("Could not open codec\n");
+ goto av_error_1;
+ }
+ av_dict_free(&opts);
+ }
+ cfg->handle.av.frame = av_frame_alloc();
+ if (cfg->handle.av.frame == NULL) {
+ DPRINTF("Could not allocate audio frame\n");
+ goto av_error_2;
+ }
+ cfg->handle.av.frame->nb_samples = cfg->handle.av.context->frame_size;
+ cfg->handle.av.frame->format = cfg->handle.av.context->sample_fmt;
+ cfg->handle.av.frame->ch_layout = cfg->handle.av.context->ch_layout;
+ cfg->rem_in_size = av_samples_get_buffer_size(NULL,
+ cfg->handle.av.context->ch_layout.nb_channels,
+ cfg->handle.av.context->frame_size,
+ cfg->handle.av.context->sample_fmt, 0);
+
+ cfg->rem_in_data = av_malloc(cfg->rem_in_size);
+ if (cfg->rem_in_data == NULL) {
+ DPRINTF("Could not allocate %u bytes sample buffer\n",
+ (unsigned)cfg->rem_in_size);
+ goto av_error_3;
+ }
+ retval = avcodec_fill_audio_frame(cfg->handle.av.frame,
+ cfg->handle.av.context->ch_layout.nb_channels,
+ cfg->handle.av.context->sample_fmt,
+ cfg->rem_in_data, cfg->rem_in_size, 0);
+ if (retval < 0) {
+ DPRINTF("Could not setup audio frame\n");
+ goto av_error_4;
+ }
+ break;
+av_error_4:
+ av_free(cfg->rem_in_data);
+av_error_3:
+ av_frame_free(&cfg->handle.av.frame);
+av_error_2:
+ avcodec_close(cfg->handle.av.context);
+av_error_1:
+ avformat_free_context(cfg->handle.av.format);
+ cfg->handle.av.context = NULL;
+av_error_0:
+ bt_close(pbe);
+ return (-1);
+#endif
+ default:
+ bt_close(pbe);
+ return (-1);
+ }
+ return (0);
+}
+
+static int
+bt_rec_transfer(struct voss_backend *pbe, void *ptr, int len)
+{
+ return (bt_receive(pbe->arg, ptr, len, 1));
+}
+
+static int
+bt_play_sbc_transfer(struct voss_backend *pbe, void *ptr, int len)
+{
+ struct bt_config *cfg = pbe->arg;
+ struct sbc_encode *sbc = cfg->handle.sbc_enc;
+ int rem_size = 1;
+ int old_len = len;
+ int err = 0;
+
+ switch (cfg->blocks) {
+ case BLOCKS_4:
+ sbc->blocks = 4;
+ rem_size *= 4;
+ break;
+ case BLOCKS_8:
+ sbc->blocks = 8;
+ rem_size *= 8;
+ break;
+ case BLOCKS_12:
+ sbc->blocks = 12;
+ rem_size *= 12;
+ break;
+ default:
+ sbc->blocks = 16;
+ rem_size *= 16;
+ break;
+ }
+
+ switch (cfg->bands) {
+ case BANDS_4:
+ rem_size *= 4;
+ sbc->bands = 4;
+ break;
+ default:
+ rem_size *= 8;
+ sbc->bands = 8;
+ break;
+ }
+
+ /* store number of samples per frame */
+ sbc->framesamples = rem_size;
+
+ if (cfg->chmode != MODE_MONO) {
+ rem_size *= 2;
+ sbc->channels = 2;
+ } else {
+ sbc->channels = 1;
+ }
+
+ rem_size *= 2; /* 16-bit samples */
+
+ while (len > 0) {
+ int delta = len;
+
+ if (delta > (int)(rem_size - sbc->rem_len))
+ delta = (int)(rem_size - sbc->rem_len);
+
+ /* copy in samples */
+ memcpy((char *)sbc->music_data + sbc->rem_len, ptr, delta);
+
+ ptr = (char *)ptr + delta;
+ len -= delta;
+ sbc->rem_len += delta;
+
+ /* check if buffer is full */
+ if ((int)sbc->rem_len == rem_size) {
+ struct sbc_header *phdr = (struct sbc_header *)cfg->mtu_data;
+ uint32_t pkt_len;
+ uint32_t rem;
+
+ if (cfg->chmode == MODE_MONO)
+ sbc->channels = 1;
+ else
+ sbc->channels = 2;
+
+ pkt_len = sbc_encode_frame(cfg);
+
+ retry:
+ if (cfg->mtu_offset == 0) {
+ phdr->id = 0x80; /* RTP v2 */
+ phdr->id2 = 0x60; /* payload type 96. */
+ phdr->seqnumMSB = (uint8_t)(cfg->mtu_seqnumber >> 8);
+ phdr->seqnumLSB = (uint8_t)(cfg->mtu_seqnumber);
+ phdr->ts3 = (uint8_t)(cfg->mtu_timestamp >> 24);
+ phdr->ts2 = (uint8_t)(cfg->mtu_timestamp >> 16);
+ phdr->ts1 = (uint8_t)(cfg->mtu_timestamp >> 8);
+ phdr->ts0 = (uint8_t)(cfg->mtu_timestamp);
+ phdr->reserved0 = 0x01;
+ phdr->numFrames = 0;
+
+ cfg->mtu_seqnumber++;
+ cfg->mtu_offset += sizeof(*phdr);
+ }
+ /* compute bytes left */
+ rem = cfg->mtu - cfg->mtu_offset;
+
+ if (phdr->numFrames == 255 || rem < pkt_len) {
+ int xlen;
+
+ if (phdr->numFrames == 0)
+ return (-1);
+ do {
+ xlen = write(cfg->fd, cfg->mtu_data, cfg->mtu_offset);
+ } while (xlen < 0 && errno == EAGAIN);
+
+ if (xlen < 0)
+ return (-1);
+
+ cfg->mtu_offset = 0;
+ goto retry;
+ }
+ memcpy(cfg->mtu_data + cfg->mtu_offset, sbc->data, pkt_len);
+ memset(sbc->data, 0, pkt_len);
+ cfg->mtu_offset += pkt_len;
+ cfg->mtu_timestamp += sbc->framesamples;
+ phdr->numFrames++;
+
+ sbc->rem_len = 0;
+ }
+ }
+ if (err == 0)
+ return (old_len);
+ return (err);
+}
+
+#ifdef HAVE_LIBAV
+static int
+bt_play_aac_transfer(struct voss_backend *pbe, void *ptr, int len)
+{
+ struct bt_config *cfg = pbe->arg;
+ struct aac_header {
+ uint8_t id;
+ uint8_t id2;
+ uint8_t seqnumMSB;
+ uint8_t seqnumLSB;
+ uint8_t ts3;
+ uint8_t ts2;
+ uint8_t ts1;
+ uint8_t ts0;
+ uint8_t sync3;
+ uint8_t sync2;
+ uint8_t sync1;
+ uint8_t sync0;
+ uint8_t fixed[8];
+ };
+ int old_len = len;
+ int err = 0;
+
+ while (len > 0) {
+ int delta = len;
+ int rem;
+
+ if (delta > (int)(cfg->rem_in_size - cfg->rem_in_len))
+ delta = (int)(cfg->rem_in_size - cfg->rem_in_len);
+
+ memcpy(cfg->rem_in_data + cfg->rem_in_len, ptr, delta);
+
+ ptr = (char *)ptr + delta;
+ len -= delta;
+ cfg->rem_in_len += delta;
+
+ /* check if buffer is full */
+ if (cfg->rem_in_len == cfg->rem_in_size) {
+ struct aac_header *phdr = (struct aac_header *)cfg->mtu_data;
+ AVPacket *pkt;
+ uint8_t *pkt_buf;
+ int pkt_len;
+
+ pkt = av_packet_alloc();
+ err = avcodec_send_frame(cfg->handle.av.context,
+ cfg->handle.av.frame);
+ if (err < 0) {
+ DPRINTF("Error encoding audio frame\n");
+ return (-1);
+ }
+ phdr->id = 0x80;/* RTP v2 */
+ phdr->id2 = 0x60; /* payload type 96. */
+ phdr->seqnumMSB = (uint8_t)(cfg->mtu_seqnumber >> 8);
+ phdr->seqnumLSB = (uint8_t)(cfg->mtu_seqnumber);
+ phdr->ts3 = (uint8_t)(cfg->mtu_timestamp >> 24);
+ phdr->ts2 = (uint8_t)(cfg->mtu_timestamp >> 16);
+ phdr->ts1 = (uint8_t)(cfg->mtu_timestamp >> 8);
+ phdr->ts0 = (uint8_t)(cfg->mtu_timestamp);
+ phdr->sync3 = 0;
+ phdr->sync2 = 0;
+ phdr->sync1 = 0;
+ phdr->sync0 = 0;
+ phdr->fixed[0] = 0xfc;
+ phdr->fixed[1] = 0x00;
+ phdr->fixed[2] = 0x00;
+ phdr->fixed[3] = 0xb0;
+ phdr->fixed[4] = 0x90;
+ phdr->fixed[5] = 0x80;
+ phdr->fixed[6] = 0x03;
+ phdr->fixed[7] = 0x00;
+
+ cfg->mtu_seqnumber++;
+ cfg->mtu_offset = sizeof(*phdr);
+
+ /* compute bytes left */
+ rem = cfg->mtu - cfg->mtu_offset;
+
+ if (avio_open_dyn_buf(&cfg->handle.av.format->pb) == 0) {
+ static int once = 0;
+
+ if (!once++)
+ (void)avformat_write_header(cfg->handle.av.format, NULL);
+ av_write_frame(cfg->handle.av.format, pkt);
+ av_packet_unref(pkt);
+ pkt_len = avio_close_dyn_buf(cfg->handle.av.format->pb, &pkt_buf);
+ if (rem < pkt_len)
+ DPRINTF("Out of buffer space\n");
+ if (pkt_len >= 3 && rem >= pkt_len) {
+ int xlen;
+
+ memcpy(cfg->mtu_data + cfg->mtu_offset, pkt_buf + 3, pkt_len - 3);
+
+ av_free(pkt_buf);
+
+ cfg->mtu_offset += pkt_len - 3;
+ if (cfg->chmode != MODE_MONO)
+ cfg->mtu_timestamp += cfg->rem_in_size / 4;
+ else
+ cfg->mtu_timestamp += cfg->rem_in_size / 2;
+ do {
+ xlen = write(cfg->fd, cfg->mtu_data, cfg->mtu_offset);
+ } while (xlen < 0 && errno == EAGAIN);
+
+ if (xlen < 0)
+ return (-1);
+ } else {
+ av_free(pkt_buf);
+ }
+ } else {
+ av_packet_unref(pkt);
+ }
+ /* reset remaining length */
+ cfg->rem_in_len = 0;
+ }
+ }
+ if (err == 0)
+ return (old_len);
+ return (err);
+}
+
+#endif
+
+static int
+bt_play_transfer(struct voss_backend *pbe, void *ptr, int len)
+{
+ struct bt_config *cfg = pbe->arg;
+
+ switch (cfg->codec) {
+ case CODEC_SBC:
+ return (bt_play_sbc_transfer(pbe, ptr, len));
+#ifdef HAVE_LIBAV
+ case CODEC_AAC:
+ return (bt_play_aac_transfer(pbe, ptr, len));
+#endif
+ default:
+ return (-1);
+ }
+}
+
+static void
+bt_rec_delay(struct voss_backend *pbe __unused, int *pdelay)
+{
+ *pdelay = -1;
+}
+
+static void
+bt_play_delay(struct voss_backend *pbe __unused, int *pdelay)
+{
+ /* TODO */
+ *pdelay = -1;
+}
+
+struct voss_backend voss_backend_bt_rec = {
+ .open = bt_rec_open,
+ .close = bt_rec_close,
+ .transfer = bt_rec_transfer,
+ .delay = bt_rec_delay,
+ .arg = &bt_rec_cfg,
+};
+
+struct voss_backend voss_backend_bt_play = {
+ .open = bt_play_open,
+ .close = bt_play_close,
+ .transfer = bt_play_transfer,
+ .delay = bt_play_delay,
+ .arg = &bt_play_cfg,
+};
diff --git a/lib/virtual_oss/bt/cosdata-gen/Makefile b/lib/virtual_oss/bt/cosdata-gen/Makefile
new file mode 100644
--- /dev/null
+++ b/lib/virtual_oss/bt/cosdata-gen/Makefile
@@ -0,0 +1,12 @@
+# $NetBSD$
+
+WARNS?= 3
+
+PROG= cosdata
+SRCS= cosdata.c
+MAN=
+
+DPADD+= ${LIBMATH}
+LDADD+= -lm
+
+.include <bsd.prog.mk>
diff --git a/lib/virtual_oss/bt/cosdata-gen/cosdata.c b/lib/virtual_oss/bt/cosdata-gen/cosdata.c
new file mode 100644
--- /dev/null
+++ b/lib/virtual_oss/bt/cosdata-gen/cosdata.c
@@ -0,0 +1,177 @@
+/*-
+ * Copyright (c) 2015 - 2016 Nathanial Sloss <nathanialsloss@yahoo.com.au>
+ * All rights reserved.
+ *
+ * This software is dedicated to the memory of -
+ * Baron James Anlezark (Barry) - 1 Jan 1949 - 13 May 2012.
+ *
+ * Barry was a man who loved his music.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <math.h>
+#include <stdio.h>
+#include <stdint.h>
+
+static const double sbc8_coeffs[] = {
+ 0.00000000e+00, 1.56575398e-04, 3.43256425e-04, 5.54620202e-04,
+ 8.23919506e-04, 1.13992507e-03, 1.47640169e-03, 1.78371725e-03,
+ 2.01182542e-03, 2.10371989e-03, 1.99454554e-03, 1.61656283e-03,
+ 9.02154502e-04, -1.78805361e-04, -1.64973098e-03, -3.49717454e-03,
+ 5.65949473e-03, 8.02941163e-03, 1.04584443e-02, 1.27472335e-02,
+ 1.46525263e-02, 1.59045603e-02, 1.62208471e-02, 1.53184106e-02,
+ 1.29371806e-02, 8.85757540e-03, 2.92408442e-03, -4.91578024e-03,
+ -1.46404076e-02, -2.61098752e-02, -3.90751381e-02, -5.31873032e-02,
+ 6.79989431e-02, 8.29847578e-02, 9.75753918e-02, 1.11196689e-01,
+ 1.23264548e-01, 1.33264415e-01, 1.40753505e-01, 1.45389847e-01,
+ 1.46955068e-01, 1.45389847e-01, 1.40753505e-01, 1.33264415e-01,
+ 1.23264548e-01, 1.11196689e-01, 9.75753918e-02, 8.29847578e-02,
+ -6.79989431e-02, -5.31873032e-02, -3.90751381e-02, -2.61098752e-02,
+ -1.46404076e-02, -4.91578024e-03, 2.92408442e-03, 8.85757540e-03,
+ 1.29371806e-02, 1.53184106e-02, 1.62208471e-02, 1.59045603e-02,
+ 1.46525263e-02, 1.27472335e-02, 1.04584443e-02, 8.02941163e-03,
+ -5.65949473e-03, -3.49717454e-03, -1.64973098e-03, -1.78805361e-04,
+ 9.02154502e-04, 1.61656283e-03, 1.99454554e-03, 2.10371989e-03,
+ 2.01182542e-03, 1.78371725e-03, 1.47640169e-03, 1.13992507e-03,
+ 8.23919506e-04, 5.54620202e-04, 3.43256425e-04, 1.56575398e-04,
+};
+
+static const double sbc4_coeffs[] = {
+ 0.00000000e+00, 5.36548976e-04, 1.49188357e-03, 2.73370904e-03,
+ 3.83720193e-03, 3.89205149e-03, 1.86581691e-03, -3.06012286e-03,
+ 1.09137620e-02, 2.04385087e-02, 2.88757392e-02, 3.21939290e-02,
+ 2.58767811e-02, 6.13245186e-03, -2.88217274e-02, -7.76463494e-02,
+ 1.35593274e-01, 1.94987841e-01, 2.46636662e-01, 2.81828203e-01,
+ 2.94315332e-01, 2.81828203e-01, 2.46636662e-01, 1.94987841e-01,
+ -1.35593274e-01, -7.76463494e-02, -2.88217274e-02, 6.13245186e-03,
+ 2.58767811e-02, 3.21939290e-02, 2.88757392e-02, 2.04385087e-02,
+ -1.09137620e-02, -3.06012286e-03, 1.86581691e-03, 3.89205149e-03,
+ 3.83720193e-03, 2.73370904e-03, 1.49188357e-03, 5.36548976e-04,
+};
+
+#define AC(x) (int)(sizeof(x) / sizeof((x)[0]))
+
+int
+main(int argc, char **argv)
+{
+ float S[8][16];
+ int i;
+ int k;
+ int count = 0;
+
+ printf("/* sbc_coeffs.h - Automatically generated by cosdata.c. */\n"
+ "\n");
+
+ printf("static const float sbc_coeffs8[] = {\n ");
+ for (k = 0; k < AC(sbc8_coeffs); k++) {
+ if ((count % 8) == 0 && count != 0)
+ printf("\n ");
+ printf("%0.12ff, ", (float)sbc8_coeffs[k]);
+ count++;
+ }
+ printf("\n};\n");
+
+ count = 0;
+ printf("static const float sbc_coeffs4[] = {\n ");
+ for (k = 0; k < AC(sbc4_coeffs); k++) {
+ if ((count % 8) == 0 && count != 0)
+ printf("\n ");
+ printf("%0.12ff, ", (float)sbc4_coeffs[k]);
+ count++;
+ }
+ printf("\n};\n");
+
+ count = 0;
+ printf("static const float cosdata8[8][16] = {\n ");
+ for (i = 0; i < 8; i++) {
+ for (k = 0; k < 16; k++) {
+ S[i][k] = cosf((float)((i + 0.5) * (k - 4) * (M_PI / 8.0)));
+
+ if ((count % 8) == 0 && count != 0)
+ printf("\n ");
+ if (k == 0)
+ printf("{ ");
+ printf("%0.12ff, ", S[i][k]);
+ if (k == 15)
+ printf("},");
+ count++;
+ }
+ }
+ printf("\n};\n");
+
+ count = 0;
+ printf("static const float cosdata4[4][8] = {\n ");
+ for (i = 0; i < 4; i++) {
+ for (k = 0; k < 8; k++) {
+ S[i][k] = cosf((float)((i + 0.5) * (k - 2) * (M_PI / 4.0)));
+
+ if ((count % 8) == 0 && count != 0)
+ printf("\n ");
+ if (k == 0)
+ printf("{ ");
+ printf("%0.12ff, ", S[i][k]);
+ if (k == 7)
+ printf("},");
+ count++;
+ }
+ }
+ printf("\n};\n");
+
+ count = 0;
+ printf("static const float cosdecdata8[8][16] = {\n ");
+ for (i = 0; i < 8; i++) {
+ for (k = 0; k < 16; k++) {
+ S[i][k] = cosf((float)((i + 0.5) * (k + 4) * (M_PI / 8.0)));
+
+ if ((count % 8) == 0 && count != 0)
+ printf("\n ");
+ if (k == 0)
+ printf("{ ");
+ printf("%0.12ff, ", S[i][k]);
+ if (k == 15)
+ printf("},");
+ count++;
+ }
+ }
+ printf("\n};\n");
+
+ count = 0;
+ printf("static const float cosdecdata4[4][8] = {\n ");
+ for (i = 0; i < 4; i++) {
+ for (k = 0; k < 8; k++) {
+ S[i][k] = cosf((float)((i + 0.5) * (k + 2) * (M_PI / 4.0)));
+
+ if ((count % 8) == 0 && count != 0)
+ printf("\n ");
+ if (k == 0)
+ printf("{ ");
+ printf("%0.12ff, ", S[i][k]);
+ if (k == 7)
+ printf("},");
+ count++;
+ }
+ }
+ printf("\n};\n");
+
+ return (0);
+}
diff --git a/lib/virtual_oss/bt/sbc_coeffs.h b/lib/virtual_oss/bt/sbc_coeffs.h
new file mode 100644
--- /dev/null
+++ b/lib/virtual_oss/bt/sbc_coeffs.h
@@ -0,0 +1,69 @@
+/* sbc_coeffs.h - Automatically generated by cosdata.c. */
+
+static const float sbc_coeffs8[] = {
+ 0.000000000000f, 0.000156575392f, 0.000343256426f, 0.000554620230f, 0.000823919487f, 0.001139925094f, 0.001476401696f, 0.001783717307f,
+ 0.002011825331f, 0.002103719860f, 0.001994545572f, 0.001616562833f, 0.000902154483f, -0.000178805363f, -0.001649730955f, -0.003497174475f,
+ 0.005659494549f, 0.008029411547f, 0.010458444245f, 0.012747233734f, 0.014652526006f, 0.015904560685f, 0.016220847145f, 0.015318410471f,
+ 0.012937180698f, 0.008857575245f, 0.002924084431f, -0.004915780388f, -0.014640407637f, -0.026109876111f, -0.039075139910f, -0.053187303245f,
+ 0.067998945713f, 0.082984760404f, 0.097575388849f, 0.111196689308f, 0.123264551163f, 0.133264422417f, 0.140753507614f, 0.145389840007f,
+ 0.146955072880f, 0.145389840007f, 0.140753507614f, 0.133264422417f, 0.123264551163f, 0.111196689308f, 0.097575388849f, 0.082984760404f,
+ -0.067998945713f, -0.053187303245f, -0.039075139910f, -0.026109876111f, -0.014640407637f, -0.004915780388f, 0.002924084431f, 0.008857575245f,
+ 0.012937180698f, 0.015318410471f, 0.016220847145f, 0.015904560685f, 0.014652526006f, 0.012747233734f, 0.010458444245f, 0.008029411547f,
+ -0.005659494549f, -0.003497174475f, -0.001649730955f, -0.000178805363f, 0.000902154483f, 0.001616562833f, 0.001994545572f, 0.002103719860f,
+ 0.002011825331f, 0.001783717307f, 0.001476401696f, 0.001139925094f, 0.000823919487f, 0.000554620230f, 0.000343256426f, 0.000156575392f,
+};
+static const float sbc_coeffs4[] = {
+ 0.000000000000f, 0.000536548963f, 0.001491883537f, 0.002733709058f, 0.003837201977f, 0.003892051522f, 0.001865816885f, -0.003060122952f,
+ 0.010913762264f, 0.020438509062f, 0.028875738382f, 0.032193928957f, 0.025876780972f, 0.006132451817f, -0.028821727261f, -0.077646352351f,
+ 0.135593280196f, 0.194987848401f, 0.246636658907f, 0.281828194857f, 0.294315338135f, 0.281828194857f, 0.246636658907f, 0.194987848401f,
+ -0.135593280196f, -0.077646352351f, -0.028821727261f, 0.006132451817f, 0.025876780972f, 0.032193928957f, 0.028875738382f, 0.020438509062f,
+ -0.010913762264f, -0.003060122952f, 0.001865816885f, 0.003892051522f, 0.003837201977f, 0.002733709058f, 0.001491883537f, 0.000536548963f,
+};
+static const float cosdata8[8][16] = {
+ { 0.707106769085f, 0.831469595432f, 0.923879504204f, 0.980785250664f, 1.000000000000f, 0.980785250664f, 0.923879504204f, 0.831469595432f,
+ 0.707106769085f, 0.555570244789f, 0.382683426142f, 0.195090353489f, -0.000000043711f, -0.195090323687f, -0.382683396339f, -0.555570185184f, },
+ { -0.707106769085f, -0.195090323687f, 0.382683426142f, 0.831469595432f, 1.000000000000f, 0.831469595432f, 0.382683426142f, -0.195090323687f,
+ -0.707106769085f, -0.980785310268f, -0.923879504204f, -0.555570423603f, 0.000000011925f, 0.555570065975f, 0.923879563808f, 0.980785310268f, },
+ { -0.707106828690f, -0.980785310268f, -0.382683396339f, 0.555570244789f, 1.000000000000f, 0.555570244789f, -0.382683396339f, -0.980785310268f,
+ -0.707106828690f, 0.195090413094f, 0.923879563808f, 0.831469655037f, 0.000000139071f, -0.831469774246f, -0.923879444599f, -0.195090219378f, },
+ { 0.707106649876f, -0.555570423603f, -0.923879504204f, 0.195090353489f, 1.000000000000f, 0.195090353489f, -0.923879504204f, -0.555570423603f,
+ 0.707106649876f, 0.831469655037f, -0.382683008909f, -0.980785369873f, -0.000000290067f, 0.980785250664f, 0.382683545351f, -0.831469595432f, },
+ { 0.707106769085f, 0.555570065975f, -0.923879504204f, -0.195090323687f, 1.000000000000f, -0.195090323687f, -0.923879504204f, 0.555570065975f,
+ 0.707106769085f, -0.831469774246f, -0.382683843374f, 0.980785250664f, -0.000000035775f, -0.980785250664f, 0.382683902979f, 0.831469714642f, },
+ { -0.707106590271f, 0.980785310268f, -0.382683575153f, -0.555570185184f, 1.000000000000f, -0.555570185184f, -0.382683575153f, 0.980785310268f,
+ -0.707106590271f, -0.195090219378f, 0.923879683018f, -0.831469595432f, -0.000000592058f, 0.831469714642f, -0.923879623413f, 0.195090919733f, },
+ { -0.707106530666f, 0.195090532303f, 0.382683604956f, -0.831469655037f, 1.000000000000f, -0.831469655037f, 0.382683604956f, 0.195090532303f,
+ -0.707106530666f, 0.980785310268f, -0.923879384995f, 0.555569529533f, -0.000000687457f, -0.555570006371f, 0.923879563808f, -0.980785191059f, },
+ { 0.707106828690f, -0.831469774246f, 0.923879563808f, -0.980785310268f, 1.000000000000f, -0.980785310268f, 0.923879563808f, -0.831469774246f,
+ 0.707106828690f, -0.555570065975f, 0.382683902979f, -0.195089668036f, 0.000000059624f, 0.195089548826f, -0.382683813572f, 0.555569946766f, },
+};
+static const float cosdata4[4][8] = {
+ { 0.707106769085f, 0.923879504204f, 1.000000000000f, 0.923879504204f, 0.707106769085f, 0.382683426142f, -0.000000043711f, -0.382683396339f, },
+ { -0.707106769085f, 0.382683426142f, 1.000000000000f, 0.382683426142f, -0.707106769085f, -0.923879504204f, 0.000000011925f, 0.923879563808f, },
+ { -0.707106828690f, -0.382683396339f, 1.000000000000f, -0.382683396339f, -0.707106828690f, 0.923879563808f, 0.000000139071f, -0.923879444599f, },
+ { 0.707106649876f, -0.923879504204f, 1.000000000000f, -0.923879504204f, 0.707106649876f, -0.382683008909f, -0.000000290067f, 0.382683545351f, },
+};
+static const float cosdecdata8[8][16] = {
+ { 0.707106769085f, 0.555570244789f, 0.382683426142f, 0.195090353489f, -0.000000043711f, -0.195090323687f, -0.382683396339f, -0.555570185184f,
+ -0.707106769085f, -0.831469655037f, -0.923879504204f, -0.980785310268f, -1.000000000000f, -0.980785310268f, -0.923879504204f, -0.831469535828f, },
+ { -0.707106769085f, -0.980785310268f, -0.923879504204f, -0.555570423603f, 0.000000011925f, 0.555570065975f, 0.923879563808f, 0.980785310268f,
+ 0.707106769085f, 0.195090532303f, -0.382683008909f, -0.831469774246f, -1.000000000000f, -0.831469714642f, -0.382683843374f, 0.195090577006f, },
+ { -0.707106828690f, 0.195090413094f, 0.923879563808f, 0.831469655037f, 0.000000139071f, -0.831469774246f, -0.923879444599f, -0.195090219378f,
+ 0.707106828690f, 0.980785310268f, 0.382683545351f, -0.555570065975f, -1.000000000000f, -0.555570542812f, 0.382683902979f, 0.980785191059f, },
+ { 0.707106649876f, 0.831469655037f, -0.382683008909f, -0.980785369873f, -0.000000290067f, 0.980785250664f, 0.382683545351f, -0.831469595432f,
+ -0.707107424736f, 0.555569529533f, 0.923879802227f, -0.195089668036f, -1.000000000000f, -0.195090815425f, 0.923879384995f, 0.555570483208f, },
+ { 0.707106769085f, -0.831469774246f, -0.382683843374f, 0.980785250664f, -0.000000035775f, -0.980785250664f, 0.382683902979f, 0.831469714642f,
+ -0.707106173038f, -0.555570006371f, 0.923879384995f, 0.195089548826f, -1.000000000000f, 0.195089697838f, 0.923879325390f, -0.555570125580f, },
+ { -0.707106590271f, -0.195090219378f, 0.923879683018f, -0.831469595432f, -0.000000592058f, 0.831469714642f, -0.923879623413f, 0.195090919733f,
+ 0.707107424736f, -0.980785191059f, 0.382683366537f, 0.555569946766f, -1.000000000000f, 0.555571198463f, 0.382683783770f, -0.980785667896f, },
+ { -0.707106530666f, 0.980785310268f, -0.923879384995f, 0.555569529533f, -0.000000687457f, -0.555570006371f, 0.923879563808f, -0.980785191059f,
+ 0.707106173038f, -0.195089071989f, -0.382684975863f, 0.831468641758f, -1.000000000000f, 0.831470131874f, -0.382683992386f, -0.195090129972f, },
+ { 0.707106828690f, -0.555570065975f, 0.382683902979f, -0.195089668036f, 0.000000059624f, 0.195089548826f, -0.382683813572f, 0.555569946766f,
+ -0.707106053829f, 0.831468641758f, -0.923880040646f, 0.980785369873f, -1.000000000000f, 0.980785429478f, -0.923880159855f, 0.831468760967f, },
+};
+static const float cosdecdata4[4][8] = {
+ { 0.707106769085f, 0.382683426142f, -0.000000043711f, -0.382683396339f, -0.707106769085f, -0.923879504204f, -1.000000000000f, -0.923879504204f, },
+ { -0.707106769085f, -0.923879504204f, 0.000000011925f, 0.923879563808f, 0.707106769085f, -0.382683008909f, -1.000000000000f, -0.382683843374f, },
+ { -0.707106828690f, 0.923879563808f, 0.000000139071f, -0.923879444599f, 0.707106828690f, 0.382683545351f, -1.000000000000f, 0.382683902979f, },
+ { 0.707106649876f, -0.382683008909f, -0.000000290067f, 0.382683545351f, -0.707107424736f, 0.923879802227f, -1.000000000000f, 0.923879384995f, },
+};
diff --git a/lib/virtual_oss/bt/sbc_encode.h b/lib/virtual_oss/bt/sbc_encode.h
new file mode 100644
--- /dev/null
+++ b/lib/virtual_oss/bt/sbc_encode.h
@@ -0,0 +1,82 @@
+/* $NetBSD$ */
+
+/*-
+ * Copyright (c) 2015 Nathanial Sloss <nathanialsloss@yahoo.com.au>
+ *
+ * This software is dedicated to the memory of -
+ * Baron James Anlezark (Barry) - 1 Jan 1949 - 13 May 2012.
+ *
+ * Barry was a man who loved his music.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _SBC_ENCODE_H_
+#define _SBC_ENCODE_H_
+
+#define MIN_BITPOOL 2
+#define DEFAULT_MAXBPOOL 250
+
+/*
+ * SBC header format
+ */
+struct sbc_header {
+ uint8_t id;
+ uint8_t id2;
+ uint8_t seqnumMSB;
+ uint8_t seqnumLSB;
+ uint8_t ts3;
+ uint8_t ts2;
+ uint8_t ts1;
+ uint8_t ts0;
+ uint8_t reserved3;
+ uint8_t reserved2;
+ uint8_t reserved1;
+ uint8_t reserved0;
+ uint8_t numFrames;
+};
+
+struct sbc_encode {
+ int16_t music_data[256];
+ uint8_t data[1024];
+ uint8_t *rem_data_ptr;
+ int rem_data_len;
+ int rem_data_frames;
+ int bits[2][8];
+ float output[256];
+ float left[160];
+ float right[160];
+ float samples[16][2][8];
+ uint32_t rem_len;
+ uint32_t rem_off;
+ uint32_t bitoffset;
+ uint32_t maxoffset;
+ uint32_t crc;
+ uint16_t framesamples;
+ uint8_t scalefactor[2][8];
+ uint8_t channels;
+ uint8_t bands;
+ uint8_t blocks;
+ uint8_t join;
+};
+
+#endif /* _SBC_ENCODE_H_ */
diff --git a/lib/virtual_oss/bt/sbc_encode.c b/lib/virtual_oss/bt/sbc_encode.c
new file mode 100644
--- /dev/null
+++ b/lib/virtual_oss/bt/sbc_encode.c
@@ -0,0 +1,701 @@
+/*-
+ * Copyright (c) 2015 Nathanial Sloss <nathanialsloss@yahoo.com.au>
+ *
+ * This software is dedicated to the memory of -
+ * Baron James Anlezark (Barry) - 1 Jan 1949 - 13 May 2012.
+ *
+ * Barry was a man who loved his music.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/endian.h>
+#include <sys/uio.h>
+
+#include <stdio.h>
+#include <errno.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <math.h>
+
+#include "sbc_coeffs.h"
+#include "bt.h"
+
+#define SYNCWORD 0x9c
+#define ABS(x) (((x) < 0) ? -(x) : (x))
+#define BIT30 (1U << 30)
+#define BM(x) ((1LL << (x)) - 1LL)
+
+/* Loudness offset allocations. */
+static const int loudnessoffset8[4][8] = {
+ {-2, 0, 0, 0, 0, 0, 0, 1},
+ {-3, 0, 0, 0, 0, 0, 1, 2},
+ {-4, 0, 0, 0, 0, 0, 1, 2},
+ {-4, 0, 0, 0, 0, 0, 1, 2},
+};
+
+static const int loudnessoffset4[4][4] = {
+ {-1, 0, 0, 0},
+ {-2, 0, 0, 1},
+ {-2, 0, 0, 1},
+ {-2, 0, 0, 1},
+};
+
+static uint8_t
+calc_scalefactors_joint(struct sbc_encode *sbc)
+{
+ float sb_j[16][2];
+ uint32_t x;
+ uint32_t y;
+ uint8_t block;
+ uint8_t joint;
+ uint8_t sb;
+ uint8_t lz;
+
+ joint = 0;
+ for (sb = 0; sb != sbc->bands - 1; sb++) {
+ for (block = 0; block < sbc->blocks; block++) {
+ sb_j[block][0] = (sbc->samples[block][0][sb] +
+ sbc->samples[block][1][sb]) / 2.0f;
+ sb_j[block][1] = (sbc->samples[block][0][sb] -
+ sbc->samples[block][1][sb]) / 2.0f;
+ }
+
+ x = 1 << 15;
+ y = 1 << 15;
+ for (block = 0; block < sbc->blocks; block++) {
+ x |= (uint32_t)ABS(sb_j[block][0]);
+ y |= (uint32_t)ABS(sb_j[block][1]);
+ }
+
+ lz = 1;
+ while (!(x & BIT30)) {
+ lz++;
+ x <<= 1;
+ }
+ x = 16 - lz;
+
+ lz = 1;
+ while (!(y & BIT30)) {
+ lz++;
+ y <<= 1;
+ }
+ y = 16 - lz;
+
+ if ((sbc->scalefactor[0][sb] + sbc->scalefactor[1][sb]) > x + y) {
+ joint |= 1 << (sbc->bands - sb - 1);
+ sbc->scalefactor[0][sb] = x;
+ sbc->scalefactor[1][sb] = y;
+ for (block = 0; block < sbc->blocks; block++) {
+ sbc->samples[block][0][sb] = sb_j[block][0];
+ sbc->samples[block][1][sb] = sb_j[block][1];
+ }
+ }
+ }
+ return (joint);
+}
+
+static void
+calc_scalefactors(struct sbc_encode *sbc)
+{
+ uint8_t block;
+ uint8_t ch;
+ uint8_t sb;
+
+ for (ch = 0; ch != sbc->channels; ch++) {
+ for (sb = 0; sb != sbc->bands; sb++) {
+ uint32_t x = 1 << 15;
+ uint8_t lx = 1;
+
+ for (block = 0; block != sbc->blocks; block++)
+ x |= (uint32_t)ABS(sbc->samples[block][ch][sb]);
+
+ while (!(x & BIT30)) {
+ lx++;
+ x <<= 1;
+ }
+ sbc->scalefactor[ch][sb] = 16 - lx;
+ }
+ }
+}
+
+static void
+calc_bitneed(struct bt_config *cfg)
+{
+ struct sbc_encode *sbc = cfg->handle.sbc_enc;
+ int32_t bitneed[2][8];
+ int32_t max_bitneed, bitcount;
+ int32_t slicecount, bitslice;
+ int32_t loudness;
+ int ch, sb, start_chan = 0;
+
+ if (cfg->chmode == MODE_DUAL)
+ sbc->channels = 1;
+
+next_chan:
+ max_bitneed = 0;
+ bitcount = 0;
+ slicecount = 0;
+
+ if (cfg->allocm == ALLOC_SNR) {
+ for (ch = start_chan; ch < sbc->channels; ch++) {
+ for (sb = 0; sb < sbc->bands; sb++) {
+ bitneed[ch][sb] = sbc->scalefactor[ch][sb];
+
+ if (bitneed[ch][sb] > max_bitneed)
+ max_bitneed = bitneed[ch][sb];
+ }
+ }
+ } else {
+ for (ch = start_chan; ch < sbc->channels; ch++) {
+ for (sb = 0; sb < sbc->bands; sb++) {
+ if (sbc->scalefactor[ch][sb] == 0) {
+ bitneed[ch][sb] = -5;
+ } else {
+ if (sbc->bands == 8) {
+ loudness = sbc->scalefactor[ch][sb] -
+ loudnessoffset8[cfg->freq][sb];
+ } else {
+ loudness = sbc->scalefactor[ch][sb] -
+ loudnessoffset4[cfg->freq][sb];
+ }
+ if (loudness > 0)
+ bitneed[ch][sb] = loudness / 2;
+ else
+ bitneed[ch][sb] = loudness;
+ }
+ if (bitneed[ch][sb] > max_bitneed)
+ max_bitneed = bitneed[ch][sb];
+ }
+ }
+ }
+
+ slicecount = bitcount = 0;
+ bitslice = max_bitneed + 1;
+ do {
+ bitslice--;
+ bitcount += slicecount;
+ slicecount = 0;
+ for (ch = start_chan; ch < sbc->channels; ch++) {
+ for (sb = 0; sb < sbc->bands; sb++) {
+ if ((bitneed[ch][sb] > bitslice + 1) &&
+ (bitneed[ch][sb] < bitslice + 16))
+ slicecount++;
+ else if (bitneed[ch][sb] == bitslice + 1)
+ slicecount += 2;
+ }
+ }
+ } while (bitcount + slicecount < cfg->bitpool);
+
+ /* check if exactly one more fits */
+ if (bitcount + slicecount == cfg->bitpool) {
+ bitcount += slicecount;
+ bitslice--;
+ }
+ for (ch = start_chan; ch < sbc->channels; ch++) {
+ for (sb = 0; sb < sbc->bands; sb++) {
+ if (bitneed[ch][sb] < bitslice + 2) {
+ sbc->bits[ch][sb] = 0;
+ } else {
+ sbc->bits[ch][sb] = bitneed[ch][sb] - bitslice;
+ if (sbc->bits[ch][sb] > 16)
+ sbc->bits[ch][sb] = 16;
+ }
+ }
+ }
+
+ if (cfg->chmode == MODE_DUAL)
+ ch = start_chan;
+ else
+ ch = 0;
+ sb = 0;
+ while (bitcount < cfg->bitpool && sb < sbc->bands) {
+ if ((sbc->bits[ch][sb] >= 2) && (sbc->bits[ch][sb] < 16)) {
+ sbc->bits[ch][sb]++;
+ bitcount++;
+ } else if ((bitneed[ch][sb] == bitslice + 1) &&
+ (cfg->bitpool > bitcount + 1)) {
+ sbc->bits[ch][sb] = 2;
+ bitcount += 2;
+ }
+ if (sbc->channels == 1 || start_chan == 1)
+ sb++;
+ else if (ch == 1) {
+ ch = 0;
+ sb++;
+ } else
+ ch = 1;
+ }
+
+ if (cfg->chmode == MODE_DUAL)
+ ch = start_chan;
+ else
+ ch = 0;
+ sb = 0;
+ while (bitcount < cfg->bitpool && sb < sbc->bands) {
+ if (sbc->bits[ch][sb] < 16) {
+ sbc->bits[ch][sb]++;
+ bitcount++;
+ }
+ if (sbc->channels == 1 || start_chan == 1)
+ sb++;
+ else if (ch == 1) {
+ ch = 0;
+ sb++;
+ } else
+ ch = 1;
+ }
+
+ if (cfg->chmode == MODE_DUAL && start_chan == 0) {
+ start_chan = 1;
+ sbc->channels = 2;
+ goto next_chan;
+ }
+}
+
+static void
+sbc_store_bits_crc(struct sbc_encode *sbc, uint32_t numbits, uint32_t value)
+{
+ uint32_t off = sbc->bitoffset;
+
+ while (numbits-- && off != sbc->maxoffset) {
+ if (value & (1 << numbits)) {
+ sbc->data[off / 8] |= 1 << ((7 - off) & 7);
+ sbc->crc ^= 0x80;
+ }
+ sbc->crc *= 2;
+ if (sbc->crc & 0x100)
+ sbc->crc ^= 0x11d; /* CRC-8 polynomial */
+
+ off++;
+ }
+ sbc->bitoffset = off;
+}
+
+static int
+sbc_encode(struct bt_config *cfg)
+{
+ struct sbc_encode *sbc = cfg->handle.sbc_enc;
+ const int16_t *input = sbc->music_data;
+ float delta[2][8];
+ float levels[2][8];
+ float mask[2][8];
+ float S;
+ float *X;
+ float Z[80];
+ float Y[80];
+ float audioout;
+ int16_t left[8];
+ int16_t right[8];
+ int16_t *data;
+ int numsamples;
+ int i;
+ int k;
+ int block;
+ int chan;
+ int sb;
+
+ for (block = 0; block < sbc->blocks; block++) {
+
+ for (i = 0; i < sbc->bands; i++) {
+ left[i] = *input++;
+ if (sbc->channels == 2)
+ right[i] = *input++;
+ }
+
+ for (chan = 0; chan < sbc->channels; chan++) {
+
+ /* select right or left channel */
+ if (chan == 0) {
+ X = sbc->left;
+ data = left;
+ } else {
+ X = sbc->right;
+ data = right;
+ }
+
+ /* shift up old data */
+ for (i = (sbc->bands * 10) - 1; i > sbc->bands - 1; i--)
+ X[i] = X[i - sbc->bands];
+ k = 0;
+ for (i = sbc->bands - 1; i >= 0; i--)
+ X[i] = data[k++];
+ for (i = 0; i < sbc->bands * 10; i++) {
+ if (sbc->bands == 8)
+ Z[i] = sbc_coeffs8[i] * X[i];
+ else
+ Z[i] = sbc_coeffs4[i] * X[i];
+ }
+ for (i = 0; i < sbc->bands * 2; i++) {
+ Y[i] = 0;
+ for (k = 0; k < 5; k++)
+ Y[i] += Z[i + k * sbc->bands * 2];
+ }
+ for (i = 0; i < sbc->bands; i++) {
+ S = 0;
+ for (k = 0; k < sbc->bands * 2; k++) {
+ if (sbc->bands == 8) {
+ S += cosdata8[i][k] * Y[k];
+ } else {
+ S += cosdata4[i][k] * Y[k];
+ }
+ }
+ sbc->samples[block][chan][i] = S * (1 << 15);
+ }
+ }
+ }
+
+ calc_scalefactors(sbc);
+
+ if (cfg->chmode == MODE_JOINT)
+ sbc->join = calc_scalefactors_joint(sbc);
+ else
+ sbc->join = 0;
+
+ calc_bitneed(cfg);
+
+ for (chan = 0; chan < sbc->channels; chan++) {
+ for (sb = 0; sb < sbc->bands; sb++) {
+ if (sbc->bits[chan][sb] == 0)
+ continue;
+ mask[chan][sb] = BM(sbc->bits[chan][sb]);
+ levels[chan][sb] = mask[chan][sb] *
+ (1LL << (15 - sbc->scalefactor[chan][sb]));
+ delta[chan][sb] =
+ (1LL << (sbc->scalefactor[chan][sb] + 16));
+ }
+ }
+
+ numsamples = 0;
+ for (block = 0; block < sbc->blocks; block++) {
+ for (chan = 0; chan < sbc->channels; chan++) {
+ for (sb = 0; sb < sbc->bands; sb++) {
+ if (sbc->bits[chan][sb] == 0)
+ continue;
+ audioout = (levels[chan][sb] *
+ (delta[chan][sb] + sbc->samples[block][chan][sb]));
+ audioout /= (1LL << 32);
+
+ audioout = roundf(audioout);
+
+ /* range check */
+ if (audioout > mask[chan][sb])
+ audioout = mask[chan][sb];
+
+ sbc->output[numsamples++] = audioout;
+ }
+ }
+ }
+ return (numsamples);
+}
+
+static void
+sbc_decode(struct bt_config *cfg)
+{
+ struct sbc_encode *sbc = cfg->handle.sbc_enc;
+ float delta[2][8];
+ float levels[2][8];
+ float audioout;
+ float *X;
+ float *V;
+ float left[160];
+ float right[160];
+ float U[160];
+ float W[160];
+ float S[8];
+ int position;
+ int block;
+ int chan;
+ int sb;
+ int i;
+ int k;
+
+ for (chan = 0; chan < sbc->channels; chan++) {
+ for (sb = 0; sb < sbc->bands; sb++) {
+ levels[chan][sb] = (1 << sbc->bits[chan][sb]) - 1;
+ delta[chan][sb] = (1 << sbc->scalefactor[chan][sb]);
+ }
+ }
+
+ i = 0;
+ for (block = 0; block < sbc->blocks; block++) {
+ for (chan = 0; chan < sbc->channels; chan++) {
+ for (sb = 0; sb < sbc->bands; sb++) {
+ if (sbc->bits[chan][sb] == 0) {
+ audioout = 0;
+ } else {
+ audioout =
+ ((((sbc->output[i] * 2.0f) + 1.0f) * delta[chan][sb]) /
+ levels[chan][sb]) - delta[chan][sb];
+ }
+ sbc->output[i++] = audioout;
+ }
+ }
+ }
+
+ if (cfg->chmode == MODE_JOINT) {
+ i = 0;
+ while (i < (sbc->blocks * sbc->bands * sbc->channels)) {
+ for (sb = 0; sb < sbc->bands; sb++) {
+ if (sbc->join & (1 << (sbc->bands - sb - 1))) {
+ audioout = sbc->output[i];
+ sbc->output[i] = (2.0f * sbc->output[i]) +
+ (2.0f * sbc->output[i + sbc->bands]);
+ sbc->output[i + sbc->bands] =
+ (2.0f * audioout) -
+ (2.0f * sbc->output[i + sbc->bands]);
+ sbc->output[i] /= 2.0f;
+ sbc->output[i + sbc->bands] /= 2.0f;
+ }
+ i++;
+ }
+ i += sbc->bands;
+ }
+ }
+ position = 0;
+ for (block = 0; block < sbc->blocks; block++) {
+ for (chan = 0; chan < sbc->channels; chan++) {
+ /* select right or left channel */
+ if (chan == 0) {
+ X = left;
+ V = sbc->left;
+ } else {
+ X = right;
+ V = sbc->right;
+ }
+ for (i = 0; i < sbc->bands; i++)
+ S[i] = sbc->output[position++];
+
+ for (i = (sbc->bands * 20) - 1; i >= (sbc->bands * 2); i--)
+ V[i] = V[i - (sbc->bands * 2)];
+ for (k = 0; k < sbc->bands * 2; k++) {
+ float vk = 0;
+ for (i = 0; i < sbc->bands; i++) {
+ if (sbc->bands == 8) {
+ vk += cosdecdata8[i][k] * S[i];
+ } else {
+ vk += cosdecdata4[i][k] * S[i];
+ }
+ }
+ V[k] = vk;
+ }
+ for (i = 0; i <= 4; i++) {
+ for (k = 0; k < sbc->bands; k++) {
+ U[(i * sbc->bands * 2) + k] =
+ V[(i * sbc->bands * 4) + k];
+ U[(i * sbc->bands
+ * 2) + sbc->bands + k] =
+ V[(i * sbc->bands * 4) +
+ (sbc->bands * 3) + k];
+ }
+ }
+ for (i = 0; i < sbc->bands * 10; i++) {
+ if (sbc->bands == 4) {
+ W[i] = U[i] * (sbc_coeffs4[i] * -4.0f);
+ } else if (sbc->bands == 8) {
+ W[i] = U[i] * (sbc_coeffs8[i] * -8.0f);
+ } else {
+ W[i] = 0;
+ }
+ }
+
+ for (k = 0; k < sbc->bands; k++) {
+ unsigned int offset = k + (block * sbc->bands);
+
+ X[offset] = 0;
+ for (i = 0; i < 10; i++) {
+ X[offset] += W[k + (i * sbc->bands)];
+ }
+
+ if (X[offset] > 32767.0)
+ X[offset] = 32767.0;
+ else if (X[offset] < -32767.0)
+ X[offset] = -32767.0;
+ }
+ }
+ }
+
+ for (i = 0, k = 0; k != (sbc->blocks * sbc->bands); k++) {
+ sbc->music_data[i++] = left[k];
+ if (sbc->channels == 2)
+ sbc->music_data[i++] = right[k];
+ }
+}
+
+size_t
+sbc_encode_frame(struct bt_config *cfg)
+{
+ struct sbc_encode *sbc = cfg->handle.sbc_enc;
+ uint8_t config;
+ uint8_t block;
+ uint8_t chan;
+ uint8_t sb;
+ uint8_t j;
+ uint8_t i;
+
+ config = (cfg->freq << 6) | (cfg->blocks << 4) |
+ (cfg->chmode << 2) | (cfg->allocm << 1) | cfg->bands;
+
+ sbc_encode(cfg);
+
+ /* set initial CRC */
+ sbc->crc = 0x5e;
+
+ /* reset data position and size */
+ sbc->bitoffset = 0;
+ sbc->maxoffset = sizeof(sbc->data) * 8;
+
+ sbc_store_bits_crc(sbc, 8, SYNCWORD);
+ sbc_store_bits_crc(sbc, 8, config);
+ sbc_store_bits_crc(sbc, 8, cfg->bitpool);
+
+ /* skip 8-bit CRC */
+ sbc->bitoffset += 8;
+
+ if (cfg->chmode == MODE_JOINT) {
+ if (sbc->bands == 8)
+ sbc_store_bits_crc(sbc, 8, sbc->join);
+ else if (sbc->bands == 4)
+ sbc_store_bits_crc(sbc, 4, sbc->join);
+ }
+ for (i = 0; i < sbc->channels; i++) {
+ for (j = 0; j < sbc->bands; j++)
+ sbc_store_bits_crc(sbc, 4, sbc->scalefactor[i][j]);
+ }
+
+ /* store 8-bit CRC */
+ sbc->data[3] = (sbc->crc & 0xFF);
+
+ i = 0;
+ for (block = 0; block < sbc->blocks; block++) {
+ for (chan = 0; chan < sbc->channels; chan++) {
+ for (sb = 0; sb < sbc->bands; sb++) {
+ if (sbc->bits[chan][sb] == 0)
+ continue;
+
+ sbc_store_bits_crc(sbc, sbc->bits[chan][sb], sbc->output[i++]);
+ }
+ }
+ }
+ return ((sbc->bitoffset + 7) / 8);
+}
+
+static uint32_t
+sbc_load_bits_crc(struct sbc_encode *sbc, uint32_t numbits)
+{
+ uint32_t off = sbc->bitoffset;
+ uint32_t value = 0;
+
+ while (numbits-- && off != sbc->maxoffset) {
+ if (sbc->rem_data_ptr[off / 8] & (1 << ((7 - off) & 7))) {
+ value |= (1 << numbits);
+ sbc->crc ^= 0x80;
+ }
+ sbc->crc *= 2;
+ if (sbc->crc & 0x100)
+ sbc->crc ^= 0x11d; /* CRC-8 polynomial */
+
+ off++;
+ }
+ sbc->bitoffset = off;
+ return (value);
+}
+
+size_t
+sbc_decode_frame(struct bt_config *cfg, int bits)
+{
+ struct sbc_encode *sbc = cfg->handle.sbc_enc;
+ uint8_t config;
+ uint8_t block;
+ uint8_t chan;
+ uint8_t sb;
+ uint8_t j;
+ uint8_t i;
+
+ sbc->rem_off = 0;
+ sbc->rem_len = 0;
+
+ config = (cfg->freq << 6) | (cfg->blocks << 4) |
+ (cfg->chmode << 2) | (cfg->allocm << 1) | cfg->bands;
+
+ /* set initial CRC */
+ sbc->crc = 0x5e;
+
+ /* reset data position and size */
+ sbc->bitoffset = 0;
+ sbc->maxoffset = bits;
+
+ /* verify SBC header */
+ if (sbc->maxoffset < (8 * 4))
+ return (0);
+ if (sbc_load_bits_crc(sbc, 8) != SYNCWORD)
+ return (0);
+ if (sbc_load_bits_crc(sbc, 8) != config)
+ return (0);
+ cfg->bitpool = sbc_load_bits_crc(sbc, 8);
+
+ (void)sbc_load_bits_crc(sbc, 8);/* CRC */
+
+ if (cfg->chmode == MODE_JOINT) {
+ if (sbc->bands == 8)
+ sbc->join = sbc_load_bits_crc(sbc, 8);
+ else if (sbc->bands == 4)
+ sbc->join = sbc_load_bits_crc(sbc, 4);
+ else
+ sbc->join = 0;
+ } else {
+ sbc->join = 0;
+ }
+
+ for (i = 0; i < sbc->channels; i++) {
+ for (j = 0; j < sbc->bands; j++)
+ sbc->scalefactor[i][j] = sbc_load_bits_crc(sbc, 4);
+ }
+
+ calc_bitneed(cfg);
+
+ i = 0;
+ for (block = 0; block < sbc->blocks; block++) {
+ for (chan = 0; chan < sbc->channels; chan++) {
+ for (sb = 0; sb < sbc->bands; sb++) {
+ if (sbc->bits[chan][sb] == 0) {
+ i++;
+ continue;
+ }
+ sbc->output[i++] =
+ sbc_load_bits_crc(sbc, sbc->bits[chan][sb]);
+ }
+ }
+ }
+
+ sbc_decode(cfg);
+
+ sbc->rem_off = 0;
+ sbc->rem_len = sbc->blocks * sbc->channels * sbc->bands;
+
+ return ((sbc->bitoffset + 7) / 8);
+}
diff --git a/lib/virtual_oss/null/Makefile b/lib/virtual_oss/null/Makefile
new file mode 100644
--- /dev/null
+++ b/lib/virtual_oss/null/Makefile
@@ -0,0 +1,10 @@
+SHLIB_NAME= voss_null.so
+SHLIBDIR= ${LIBDIR}/virtual_oss
+
+SRCS= null.c
+
+CFLAGS+= -I${SRCTOP}/usr.sbin/virtual_oss/virtual_oss \
+ -I${SRCTOP}/contrib/libsamplerate
+LIBADD= samplerate
+
+.include <bsd.lib.mk>
diff --git a/lib/virtual_oss/null/null.c b/lib/virtual_oss/null/null.c
new file mode 100644
--- /dev/null
+++ b/lib/virtual_oss/null/null.c
@@ -0,0 +1,102 @@
+/*-
+ * Copyright (c) 2015-2022 Hans Petter Selasky
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/queue.h>
+#include <sys/filio.h>
+#include <sys/soundcard.h>
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <err.h>
+#include <time.h>
+
+#include "backend.h"
+#include "int.h"
+
+static void
+null_close(struct voss_backend *pbe __unused)
+{
+}
+
+static int
+null_open(struct voss_backend *pbe __unused, const char *devname __unused,
+ int samplerate __unused, int bufsize __unused, int *pchannels __unused,
+ int *pformat)
+{
+ int value[3];
+ int i;
+
+ value[0] = *pformat & VPREFERRED_SNE_AFMT;
+ value[1] = *pformat & VPREFERRED_SLE_AFMT;
+ value[2] = *pformat & VPREFERRED_SBE_AFMT;
+
+ for (i = 0; i != 3; i++) {
+ if (value[i] == 0)
+ continue;
+ *pformat = value[i];
+ return (0);
+ }
+ return (-1);
+}
+
+static int
+null_rec_transfer(struct voss_backend *pbe __unused, void *ptr, int len)
+{
+
+ if (voss_has_synchronization == 0)
+ virtual_oss_wait();
+ memset(ptr, 0, len);
+ return (len);
+}
+
+static int
+null_play_transfer(struct voss_backend *pbe __unused, void *ptr __unused,
+ int len)
+{
+ return (len);
+}
+
+static void
+null_delay(struct voss_backend *pbe __unused, int *pdelay)
+{
+ *pdelay = -1;
+}
+
+struct voss_backend voss_backend_null_rec = {
+ .open = null_open,
+ .close = null_close,
+ .transfer = null_rec_transfer,
+ .delay = null_delay,
+};
+
+struct voss_backend voss_backend_null_play = {
+ .open = null_open,
+ .close = null_close,
+ .transfer = null_play_transfer,
+ .delay = null_delay,
+};
diff --git a/lib/virtual_oss/oss/Makefile b/lib/virtual_oss/oss/Makefile
new file mode 100644
--- /dev/null
+++ b/lib/virtual_oss/oss/Makefile
@@ -0,0 +1,10 @@
+SHLIB_NAME= voss_oss.so
+SHLIBDIR= ${LIBDIR}/virtual_oss
+
+SRCS= oss.c
+
+CFLAGS+= -I${SRCTOP}/usr.sbin/virtual_oss/virtual_oss \
+ -I${SRCTOP}/contrib/libsamplerate
+LIBADD= samplerate
+
+.include <bsd.lib.mk>
diff --git a/lib/virtual_oss/oss/oss.c b/lib/virtual_oss/oss/oss.c
new file mode 100644
--- /dev/null
+++ b/lib/virtual_oss/oss/oss.c
@@ -0,0 +1,197 @@
+/*-
+ * Copyright (c) 2015-2019 Hans Petter Selasky
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/queue.h>
+#include <sys/filio.h>
+#include <sys/soundcard.h>
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <err.h>
+#include <poll.h>
+
+#include "backend.h"
+#include "int.h"
+
+static int
+oss_set_format(int fd, int *format)
+{
+ int value[6];
+ int error;
+ int fmt;
+ int i;
+
+ value[0] = *format & VPREFERRED_SNE_AFMT;
+ value[1] = *format & VPREFERRED_UNE_AFMT;
+ value[2] = *format & VPREFERRED_SLE_AFMT;
+ value[3] = *format & VPREFERRED_SBE_AFMT;
+ value[4] = *format & VPREFERRED_ULE_AFMT;
+ value[5] = *format & VPREFERRED_UBE_AFMT;
+
+ for (i = 0; i != 6; i++) {
+ fmt = value[i];
+ if (fmt == 0)
+ continue;
+ error = ioctl(fd, SNDCTL_DSP_SETFMT, &fmt);
+ /* make sure we got the format we asked for */
+ if (error == 0 && fmt == value[i]) {
+ *format = fmt;
+ return (0);
+ }
+ }
+ return (-1);
+}
+
+static void
+oss_close(struct voss_backend *pbe)
+{
+ if (pbe->fd > -1) {
+ close(pbe->fd);
+ pbe->fd = -1;
+ }
+}
+
+static int
+oss_open(struct voss_backend *pbe, const char *devname, int samplerate,
+ int bufsize, int *pchannels, int *pformat, int attr, int fionbio)
+{
+ int temp;
+ int err;
+
+ pbe->fd = open(devname, attr);
+ if (pbe->fd < 0) {
+ warn("Could not open DSP device '%s'", devname);
+ return (-1);
+ }
+ err = ioctl(pbe->fd, FIONBIO, &fionbio);
+ if (err < 0) {
+ warn("Could not set blocking mode on DSP");
+ goto error;
+ }
+ err = oss_set_format(pbe->fd, pformat);
+ if (err < 0) {
+ warn("Could not set sample format 0x%08x", *pformat);
+ goto error;
+ }
+ temp = *pchannels;
+ bufsize /= temp; /* get buffer size per channel */
+ do {
+ err = ioctl(pbe->fd, SOUND_PCM_WRITE_CHANNELS, &temp);
+ } while (err < 0 && --temp > 0);
+
+ err = ioctl(pbe->fd, SOUND_PCM_READ_CHANNELS, &temp);
+ if (err < 0 || temp <= 0 || temp > *pchannels) {
+ warn("Could not set DSP channels: %d / %d", temp, *pchannels);
+ goto error;
+ }
+ *pchannels = temp;
+
+ temp = samplerate;
+ err = ioctl(pbe->fd, SNDCTL_DSP_SPEED, &temp);
+ if (err < 0 || temp != samplerate) {
+ warn("Could not set sample rate to %d / %d Hz", temp, samplerate);
+ goto error;
+ }
+
+ temp = bufsize * (*pchannels);
+ err = ioctl(pbe->fd, SNDCTL_DSP_SETBLKSIZE, &temp);
+ if (err < 0) {
+ warn("Could not set block size to %d", temp);
+ goto error;
+ }
+ return (0);
+error:
+ close(pbe->fd);
+ pbe->fd = -1;
+ return (-1);
+}
+
+static int
+oss_rec_open(struct voss_backend *pbe, const char *devname, int samplerate,
+ int bufsize, int *pchannels, int *pformat)
+{
+ return (oss_open(pbe, devname, samplerate, bufsize, pchannels, pformat, O_RDONLY, 0));
+}
+
+static int
+oss_play_open(struct voss_backend *pbe, const char *devname, int samplerate,
+ int bufsize, int *pchannels, int *pformat)
+{
+ bufsize *= 4; /* XXX allow extra space for jitter */
+ return (oss_open(pbe, devname, samplerate, bufsize, pchannels, pformat, O_WRONLY, 0));
+}
+
+static int
+oss_rec_transfer(struct voss_backend *pbe, void *ptr, int len)
+{
+ struct pollfd fds = { .fd = pbe->fd, .events = POLLIN | POLLRDNORM };
+ int err;
+
+ /* wait at maximum 2 seconds for data, else something is wrong */
+ err = poll(&fds, 1, 2000);
+ if (err < 1)
+ return (-1);
+ return (read(pbe->fd, ptr, len));
+}
+
+static int
+oss_play_transfer(struct voss_backend *pbe, void *ptr, int len)
+{
+ return (write(pbe->fd, ptr, len));
+}
+
+static void
+oss_rec_delay(struct voss_backend *pbe, int *pdelay)
+{
+ if (ioctl(pbe->fd, FIONREAD, pdelay) != 0)
+ *pdelay = -1;
+}
+
+static void
+oss_play_delay(struct voss_backend *pbe, int *pdelay)
+{
+ if (voss_has_synchronization != 0 ||
+ ioctl(pbe->fd, SNDCTL_DSP_GETODELAY, pdelay) != 0)
+ *pdelay = -1;
+}
+
+struct voss_backend voss_backend_oss_rec = {
+ .open = oss_rec_open,
+ .close = oss_close,
+ .transfer = oss_rec_transfer,
+ .delay = oss_rec_delay,
+ .fd = -1,
+};
+
+struct voss_backend voss_backend_oss_play = {
+ .open = oss_play_open,
+ .close = oss_close,
+ .transfer = oss_play_transfer,
+ .delay = oss_play_delay,
+ .fd = -1,
+};
diff --git a/lib/virtual_oss/sndio/Makefile b/lib/virtual_oss/sndio/Makefile
new file mode 100644
--- /dev/null
+++ b/lib/virtual_oss/sndio/Makefile
@@ -0,0 +1,12 @@
+SHLIB_NAME= voss_sndio.so
+SHLIBDIR= ${LIBDIR}/virtual_oss
+
+SRCS= sndio.c
+
+CFLAGS+= -I${SRCTOP}/usr.sbin/virtual_oss/virtual_oss \
+ -I${SRCTOP}/contrib/libsamplerate \
+ -I${LOCALBASE:U/usr/local}/include
+LDFLAGS+= -L${LOCALBASE:U/usr/local}/lib -lsndio
+LIBADD= samplerate
+
+.include <bsd.lib.mk>
diff --git a/lib/virtual_oss/sndio/sndio.c b/lib/virtual_oss/sndio/sndio.c
new file mode 100644
--- /dev/null
+++ b/lib/virtual_oss/sndio/sndio.c
@@ -0,0 +1,203 @@
+/*-
+ * Copyright (c) 2021 Tim Creech <tcreech@tcreech.com>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/queue.h>
+#include <sys/soundcard.h>
+
+#include <err.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <sndio.h>
+
+#include "backend.h"
+#include "int.h"
+
+static struct sio_hdl *
+get_sio_hdl(struct voss_backend *pbe)
+{
+ if (pbe)
+ return (pbe->arg);
+
+ return (NULL);
+}
+
+static void
+sndio_close(struct voss_backend *pbe)
+{
+ if (!pbe)
+ return;
+
+ if (get_sio_hdl(pbe))
+ sio_close(get_sio_hdl(pbe));
+}
+
+static int
+sndio_get_signedness(int *fmt)
+{
+ int s_fmt = *fmt & (VPREFERRED_SLE_AFMT | VPREFERRED_SBE_AFMT);
+
+ if (s_fmt) {
+ *fmt = s_fmt;
+ return (1);
+ }
+ *fmt = *fmt & (VPREFERRED_ULE_AFMT | VPREFERRED_UBE_AFMT);
+ return (0);
+}
+
+static int
+sndio_get_endianness_is_le(int *fmt)
+{
+ int le_fmt = *fmt & (VPREFERRED_SLE_AFMT | VPREFERRED_ULE_AFMT);
+
+ if (le_fmt) {
+ *fmt = le_fmt;
+ return (1);
+ }
+ *fmt = *fmt & (VPREFERRED_SBE_AFMT | VPREFERRED_UBE_AFMT);
+ return (0);
+}
+
+static int
+sndio_get_bits(int *fmt)
+{
+ if (*fmt & AFMT_16BIT)
+ return (16);
+ if (*fmt & AFMT_24BIT)
+ return (24);
+ if (*fmt & AFMT_32BIT)
+ return (32);
+ if (*fmt & AFMT_8BIT)
+ return (8);
+ return (-1);
+ /* TODO AFMT_BIT */
+}
+
+static int
+sndio_open(struct voss_backend *pbe, const char *devname,
+ int samplerate, int bufsize, int *pchannels, int *pformat, int direction)
+{
+ const char *sndio_name = devname + strlen("/dev/sndio/");
+
+ int sig = sndio_get_signedness(pformat);
+ int le = sndio_get_endianness_is_le(pformat);
+ int bits = sndio_get_bits(pformat);
+
+ if (bits == -1) {
+ warn("unsupported format precision");
+ return (-1);
+ }
+
+ struct sio_hdl *hdl = sio_open(sndio_name, direction, 0);
+
+ if (hdl == 0) {
+ warn("sndio: failed to open device");
+ return (-1);
+ }
+
+ struct sio_par par;
+
+ sio_initpar(&par);
+ par.pchan = *pchannels;
+ par.sig = sig;
+ par.bits = bits;
+ par.bps = SIO_BPS(bits);
+ par.le = le;
+ par.rate = samplerate;
+ par.appbufsz = bufsize;
+ par.xrun = SIO_SYNC;
+ if (!sio_setpar(hdl, &par))
+ errx(1, "internal error, sio_setpar() failed");
+ if (!sio_getpar(hdl, &par))
+ errx(1, "internal error, sio_getpar() failed");
+ if ((int)par.pchan != *pchannels)
+ errx(1, "couldn't set number of channels");
+ if ((int)par.sig != sig || (int)par.bits != bits || (int)par.le != le)
+ errx(1, "couldn't set format");
+ if ((int)par.bits != bits)
+ errx(1, "couldn't set precision");
+ if ((int)par.rate < samplerate * 995 / 1000 ||
+ (int)par.rate > samplerate * 1005 / 1000)
+ errx(1, "couldn't set rate");
+ if (par.xrun != SIO_SYNC)
+ errx(1, "couldn't set xun policy");
+
+ /* Save the device handle with the backend */
+ pbe->arg = hdl;
+
+ /* Start the device. */
+ if (!sio_start(hdl))
+ errx(1, "couldn't start device");
+
+ return (0);
+}
+
+static int
+sndio_open_play(struct voss_backend *pbe, const char *devname,
+ int samplerate, int bufsize, int *pchannels, int *pformat)
+{
+ return (sndio_open(pbe, devname, samplerate, bufsize, pchannels, pformat, SIO_PLAY));
+}
+
+static int
+sndio_open_rec(struct voss_backend *pbe, const char *devname,
+ int samplerate, int bufsize, int *pchannels, int *pformat)
+{
+ return (sndio_open(pbe, devname, samplerate, bufsize, pchannels, pformat, SIO_REC));
+}
+
+static int
+sndio_play_transfer(struct voss_backend *pbe, void *ptr, int len)
+{
+ return (sio_write(get_sio_hdl(pbe), ptr, len));
+}
+
+static int
+sndio_rec_transfer(struct voss_backend *pbe, void *ptr, int len)
+{
+ return (sio_read(get_sio_hdl(pbe), ptr, len));
+}
+
+static void
+sndio_delay(struct voss_backend *pbe __unused, int *pdelay)
+{
+ *pdelay = -1;
+}
+
+struct voss_backend voss_backend_sndio_rec = {
+ .open = sndio_open_rec,
+ .close = sndio_close,
+ .transfer = sndio_rec_transfer,
+ .delay = sndio_delay,
+ .fd = -1,
+};
+
+struct voss_backend voss_backend_sndio_play = {
+ .open = sndio_open_play,
+ .close = sndio_close,
+ .transfer = sndio_play_transfer,
+ .delay = sndio_delay,
+ .fd = -1,
+};
diff --git a/libexec/rc/rc.d/Makefile b/libexec/rc/rc.d/Makefile
--- a/libexec/rc/rc.d/Makefile
+++ b/libexec/rc/rc.d/Makefile
@@ -75,6 +75,7 @@
ugidfw \
var \
var_run \
+ virtual_oss \
watchdogd
CONFGROUPS+= DEVD
diff --git a/libexec/rc/rc.d/virtual_oss b/libexec/rc/rc.d/virtual_oss
new file mode 100644
--- /dev/null
+++ b/libexec/rc/rc.d/virtual_oss
@@ -0,0 +1,119 @@
+#!/bin/sh
+
+# PROVIDE: virtual_oss
+# REQUIRE: kld ldconfig
+# BEFORE: LOGIN sndiod
+# KEYWORD: shutdown
+
+. /etc/rc.subr
+
+name="virtual_oss"
+desc="virtual_oss device manager"
+rcvar="${name}_enable"
+
+command="/usr/sbin/${name}"
+command_args="-B"
+
+load_rc_config "$name"
+start_precmd="${name}_precmd"
+start_cmd="${name}_start"
+stop_cmd="${name}_stop"
+status_cmd="${name}_status"
+
+configs=
+pidpath="/var/run/${name}"
+virtual_oss_default_args="\
+ -S \
+ -C 2 \
+ -c 2 \
+ -r 48000 \
+ -b 24 \
+ -s 8ms \
+ -i 8 \
+ -f /dev/dsp \
+ -d dsp \
+ -t vdsp.ctl"
+
+# Set to NO by default. Set it to "YES" to enable virtual_oss.
+: "${virtual_oss_enable:="NO"}"
+
+# List of configurations to use. Default is "dsp".
+: "${virtual_oss_configs:="dsp"}"
+
+# Default (dsp) virtual_oss config.
+: "${virtual_oss_dsp:="${virtual_oss_default_args}"}"
+
+virtual_oss_pids()
+{
+ pids=$(pgrep -d ' ' ${name})
+ pids=${pids% }
+ printf '%s\n' "${pids}"
+}
+
+virtual_oss_precmd()
+{
+ /usr/bin/install -d -m 0755 -o root "${pidpath}"
+ load_kld cuse
+}
+
+start_instance()
+{
+ config="$1"
+ instance_args=$(eval "echo \$virtual_oss_${config}")
+ if [ -z "${instance_args}" ]; then
+ warn "no such config: ${config}"
+ else
+ startmsg -n "Starting virtual_oss config: ${config}: "
+ ${command} \
+ ${command_args} \
+ -D "${pidpath}/${config}.pid" \
+ ${instance_args}
+ startmsg "done"
+ fi
+}
+
+stop_instance()
+{
+ config="$1"
+ instance_args=$(eval "echo \$virtual_oss_${config}")
+ if [ -z "${instance_args}" ]; then
+ warn "no such config: ${config}"
+ else
+ startmsg -n "Stopping virtual_oss config: ${config}: "
+ kill "$(cat "${pidpath}/${config}.pid")"
+ rm -f "${pidpath}/${config}.pid"
+ startmsg "done"
+ fi
+}
+
+virtual_oss_start()
+{
+ configs="$1"
+ [ -z "${configs}" ] && configs="${virtual_oss_configs}"
+ for config in ${configs}; do
+ start_instance "${config}"
+ done
+}
+
+virtual_oss_stop()
+{
+ configs="$1"
+ [ -z "${configs}" ] && configs="${virtual_oss_configs}"
+ for config in ${configs}; do
+ stop_instance "${config}"
+ done
+}
+
+virtual_oss_status()
+{
+ pids=$(virtual_oss_pids)
+
+ if [ "${pids}" ]; then
+ echo "${name} is running as pid ${pids}."
+ else
+ echo "${name} is not running."
+ return 1
+ fi
+}
+
+run_rc_command "$@"
diff --git a/usr.sbin/Makefile b/usr.sbin/Makefile
--- a/usr.sbin/Makefile
+++ b/usr.sbin/Makefile
@@ -99,6 +99,7 @@
valectl \
vigr \
vipw \
+ virtual_oss \
wake \
watch \
watchdogd \
diff --git a/usr.sbin/virtual_oss/Makefile b/usr.sbin/virtual_oss/Makefile
new file mode 100644
--- /dev/null
+++ b/usr.sbin/virtual_oss/Makefile
@@ -0,0 +1,8 @@
+.include <src.opts.mk>
+
+SUBDIR+= virtual_bt_speaker \
+ virtual_oss_cmd \
+ virtual_oss
+
+.include "Makefile.inc"
+.include <bsd.subdir.mk>
diff --git a/usr.sbin/virtual_oss/Makefile.inc b/usr.sbin/virtual_oss/Makefile.inc
new file mode 100644
--- /dev/null
+++ b/usr.sbin/virtual_oss/Makefile.inc
@@ -0,0 +1 @@
+.include "../Makefile.inc"
diff --git a/usr.sbin/virtual_oss/virtual_bt_speaker/Makefile b/usr.sbin/virtual_oss/virtual_bt_speaker/Makefile
new file mode 100644
--- /dev/null
+++ b/usr.sbin/virtual_oss/virtual_bt_speaker/Makefile
@@ -0,0 +1,11 @@
+PROG= virtual_bt_speaker
+MAN= ${PROG}.8
+
+SRCS= bt_speaker.c
+
+CFLAGS+= -I${SRCTOP}/usr.sbin/virtual_oss/virtual_oss \
+ -I${SRCTOP}/lib/virtual_oss/bt
+
+LDFLAGS+= -L${LIBDIR} -lm -lbluetooth -lsdp
+
+.include <bsd.prog.mk>
diff --git a/usr.sbin/virtual_oss/virtual_bt_speaker/bt_speaker.c b/usr.sbin/virtual_oss/virtual_bt_speaker/bt_speaker.c
new file mode 100644
--- /dev/null
+++ b/usr.sbin/virtual_oss/virtual_bt_speaker/bt_speaker.c
@@ -0,0 +1,542 @@
+/*-
+ * Copyright (c) 2019 Google LLC, written by Richard Kralovic <riso@google.com>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/types.h>
+#include <sys/rtprio.h>
+#include <sys/soundcard.h>
+
+#include <dlfcn.h>
+#include <err.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sysexits.h>
+#include <time.h>
+#include <unistd.h>
+#include <poll.h>
+#include <getopt.h>
+
+#define L2CAP_SOCKET_CHECKED
+#include <bluetooth.h>
+#include <sdp.h>
+
+#include "avdtp_signal.h"
+#include "bt.h"
+#include "utils.h"
+
+static int (*bt_receive_f)(struct bt_config *, void *, int, int);
+static int (*avdtpACPHandlePacket_f)(struct bt_config *cfg);
+static void (*avdtpACPFree_f)(struct bt_config *);
+
+static int bt_in_background;
+
+static void
+message(const char *fmt,...)
+{
+ va_list list;
+
+ if (bt_in_background)
+ return;
+
+ va_start(list, fmt);
+ vfprintf(stderr, fmt, list);
+ va_end(list);
+}
+
+struct bt_audio_receiver {
+ const char *devname;
+ const char *sdp_socket_path;
+ uint16_t l2cap_psm;
+ int fd_listen;
+ void *sdp_session;
+ uint32_t sdp_handle;
+};
+
+static int
+register_sdp(struct bt_audio_receiver *r)
+{
+ struct sdp_audio_sink_profile record = {};
+
+ r->sdp_session = sdp_open_local(r->sdp_socket_path);
+ if (r->sdp_session == NULL || sdp_error(r->sdp_session)) {
+ sdp_close(r->sdp_session);
+ r->sdp_session = NULL;
+ return (0);
+ }
+
+ record.psm = r->l2cap_psm;
+ record.protover = 0x100;
+ record.features = 0x01; /* player only */
+
+ if (sdp_register_service(r->sdp_session, SDP_SERVICE_CLASS_AUDIO_SINK,
+ NG_HCI_BDADDR_ANY, (const uint8_t *)&record, sizeof(record),
+ &r->sdp_handle)) {
+ message("SDP failed to register: %s\n",
+ strerror(sdp_error(r->sdp_session)));
+ sdp_close(r->sdp_session);
+ r->sdp_session = NULL;
+ return (0);
+ }
+ return (1);
+}
+
+static void
+unregister_sdp(struct bt_audio_receiver *r)
+{
+ sdp_unregister_service(r->sdp_session, r->sdp_handle);
+ sdp_close(r->sdp_session);
+ r->sdp_session = NULL;
+}
+
+static int
+start_listen(struct bt_audio_receiver *r)
+{
+ struct sockaddr_l2cap addr = {};
+
+ r->fd_listen = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BLUETOOTH_PROTO_L2CAP);
+ if (r->fd_listen < 0)
+ return (0);
+
+ addr.l2cap_len = sizeof(addr);
+ addr.l2cap_family = AF_BLUETOOTH;
+ addr.l2cap_psm = r->l2cap_psm;
+
+ if (bind(r->fd_listen, (struct sockaddr *)&addr, sizeof(addr)) < 0 ||
+ listen(r->fd_listen, 4) < 0) {
+ close(r->fd_listen);
+ return (0);
+ }
+ return (1);
+}
+
+static void
+stop_listen(struct bt_audio_receiver *r)
+{
+ close(r->fd_listen);
+}
+
+struct bt_audio_connection {
+ struct bt_audio_receiver *r;
+ struct sockaddr_l2cap peer_addr;
+ struct bt_config cfg;
+ int oss_fd;
+};
+
+static void
+close_connection(struct bt_audio_connection *c)
+{
+ avdtpACPFree_f(&c->cfg);
+ if (c->cfg.fd != -1)
+ close(c->cfg.fd);
+ if (c->cfg.hc != -1)
+ close(c->cfg.hc);
+ if (c->oss_fd != -1)
+ close(c->oss_fd);
+ free(c);
+}
+
+static struct bt_audio_connection *
+wait_for_connection(struct bt_audio_receiver *r)
+{
+ struct bt_audio_connection *c =
+ malloc(sizeof(struct bt_audio_connection));
+ socklen_t addrlen;
+
+ memset(c, 0, sizeof(*c));
+
+ c->r = r;
+ c->cfg.fd = -1;
+ c->oss_fd = -1;
+
+ addrlen = sizeof(c->peer_addr);
+ c->cfg.hc = accept(r->fd_listen, (struct sockaddr *)&c->peer_addr, &addrlen);
+
+ message("Accepted control connection, %d\n", c->cfg.hc);
+ if (c->cfg.hc < 0) {
+ close_connection(c);
+ return NULL;
+ }
+ c->cfg.sep = 0; /* to be set later */
+ c->cfg.media_Type = mediaTypeAudio;
+ c->cfg.chmode = MODE_DUAL;
+ c->cfg.aacMode1 = 0; /* TODO: support AAC */
+ c->cfg.aacMode2 = 0;
+ c->cfg.acceptor_state = acpInitial;
+
+ return (c);
+}
+
+static void
+setup_oss(struct bt_audio_connection *c)
+{
+ c->oss_fd = open(c->r->devname, O_WRONLY);
+
+ if (c->oss_fd < 0)
+ goto err;
+
+ int v;
+
+ switch (c->cfg.chmode) {
+ case MODE_STEREO:
+ case MODE_JOINT:
+ case MODE_DUAL:
+ v = 2;
+ break;
+ case MODE_MONO:
+ v = 1;
+ break;
+ default:
+ message("Wrong chmode\n");
+ goto err;
+ }
+
+ if (ioctl(c->oss_fd, SNDCTL_DSP_CHANNELS, &v) < 0) {
+ message("SNDCTL_DSP_CHANNELS failed\n");
+ goto err;
+ }
+ v = AFMT_S16_NE;
+ if (ioctl(c->oss_fd, SNDCTL_DSP_SETFMT, &v) < 0) {
+ message("SNDCTL_DSP_SETFMT failed\n");
+ goto err;
+ }
+ switch (c->cfg.freq) {
+ case FREQ_16K:
+ v = 16000;
+ break;
+ case FREQ_32K:
+ v = 32000;
+ break;
+ case FREQ_44_1K:
+ v = 44100;
+ break;
+ case FREQ_48K:
+ v = 48000;
+ break;
+ default:
+ message("Wrong freq\n");
+ goto err;
+ }
+
+ if (ioctl(c->oss_fd, SNDCTL_DSP_SPEED, &v) < 0) {
+ message("SNDCTL_DSP_SETFMT failed\n");
+ goto err;
+ }
+ v = (2 << 16) | 15; /* 2 fragments of 32k each */
+ if (ioctl(c->oss_fd, SNDCTL_DSP_SETFRAGMENT, &v) < 0) {
+ message("SNDCTL_DSP_SETFRAGMENT failed\n");
+ goto err;
+ }
+ return;
+
+err:
+ c->oss_fd = -1;
+ message("Cannot open oss device %s\n", c->r->devname);
+}
+
+static void
+process_connection(struct bt_audio_connection *c)
+{
+ struct pollfd pfd[3] = {};
+ time_t oss_attempt = 0;
+
+ while (c->cfg.acceptor_state != acpStreamClosed) {
+ int np;
+
+ pfd[0].fd = c->r->fd_listen;
+ pfd[0].events = POLLIN | POLLRDNORM;
+ pfd[0].revents = 0;
+
+ pfd[1].fd = c->cfg.hc;
+ pfd[1].events = POLLIN | POLLRDNORM;
+ pfd[1].revents = 0;
+
+ pfd[2].fd = c->cfg.fd;
+ pfd[2].events = POLLIN | POLLRDNORM;
+ pfd[2].revents = 0;
+
+ if (c->cfg.fd != -1)
+ np = 3;
+ else
+ np = 2;
+
+ if (poll(pfd, np, INFTIM) < 0)
+ return;
+
+ if (pfd[1].revents != 0) {
+ int retval;
+
+ message("Handling packet: state = %d, ",
+ c->cfg.acceptor_state);
+ retval = avdtpACPHandlePacket_f(&c->cfg);
+ message("retval = %d\n", retval);
+ if (retval < 0)
+ return;
+ }
+ if (pfd[0].revents != 0) {
+ socklen_t addrlen = sizeof(c->peer_addr);
+ int fd = accept4(c->r->fd_listen,
+ (struct sockaddr *)&c->peer_addr, &addrlen,
+ SOCK_NONBLOCK);
+
+ if (fd < 0)
+ return;
+
+ if (c->cfg.fd < 0) {
+ if (c->cfg.acceptor_state == acpStreamOpened) {
+ socklen_t mtusize = sizeof(uint16_t);
+ c->cfg.fd = fd;
+
+ if (getsockopt(c->cfg.fd, SOL_L2CAP, SO_L2CAP_IMTU, &c->cfg.mtu, &mtusize) == -1) {
+ message("Could not get MTU size\n");
+ return;
+ }
+
+ int temp = c->cfg.mtu * 32;
+
+ if (setsockopt(c->cfg.fd, SOL_SOCKET, SO_RCVBUF, &temp, sizeof(temp)) == -1) {
+ message("Could not set send buffer size\n");
+ return;
+ }
+
+ temp = 1;
+ if (setsockopt(c->cfg.fd, SOL_SOCKET, SO_RCVLOWAT, &temp, sizeof(temp)) == -1) {
+ message("Could not set low water mark\n");
+ return;
+ }
+ message("Accepted data connection, %d\n", c->cfg.fd);
+ }
+ } else {
+ close(fd);
+ }
+ }
+ if (pfd[2].revents != 0) {
+ uint8_t data[65536];
+ int len;
+
+ if ((len = bt_receive_f(&c->cfg, data, sizeof(data), 0)) < 0) {
+ return;
+ }
+ if (c->cfg.acceptor_state != acpStreamSuspended &&
+ c->oss_fd < 0 &&
+ time(NULL) != oss_attempt) {
+ message("Trying to open dsp\n");
+ setup_oss(c);
+ oss_attempt = time(NULL);
+ }
+ if (c->oss_fd > -1) {
+ uint8_t *end = data + len;
+ uint8_t *ptr = data;
+ unsigned delay;
+ unsigned jitter_limit;
+
+ switch (c->cfg.freq) {
+ case FREQ_16K:
+ jitter_limit = (16000 / 20);
+ break;
+ case FREQ_32K:
+ jitter_limit = (32000 / 20);
+ break;
+ case FREQ_44_1K:
+ jitter_limit = (44100 / 20);
+ break;
+ default:
+ jitter_limit = (48000 / 20);
+ break;
+ }
+
+ if (c->cfg.chmode == MODE_MONO) {
+ if (len >= 2 &&
+ ioctl(c->oss_fd, SNDCTL_DSP_GETODELAY, &delay) == 0 &&
+ delay < (jitter_limit * 2)) {
+ uint8_t jitter[jitter_limit * 4] __aligned(4);
+ size_t x;
+
+ /* repeat last sample */
+ for (x = 0; x != sizeof(jitter); x++)
+ jitter[x] = ptr[x % 2];
+
+ write(c->oss_fd, jitter, sizeof(jitter));
+ }
+ } else {
+ if (len >= 4 &&
+ ioctl(c->oss_fd, SNDCTL_DSP_GETODELAY, &delay) == 0 &&
+ delay < (jitter_limit * 4)) {
+ uint8_t jitter[jitter_limit * 8] __aligned(4);
+ size_t x;
+
+ /* repeat last sample */
+ for (x = 0; x != sizeof(jitter); x++)
+ jitter[x] = ptr[x % 4];
+
+ write(c->oss_fd, jitter, sizeof(jitter));
+ }
+ }
+ while (ptr != end) {
+ int written = write(c->oss_fd, ptr, end - ptr);
+
+ if (written < 0) {
+ if (errno != EINTR && errno != EAGAIN)
+ break;
+ written = 0;
+ }
+ ptr += written;
+ }
+ if (ptr != end) {
+ message("Not all written, closing dsp\n");
+ close(c->oss_fd);
+ c->oss_fd = -1;
+ oss_attempt = time(NULL);
+ }
+ }
+ }
+
+ if (c->cfg.acceptor_state == acpStreamSuspended &&
+ c->oss_fd > -1) {
+ close(c->oss_fd);
+ c->oss_fd = -1;
+ }
+ }
+}
+
+static struct option bt_speaker_opts[] = {
+ {"device", required_argument, NULL, 'd'},
+ {"sdp_socket_path", required_argument, NULL, 'p'},
+ {"rtprio", required_argument, NULL, 'i'},
+ {"background", no_argument, NULL, 'B'},
+ {"help", no_argument, NULL, 'h'},
+ {NULL, 0, NULL, 0}
+};
+
+static void
+usage(void)
+{
+ fprintf(stderr, "Usage: virtual_bt_speaker -d /dev/dsp\n"
+ "\t" "-d, --device [device]\n"
+ "\t" "-p, --sdp_socket_path [path]\n"
+ "\t" "-i, --rtprio [priority]\n"
+ "\t" "-B, --background\n"
+ );
+ exit(EX_USAGE);
+}
+
+int
+main(int argc, char **argv)
+{
+ struct bt_audio_receiver r = {};
+ struct rtprio rtp = {};
+ void *hdl;
+ int ch;
+
+ r.devname = NULL;
+ r.sdp_socket_path = NULL;
+ r.l2cap_psm = SDP_UUID_PROTOCOL_AVDTP;
+
+ while ((ch = getopt_long(argc, argv, "p:i:d:Bh", bt_speaker_opts, NULL)) != -1) {
+ switch (ch) {
+ case 'd':
+ r.devname = optarg;
+ break;
+ case 'p':
+ r.sdp_socket_path = optarg;
+ break;
+ case 'B':
+ bt_in_background = 1;
+ break;
+ case 'i':
+ rtp.type = RTP_PRIO_REALTIME;
+ rtp.prio = atoi(optarg);
+ if (rtprio(RTP_SET, getpid(), &rtp) != 0) {
+ message("Cannot set realtime priority\n");
+ }
+ break;
+ default:
+ usage();
+ break;
+ }
+ }
+
+ if (r.devname == NULL)
+ errx(EX_USAGE, "No devicename specified");
+
+ if (bt_in_background) {
+ if (daemon(0, 0) != 0)
+ errx(EX_SOFTWARE, "Cannot become daemon");
+ }
+
+ if ((hdl = dlopen("/usr/lib/virtual_oss/voss_bt.so", RTLD_NOW)) == NULL)
+ errx(1, "%s", dlerror());
+ if ((bt_receive_f = dlsym(hdl, "bt_receive")) == NULL)
+ goto err_dlsym;
+ if ((avdtpACPHandlePacket_f = dlsym(hdl, "avdtpACPHandlePacket")) ==
+ NULL)
+ goto err_dlsym;
+ if ((avdtpACPFree_f = dlsym(hdl, "avdtpACPFree")) == NULL)
+ goto err_dlsym;
+
+ while (1) {
+ message("Starting to listen\n");
+ if (!start_listen(&r)) {
+ message("Failed to initialize server socket\n");
+ goto err_listen;
+ }
+ message("Registering service via SDP\n");
+ if (!register_sdp(&r)) {
+ message("Failed to register in SDP\n");
+ goto err_sdp;
+ }
+ while (1) {
+ message("Waiting for connection...\n");
+ struct bt_audio_connection *c = wait_for_connection(&r);
+
+ if (c == NULL) {
+ message("Failed to get connection\n");
+ goto err_conn;
+ }
+ message("Got connection...\n");
+
+ process_connection(c);
+
+ message("Connection finished...\n");
+
+ close_connection(c);
+ }
+err_conn:
+ message("Unregistering service\n");
+ unregister_sdp(&r);
+err_sdp:
+ stop_listen(&r);
+err_listen:
+ sleep(5);
+ }
+ return (0);
+
+err_dlsym:
+ warnx("%s", dlerror());
+ dlclose(hdl);
+ exit(EXIT_FAILURE);
+}
diff --git a/usr.sbin/virtual_oss/virtual_bt_speaker/virtual_bt_speaker.8 b/usr.sbin/virtual_oss/virtual_bt_speaker/virtual_bt_speaker.8
new file mode 100644
--- /dev/null
+++ b/usr.sbin/virtual_oss/virtual_bt_speaker/virtual_bt_speaker.8
@@ -0,0 +1,71 @@
+.\"
+.\" Copyright (c) 2019 Google LLC, written by Richard Kralovic <riso@google.com>
+.\"
+.\" All rights reserved.
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\" notice, this list of conditions and the following disclaimer.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\" notice, this list of conditions and the following disclaimer in the
+.\" documentation and/or other materials provided with the distribution.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+.\" ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+.\" SUCH DAMAGE.
+.\"
+.\"
+.Dd February 12, 2025
+.Dt VIRTUAL_BT_SPEAKER 8
+.Os
+.Sh NAME
+.Nm virtual_bt_speaker
+.Nd virtual bluetooth speaker
+.Sh SYNOPSIS
+.Nm
+.Op Fl h
+.Sh DESCRIPTION
+.Nm
+provides bluetooth speaker functionality.
+It receives connections from bluetooth devices that stream music, and
+forwards the received stream to the given OSS device.
+This utility depends on
+.Xr sdpd 8
+running in the background.
+.Pp
+The following options are available:
+.Bl -tag -width indent
+.It Fl B
+Run program in background.
+.It Fl d Ar devname
+OSS device to play the received streams.
+.It Fl p Ar socketpath
+Path to SDP control socket.
+Default is to use default location.
+.It Fl i Ar priority
+Set real-time priority.
+.It Fl h
+Show usage.
+.El
+.Sh EXAMPLES
+.Bd -literal -offset indent
+virtual_bt_speaker -d /dev/dspX
+.Ed
+.Sh SEE ALSO
+.Xr sdpd 8
+and
+.Xr virtual_oss 8
+.Sh AUTHORS
+.Nm
+was written by
+.An Richard Kralovic riso@google.com .
diff --git a/usr.sbin/virtual_oss/virtual_equalizer/Makefile b/usr.sbin/virtual_oss/virtual_equalizer/Makefile
new file mode 100644
--- /dev/null
+++ b/usr.sbin/virtual_oss/virtual_equalizer/Makefile
@@ -0,0 +1,11 @@
+PROG= virtual_equalizer
+MAN= ${PROG}.8
+
+SRCS= equalizer.c
+
+CFLAGS+= -I${SRCTOP}/usr.sbin/virtual_oss/virtual_oss \
+ -I/usr/local/include
+
+LDFLAGS+= -L/usr/local/lib -lm -lfftw3
+
+.include <bsd.prog.mk>
diff --git a/usr.sbin/virtual_oss/virtual_equalizer/equalizer.c b/usr.sbin/virtual_oss/virtual_equalizer/equalizer.c
new file mode 100644
--- /dev/null
+++ b/usr.sbin/virtual_oss/virtual_equalizer/equalizer.c
@@ -0,0 +1,431 @@
+/*-
+ * Copyright (c) 2019 Google LLC, written by Richard Kralovic <riso@google.com>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <sys/soundcard.h>
+#include <sys/types.h>
+#include <sys/un.h>
+
+#include <err.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <fftw3.h>
+#include <getopt.h>
+#include <math.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sysexits.h>
+#include <unistd.h>
+
+#include "virtual_oss.h"
+
+struct Equalizer {
+ double rate;
+ int block_size;
+ int do_normalize;
+
+ /* (block_size * 2) elements, time domain */
+ double *fftw_time;
+
+ /* (block_size * 2) elements, half-complex, freq domain */
+ double *fftw_freq;
+
+ fftw_plan forward;
+ fftw_plan inverse;
+};
+
+static int be_silent = 0;
+
+static void
+message(const char *fmt,...)
+{
+ va_list list;
+
+ if (be_silent)
+ return;
+ va_start(list, fmt);
+ vfprintf(stderr, fmt, list);
+ va_end(list);
+}
+
+/*
+ * Masking window value for -1 < x < 1.
+ *
+ * Window must be symmetric, thus, this function is queried for x >= 0
+ * only. Currently a Hann window.
+ */
+static double
+equalizer_get_window(double x)
+{
+ return (0.5 + 0.5 * cos(M_PI * x));
+}
+
+static int
+equalizer_load_freq_amps(struct Equalizer *e, const char *config)
+{
+ double prev_f = 0.0;
+ double prev_amp = 1.0;
+ double next_f = 0.0;
+ double next_amp = 1.0;
+ int i;
+
+ if (strncasecmp(config, "normalize", 4) == 0) {
+ while (*config != 0) {
+ if (*config == '\n') {
+ config++;
+ break;
+ }
+ config++;
+ }
+ e->do_normalize = 1;
+ } else {
+ e->do_normalize = 0;
+ }
+
+ for (i = 0; i <= (e->block_size / 2); ++i) {
+ const double f = (i * e->rate) / e->block_size;
+
+ while (f >= next_f) {
+ prev_f = next_f;
+ prev_amp = next_amp;
+
+ if (*config == 0) {
+ next_f = e->rate;
+ next_amp = prev_amp;
+ } else {
+ int len;
+
+ if (sscanf(config, "%lf %lf %n", &next_f, &next_amp, &len) == 2) {
+ config += len;
+ if (next_f < prev_f) {
+ message("Parse error: Nonincreasing sequence of frequencies.\n");
+ return (0);
+ }
+ } else {
+ message("Parse error.\n");
+ return (0);
+ }
+ }
+ if (prev_f == 0.0)
+ prev_amp = next_amp;
+ }
+ e->fftw_freq[i] = ((f - prev_f) / (next_f - prev_f)) * (next_amp - prev_amp) + prev_amp;
+ }
+ return (1);
+}
+
+static void
+equalizer_init(struct Equalizer *e, int rate, int block_size)
+{
+ size_t buffer_size;
+
+ e->rate = rate;
+ e->block_size = block_size;
+
+ buffer_size = sizeof(double) * e->block_size;
+
+ e->fftw_time = (double *)malloc(buffer_size);
+ e->fftw_freq = (double *)malloc(buffer_size);
+
+ e->forward = fftw_plan_r2r_1d(block_size, e->fftw_time, e->fftw_freq,
+ FFTW_R2HC, FFTW_MEASURE);
+ e->inverse = fftw_plan_r2r_1d(block_size, e->fftw_freq, e->fftw_time,
+ FFTW_HC2R, FFTW_MEASURE);
+}
+
+static int
+equalizer_load(struct Equalizer *eq, const char *config)
+{
+ int retval = 0;
+ int N = eq->block_size;
+ int buffer_size = sizeof(double) * N;
+ int i;
+
+ memset(eq->fftw_freq, 0, buffer_size);
+
+ message("\n\nReloading amplification specifications:\n%s\n", config);
+
+ if (!equalizer_load_freq_amps(eq, config))
+ goto end;
+
+ double *requested_freq = (double *)malloc(buffer_size);
+
+ memcpy(requested_freq, eq->fftw_freq, buffer_size);
+
+ fftw_execute(eq->inverse);
+
+ /* Multiply by symmetric window and shift */
+ for (i = 0; i < (N / 2); ++i) {
+ double weight = equalizer_get_window(i / (double)(N / 2)) / N;
+
+ eq->fftw_time[N / 2 + i] = eq->fftw_time[i] * weight;
+ }
+ for (i = (N / 2 - 1); i > 0; --i) {
+ eq->fftw_time[i] = eq->fftw_time[N - i];
+ }
+ eq->fftw_time[0] = 0;
+
+ fftw_execute(eq->forward);
+ for (i = 0; i < N; ++i) {
+ eq->fftw_freq[i] /= (double)N;
+ }
+
+ /* Debug output */
+ for (i = 0; i <= (N / 2); ++i) {
+ double f = (eq->rate / N) * i;
+ double a = sqrt(pow(eq->fftw_freq[i], 2.0) +
+ ((i > 0 && i < N / 2) ? pow(eq->fftw_freq[N - i], 2.0) : 0));
+
+ a *= N;
+ double r = requested_freq[i];
+
+ message("%3.1lf Hz: requested %2.2lf, got %2.7lf (log10 = %.2lf), %3.7lfdb\n",
+ f, r, a, log(a) / log(10), (log(a / r) / log(10.0)) * 10.0);
+ }
+
+ /* Normalize FIR filter, if any */
+ if (eq->do_normalize) {
+ double sum = 0;
+
+ for (i = 0; i < N; ++i)
+ sum += fabs(eq->fftw_time[i]);
+ if (sum != 0.0) {
+ for (i = 0; i < N; ++i)
+ eq->fftw_time[i] /= sum;
+ }
+ }
+ for (i = 0; i < N; ++i) {
+ message("%.3lf ms: %.10lf\n", 1000.0 * i / eq->rate, eq->fftw_time[i]);
+ }
+
+ /* End of debug */
+
+ retval = 1;
+
+ free(requested_freq);
+end:
+ return (retval);
+}
+
+static void
+equalizer_done(struct Equalizer *eq)
+{
+
+ fftw_destroy_plan(eq->forward);
+ fftw_destroy_plan(eq->inverse);
+ free(eq->fftw_time);
+ free(eq->fftw_freq);
+}
+
+static struct option equalizer_opts[] = {
+ {"device", required_argument, NULL, 'd'},
+ {"part", required_argument, NULL, 'p'},
+ {"channels", required_argument, NULL, 'c'},
+ {"what", required_argument, NULL, 'w'},
+ {"off", no_argument, NULL, 'o'},
+ {"quiet", no_argument, NULL, 'q'},
+ {"file", no_argument, NULL, 'f'},
+ {"help", no_argument, NULL, 'h'},
+};
+
+static void
+usage(void)
+{
+ message("Usage: virtual_equalizer -d /dev/vdsp.ctl \n"
+ "\t -d, --device [control device]\n"
+ "\t -w, --what [rx_dev,tx_dev,rx_loop,tx_loop, default tx_dev]\n"
+ "\t -p, --part [part number, default 0]\n"
+ "\t -c, --channels [channels, default -1]\n"
+ "\t -f, --file [read input from file, default standard input]\n"
+ "\t -o, --off [disable equalizer]\n"
+ "\t -q, --quiet\n"
+ "\t -h, --help\n");
+ exit(EX_USAGE);
+}
+
+int
+main(int argc, char **argv)
+{
+ struct virtual_oss_fir_filter fir = {};
+ struct virtual_oss_io_info info = {};
+
+ struct Equalizer e;
+
+ char buffer[65536];
+ unsigned cmd_fir_set = VIRTUAL_OSS_SET_TX_DEV_FIR_FILTER;
+ unsigned cmd_fir_get = VIRTUAL_OSS_GET_TX_DEV_FIR_FILTER;
+ unsigned cmd_info = VIRTUAL_OSS_GET_DEV_INFO;
+ const char *dsp = NULL;
+ int rate;
+ int channels = -1;
+ int part = 0;
+ int opt;
+ int len;
+ int offset;
+ int disable = 0;
+ int f = STDIN_FILENO;
+
+ while ((opt = getopt_long(argc, argv, "d:c:f:op:w:qh",
+ equalizer_opts, NULL)) != -1) {
+ switch (opt) {
+ case 'd':
+ dsp = optarg;
+ break;
+ case 'c':
+ channels = atoi(optarg);
+ if (channels == 0) {
+ message("Wrong number of channels\n");
+ usage();
+ }
+ break;
+ case 'p':
+ part = atoi(optarg);
+ if (part < 0) {
+ message("Invalid part number\n");
+ usage();
+ }
+ break;
+ case 'w':
+ if (strcmp(optarg, "rx_dev") == 0) {
+ cmd_fir_set = VIRTUAL_OSS_SET_RX_DEV_FIR_FILTER;
+ cmd_fir_get = VIRTUAL_OSS_GET_RX_DEV_FIR_FILTER;
+ cmd_info = VIRTUAL_OSS_GET_DEV_INFO;
+ } else if (strcmp(optarg, "tx_dev") == 0) {
+ cmd_fir_set = VIRTUAL_OSS_SET_TX_DEV_FIR_FILTER;
+ cmd_fir_get = VIRTUAL_OSS_GET_TX_DEV_FIR_FILTER;
+ cmd_info = VIRTUAL_OSS_GET_DEV_INFO;
+ } else if (strcmp(optarg, "rx_loop") == 0) {
+ cmd_fir_set = VIRTUAL_OSS_SET_RX_LOOP_FIR_FILTER;
+ cmd_fir_get = VIRTUAL_OSS_GET_RX_LOOP_FIR_FILTER;
+ cmd_info = VIRTUAL_OSS_GET_LOOP_INFO;
+ } else if (strcmp(optarg, "tx_loop") == 0) {
+ cmd_fir_set = VIRTUAL_OSS_SET_TX_LOOP_FIR_FILTER;
+ cmd_fir_get = VIRTUAL_OSS_GET_TX_LOOP_FIR_FILTER;
+ cmd_info = VIRTUAL_OSS_GET_LOOP_INFO;
+ } else {
+ message("Bad -w argument not recognized\n");
+ usage();
+ }
+ break;
+ case 'f':
+ if (f != STDIN_FILENO) {
+ message("Can only specify one file\n");
+ usage();
+ }
+ f = open(optarg, O_RDONLY);
+ if (f < 0) {
+ message("Cannot open specified file\n");
+ usage();
+ }
+ break;
+ case 'o':
+ disable = 1;
+ break;
+ case 'q':
+ be_silent = 1;
+ break;
+ default:
+ usage();
+ }
+ }
+
+ fir.number = part;
+ info.number = part;
+
+ int fd = open(dsp, O_RDWR);
+
+ if (fd < 0) {
+ message("Cannot open DSP device\n");
+ return (EX_SOFTWARE);
+ }
+ if (ioctl(fd, VIRTUAL_OSS_GET_SAMPLE_RATE, &rate) < 0) {
+ message("Cannot get sample rate\n");
+ return (EX_SOFTWARE);
+ }
+ if (ioctl(fd, cmd_fir_get, &fir) < 0) {
+ message("Cannot get current FIR filter\n");
+ return (EX_SOFTWARE);
+ }
+ if (disable) {
+ for (fir.channel = 0; fir.channel != channels; fir.channel++) {
+ if (ioctl(fd, cmd_fir_set, &fir) < 0) {
+ if (fir.channel == 0) {
+ message("Cannot disable FIR filter\n");
+ return (EX_SOFTWARE);
+ }
+ break;
+ }
+ }
+ return (0);
+ }
+ equalizer_init(&e, rate, fir.filter_size);
+ equalizer_load(&e, "");
+
+ if (f == STDIN_FILENO) {
+ if (ioctl(fd, cmd_info, &info) < 0) {
+ message("Cannot read part information\n");
+ return (EX_SOFTWARE);
+ }
+ message("Please enter EQ layout for %s, <freq> <gain>:\n", info.name);
+ }
+ offset = 0;
+ while (1) {
+ if (offset == (int)(sizeof(buffer) - 1)) {
+ message("Too much input data\n");
+ return (EX_SOFTWARE);
+ }
+ len = read(f, buffer + offset, sizeof(buffer) - 1 - offset);
+ if (len <= 0)
+ break;
+ offset += len;
+ }
+ buffer[offset] = 0;
+ close(f);
+
+ if (f == STDIN_FILENO)
+ message("Loading new EQ layout\n");
+
+ if (equalizer_load(&e, buffer) == 0) {
+ message("Invalid equalizer data\n");
+ return (EX_SOFTWARE);
+ }
+ fir.filter_data = e.fftw_time;
+
+ for (fir.channel = 0; fir.channel != channels; fir.channel++) {
+ if (ioctl(fd, cmd_fir_set, &fir) < 0) {
+ if (fir.channel == 0)
+ message("Cannot set FIR filter on channel\n");
+ break;
+ }
+ }
+
+ close(fd);
+ equalizer_done(&e);
+
+ return (0);
+}
diff --git a/usr.sbin/virtual_oss/virtual_equalizer/virtual_equalizer.8 b/usr.sbin/virtual_oss/virtual_equalizer/virtual_equalizer.8
new file mode 100644
--- /dev/null
+++ b/usr.sbin/virtual_oss/virtual_equalizer/virtual_equalizer.8
@@ -0,0 +1,127 @@
+.\"
+.\" Copyright (c) 2019 Google LLC, written by Richard Kralovic <riso@google.com>
+.\"
+.\" All rights reserved.
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\" notice, this list of conditions and the following disclaimer.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\" notice, this list of conditions and the following disclaimer in the
+.\" documentation and/or other materials provided with the distribution.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+.\" ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+.\" SUCH DAMAGE.
+.\"
+.\"
+.Dd February 12, 2025
+.Dt VIRTUAL_EQUALIZER 8
+.Os
+.Sh NAME
+.Nm virtual_equalizer
+.Nd audio equalizer
+.Sh SYNOPSIS
+.Nm
+.Op Fl h
+.Op Fl o
+.Op Fl q
+.Op Fl d Ar devname
+.Op Fl w Ar what
+.Op Fl p Ar part
+.Op Fl c Ar channels
+.Op Fl f Ar file
+.Sh DESCRIPTION
+.Nm
+sets the given frequency response for the given
+.Xr virtual_oss 8
+instance via the control character device given by the -d option.
+The design goal of this equalizer is to provide precise equalization
+for arbitrary requested frequency response at the expense of higher
+latency, utilizing a so-called finite impulse response, FIR, filter.
+.Pp
+The requested frequency response is configured via standard input or
+the file specified by the -f option.
+There is one control point in per line.
+Each line consists of two numbers, frequency in Hz and requested
+amplification.
+Amplification between two consecutive control points is a linear
+interpolation of the given control point values.
+.Pp
+To make the filter finite, it is windowed in time domain using a Hann
+window.
+The windowing actually modifies the frequency response - the actual
+response is a convolution of the requested response and spectrum of
+the window.
+This is, however, very close to the requested response.
+.Pp
+The following options are available:
+.Bl -tag -width indent
+.It Fl q
+Be quiet and don't print anything to standard output.
+.It Fl d Ar device
+The
+.Xr virtual_oss 8
+control character device.
+.It Fl w Ar what
+Select what part the FIR filter should apply to.
+Valid values are: rx_dev, tx_dev, rx_loop and tx_loop.
+The default value is tx_dev.
+.It Fl p Ar part
+Select the index of the part given by the -w option to apply the filter to.
+Default is zero.
+.It Fl c Ar channels
+Select number of channels to apply filter to, starting at channel zero.
+By default all channels of the given part are updated.
+.It Fl f Ar file
+Read filter coefficients from the given file instead of standard input.
+.It Fl o
+Turn equalizer off.
+.It Fl h
+Show usage.
+.El
+.Sh EXAMPLES
+To pass only frequencies between 200Hz and 400Hz:
+.Bd -literal -offset indent
+# Note that the -F and -G options enable FIR filtering.
+virtual_oss -B -C 2 -c 2 -S -Q 0 -b 32 -r 48000 -s 8ms -F 80ms -G 80ms \\
+ -f /dev/dsp -d dsp.virtual -t vdsp.ctl
+
+# For simplex operation use this:
+virtual_oss -B -C 2 -c 2 -S -Q 0 -b 32 -r 48000 -s 8ms -F 80ms -G 80ms \\
+ -R /dev/null -O /dev/dsp -d dsp.virtual -t vdsp.ctl
+
+# Load normalized filter points to avoid sample value overflow
+cat << EOF | virtual_equalizer -d /dev/vdsp.ctl -w tx_dev -p 0 -c 2
+NORMALIZE
+199 0.0
+200 1.0
+400 1.0
+401 0.0
+EOF
+
+# Load FIR filter based on sine frequency points
+cat << EOF | virtual_equalizer -d /dev/vdsp.ctl -w tx_dev -p 0 -c 2
+199 0.0
+200 1.0
+400 1.0
+401 0.0
+EOF
+
+.Ed
+.Sh SEE ALSO
+.Xr virtual_oss 8
+.Sh AUTHORS
+.Nm
+was written by
+.An Richard Kralovic riso@google.com .
diff --git a/usr.sbin/virtual_oss/virtual_oss/Makefile b/usr.sbin/virtual_oss/virtual_oss/Makefile
new file mode 100644
--- /dev/null
+++ b/usr.sbin/virtual_oss/virtual_oss/Makefile
@@ -0,0 +1,24 @@
+PROG= virtual_oss
+MAN= ${PROG}.8
+
+SRCS= audio_delay.c \
+ compressor.c \
+ ctl.c \
+ eq.c \
+ format.c \
+ httpd.c \
+ main.c \
+ mul.c \
+ ring.c \
+ virtual_oss.c
+
+CFLAGS+= -I${SRCTOP}/contrib/libsamplerate
+# The --export-dynamic-symbol flags below are needed because some backends make
+# use of those symbols.
+LDFLAGS+= -lpthread -lcuse -lnv -lm \
+ -Wl,--export-dynamic-symbol=virtual_oss_wait \
+ -Wl,--export-dynamic-symbol=voss_has_synchronization
+LIBADD= samplerate
+LDFLAGS+= -L${.OBJDIR:H:H}/libsamplerate
+
+.include <bsd.prog.mk>
diff --git a/usr.sbin/virtual_oss/virtual_oss/audio_delay.c b/usr.sbin/virtual_oss/virtual_oss/audio_delay.c
new file mode 100644
--- /dev/null
+++ b/usr.sbin/virtual_oss/virtual_oss/audio_delay.c
@@ -0,0 +1,238 @@
+/*-
+ * Copyright (c) 2014 Hans Petter Selasky
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/queue.h>
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <err.h>
+#include <math.h>
+#include <sysexits.h>
+
+#include "int.h"
+
+#define REF_FREQ 500 /* HZ */
+
+uint32_t voss_ad_last_delay;
+uint8_t voss_ad_enabled;
+uint8_t voss_ad_output_signal;
+uint8_t voss_ad_input_channel;
+uint8_t voss_ad_output_channel;
+
+static struct voss_ad {
+ double *wave;
+
+ double *sin_a;
+ double *cos_a;
+
+ double *sin_b;
+ double *cos_b;
+
+ double *buf_a;
+ double *buf_b;
+
+ double sum_sin_a;
+ double sum_cos_a;
+
+ double sum_sin_b;
+ double sum_cos_b;
+
+ uint32_t len_a;
+ uint32_t len_b;
+
+ uint32_t offset_a;
+ uint32_t offset_b;
+} voss_ad;
+
+void
+voss_ad_reset(void)
+{
+ uint32_t x;
+
+ for (x = 0; x != voss_ad.len_a; x++)
+ voss_ad.buf_a[x] = 0;
+
+ for (x = 0; x != voss_ad.len_b; x++)
+ voss_ad.buf_b[x] = 0;
+
+ voss_ad.sum_sin_a = 0;
+ voss_ad.sum_cos_a = 0;
+ voss_ad.sum_sin_b = 0;
+ voss_ad.sum_cos_b = 0;
+
+ voss_ad.offset_a = 0;
+ voss_ad.offset_b = 0;
+
+ voss_ad_last_delay = 0;
+}
+
+void
+voss_ad_init(uint32_t rate)
+{
+ double freq;
+ int samples;
+ int len;
+ int x;
+
+ len = sqrt(rate);
+
+ samples = len * len;
+
+ voss_ad.wave = malloc(sizeof(voss_ad.wave[0]) * samples);
+
+ voss_ad.sin_a = malloc(sizeof(voss_ad.sin_a[0]) * len);
+ voss_ad.cos_a = malloc(sizeof(voss_ad.cos_a[0]) * len);
+ voss_ad.buf_a = malloc(sizeof(voss_ad.buf_a[0]) * len);
+ voss_ad.len_a = len;
+
+ voss_ad.sin_b = malloc(sizeof(voss_ad.sin_b[0]) * samples);
+ voss_ad.cos_b = malloc(sizeof(voss_ad.cos_b[0]) * samples);
+ voss_ad.buf_b = malloc(sizeof(voss_ad.buf_b[0]) * samples);
+ voss_ad.len_b = samples;
+
+ if (voss_ad.sin_a == NULL || voss_ad.cos_a == NULL ||
+ voss_ad.sin_b == NULL || voss_ad.cos_b == NULL ||
+ voss_ad.buf_a == NULL || voss_ad.buf_b == NULL)
+ errx(EX_SOFTWARE, "Out of memory");
+
+ freq = 1.0;
+
+ while (1) {
+ double temp = freq * ((double)rate) / ((double)len);
+ if (temp >= REF_FREQ)
+ break;
+ freq += 1.0;
+ }
+
+ for (x = 0; x != len; x++) {
+ voss_ad.sin_a[x] = sin(freq * 2.0 * M_PI * ((double)x) / ((double)len));
+ voss_ad.cos_a[x] = cos(freq * 2.0 * M_PI * ((double)x) / ((double)len));
+ voss_ad.buf_a[x] = 0;
+ }
+
+ for (x = 0; x != samples; x++) {
+
+ voss_ad.wave[x] = sin(freq * 2.0 * M_PI * ((double)x) / ((double)len)) *
+ (1.0 + sin(2.0 * M_PI * ((double)x) / ((double)samples))) / 2.0;
+
+ voss_ad.sin_b[x] = sin(2.0 * M_PI * ((double)x) / ((double)samples));
+ voss_ad.cos_b[x] = cos(2.0 * M_PI * ((double)x) / ((double)samples));
+ voss_ad.buf_b[x] = 0;
+ }
+}
+
+static double
+voss_add_decode_offset(double x /* cos */, double y /* sin */)
+{
+ uint32_t v;
+ double r;
+
+ r = sqrt((x * x) + (y * y));
+
+ if (r == 0.0)
+ return (0);
+
+ x /= r;
+ y /= r;
+
+ v = 0;
+
+ if (y < 0) {
+ v |= 1;
+ y = -y;
+ }
+ if (x < 0) {
+ v |= 2;
+ x = -x;
+ }
+
+ if (y < x) {
+ r = acos(y);
+ } else {
+ r = asin(x);
+ }
+
+ switch (v) {
+ case 0:
+ r = (2.0 * M_PI) - r;
+ break;
+ case 1:
+ r = M_PI + r;
+ break;
+ case 3:
+ r = M_PI - r;
+ break;
+ default:
+ break;
+ }
+ return (r);
+}
+
+double
+voss_ad_getput_sample(double sample)
+{
+ double retval;
+ double phase;
+ uint32_t xa;
+ uint32_t xb;
+
+ xa = voss_ad.offset_a;
+ xb = voss_ad.offset_b;
+ retval = voss_ad.wave[xb];
+
+ sample -= voss_ad.buf_a[xa];
+ voss_ad.sum_sin_a += voss_ad.sin_a[xa] * sample;
+ voss_ad.sum_cos_a += voss_ad.cos_a[xa] * sample;
+ voss_ad.buf_a[xa] += sample;
+
+ sample = sqrt((voss_ad.sum_sin_a * voss_ad.sum_sin_a) +
+ (voss_ad.sum_cos_a * voss_ad.sum_cos_a));
+
+ sample -= voss_ad.buf_b[xb];
+ voss_ad.sum_sin_b += voss_ad.sin_b[xb] * sample;
+ voss_ad.sum_cos_b += voss_ad.cos_b[xb] * sample;
+ voss_ad.buf_b[xb] += sample;
+
+ if (++xa == voss_ad.len_a)
+ xa = 0;
+
+ if (++xb == voss_ad.len_b) {
+ xb = 0;
+
+ phase = voss_add_decode_offset(
+ voss_ad.sum_cos_b, voss_ad.sum_sin_b);
+
+ voss_ad_last_delay = (uint32_t)(phase * (double)(voss_ad.len_b) / (2.0 * M_PI)) - (voss_ad.len_a / 2);
+ if (voss_ad_last_delay > voss_ad.len_b)
+ voss_ad_last_delay = voss_ad.len_b;
+ }
+ voss_ad.offset_a = xa;
+ voss_ad.offset_b = xb;
+
+ return (retval * (1LL << voss_ad_output_signal));
+}
diff --git a/usr.sbin/virtual_oss/virtual_oss/backend.h b/usr.sbin/virtual_oss/virtual_oss/backend.h
new file mode 100644
--- /dev/null
+++ b/usr.sbin/virtual_oss/virtual_oss/backend.h
@@ -0,0 +1,53 @@
+/*-
+ * Copyright (c) 2015 Hans Petter Selasky
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef _VIRTUAL_BACKEND_H_
+#define _VIRTUAL_BACKEND_H_
+
+struct voss_backend {
+ int (*open)(struct voss_backend *, const char *, int, int, int *, int *);
+ void (*close)(struct voss_backend *);
+ int (*transfer)(struct voss_backend *, void *, int);
+ void (*delay)(struct voss_backend *, int *);
+ void *arg;
+ int fd;
+};
+
+/* Currently selected backends */
+extern struct voss_backend *voss_rx_backend;
+extern struct voss_backend *voss_tx_backend;
+
+/* Available backends */
+/* XXX Get rid somehow? */
+extern struct voss_backend voss_backend_null_rec;
+extern struct voss_backend voss_backend_null_play;
+extern struct voss_backend voss_backend_oss_rec;
+extern struct voss_backend voss_backend_oss_play;
+extern struct voss_backend voss_backend_bt_rec;
+extern struct voss_backend voss_backend_bt_play;
+extern struct voss_backend voss_backend_sndio_rec;
+extern struct voss_backend voss_backend_sndio_play;
+
+#endif /* _VIRTUAL_BACKEND_H_ */
diff --git a/usr.sbin/virtual_oss/virtual_oss/compressor.c b/usr.sbin/virtual_oss/virtual_oss/compressor.c
new file mode 100644
--- /dev/null
+++ b/usr.sbin/virtual_oss/virtual_oss/compressor.c
@@ -0,0 +1,76 @@
+/*-
+ * Copyright (c) 2020 Hans Petter Selasky
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/queue.h>
+
+#include <stdint.h>
+#include <string.h>
+
+#include "int.h"
+#include "virtual_oss.h"
+
+struct virtual_compressor voss_output_compressor_param = {
+ .knee = 85,
+ .attack = 3,
+ .decay = 20,
+};
+double voss_output_compressor_gain[VMAX_CHAN];
+
+void
+voss_compressor(int64_t *buffer, double *p_ch_gain,
+ const struct virtual_compressor *p_param, const unsigned samples,
+ const unsigned maxchan, const int64_t fmt_max)
+{
+ int64_t knee_amp;
+ int64_t sample;
+ unsigned ch;
+ unsigned i;
+ double amp;
+
+ /* check if compressor is enabled */
+ if (p_param->enabled != 1)
+ return;
+
+ knee_amp = (fmt_max * p_param->knee) / VIRTUAL_OSS_KNEE_MAX;
+
+ for (ch = i = 0; i != samples; i++) {
+ sample = buffer[i];
+ if (sample < 0)
+ sample = -sample;
+
+ amp = p_ch_gain[ch];
+ if (sample > knee_amp) {
+ const double gain = (double)knee_amp / (double)sample;
+ if (gain < amp)
+ amp += (gain - amp) / (1LL << p_param->attack);
+ }
+ buffer[i] *= amp;
+ amp += (1.0 - amp) / (1LL << p_param->decay);
+ p_ch_gain[ch] = amp;
+
+ if (++ch == maxchan)
+ ch = 0;
+ }
+}
diff --git a/usr.sbin/virtual_oss/virtual_oss/ctl.c b/usr.sbin/virtual_oss/virtual_oss/ctl.c
new file mode 100644
--- /dev/null
+++ b/usr.sbin/virtual_oss/virtual_oss/ctl.c
@@ -0,0 +1,615 @@
+/*-
+ * Copyright (c) 2012-2022 Hans Petter Selasky
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/types.h>
+#include <sys/queue.h>
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <cuse.h>
+
+#include "int.h"
+#include "virtual_oss.h"
+
+int64_t voss_output_peak[VMAX_CHAN];
+int64_t voss_input_peak[VMAX_CHAN];
+
+static int
+vctl_open(struct cuse_dev *pdev __unused, int fflags __unused)
+{
+ return (0);
+}
+
+static int
+vctl_close(struct cuse_dev *pdev __unused, int fflags __unused)
+{
+ return (0);
+}
+
+static vprofile_t *
+vprofile_by_index(const vprofile_head_t *phead, int index)
+{
+ vprofile_t *pvp;
+
+ TAILQ_FOREACH(pvp, phead, entry) {
+ if (!index--)
+ return (pvp);
+ }
+ return (NULL);
+}
+
+static vmonitor_t *
+vmonitor_by_index(int index, vmonitor_head_t *phead)
+{
+ vmonitor_t *pvm;
+
+ TAILQ_FOREACH(pvm, phead, entry) {
+ if (!index--)
+ return (pvm);
+ }
+ return (NULL);
+}
+
+static int
+vctl_ioctl(struct cuse_dev *pdev __unused, int fflags __unused,
+ unsigned long cmd, void *peer_data)
+{
+ union {
+ int val;
+ struct virtual_oss_io_info io_info;
+ struct virtual_oss_mon_info mon_info;
+ struct virtual_oss_io_peak io_peak;
+ struct virtual_oss_mon_peak mon_peak;
+ struct virtual_oss_compressor out_lim;
+ struct virtual_oss_io_limit io_lim;
+ struct virtual_oss_master_peak master_peak;
+ struct virtual_oss_audio_delay_locator ad_locator;
+ struct virtual_oss_fir_filter fir_filter;
+ struct virtual_oss_system_info sys_info;
+ char options[VIRTUAL_OSS_OPTIONS_MAX];
+ } data;
+
+ vprofile_t *pvp;
+ vmonitor_t *pvm;
+
+ int chan;
+ int len;
+ int error;
+
+ len = IOCPARM_LEN(cmd);
+
+ if (len < 0 || len > (int)sizeof(data))
+ return (CUSE_ERR_INVALID);
+
+ if (cmd & IOC_IN) {
+ error = cuse_copy_in(peer_data, &data, len);
+ if (error)
+ return (error);
+ } else {
+ error = 0;
+ }
+
+ atomic_lock();
+ switch (cmd) {
+ case VIRTUAL_OSS_GET_DEV_INFO:
+ case VIRTUAL_OSS_SET_DEV_INFO:
+ case VIRTUAL_OSS_GET_DEV_PEAK:
+ case VIRTUAL_OSS_SET_DEV_LIMIT:
+ case VIRTUAL_OSS_GET_DEV_LIMIT:
+ case VIRTUAL_OSS_SET_RX_DEV_FIR_FILTER:
+ case VIRTUAL_OSS_GET_RX_DEV_FIR_FILTER:
+ case VIRTUAL_OSS_SET_TX_DEV_FIR_FILTER:
+ case VIRTUAL_OSS_GET_TX_DEV_FIR_FILTER:
+ pvp = vprofile_by_index(&virtual_profile_client_head, data.val);
+ break;
+ case VIRTUAL_OSS_GET_LOOP_INFO:
+ case VIRTUAL_OSS_SET_LOOP_INFO:
+ case VIRTUAL_OSS_GET_LOOP_PEAK:
+ case VIRTUAL_OSS_SET_LOOP_LIMIT:
+ case VIRTUAL_OSS_GET_LOOP_LIMIT:
+ case VIRTUAL_OSS_SET_RX_LOOP_FIR_FILTER:
+ case VIRTUAL_OSS_GET_RX_LOOP_FIR_FILTER:
+ case VIRTUAL_OSS_SET_TX_LOOP_FIR_FILTER:
+ case VIRTUAL_OSS_GET_TX_LOOP_FIR_FILTER:
+ pvp = vprofile_by_index(&virtual_profile_loopback_head, data.val);
+ break;
+ default:
+ pvp = NULL;
+ break;
+ }
+
+ switch (cmd) {
+ case VIRTUAL_OSS_GET_VERSION:
+ data.val = VIRTUAL_OSS_VERSION;
+ break;
+ case VIRTUAL_OSS_GET_DEV_INFO:
+ case VIRTUAL_OSS_GET_LOOP_INFO:
+ if (pvp == NULL ||
+ data.io_info.channel < 0 ||
+ data.io_info.channel >= (int)pvp->channels) {
+ error = CUSE_ERR_INVALID;
+ break;
+ }
+ strlcpy(data.io_info.name, pvp->oss_name, sizeof(data.io_info.name));
+ chan = data.io_info.channel;
+ data.io_info.rx_amp = pvp->rx_shift[chan];
+ data.io_info.tx_amp = pvp->tx_shift[chan];
+ data.io_info.rx_chan = pvp->rx_src[chan];
+ data.io_info.tx_chan = pvp->tx_dst[chan];
+ data.io_info.rx_mute = pvp->rx_mute[chan] ? 1 : 0;
+ data.io_info.tx_mute = pvp->tx_mute[chan] ? 1 : 0;
+ data.io_info.rx_pol = pvp->rx_pol[chan] ? 1 : 0;
+ data.io_info.tx_pol = pvp->tx_pol[chan] ? 1 : 0;
+ data.io_info.bits = pvp->bits;
+ data.io_info.rx_delay = pvp->rec_delay;
+ data.io_info.rx_delay_limit = voss_dsp_sample_rate;
+ break;
+ case VIRTUAL_OSS_SET_DEV_INFO:
+ case VIRTUAL_OSS_SET_LOOP_INFO:
+ if (pvp == NULL ||
+ data.io_info.channel < 0 ||
+ data.io_info.channel >= (int)pvp->channels ||
+ data.io_info.rx_amp < -31 || data.io_info.rx_amp > 31 ||
+ data.io_info.tx_amp < -31 || data.io_info.tx_amp > 31 ||
+ data.io_info.rx_delay < 0 ||
+ data.io_info.rx_delay > (int)voss_dsp_sample_rate) {
+ error = CUSE_ERR_INVALID;
+ break;
+ }
+ chan = data.io_info.channel;
+ pvp->rx_shift[chan] = data.io_info.rx_amp;
+ pvp->tx_shift[chan] = data.io_info.tx_amp;
+ pvp->rx_src[chan] = data.io_info.rx_chan;
+ pvp->tx_dst[chan] = data.io_info.tx_chan;
+ pvp->rx_mute[chan] = data.io_info.rx_mute ? 1 : 0;
+ pvp->tx_mute[chan] = data.io_info.tx_mute ? 1 : 0;
+ pvp->rx_pol[chan] = data.io_info.rx_pol ? 1 : 0;
+ pvp->tx_pol[chan] = data.io_info.tx_pol ? 1 : 0;
+ pvp->rec_delay = data.io_info.rx_delay;
+ break;
+ case VIRTUAL_OSS_GET_INPUT_MON_INFO:
+ pvm = vmonitor_by_index(data.mon_info.number,
+ &virtual_monitor_input);
+ if (pvm == NULL) {
+ error = CUSE_ERR_INVALID;
+ break;
+ }
+ data.mon_info.src_chan = pvm->src_chan;
+ data.mon_info.dst_chan = pvm->dst_chan;
+ data.mon_info.pol = pvm->pol;
+ data.mon_info.mute = pvm->mute;
+ data.mon_info.amp = pvm->shift;
+ data.mon_info.bits = voss_dsp_bits;
+ break;
+ case VIRTUAL_OSS_SET_INPUT_MON_INFO:
+ pvm = vmonitor_by_index(data.mon_info.number,
+ &virtual_monitor_input);
+ if (pvm == NULL ||
+ data.mon_info.amp < -31 ||
+ data.mon_info.amp > 31) {
+ error = CUSE_ERR_INVALID;
+ break;
+ }
+ pvm->src_chan = data.mon_info.src_chan;
+ pvm->dst_chan = data.mon_info.dst_chan;
+ pvm->pol = data.mon_info.pol ? 1 : 0;
+ pvm->mute = data.mon_info.mute ? 1 : 0;
+ pvm->shift = data.mon_info.amp;
+ break;
+ case VIRTUAL_OSS_GET_OUTPUT_MON_INFO:
+ pvm = vmonitor_by_index(data.mon_info.number,
+ &virtual_monitor_output);
+ if (pvm == NULL) {
+ error = CUSE_ERR_INVALID;
+ break;
+ }
+ data.mon_info.src_chan = pvm->src_chan;
+ data.mon_info.dst_chan = pvm->dst_chan;
+ data.mon_info.pol = pvm->pol;
+ data.mon_info.mute = pvm->mute;
+ data.mon_info.amp = pvm->shift;
+ data.mon_info.bits = voss_dsp_bits;
+ break;
+ case VIRTUAL_OSS_SET_OUTPUT_MON_INFO:
+ pvm = vmonitor_by_index(data.mon_info.number,
+ &virtual_monitor_output);
+ if (pvm == NULL ||
+ data.mon_info.amp < -31 ||
+ data.mon_info.amp > 31) {
+ error = CUSE_ERR_INVALID;
+ break;
+ }
+ pvm->src_chan = data.mon_info.src_chan;
+ pvm->dst_chan = data.mon_info.dst_chan;
+ pvm->pol = data.mon_info.pol ? 1 : 0;
+ pvm->mute = data.mon_info.mute ? 1 : 0;
+ pvm->shift = data.mon_info.amp;
+ break;
+ case VIRTUAL_OSS_GET_LOCAL_MON_INFO:
+ pvm = vmonitor_by_index(data.mon_info.number,
+ &virtual_monitor_local);
+ if (pvm == NULL) {
+ error = CUSE_ERR_INVALID;
+ break;
+ }
+ data.mon_info.src_chan = pvm->src_chan;
+ data.mon_info.dst_chan = pvm->dst_chan;
+ data.mon_info.pol = pvm->pol;
+ data.mon_info.mute = pvm->mute;
+ data.mon_info.amp = pvm->shift;
+ data.mon_info.bits = voss_dsp_bits;
+ break;
+ case VIRTUAL_OSS_SET_LOCAL_MON_INFO:
+ pvm = vmonitor_by_index(data.mon_info.number,
+ &virtual_monitor_local);
+ if (pvm == NULL ||
+ data.mon_info.amp < -31 ||
+ data.mon_info.amp > 31) {
+ error = CUSE_ERR_INVALID;
+ break;
+ }
+ pvm->src_chan = data.mon_info.src_chan;
+ pvm->dst_chan = data.mon_info.dst_chan;
+ pvm->pol = data.mon_info.pol ? 1 : 0;
+ pvm->mute = data.mon_info.mute ? 1 : 0;
+ pvm->shift = data.mon_info.amp;
+ break;
+ case VIRTUAL_OSS_GET_DEV_PEAK:
+ case VIRTUAL_OSS_GET_LOOP_PEAK:
+ if (pvp == NULL ||
+ data.io_peak.channel < 0 ||
+ data.io_peak.channel >= (int)pvp->channels) {
+ error = CUSE_ERR_INVALID;
+ break;
+ }
+ strlcpy(data.io_peak.name, pvp->oss_name, sizeof(data.io_peak.name));
+ chan = data.io_peak.channel;
+ data.io_peak.rx_peak_value = pvp->rx_peak_value[chan];
+ pvp->rx_peak_value[chan] = 0;
+ data.io_peak.tx_peak_value = pvp->tx_peak_value[chan];
+ pvp->tx_peak_value[chan] = 0;
+ data.io_peak.bits = pvp->bits;
+ break;
+ case VIRTUAL_OSS_GET_INPUT_MON_PEAK:
+ pvm = vmonitor_by_index(data.mon_peak.number,
+ &virtual_monitor_input);
+ if (pvm == NULL) {
+ error = CUSE_ERR_INVALID;
+ break;
+ }
+ data.mon_peak.peak_value = pvm->peak_value;
+ data.mon_peak.bits = voss_dsp_bits;
+ pvm->peak_value = 0;
+ break;
+ case VIRTUAL_OSS_GET_OUTPUT_MON_PEAK:
+ pvm = vmonitor_by_index(data.mon_peak.number,
+ &virtual_monitor_output);
+ if (pvm == NULL) {
+ error = CUSE_ERR_INVALID;
+ break;
+ }
+ data.mon_peak.peak_value = pvm->peak_value;
+ data.mon_peak.bits = voss_dsp_bits;
+ pvm->peak_value = 0;
+ break;
+ case VIRTUAL_OSS_GET_LOCAL_MON_PEAK:
+ pvm = vmonitor_by_index(data.mon_peak.number,
+ &virtual_monitor_local);
+ if (pvm == NULL) {
+ error = CUSE_ERR_INVALID;
+ break;
+ }
+ data.mon_peak.peak_value = pvm->peak_value;
+ data.mon_peak.bits = voss_dsp_bits;
+ pvm->peak_value = 0;
+ break;
+ case VIRTUAL_OSS_ADD_INPUT_MON:
+ pvm = vmonitor_alloc(&data.val,
+ &virtual_monitor_input);
+ if (pvm == NULL)
+ error = CUSE_ERR_INVALID;
+ break;
+ case VIRTUAL_OSS_ADD_OUTPUT_MON:
+ pvm = vmonitor_alloc(&data.val,
+ &virtual_monitor_output);
+ if (pvm == NULL)
+ error = CUSE_ERR_INVALID;
+ break;
+ case VIRTUAL_OSS_ADD_LOCAL_MON:
+ pvm = vmonitor_alloc(&data.val,
+ &virtual_monitor_local);
+ if (pvm == NULL)
+ error = CUSE_ERR_INVALID;
+ break;
+ case VIRTUAL_OSS_SET_OUTPUT_LIMIT:
+ if (data.out_lim.enabled < 0 ||
+ data.out_lim.enabled > 1 ||
+ data.out_lim.knee < VIRTUAL_OSS_KNEE_MIN ||
+ data.out_lim.knee > VIRTUAL_OSS_KNEE_MAX ||
+ data.out_lim.attack < VIRTUAL_OSS_ATTACK_MIN ||
+ data.out_lim.attack > VIRTUAL_OSS_ATTACK_MAX ||
+ data.out_lim.decay < VIRTUAL_OSS_DECAY_MIN ||
+ data.out_lim.decay > VIRTUAL_OSS_DECAY_MAX ||
+ data.out_lim.gain != 0) {
+ error = CUSE_ERR_INVALID;
+ break;
+ }
+ voss_output_compressor_param.enabled = data.out_lim.enabled;
+ voss_output_compressor_param.knee = data.out_lim.knee;
+ voss_output_compressor_param.attack = data.out_lim.attack;
+ voss_output_compressor_param.decay = data.out_lim.decay;
+ break;
+ case VIRTUAL_OSS_GET_OUTPUT_LIMIT:
+ data.out_lim.enabled = voss_output_compressor_param.enabled;
+ data.out_lim.knee = voss_output_compressor_param.knee;
+ data.out_lim.attack = voss_output_compressor_param.attack;
+ data.out_lim.decay = voss_output_compressor_param.decay;
+ data.out_lim.gain = 1000;
+ for (chan = 0; chan != VMAX_CHAN; chan++) {
+ int gain = voss_output_compressor_gain[chan] * 1000.0;
+ if (data.out_lim.gain > gain)
+ data.out_lim.gain = gain;
+ }
+ break;
+ case VIRTUAL_OSS_SET_DEV_LIMIT:
+ case VIRTUAL_OSS_SET_LOOP_LIMIT:
+ if (pvp == NULL ||
+ data.io_lim.param.enabled < 0 ||
+ data.io_lim.param.enabled > 1 ||
+ data.io_lim.param.knee < VIRTUAL_OSS_KNEE_MIN ||
+ data.io_lim.param.knee > VIRTUAL_OSS_KNEE_MAX ||
+ data.io_lim.param.attack < VIRTUAL_OSS_ATTACK_MIN ||
+ data.io_lim.param.attack > VIRTUAL_OSS_ATTACK_MAX ||
+ data.io_lim.param.decay < VIRTUAL_OSS_DECAY_MIN ||
+ data.io_lim.param.decay > VIRTUAL_OSS_DECAY_MAX ||
+ data.io_lim.param.gain != 0) {
+ error = CUSE_ERR_INVALID;
+ break;
+ }
+ pvp->rx_compressor_param.enabled = data.io_lim.param.enabled;
+ pvp->rx_compressor_param.knee = data.io_lim.param.knee;
+ pvp->rx_compressor_param.attack = data.io_lim.param.attack;
+ pvp->rx_compressor_param.decay = data.io_lim.param.decay;
+ break;
+ case VIRTUAL_OSS_GET_DEV_LIMIT:
+ case VIRTUAL_OSS_GET_LOOP_LIMIT:
+ if (pvp == NULL) {
+ error = CUSE_ERR_INVALID;
+ break;
+ }
+ data.io_lim.param.enabled = pvp->rx_compressor_param.enabled;
+ data.io_lim.param.knee = pvp->rx_compressor_param.knee;
+ data.io_lim.param.attack = pvp->rx_compressor_param.attack;
+ data.io_lim.param.decay = pvp->rx_compressor_param.decay;
+ data.io_lim.param.gain = 1000;
+
+ for (chan = 0; chan != VMAX_CHAN; chan++) {
+ int gain = pvp->rx_compressor_gain[chan] * 1000.0;
+ if (data.io_lim.param.gain > gain)
+ data.io_lim.param.gain = gain;
+ }
+ break;
+ case VIRTUAL_OSS_GET_OUTPUT_PEAK:
+ chan = data.master_peak.channel;
+ if (chan < 0 ||
+ chan >= (int)voss_max_channels) {
+ error = CUSE_ERR_INVALID;
+ break;
+ }
+ data.master_peak.bits = voss_dsp_bits;
+ data.master_peak.peak_value = voss_output_peak[chan];
+ voss_output_peak[chan] = 0;
+ break;
+ case VIRTUAL_OSS_GET_INPUT_PEAK:
+ chan = data.master_peak.channel;
+ if (chan < 0 ||
+ chan >= (int)voss_dsp_max_channels) {
+ error = CUSE_ERR_INVALID;
+ break;
+ }
+ data.master_peak.bits = voss_dsp_bits;
+ data.master_peak.peak_value = voss_input_peak[chan];
+ voss_input_peak[chan] = 0;
+ break;
+
+ case VIRTUAL_OSS_SET_RECORDING:
+ voss_is_recording = data.val ? 1 : 0;
+ break;
+
+ case VIRTUAL_OSS_GET_RECORDING:
+ data.val = voss_is_recording;
+ break;
+
+ case VIRTUAL_OSS_SET_AUDIO_DELAY_LOCATOR:
+ if (data.ad_locator.channel_output < 0 ||
+ data.ad_locator.channel_output >= (int)voss_mix_channels) {
+ error = CUSE_ERR_INVALID;
+ break;
+ }
+ if (data.ad_locator.channel_input < 0 ||
+ data.ad_locator.channel_input >= (int)voss_mix_channels) {
+ error = CUSE_ERR_INVALID;
+ break;
+ }
+ if (data.ad_locator.signal_output_level < 0 ||
+ data.ad_locator.signal_output_level >= 64) {
+ error = CUSE_ERR_INVALID;
+ break;
+ }
+ voss_ad_enabled = (data.ad_locator.locator_enabled != 0);
+ voss_ad_output_signal = data.ad_locator.signal_output_level;
+ voss_ad_output_channel = data.ad_locator.channel_output;
+ voss_ad_input_channel = data.ad_locator.channel_input;
+ break;
+
+ case VIRTUAL_OSS_GET_AUDIO_DELAY_LOCATOR:
+ data.ad_locator.locator_enabled = voss_ad_enabled;
+ data.ad_locator.signal_output_level = voss_ad_output_signal;
+ data.ad_locator.channel_output = voss_ad_output_channel;
+ data.ad_locator.channel_input = voss_ad_input_channel;
+ data.ad_locator.channel_last = voss_mix_channels - 1;
+ data.ad_locator.signal_input_delay = voss_ad_last_delay;
+ data.ad_locator.signal_delay_hz = voss_dsp_sample_rate;
+ break;
+
+ case VIRTUAL_OSS_RST_AUDIO_DELAY_LOCATOR:
+ voss_ad_reset();
+ break;
+
+ case VIRTUAL_OSS_ADD_OPTIONS:
+ data.options[VIRTUAL_OSS_OPTIONS_MAX - 1] = 0;
+ voss_add_options(data.options);
+ break;
+
+ case VIRTUAL_OSS_GET_RX_DEV_FIR_FILTER:
+ case VIRTUAL_OSS_GET_RX_LOOP_FIR_FILTER:
+ if (pvp == NULL ||
+ data.fir_filter.channel < 0 ||
+ data.fir_filter.channel >= (int)pvp->channels) {
+ error = CUSE_ERR_INVALID;
+ } else if (data.fir_filter.filter_data == NULL) {
+ data.fir_filter.filter_size = pvp->rx_filter_size;
+ } else if (data.fir_filter.filter_size != (int)pvp->rx_filter_size) {
+ error = CUSE_ERR_INVALID;
+ } else if (pvp->rx_filter_data[data.fir_filter.channel] == NULL) {
+ error = CUSE_ERR_NO_MEMORY; /* filter disabled */
+ } else {
+ error = cuse_copy_out(pvp->rx_filter_data[data.fir_filter.channel],
+ data.fir_filter.filter_data,
+ sizeof(pvp->rx_filter_data[0][0]) *
+ data.fir_filter.filter_size);
+ }
+ break;
+
+ case VIRTUAL_OSS_GET_TX_DEV_FIR_FILTER:
+ case VIRTUAL_OSS_GET_TX_LOOP_FIR_FILTER:
+ if (pvp == NULL ||
+ data.fir_filter.channel < 0 ||
+ data.fir_filter.channel >= (int)pvp->channels) {
+ error = CUSE_ERR_INVALID;
+ } else if (data.fir_filter.filter_data == NULL) {
+ data.fir_filter.filter_size = pvp->tx_filter_size;
+ } else if (data.fir_filter.filter_size != (int)pvp->tx_filter_size) {
+ error = CUSE_ERR_INVALID;
+ } else if (pvp->tx_filter_data[data.fir_filter.channel] == NULL) {
+ error = CUSE_ERR_NO_MEMORY; /* filter disabled */
+ } else {
+ error = cuse_copy_out(pvp->tx_filter_data[data.fir_filter.channel],
+ data.fir_filter.filter_data,
+ sizeof(pvp->tx_filter_data[0][0]) *
+ data.fir_filter.filter_size);
+ }
+ break;
+
+ case VIRTUAL_OSS_SET_RX_DEV_FIR_FILTER:
+ case VIRTUAL_OSS_SET_RX_LOOP_FIR_FILTER:
+ if (pvp == NULL ||
+ data.fir_filter.channel < 0 ||
+ data.fir_filter.channel >= (int)pvp->channels) {
+ error = CUSE_ERR_INVALID;
+ } else if (data.fir_filter.filter_data == NULL) {
+ free(pvp->rx_filter_data[data.fir_filter.channel]);
+ pvp->rx_filter_data[data.fir_filter.channel] = NULL; /* disable filter */
+ } else if (data.fir_filter.filter_size != (int)pvp->rx_filter_size) {
+ error = CUSE_ERR_INVALID;
+ } else if (pvp->rx_filter_size != 0) {
+ size_t size = sizeof(pvp->rx_filter_data[0][0]) * pvp->rx_filter_size;
+ if (pvp->rx_filter_data[data.fir_filter.channel] == NULL) {
+ pvp->rx_filter_data[data.fir_filter.channel] = malloc(size);
+ if (pvp->rx_filter_data[data.fir_filter.channel] == NULL)
+ error = CUSE_ERR_NO_MEMORY;
+ else
+ memset(pvp->rx_filter_data[data.fir_filter.channel], 0, size);
+ }
+ if (pvp->rx_filter_data[data.fir_filter.channel] != NULL) {
+ error = cuse_copy_in(data.fir_filter.filter_data,
+ pvp->rx_filter_data[data.fir_filter.channel], size);
+ }
+ }
+ break;
+
+ case VIRTUAL_OSS_SET_TX_DEV_FIR_FILTER:
+ case VIRTUAL_OSS_SET_TX_LOOP_FIR_FILTER:
+ if (pvp == NULL ||
+ data.fir_filter.channel < 0 ||
+ data.fir_filter.channel >= (int)pvp->channels) {
+ error = CUSE_ERR_INVALID;
+ } else if (data.fir_filter.filter_data == NULL) {
+ free(pvp->tx_filter_data[data.fir_filter.channel]);
+ pvp->tx_filter_data[data.fir_filter.channel] = NULL; /* disable filter */
+ } else if (data.fir_filter.filter_size != (int)pvp->tx_filter_size) {
+ error = CUSE_ERR_INVALID;
+ } else if (pvp->tx_filter_size != 0) {
+ size_t size = sizeof(pvp->tx_filter_data[0][0]) * pvp->tx_filter_size;
+ if (pvp->tx_filter_data[data.fir_filter.channel] == NULL) {
+ pvp->tx_filter_data[data.fir_filter.channel] = malloc(size);
+ if (pvp->tx_filter_data[data.fir_filter.channel] == NULL)
+ error = CUSE_ERR_NO_MEMORY;
+ else
+ memset(pvp->tx_filter_data[data.fir_filter.channel], 0, size);
+ }
+ if (pvp->tx_filter_data[data.fir_filter.channel] != NULL) {
+ error = cuse_copy_in(data.fir_filter.filter_data,
+ pvp->tx_filter_data[data.fir_filter.channel], size);
+ }
+ }
+ break;
+
+ case VIRTUAL_OSS_GET_SAMPLE_RATE:
+ data.val = voss_dsp_sample_rate;
+ break;
+
+ case VIRTUAL_OSS_GET_SYSTEM_INFO:
+ data.sys_info.tx_jitter_up = voss_jitter_up;
+ data.sys_info.tx_jitter_down = voss_jitter_down;
+ data.sys_info.sample_rate = voss_dsp_sample_rate;
+ data.sys_info.sample_bits = voss_dsp_bits;
+ data.sys_info.sample_channels = voss_mix_channels;
+ strlcpy(data.sys_info.rx_device_name, voss_dsp_rx_device,
+ sizeof(data.sys_info.rx_device_name));
+ strlcpy(data.sys_info.tx_device_name, voss_dsp_tx_device,
+ sizeof(data.sys_info.tx_device_name));
+ break;
+
+ default:
+ error = CUSE_ERR_INVALID;
+ break;
+ }
+ atomic_unlock();
+
+ if (error == 0) {
+ if (cmd & IOC_OUT)
+ error = cuse_copy_out(&data, peer_data, len);
+ }
+ return (error);
+}
+
+const struct cuse_methods vctl_methods = {
+ .cm_open = vctl_open,
+ .cm_close = vctl_close,
+ .cm_ioctl = vctl_ioctl,
+};
diff --git a/usr.sbin/virtual_oss/virtual_oss/eq.c b/usr.sbin/virtual_oss/virtual_oss/eq.c
new file mode 100644
--- /dev/null
+++ b/usr.sbin/virtual_oss/virtual_oss/eq.c
@@ -0,0 +1,226 @@
+/*-
+ * Copyright (c) 2021 Hans Petter Selasky
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/queue.h>
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+
+#include "int.h"
+
+void
+vclient_tx_equalizer(struct virtual_client *pvc,
+ int64_t *src, size_t total)
+{
+ double *f_data;
+ size_t channels;
+ size_t f_size;
+ size_t x;
+
+ f_size = pvc->profile->tx_filter_size;
+ if (f_size == 0 || total == 0)
+ return;
+
+ channels = pvc->channels;
+ total /= channels;
+
+ while (1) {
+ size_t delta;
+ size_t offset;
+ size_t y;
+
+ offset = pvc->tx_filter_offset;
+ delta = f_size - offset;
+
+ if (delta > total)
+ delta = total;
+
+ for (x = 0; x != channels; x++) {
+ f_data = pvc->profile->tx_filter_data[x];
+ if (f_data == NULL)
+ continue;
+
+ for (y = 0; y != delta; y++) {
+ pvc->tx_filter_in[x][y + offset] = src[x + y * channels];
+ src[x + y * channels] = pvc->tx_filter_out[x][y + offset];
+ }
+ }
+
+ pvc->tx_filter_offset += delta;
+ total -= delta;
+ src += delta * channels;
+
+ /* check if there is enough data for a new transform */
+ if (pvc->tx_filter_offset == f_size) {
+ for (x = 0; x != channels; x++) {
+ f_data = pvc->profile->tx_filter_data[x];
+ if (f_data == NULL)
+ continue;
+
+ /* shift down output */
+ for (y = 0; y != f_size; y++) {
+ pvc->tx_filter_out[x][y] = pvc->tx_filter_out[x][y + f_size];
+ pvc->tx_filter_out[x][y + f_size] = 0;
+ }
+ /* perform transform */
+ voss_x3_multiply_double(pvc->tx_filter_in[x],
+ f_data, pvc->tx_filter_out[x], f_size);
+ }
+ pvc->tx_filter_offset = 0;
+ }
+ if (total == 0)
+ break;
+ }
+}
+
+void
+vclient_rx_equalizer(struct virtual_client *pvc,
+ int64_t *src, size_t total)
+{
+ double *f_data;
+ size_t channels;
+ size_t f_size;
+ size_t x;
+
+ f_size = pvc->profile->rx_filter_size;
+
+ if (f_size == 0 || total == 0)
+ return;
+
+ channels = pvc->channels;
+ total /= channels;
+
+ while (1) {
+ size_t delta;
+ size_t offset;
+ size_t y;
+
+ offset = pvc->rx_filter_offset;
+ delta = f_size - offset;
+
+ if (delta > total)
+ delta = total;
+
+ for (x = 0; x != channels; x++) {
+ f_data = pvc->profile->rx_filter_data[x];
+ if (f_data == NULL)
+ continue;
+
+ for (y = 0; y != delta; y++) {
+ pvc->rx_filter_in[x][y + offset] = src[x + y * channels];
+ src[x + y * channels] = pvc->rx_filter_out[x][y + offset];
+ }
+ }
+
+ pvc->rx_filter_offset += delta;
+ total -= delta;
+ src += delta * channels;
+
+ /* check if there is enough data for a new transform */
+ if (pvc->rx_filter_offset == f_size) {
+ for (x = 0; x != channels; x++) {
+ f_data = pvc->profile->rx_filter_data[x];
+ if (f_data == NULL)
+ continue;
+
+ /* shift output down */
+ for (y = 0; y != f_size; y++) {
+ pvc->rx_filter_out[x][y] = pvc->rx_filter_out[x][y + f_size];
+ pvc->rx_filter_out[x][y + f_size] = 0;
+ }
+ /* perform transform */
+ voss_x3_multiply_double(pvc->rx_filter_in[x],
+ f_data, pvc->rx_filter_out[x], f_size);
+ }
+ pvc->rx_filter_offset = 0;
+ }
+ if (total == 0)
+ break;
+ }
+}
+
+int
+vclient_eq_alloc(struct virtual_client *pvc)
+{
+ uint8_t x;
+
+ pvc->tx_filter_offset = 0;
+ pvc->rx_filter_offset = 0;
+
+ for (x = 0; x != pvc->channels; x++) {
+ uint32_t size;
+
+ size = pvc->profile->tx_filter_size;
+ if (size != 0) {
+ pvc->tx_filter_in[x] =
+ malloc(sizeof(pvc->tx_filter_in[x][0]) * size);
+ pvc->tx_filter_out[x] =
+ calloc(2 * size, sizeof(pvc->tx_filter_out[x][0]));
+ if (pvc->tx_filter_in[x] == NULL ||
+ pvc->tx_filter_out[x] == NULL)
+ goto error;
+ }
+ size = pvc->profile->rx_filter_size;
+ if (size != 0) {
+ pvc->rx_filter_in[x] =
+ malloc(sizeof(pvc->rx_filter_in[x][0]) * size);
+ pvc->rx_filter_out[x] =
+ calloc(2 * size, sizeof(pvc->rx_filter_out[x][0]));
+ if (pvc->rx_filter_in[x] == NULL ||
+ pvc->rx_filter_out[x] == NULL)
+ goto error;
+ }
+ }
+ return (0);
+
+error:
+ vclient_eq_free(pvc);
+ return (ENOMEM);
+}
+
+void
+vclient_eq_free(struct virtual_client *pvc)
+{
+ uint8_t x;
+
+ pvc->tx_filter_offset = 0;
+ pvc->rx_filter_offset = 0;
+
+ for (x = 0; x != VMAX_CHAN; x++) {
+ free(pvc->tx_filter_in[x]);
+ pvc->tx_filter_in[x] = NULL;
+
+ free(pvc->rx_filter_in[x]);
+ pvc->rx_filter_in[x] = NULL;
+
+ free(pvc->tx_filter_out[x]);
+ pvc->tx_filter_out[x] = NULL;
+
+ free(pvc->rx_filter_out[x]);
+ pvc->rx_filter_out[x] = NULL;
+ }
+}
diff --git a/usr.sbin/virtual_oss/virtual_oss/format.c b/usr.sbin/virtual_oss/virtual_oss/format.c
new file mode 100644
--- /dev/null
+++ b/usr.sbin/virtual_oss/virtual_oss/format.c
@@ -0,0 +1,429 @@
+/*-
+ * Copyright (c) 2012-2020 Hans Petter Selasky
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/queue.h>
+#include <sys/soundcard.h>
+
+#include <stdint.h>
+#include <string.h>
+
+#include "int.h"
+
+void
+format_import(uint32_t fmt, const uint8_t *src, uint32_t len,
+ int64_t *dst)
+{
+ const uint8_t *end = src + len;
+ int64_t val;
+
+ if (fmt & AFMT_16BIT) {
+ while (src != end) {
+ if (fmt & (AFMT_S16_LE | AFMT_U16_LE))
+ val = src[0] | (src[1] << 8);
+ else
+ val = src[1] | (src[0] << 8);
+
+ src += 2;
+
+ if (fmt & (AFMT_U16_LE | AFMT_U16_BE))
+ val = val ^ 0x8000;
+
+ val <<= (64 - 16);
+ val >>= (64 - 16);
+
+ *dst++ = val;
+ }
+
+ } else if (fmt & AFMT_24BIT) {
+ while (src < end) {
+ if (fmt & (AFMT_S24_LE | AFMT_U24_LE))
+ val = src[0] | (src[1] << 8) | (src[2] << 16);
+ else
+ val = src[2] | (src[1] << 8) | (src[0] << 16);
+
+ src += 3;
+
+ if (fmt & (AFMT_U24_LE | AFMT_U24_BE))
+ val = val ^ 0x800000;
+
+ val <<= (64 - 24);
+ val >>= (64 - 24);
+
+ *dst++ = val;
+ }
+ } else if (fmt & AFMT_32BIT) {
+ while (src < end) {
+ int64_t e, m, s;
+
+ if (fmt & (AFMT_S32_LE | AFMT_U32_LE | AFMT_F32_LE))
+ val = src[0] | (src[1] << 8) | (src[2] << 16) | (src[3] << 24);
+ else
+ val = src[3] | (src[2] << 8) | (src[1] << 16) | (src[0] << 24);
+
+ src += 4;
+
+ if (fmt & (AFMT_U32_LE | AFMT_U32_BE))
+ val = val ^ 0x80000000LL;
+
+ if (fmt & (AFMT_F32_LE | AFMT_F32_BE)) {
+ e = (val >> 23) & 0xff;
+ /* NaN, +/- Inf or too small */
+ if (e == 0xff || e < 96) {
+ val = 0;
+ goto skip;
+ }
+ s = val & 0x80000000U;
+ if (e > 126) {
+ val = s == 0 ? format_max(fmt) :
+ -0x80000000LL;
+ goto skip;
+ }
+ m = 0x800000 | (val & 0x7fffff);
+ e += 8 - 127;
+ if (e < 0)
+ m >>= -e;
+ else
+ m <<= e;
+ val = s == 0 ? m : -m;
+ }
+skip:
+ val <<= (64 - 32);
+ val >>= (64 - 32);
+
+ *dst++ = val;
+ }
+
+ } else if (fmt & AFMT_8BIT) {
+ while (src < end) {
+ val = src[0];
+
+ src += 1;
+
+ if (fmt & AFMT_U8)
+ val = val ^ 0x80;
+
+ val <<= (64 - 8);
+ val >>= (64 - 8);
+
+ *dst++ = val;
+ }
+ }
+}
+
+void
+format_export(uint32_t fmt, const int64_t *src, uint8_t *dst, uint32_t len)
+{
+ const uint8_t *end = dst + len;
+ int64_t val;
+
+ if (fmt & AFMT_16BIT) {
+ while (dst != end) {
+
+ val = *src++;
+
+ if (val > 0x7FFF)
+ val = 0x7FFF;
+ else if (val < -0x7FFF)
+ val = -0x7FFF;
+
+ if (fmt & (AFMT_U16_LE | AFMT_U16_BE))
+ val = val ^ 0x8000;
+
+ if (fmt & (AFMT_S16_LE | AFMT_U16_LE)) {
+ dst[0] = val;
+ dst[1] = val >> 8;
+ } else {
+ dst[1] = val;
+ dst[0] = val >> 8;
+ }
+
+ dst += 2;
+ }
+
+ } else if (fmt & AFMT_24BIT) {
+ while (dst != end) {
+
+ val = *src++;
+
+ if (val > 0x7FFFFF)
+ val = 0x7FFFFF;
+ else if (val < -0x7FFFFF)
+ val = -0x7FFFFF;
+
+ if (fmt & (AFMT_U24_LE | AFMT_U24_BE))
+ val = val ^ 0x800000;
+
+ if (fmt & (AFMT_S24_LE | AFMT_U24_LE)) {
+ dst[0] = val;
+ dst[1] = val >> 8;
+ dst[2] = val >> 16;
+ } else {
+ dst[2] = val;
+ dst[1] = val >> 8;
+ dst[0] = val >> 16;
+ }
+
+ dst += 3;
+ }
+ } else if (fmt & AFMT_32BIT) {
+ while (dst != end) {
+ int64_t r, e;
+
+ val = *src++;
+
+ if (val > 0x7FFFFFFFLL)
+ val = 0x7FFFFFFFLL;
+ else if (val < -0x7FFFFFFFLL)
+ val = -0x7FFFFFFFLL;
+
+ if (fmt & (AFMT_F32_LE | AFMT_F32_BE)) {
+ if (val == 0)
+ r = 0;
+ else if (val == format_max(fmt))
+ r = 0x3f800000;
+ else if (val == -0x80000000LL)
+ r = 0x80000000U | 0x3f800000;
+ else {
+ r = 0;
+ if (val < 0) {
+ r |= 0x80000000U;
+ val = -val;
+ }
+ e = 127 - 8;
+ while ((val & 0x7f000000) != 0) {
+ val >>= 1;
+ e++;
+ }
+ while ((val & 0x7f800000) == 0) {
+ val <<= 1;
+ e--;
+ }
+ r |= (e & 0xff) << 23;
+ r |= val & 0x7fffff;
+ }
+ val = r;
+ }
+
+ if (fmt & (AFMT_U32_LE | AFMT_U32_BE))
+ val = val ^ 0x80000000LL;
+
+ if (fmt & (AFMT_S32_LE | AFMT_U32_LE | AFMT_F32_LE)) {
+ dst[0] = val;
+ dst[1] = val >> 8;
+ dst[2] = val >> 16;
+ dst[3] = val >> 24;
+ } else {
+ dst[3] = val;
+ dst[2] = val >> 8;
+ dst[1] = val >> 16;
+ dst[0] = val >> 24;
+ }
+
+ dst += 4;
+ }
+
+ } else if (fmt & AFMT_8BIT) {
+ while (dst != end) {
+
+ val = *src++;
+
+ if (val > 0x7F)
+ val = 0x7F;
+ else if (val < -0x7F)
+ val = -0x7F;
+
+ if (fmt & (AFMT_U8))
+ val = val ^ 0x80;
+
+ dst[0] = val;
+
+ dst += 1;
+ }
+ }
+}
+
+int64_t
+format_max(uint32_t fmt)
+{
+ if (fmt & AFMT_16BIT)
+ return (0x7FFF);
+ else if (fmt & AFMT_24BIT)
+ return (0x7FFFFF);
+ else if (fmt & AFMT_32BIT)
+ return (0x7FFFFFFF);
+ else if (fmt & AFMT_8BIT)
+ return (0x7F);
+ return (0);
+}
+
+void
+format_maximum(const int64_t *src, int64_t *dst, uint32_t ch,
+ uint32_t samples, int8_t shift)
+{
+ const int64_t *end = src + (samples * ch);
+ int64_t max[ch];
+ int64_t temp;
+ uint32_t x;
+
+ memset(max, 0, sizeof(max));
+
+ while (src != end) {
+ for (x = 0; x != ch; x++) {
+ temp = *src++;
+ if (temp < 0)
+ temp = -temp;
+ if (temp > max[x])
+ max[x] = temp;
+ }
+ }
+
+ for (x = 0; x != ch; x++) {
+ if (shift < 0)
+ max[x] >>= -shift;
+ else
+ max[x] <<= shift;
+ if (dst[x] < max[x])
+ dst[x] = max[x];
+ }
+}
+
+void
+format_remix(int64_t *buffer_data, uint32_t in_chans,
+ uint32_t out_chans, uint32_t samples)
+{
+ uint32_t x;
+
+ if (out_chans > in_chans) {
+ uint32_t dst = out_chans * (samples - 1);
+ uint32_t src = in_chans * (samples - 1);
+ uint32_t fill = out_chans - in_chans;
+
+ for (x = 0; x != samples; x++) {
+ memset(buffer_data + dst + in_chans, 0, 8 * fill);
+ if (src != dst) {
+ memcpy(buffer_data + dst,
+ buffer_data + src,
+ in_chans * 8);
+ }
+ dst -= out_chans;
+ src -= in_chans;
+ }
+ } else if (out_chans < in_chans) {
+ uint32_t dst = 0;
+ uint32_t src = 0;
+
+ for (x = 0; x != samples; x++) {
+ if (src != dst) {
+ memcpy(buffer_data + dst,
+ buffer_data + src,
+ out_chans * 8);
+ }
+ dst += out_chans;
+ src += in_chans;
+ }
+ }
+}
+
+void
+format_silence(uint32_t fmt, uint8_t *dst, uint32_t len)
+{
+ const uint8_t *end = dst + len;
+
+ if (fmt & AFMT_16BIT) {
+ uint16_t val;
+
+ if (fmt & (AFMT_U16_LE | AFMT_U16_BE))
+ val = 1U << 15;
+ else
+ val = 0;
+
+ while (dst != end) {
+ if (fmt & (AFMT_S16_LE | AFMT_U16_LE)) {
+ dst[0] = val;
+ dst[1] = val >> 8;
+ } else {
+ dst[1] = val;
+ dst[0] = val >> 8;
+ }
+ dst += 2;
+ }
+
+ } else if (fmt & AFMT_24BIT) {
+ uint32_t val;
+
+ if (fmt & (AFMT_U24_LE | AFMT_U24_BE))
+ val = 1U << 23;
+ else
+ val = 0;
+
+ while (dst != end) {
+ if (fmt & (AFMT_S24_LE | AFMT_U24_LE)) {
+ dst[0] = val;
+ dst[1] = val >> 8;
+ dst[2] = val >> 16;
+ } else {
+ dst[2] = val;
+ dst[1] = val >> 8;
+ dst[0] = val >> 16;
+ }
+ dst += 3;
+ }
+ } else if (fmt & AFMT_32BIT) {
+ uint32_t val;
+
+ if (fmt & (AFMT_U32_LE | AFMT_U32_BE))
+ val = 1U << 31;
+ else
+ val = 0;
+
+ while (dst != end) {
+ if (fmt & (AFMT_S32_LE | AFMT_U32_LE | AFMT_F32_LE)) {
+ dst[0] = val;
+ dst[1] = val >> 8;
+ dst[2] = val >> 16;
+ dst[3] = val >> 24;
+ } else {
+ dst[3] = val;
+ dst[2] = val >> 8;
+ dst[1] = val >> 16;
+ dst[0] = val >> 24;
+ }
+ dst += 4;
+ }
+
+ } else if (fmt & AFMT_8BIT) {
+ uint8_t val;
+
+ if (fmt & AFMT_U8)
+ val = 1U << 7;
+ else
+ val = 0;
+
+ while (dst != end) {
+ dst[0] = val;
+ dst += 1;
+ }
+ }
+}
diff --git a/usr.sbin/virtual_oss/virtual_oss/httpd.c b/usr.sbin/virtual_oss/virtual_oss/httpd.c
new file mode 100644
--- /dev/null
+++ b/usr.sbin/virtual_oss/virtual_oss/httpd.c
@@ -0,0 +1,844 @@
+/*-
+ * Copyright (c) 2020 Hans Petter Selasky
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/types.h>
+#include <sys/queue.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <sys/endian.h>
+#include <sys/uio.h>
+#include <sys/soundcard.h>
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <err.h>
+#include <errno.h>
+#include <poll.h>
+#include <sysexits.h>
+
+#include <netdb.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+
+#include <net/if.h>
+#include <net/if_vlan_var.h>
+#include <net/bpf.h>
+
+#include <arpa/inet.h>
+
+#include <pthread.h>
+
+#include "int.h"
+
+#define VOSS_HTTPD_BIND_MAX 8
+#define VOSS_HTTPD_MAX_STREAM_TIME (60 * 60 * 3) /* seconds */
+
+struct http_state {
+ int fd;
+ uint64_t ts;
+};
+
+struct rtp_raw_packet {
+ struct {
+ uint32_t padding;
+ uint8_t dhost[6];
+ uint8_t shost[6];
+ uint16_t ether_type;
+ } __packed eth;
+ struct {
+ uint8_t hl_ver;
+ uint8_t tos;
+ uint16_t len;
+ uint16_t ident;
+ uint16_t offset;
+ uint8_t ttl;
+ uint8_t protocol;
+ uint16_t chksum;
+ union {
+ uint32_t sourceip;
+ uint16_t source16[2];
+ };
+ union {
+ uint32_t destip;
+ uint16_t dest16[2];
+ };
+ } __packed ip;
+ struct {
+ uint16_t srcport;
+ uint16_t dstport;
+ uint16_t len;
+ uint16_t chksum;
+ } __packed udp;
+ union {
+ uint8_t header8[12];
+ uint16_t header16[6];
+ uint32_t header32[3];
+ } __packed rtp;
+
+} __packed;
+
+static const char *
+voss_httpd_bind_rtp(vclient_t *pvc, const char *ifname, int *pfd)
+{
+ const char *perr = NULL;
+ struct vlanreq vr = {};
+ struct ifreq ifr = {};
+ int fd;
+
+ fd = socket(AF_LOCAL, SOCK_DGRAM, 0);
+ if (fd < 0) {
+ perr = "Cannot open raw RTP socket";
+ goto done;
+ }
+
+ strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
+ ifr.ifr_data = (void *)&vr;
+
+ if (ioctl(fd, SIOCGETVLAN, &ifr) == 0)
+ pvc->profile->http.rtp_vlanid = vr.vlr_tag;
+ else
+ pvc->profile->http.rtp_vlanid = 0;
+
+ close(fd);
+
+ ifr.ifr_data = NULL;
+
+ *pfd = fd = open("/dev/bpf", O_RDWR);
+ if (fd < 0) {
+ perr = "Cannot open BPF device";
+ goto done;
+ }
+
+ if (ioctl(fd, BIOCSETIF, &ifr) != 0) {
+ perr = "Cannot bind BPF device to network interface";
+ goto done;
+ }
+done:
+ if (perr != NULL && fd > -1)
+ close(fd);
+ return (perr);
+}
+
+static uint16_t
+voss_ipv4_csum(const uint16_t *ptr, size_t count)
+{
+ uint32_t sum = 0;
+
+ while (count--)
+ sum += *ptr++;
+
+ sum = (sum >> 16) + (sum & 0xffff);
+ sum += (sum >> 16);
+
+ return (~sum);
+}
+
+static uint16_t
+voss_udp_csum(uint32_t sum, const uint16_t *hdr, size_t count,
+ const uint16_t *ptr, size_t length)
+{
+ while (count--)
+ sum += *hdr++;
+
+ while (length > 1) {
+ sum += *ptr++;
+ length -= 2;
+ }
+
+ if (length & 1)
+ sum += *__DECONST(uint8_t *, ptr);
+
+ sum = (sum >> 16) + (sum & 0xffff);
+ sum += (sum >> 16);
+
+ return (~sum);
+}
+
+static void
+voss_httpd_send_rtp_sub(vclient_t *pvc, int fd, void *ptr, size_t len, uint32_t ts)
+{
+ struct rtp_raw_packet pkt = {};
+ struct iovec iov[2];
+ size_t total_ip;
+ uint16_t port = atoi(pvc->profile->http.rtp_port);
+ size_t x;
+
+ /* NOTE: BPF filter will insert VLAN header for us */
+ memset(pkt.eth.dhost, 255, sizeof(pkt.eth.dhost));
+ memset(pkt.eth.shost, 1, sizeof(pkt.eth.shost));
+ pkt.eth.ether_type = htobe16(0x0800);
+ total_ip = sizeof(pkt.ip) + sizeof(pkt.udp) + sizeof(pkt.rtp) + len;
+
+ iov[0].iov_base = pkt.eth.dhost;
+ iov[0].iov_len = 14 + total_ip - len;
+
+ iov[1].iov_base = alloca(len);
+ iov[1].iov_len = len;
+
+ /* byte swap data - WAV files are 16-bit little endian */
+ for (x = 0; x != (len / 2); x++)
+ ((uint16_t *)iov[1].iov_base)[x] = bswap16(((uint16_t *)ptr)[x]);
+
+ pkt.ip.hl_ver = 0x45;
+ pkt.ip.len = htobe16(total_ip);
+ pkt.ip.ttl = 8;
+ pkt.ip.protocol = 17; /* UDP */
+ pkt.ip.sourceip = 0x01010101U;
+ pkt.ip.destip = htobe32((239 << 24) + (255 << 16) + (1 << 0));
+ pkt.ip.chksum = voss_ipv4_csum((void *)&pkt.ip, sizeof(pkt.ip) / 2);
+
+ pkt.udp.srcport = htobe16(port);
+ pkt.udp.dstport = htobe16(port);
+ pkt.udp.len = htobe16(total_ip - sizeof(pkt.ip));
+
+ pkt.rtp.header8[0] = (2 << 6);
+ pkt.rtp.header8[1] = ((pvc->channels == 2) ? 10 : 11) | 0x80;
+
+ pkt.rtp.header16[1] = htobe16(pvc->profile->http.rtp_seqnum);
+ pkt.rtp.header32[1] = htobe32(ts);
+ pkt.rtp.header32[2] = htobe32(0);
+
+ pkt.udp.chksum = voss_udp_csum(pkt.ip.dest16[0] + pkt.ip.dest16[1] +
+ pkt.ip.source16[0] + pkt.ip.source16[1] + 0x1100 + pkt.udp.len,
+ (void *)&pkt.udp, sizeof(pkt.udp) / 2 + sizeof(pkt.rtp) / 2,
+ iov[1].iov_base, iov[1].iov_len);
+
+ pvc->profile->http.rtp_seqnum++;
+ pvc->profile->http.rtp_ts += len / (2 * pvc->channels);
+
+ if (writev(fd, iov, 2) < 0)
+ ;
+}
+
+static void
+voss_httpd_send_rtp(vclient_t *pvc, int fd, void *ptr, size_t len, uint32_t ts)
+{
+ const uint32_t mod = pvc->channels * vclient_sample_bytes(pvc);
+ const uint32_t max = 1420 - (1420 % mod);
+
+ while (len >= max) {
+ voss_httpd_send_rtp_sub(pvc, fd, ptr, max, ts);
+ len -= max;
+ ptr = (uint8_t *)ptr + max;
+ }
+
+ if (len != 0)
+ voss_httpd_send_rtp_sub(pvc, fd, ptr, len, ts);
+}
+
+static size_t
+voss_httpd_usage(vclient_t *pvc)
+{
+ size_t usage = 0;
+ size_t x;
+
+ for (x = 0; x < pvc->profile->http.nstate; x++)
+ usage += (pvc->profile->http.state[x].fd != -1);
+ return (usage);
+}
+
+static char *
+voss_httpd_read_line(FILE *io, char *linebuffer, size_t linelen)
+{
+ char buffer[2];
+ size_t size = 0;
+
+ if (fread(buffer, 1, 2, io) != 2)
+ return (NULL);
+
+ while (1) {
+ if (buffer[0] == '\r' && buffer[1] == '\n')
+ break;
+ if (size == (linelen - 1))
+ return (NULL);
+ linebuffer[size++] = buffer[0];
+ buffer[0] = buffer[1];
+ if (fread(buffer + 1, 1, 1, io) != 1)
+ return (NULL);
+ }
+ linebuffer[size++] = 0;
+
+ return (linebuffer);
+}
+
+static int
+voss_http_generate_wav_header(vclient_t *pvc, FILE *io,
+ uintmax_t r_start, uintmax_t r_end, bool is_partial)
+{
+ uint8_t buffer[256];
+ uint8_t *ptr;
+ uintmax_t dummy_len;
+ uintmax_t delta;
+ size_t mod;
+ size_t len;
+ size_t buflen;
+
+ ptr = buffer;
+ mod = pvc->channels * vclient_sample_bytes(pvc);
+
+ if (mod == 0 || sizeof(buffer) < (44 + mod - 1))
+ return (-1);
+
+ /* align to next sample */
+ len = 44 + mod - 1;
+ len -= len % mod;
+
+ buflen = len;
+
+ /* clear block */
+ memset(ptr, 0, len);
+
+ /* fill out data header */
+ ptr[len - 8] = 'd';
+ ptr[len - 7] = 'a';
+ ptr[len - 6] = 't';
+ ptr[len - 5] = 'a';
+
+ /* magic for unspecified length */
+ ptr[len - 4] = 0x00;
+ ptr[len - 3] = 0xF0;
+ ptr[len - 2] = 0xFF;
+ ptr[len - 1] = 0x7F;
+
+ /* fill out header */
+ *ptr++ = 'R';
+ *ptr++ = 'I';
+ *ptr++ = 'F';
+ *ptr++ = 'F';
+
+ /* total chunk size - unknown */
+
+ *ptr++ = 0;
+ *ptr++ = 0;
+ *ptr++ = 0;
+ *ptr++ = 0;
+
+ *ptr++ = 'W';
+ *ptr++ = 'A';
+ *ptr++ = 'V';
+ *ptr++ = 'E';
+ *ptr++ = 'f';
+ *ptr++ = 'm';
+ *ptr++ = 't';
+ *ptr++ = ' ';
+
+ /* make sure header fits in PCM block */
+ len -= 28;
+
+ *ptr++ = len;
+ *ptr++ = len >> 8;
+ *ptr++ = len >> 16;
+ *ptr++ = len >> 24;
+
+ /* audioformat = PCM */
+
+ *ptr++ = 0x01;
+ *ptr++ = 0x00;
+
+ /* number of channels */
+
+ len = pvc->channels;
+
+ *ptr++ = len;
+ *ptr++ = len >> 8;
+
+ /* sample rate */
+
+ len = pvc->sample_rate;
+
+ *ptr++ = len;
+ *ptr++ = len >> 8;
+ *ptr++ = len >> 16;
+ *ptr++ = len >> 24;
+
+ /* byte rate */
+
+ len = pvc->sample_rate * pvc->channels * vclient_sample_bytes(pvc);
+
+ *ptr++ = len;
+ *ptr++ = len >> 8;
+ *ptr++ = len >> 16;
+ *ptr++ = len >> 24;
+
+ /* block align */
+
+ len = pvc->channels * vclient_sample_bytes(pvc);
+
+ *ptr++ = len;
+ *ptr++ = len >> 8;
+
+ /* bits per sample */
+
+ len = vclient_sample_bytes(pvc) * 8;
+
+ *ptr++ = len;
+ *ptr++ = len >> 8;
+
+ /* check if alignment is correct */
+ if (r_start >= buflen && (r_start % mod) != 0)
+ return (2);
+
+ dummy_len = pvc->sample_rate * pvc->channels * vclient_sample_bytes(pvc);
+ dummy_len *= VOSS_HTTPD_MAX_STREAM_TIME;
+
+ /* fixup end */
+ if (r_end >= dummy_len)
+ r_end = dummy_len - 1;
+
+ delta = r_end - r_start + 1;
+
+ if (is_partial) {
+ fprintf(io, "HTTP/1.1 206 Partial Content\r\n"
+ "Content-Type: audio/wav\r\n"
+ "Server: virtual_oss/1.0\r\n"
+ "Cache-Control: no-cache, no-store\r\n"
+ "Expires: Mon, 26 Jul 1997 05:00:00 GMT\r\n"
+ "Connection: Close\r\n"
+ "Content-Range: bytes %ju-%ju/%ju\r\n"
+ "Content-Length: %ju\r\n"
+ "\r\n", r_start, r_end, dummy_len, delta);
+ } else {
+ fprintf(io, "HTTP/1.0 200 OK\r\n"
+ "Content-Type: audio/wav\r\n"
+ "Server: virtual_oss/1.0\r\n"
+ "Cache-Control: no-cache, no-store\r\n"
+ "Expires: Mon, 26 Jul 1997 05:00:00 GMT\r\n"
+ "Connection: Close\r\n"
+ "Content-Length: %ju\r\n"
+ "\r\n", dummy_len);
+ }
+
+ /* check if we should insert a header */
+ if (r_start < buflen) {
+ buflen -= r_start;
+ if (buflen > delta)
+ buflen = delta;
+ /* send data */
+ if (fwrite(buffer + r_start, buflen, 1, io) != 1)
+ return (-1);
+ /* check if all data was read */
+ if (buflen == delta)
+ return (1);
+ }
+ return (0);
+}
+
+static void
+voss_httpd_handle_connection(vclient_t *pvc, int fd, const struct sockaddr_in *sa)
+{
+ char linebuffer[2048];
+ uintmax_t r_start = 0;
+ uintmax_t r_end = -1ULL;
+ bool is_partial = false;
+ char *line;
+ FILE *io;
+ size_t x;
+ int page;
+
+ io = fdopen(fd, "r+");
+ if (io == NULL)
+ goto done;
+
+ page = -1;
+
+ /* dump HTTP request header */
+ while (1) {
+ line = voss_httpd_read_line(io, linebuffer, sizeof(linebuffer));
+ if (line == NULL)
+ goto done;
+ if (line[0] == 0)
+ break;
+ if (page < 0 && (strstr(line, "GET / ") == line ||
+ strstr(line, "GET /index.html") == line)) {
+ page = 0;
+ } else if (page < 0 && strstr(line, "GET /stream.wav") == line) {
+ page = 1;
+ } else if (page < 0 && strstr(line, "GET /stream.m3u") == line) {
+ page = 2;
+ } else if (strstr(line, "Range: bytes=") == line &&
+ sscanf(line, "Range: bytes=%zu-%zu", &r_start, &r_end) >= 1) {
+ is_partial = true;
+ }
+ }
+
+ switch (page) {
+ case 0:
+ x = voss_httpd_usage(pvc);
+
+ fprintf(io, "HTTP/1.0 200 OK\r\n"
+ "Content-Type: text/html\r\n"
+ "Server: virtual_oss/1.0\r\n"
+ "Cache-Control: no-cache, no-store\r\n"
+ "Expires: Mon, 26 Jul 1997 05:00:00 GMT\r\n"
+ "\r\n"
+ "<html><head><title>Welcome to live streaming</title>"
+ "<meta http-equiv=\"Cache-Control\" content=\"no-cache, no-store, must-revalidate\" />"
+ "<meta http-equiv=\"Pragma\" content=\"no-cache\" />"
+ "<meta http-equiv=\"Expires\" content=\"0\" />"
+ "</head>"
+ "<body>"
+ "<h1>Live HD stream</h1>"
+ "<br>"
+ "<br>"
+ "<h2>Alternative 1 (recommended)</h2>"
+ "<ol type=\"1\">"
+ "<li>Install <a href=\"https://www.videolan.org\">VideoLanClient (VLC)</a>, from App- or Play-store free of charge</li>"
+ "<li>Open VLC and select Network Stream</li>"
+ "<li>Enter, copy or share this network address to VLC: <a href=\"http://%s:%s/stream.m3u\">http://%s:%s/stream.m3u</a></li>"
+ "</ol>"
+ "<br>"
+ "<br>"
+ "<h2>Alternative 2 (on your own)</h2>"
+ "<br>"
+ "<br>"
+ "<audio id=\"audio\" controls=\"true\" src=\"stream.wav\" preload=\"none\"></audio>"
+ "<br>"
+ "<br>",
+ pvc->profile->http.host, pvc->profile->http.port,
+ pvc->profile->http.host, pvc->profile->http.port);
+
+ if (x == pvc->profile->http.nstate)
+ fprintf(io, "<h2>There are currently no free slots (%zu active). Try again later!</h2>", x);
+ else
+ fprintf(io, "<h2>There are %zu free slots (%zu active)</h2>", pvc->profile->http.nstate - x, x);
+
+ fprintf(io, "</body></html>");
+ break;
+ case 1:
+ for (x = 0; x < pvc->profile->http.nstate; x++) {
+ if (pvc->profile->http.state[x].fd >= 0)
+ continue;
+ switch (voss_http_generate_wav_header(pvc, io, r_start, r_end, is_partial)) {
+ static const int enable = 1;
+
+ case 0:
+ fflush(io);
+ fdclose(io, NULL);
+ if (ioctl(fd, FIONBIO, &enable) != 0) {
+ close(fd);
+ return;
+ }
+ pvc->profile->http.state[x].ts =
+ virtual_oss_timestamp() - 1000000000ULL;
+ pvc->profile->http.state[x].fd = fd;
+ return;
+ case 1:
+ fclose(io);
+ return;
+ case 2:
+ fprintf(io, "HTTP/1.1 416 Range Not Satisfiable\r\n"
+ "Server: virtual_oss/1.0\r\n"
+ "\r\n");
+ goto done;
+ default:
+ goto done;
+ }
+ }
+ fprintf(io, "HTTP/1.0 503 Out of Resources\r\n"
+ "Server: virtual_oss/1.0\r\n"
+ "\r\n");
+ break;
+ case 2:
+ fprintf(io, "HTTP/1.0 200 OK\r\n"
+ "Content-Type: audio/mpegurl\r\n"
+ "Server: virtual_oss/1.0\r\n"
+ "Cache-Control: no-cache, no-store\r\n"
+ "Expires: Mon, 26 Jul 1997 05:00:00 GMT\r\n"
+ "\r\n");
+ if (sa->sin_family == AF_INET && pvc->profile->http.rtp_port != NULL) {
+ fprintf(io, "rtp://239.255.0.1:%s\r\n", pvc->profile->http.rtp_port);
+ } else {
+ fprintf(io, "http://%s:%s/stream.wav\r\n",
+ pvc->profile->http.host, pvc->profile->http.port);
+ }
+ break;
+ default:
+ fprintf(io, "HTTP/1.0 404 Not Found\r\n"
+ "Content-Type: text/html\r\n"
+ "Server: virtual_oss/1.0\r\n"
+ "\r\n"
+ "<html><head><title>virtual_oss</title></head>"
+ "<body>"
+ "<h1>Invalid page requested! "
+ "<a HREF=\"index.html\">Click here to go back</a>.</h1><br>"
+ "</body>"
+ "</html>");
+ break;
+ }
+done:
+ if (io != NULL)
+ fclose(io);
+ else
+ close(fd);
+}
+
+static int
+voss_httpd_do_listen(vclient_t *pvc, const char *host, const char *port,
+ struct pollfd *pfd, int num_sock, int buffer)
+{
+ static const struct timeval timeout = {.tv_sec = 1};
+ struct addrinfo hints = {};
+ struct addrinfo *res;
+ struct addrinfo *res0;
+ int error;
+ int flag;
+ int s;
+ int ns = 0;
+
+ hints.ai_family = AF_UNSPEC;
+ hints.ai_socktype = SOCK_STREAM;
+ hints.ai_protocol = IPPROTO_TCP;
+ hints.ai_flags = AI_PASSIVE;
+
+ if ((error = getaddrinfo(host, port, &hints, &res)))
+ return (-1);
+
+ res0 = res;
+
+ do {
+ if ((s = socket(res0->ai_family, res0->ai_socktype,
+ res0->ai_protocol)) < 0)
+ continue;
+
+ flag = 1;
+ setsockopt(s, SOL_SOCKET, SO_REUSEPORT, &flag, (int)sizeof(flag));
+ setsockopt(s, SOL_SOCKET, SO_SNDBUF, &buffer, (int)sizeof(buffer));
+ setsockopt(s, SOL_SOCKET, SO_RCVBUF, &buffer, (int)sizeof(buffer));
+ setsockopt(s, SOL_SOCKET, SO_SNDTIMEO, &timeout, (int)sizeof(timeout));
+ setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &timeout, (int)sizeof(timeout));
+
+ if (bind(s, res0->ai_addr, res0->ai_addrlen) == 0) {
+ if (listen(s, pvc->profile->http.nstate) == 0) {
+ if (ns < num_sock) {
+ pfd[ns++].fd = s;
+ continue;
+ }
+ close(s);
+ break;
+ }
+ }
+ close(s);
+ } while ((res0 = res0->ai_next) != NULL);
+
+ freeaddrinfo(res);
+
+ return (ns);
+}
+
+static size_t
+voss_httpd_buflimit(vclient_t *pvc)
+{
+ /* don't buffer more than 250ms */
+ return ((pvc->sample_rate / 4) *
+ pvc->channels * vclient_sample_bytes(pvc));
+};
+
+static void
+voss_httpd_server(vclient_t *pvc)
+{
+ const size_t bufferlimit = voss_httpd_buflimit(pvc);
+ const char *host = pvc->profile->http.host;
+ const char *port = pvc->profile->http.port;
+ struct sockaddr sa = {};
+ struct pollfd fds[VOSS_HTTPD_BIND_MAX] = {};
+ int nfd;
+
+ nfd = voss_httpd_do_listen(pvc, host, port, fds, VOSS_HTTPD_BIND_MAX, bufferlimit);
+ if (nfd < 1) {
+ errx(EX_SOFTWARE, "Could not bind to "
+ "'%s' and '%s'", host, port);
+ }
+
+ while (1) {
+ struct sockaddr_in si;
+ int ns = nfd;
+ int c;
+ int f;
+
+ for (c = 0; c != ns; c++) {
+ fds[c].events = (POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI |
+ POLLERR | POLLHUP | POLLNVAL);
+ fds[c].revents = 0;
+ }
+ if (poll(fds, ns, -1) < 0)
+ errx(EX_SOFTWARE, "Polling failed");
+
+ for (c = 0; c != ns; c++) {
+ socklen_t socklen = sizeof(sa);
+
+ if (fds[c].revents == 0)
+ continue;
+ f = accept(fds[c].fd, &sa, &socklen);
+ if (f < 0)
+ continue;
+ memcpy(&si, &sa, sizeof(sa));
+ voss_httpd_handle_connection(pvc, f, &si);
+ }
+ }
+}
+
+static void
+voss_httpd_streamer(vclient_t *pvc)
+{
+ const size_t bufferlimit = voss_httpd_buflimit(pvc);
+ uint8_t *ptr;
+ size_t len;
+ uint64_t ts;
+ size_t x;
+
+ atomic_lock();
+ while (1) {
+ if (vclient_export_read_locked(pvc) != 0) {
+ atomic_wait();
+ continue;
+ }
+ vring_get_read(&pvc->rx_ring[1], &ptr, &len);
+ if (len == 0) {
+ /* try to avoid ring wraps */
+ vring_reset(&pvc->rx_ring[1]);
+ atomic_wait();
+ continue;
+ }
+ atomic_unlock();
+
+ ts = virtual_oss_timestamp();
+
+ /* check if we should send RTP data, if any */
+ if (pvc->profile->http.rtp_fd > -1) {
+ voss_httpd_send_rtp(pvc, pvc->profile->http.rtp_fd,
+ ptr, len, pvc->profile->http.rtp_ts);
+ }
+
+ /* send HTTP data, if any */
+ for (x = 0; x < pvc->profile->http.nstate; x++) {
+ int fd = pvc->profile->http.state[x].fd;
+ uint64_t delta = ts - pvc->profile->http.state[x].ts;
+ uint8_t buf[1];
+ int write_len;
+
+ if (fd < 0) {
+ /* do nothing */
+ } else if (delta >= (8ULL * 1000000000ULL)) {
+ /* no data for 8 seconds - terminate */
+ pvc->profile->http.state[x].fd = -1;
+ close(fd);
+ } else if (read(fd, buf, sizeof(buf)) != -1 || errno != EWOULDBLOCK) {
+ pvc->profile->http.state[x].fd = -1;
+ close(fd);
+ } else if (ioctl(fd, FIONWRITE, &write_len) < 0) {
+ pvc->profile->http.state[x].fd = -1;
+ close(fd);
+ } else if ((ssize_t)(bufferlimit - write_len) < (ssize_t)len) {
+ /* do nothing */
+ } else if (write(fd, ptr, len) != (ssize_t)len) {
+ pvc->profile->http.state[x].fd = -1;
+ close(fd);
+ } else {
+ /* update timestamp */
+ pvc->profile->http.state[x].ts = ts;
+ }
+ }
+
+ atomic_lock();
+ vring_inc_read(&pvc->rx_ring[1], len);
+ }
+}
+
+const char *
+voss_httpd_start(vprofile_t *pvp)
+{
+ vclient_t *pvc;
+ pthread_t td;
+ int error;
+ size_t x;
+
+ if (pvp->http.host == NULL || pvp->http.port == NULL || pvp->http.nstate == 0)
+ return (NULL);
+
+ pvp->http.state = malloc(sizeof(pvp->http.state[0]) * pvp->http.nstate);
+ if (pvp->http.state == NULL)
+ return ("Could not allocate HTTP states");
+
+ for (x = 0; x != pvp->http.nstate; x++) {
+ pvp->http.state[x].fd = -1;
+ pvp->http.state[x].ts = 0;
+ }
+
+ pvc = vclient_alloc();
+ if (pvc == NULL)
+ return ("Could not allocate client for HTTP server");
+
+ pvc->profile = pvp;
+
+ if (pvp->http.rtp_ifname != NULL) {
+ const char *perr;
+
+ if (pvc->channels > 2)
+ return ("RTP only supports 44.1kHz, 1 or 2 channels at 16-bit depth");
+
+ /* bind to UDP port */
+ perr = voss_httpd_bind_rtp(pvc, pvp->http.rtp_ifname,
+ &pvp->http.rtp_fd);
+ if (perr != NULL)
+ return (perr);
+
+ /* setup buffers */
+ error = vclient_setup_buffers(pvc, 0, 0,
+ pvp->channels, AFMT_S16_LE, 44100);
+ } else {
+ pvp->http.rtp_fd = -1;
+
+ /* setup buffers */
+ error = vclient_setup_buffers(pvc, 0, 0, pvp->channels,
+ vclient_get_default_fmt(pvp, VTYPE_WAV_HDR),
+ voss_dsp_sample_rate);
+ }
+
+ if (error != 0) {
+ vclient_free(pvc);
+ return ("Could not allocate buffers for HTTP server");
+ }
+
+ /* trigger enabled */
+ pvc->rx_enabled = 1;
+
+ pvc->type = VTYPE_OSS_DAT;
+
+ atomic_lock();
+ TAILQ_INSERT_TAIL(&pvp->head, pvc, entry);
+ atomic_unlock();
+
+ if (pthread_create(&td, NULL, (void *)&voss_httpd_server, pvc))
+ return ("Could not create HTTP daemon thread");
+ if (pthread_create(&td, NULL, (void *)&voss_httpd_streamer, pvc))
+ return ("Could not create HTTP streamer thread");
+
+ return (NULL);
+}
diff --git a/usr.sbin/virtual_oss/virtual_oss/int.h b/usr.sbin/virtual_oss/virtual_oss/int.h
new file mode 100644
--- /dev/null
+++ b/usr.sbin/virtual_oss/virtual_oss/int.h
@@ -0,0 +1,327 @@
+/*-
+ * Copyright (c) 2012-2022 Hans Petter Selasky
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef _VIRTUAL_INT_H_
+#define _VIRTUAL_INT_H_
+
+#include <signal.h>
+#include <pthread.h>
+
+#include <cuse.h>
+#include <samplerate.h>
+
+extern pthread_mutex_t atomic_mtx;
+extern pthread_cond_t atomic_cv;
+
+#define atomic_lock() pthread_mutex_lock(&atomic_mtx)
+#define atomic_unlock() pthread_mutex_unlock(&atomic_mtx)
+#define atomic_wait() pthread_cond_wait(&atomic_cv, &atomic_mtx)
+#define atomic_wakeup() do { \
+ pthread_cond_broadcast(&atomic_cv); \
+ cuse_poll_wakeup(); \
+} while (0)
+
+#define AFMT_32BIT \
+ (AFMT_S32_LE | AFMT_S32_BE | AFMT_U32_LE | AFMT_U32_BE | \
+ AFMT_F32_LE | AFMT_F32_BE)
+#define AFMT_24BIT \
+ (AFMT_S24_LE | AFMT_S24_BE | AFMT_U24_LE | AFMT_U24_BE)
+#define AFMT_16BIT \
+ (AFMT_S16_LE | AFMT_S16_BE | AFMT_U16_LE | AFMT_U16_BE)
+#define AFMT_8BIT \
+ (AFMT_U8 | AFMT_S8)
+
+#define VMAX_CHAN 64
+#define VMAX_STRING 64 /* characters */
+
+#define VTYPE_OSS_DAT 0
+#define VTYPE_WAV_HDR 1
+#define VTYPE_WAV_DAT 2
+
+#define VPREFERRED_SNE_AFMT \
+ (AFMT_S8 | AFMT_S16_NE | AFMT_S24_NE | AFMT_S32_NE | AFMT_F32_NE)
+#define VPREFERRED_UNE_AFMT \
+ (AFMT_U8 | AFMT_U16_NE | AFMT_U24_NE | AFMT_U32_NE)
+#define VPREFERRED_SLE_AFMT \
+ (AFMT_S8 | AFMT_S16_LE | AFMT_S24_LE | AFMT_S32_LE | AFMT_F32_LE)
+#define VPREFERRED_SBE_AFMT \
+ (AFMT_S8 | AFMT_S16_BE | AFMT_S24_BE | AFMT_S32_BE | AFMT_F32_BE)
+#define VPREFERRED_ULE_AFMT \
+ (AFMT_U8 | AFMT_U16_LE | AFMT_U24_LE | AFMT_U32_LE)
+#define VPREFERRED_UBE_AFMT \
+ (AFMT_U8 | AFMT_U16_BE | AFMT_U24_BE | AFMT_U32_BE)
+
+#define VSUPPORTED_AFMT \
+ (AFMT_S16_BE | AFMT_S16_LE | AFMT_U16_BE | AFMT_U16_LE | \
+ AFMT_S24_BE | AFMT_S24_LE | AFMT_U24_BE | AFMT_U24_LE | \
+ AFMT_S32_BE | AFMT_S32_LE | AFMT_U32_BE | AFMT_U32_LE | \
+ AFMT_F32_BE | AFMT_F32_LE | \
+ AFMT_U8 | AFMT_S8)
+
+#define VVOLUME_UNIT_SHIFT 7
+
+struct virtual_profile;
+
+typedef TAILQ_ENTRY(virtual_profile) vprofile_entry_t;
+typedef TAILQ_HEAD(, virtual_profile) vprofile_head_t;
+typedef struct virtual_profile vprofile_t;
+
+struct virtual_client;
+
+typedef TAILQ_ENTRY(virtual_client) vclient_entry_t;
+typedef TAILQ_HEAD(, virtual_client) vclient_head_t;
+typedef struct virtual_client vclient_t;
+
+struct virtual_monitor;
+typedef TAILQ_ENTRY(virtual_monitor) vmonitor_entry_t;
+typedef TAILQ_HEAD(, virtual_monitor) vmonitor_head_t;
+typedef struct virtual_monitor vmonitor_t;
+
+struct virtual_resample;
+typedef struct virtual_resample vresample_t;
+
+struct cuse_methods;
+
+struct virtual_compressor {
+ uint8_t enabled; /* 0..1 */
+ uint8_t knee; /* 0..255 */
+ uint8_t attack; /* 0..62 */
+ uint8_t decay; /* 0..62 */
+};
+
+struct virtual_profile {
+ vprofile_entry_t entry;
+ vclient_head_t head;
+ char oss_name[VMAX_STRING];
+ char wav_name[VMAX_STRING];
+ uint32_t rx_filter_size;
+ uint32_t tx_filter_size;
+ double *rx_filter_data[VMAX_CHAN];
+ double *tx_filter_data[VMAX_CHAN];
+ int64_t rx_peak_value[VMAX_CHAN];
+ int64_t tx_peak_value[VMAX_CHAN];
+ int8_t rx_shift[VMAX_CHAN];
+ int8_t tx_shift[VMAX_CHAN];
+ uint8_t rx_src[VMAX_CHAN];
+ uint8_t tx_dst[VMAX_CHAN];
+ uint8_t rx_mute[VMAX_CHAN];
+ uint8_t tx_mute[VMAX_CHAN];
+ uint8_t rx_pol[VMAX_CHAN];
+ uint8_t tx_pol[VMAX_CHAN];
+ uint8_t bits;
+ uint8_t channels;
+ struct virtual_compressor rx_compressor_param;
+ double rx_compressor_gain[VMAX_CHAN];
+ uint8_t synchronized;
+ uint32_t rec_delay;
+ int fd_sta;
+ struct {
+ const char * host;
+ const char * port;
+ const char * rtp_ifname;
+ const char * rtp_port;
+ volatile struct http_state * state;
+ size_t nstate;
+ int rtp_fd;
+ int rtp_vlanid;
+ uint32_t rtp_ts;
+ uint16_t rtp_seqnum;
+ } http;
+};
+
+struct virtual_ring {
+ uint8_t *buf_start;
+ uint32_t pos_read;
+ uint32_t total_size;
+ uint32_t len_write;
+};
+
+struct virtual_resample {
+ SRC_DATA data;
+ SRC_STATE *state;
+ float *data_in;
+ float *data_out;
+};
+
+struct virtual_client {
+ vclient_entry_t entry;
+ uint32_t tx_filter_offset;
+ uint32_t rx_filter_offset;
+ int64_t *tx_filter_in[VMAX_CHAN];
+ int64_t *rx_filter_in[VMAX_CHAN];
+ double *tx_filter_out[VMAX_CHAN];
+ double *rx_filter_out[VMAX_CHAN];
+ struct virtual_ring rx_ring[2];
+ struct virtual_ring tx_ring[2];
+ vresample_t rx_resample;
+ vresample_t tx_resample;
+ struct virtual_profile *profile;
+ uint64_t rx_samples;
+ uint64_t rx_timestamp;
+ uint64_t tx_samples;
+ uint64_t tx_timestamp;
+ uint32_t buffer_frags;
+ uint32_t buffer_size;
+ uint32_t low_water;
+ uint32_t rec_delay;
+ uint32_t rx_noise_rem;
+ uint32_t tx_noise_rem;
+ int rx_busy;
+ int tx_busy;
+ int channels;
+ int format;
+ int rx_enabled;
+ int tx_enabled;
+ int rx_volume;
+ int tx_volume;
+ int type; /* VTYPE_XXX */
+ int sample_rate;
+ uint32_t buffer_size_set:1;
+ uint32_t buffer_frags_set:1;
+ uint32_t sync_busy:1;
+ uint32_t sync_wakeup:1;
+ int padding:28;
+};
+
+struct virtual_monitor {
+ vmonitor_entry_t entry;
+ int64_t peak_value;
+ uint8_t src_chan;
+ uint8_t dst_chan;
+ uint8_t pol;
+ uint8_t mute;
+ int8_t shift;
+};
+
+extern vprofile_head_t virtual_profile_client_head;
+extern vprofile_head_t virtual_profile_loopback_head;
+
+extern vmonitor_head_t virtual_monitor_input;
+extern vmonitor_head_t virtual_monitor_local;
+extern vmonitor_head_t virtual_monitor_output;
+
+extern const struct cuse_methods vctl_methods;
+
+extern struct virtual_compressor voss_output_compressor_param;
+extern double voss_output_compressor_gain[VMAX_CHAN];
+extern int64_t voss_output_peak[VMAX_CHAN];
+extern int64_t voss_input_peak[VMAX_CHAN];
+extern uint32_t voss_jitter_up;
+extern uint32_t voss_jitter_down;
+extern uint32_t voss_max_channels;
+extern uint32_t voss_mix_channels;
+extern uint32_t voss_dsp_samples;
+extern uint32_t voss_dsp_max_channels;
+extern uint32_t voss_dsp_sample_rate;
+extern uint32_t voss_dsp_bits;
+extern uint8_t voss_libsamplerate_enable;
+extern uint8_t voss_libsamplerate_quality;
+extern int voss_is_recording;
+extern int voss_has_synchronization;
+extern char voss_dsp_rx_device[VMAX_STRING];
+extern char voss_dsp_tx_device[VMAX_STRING];
+extern char voss_ctl_device[VMAX_STRING];
+extern volatile sig_atomic_t voss_exit;
+
+extern int vring_alloc(struct virtual_ring *, size_t);
+extern void vring_free(struct virtual_ring *);
+extern void vring_reset(struct virtual_ring *);
+extern void vring_get_read(struct virtual_ring *, uint8_t **, size_t *);
+extern void vring_get_write(struct virtual_ring *, uint8_t **, size_t *);
+extern void vring_inc_read(struct virtual_ring *, size_t);
+extern void vring_inc_write(struct virtual_ring *, size_t);
+extern size_t vring_total_read_len(struct virtual_ring *);
+extern size_t vring_total_write_len(struct virtual_ring *);
+extern size_t vring_write_linear(struct virtual_ring *, const uint8_t *, size_t);
+extern size_t vring_read_linear(struct virtual_ring *, uint8_t *, size_t);
+extern size_t vring_write_zero(struct virtual_ring *, size_t);
+
+extern vclient_t *vclient_alloc(void);
+extern void vclient_free(vclient_t *);
+
+extern int vclient_get_default_fmt(vprofile_t *, int type);
+extern int vclient_setup_buffers(vclient_t *, int size, int frags,
+ int channels, int format, int sample_rate);
+extern int vclient_export_read_locked(vclient_t *);
+extern void vclient_import_write_locked(vclient_t *);
+
+extern uint32_t vclient_sample_bytes(vclient_t *);
+extern uint32_t vclient_bufsize_internal(vclient_t *);
+extern uint32_t vclient_bufsize_scaled(vclient_t *);
+
+extern int64_t vclient_noise(uint32_t *, int64_t, int8_t);
+
+extern vmonitor_t *vmonitor_alloc(int *, vmonitor_head_t *);
+
+extern uint32_t format_best(uint32_t);
+extern void format_import(uint32_t, const uint8_t *, uint32_t, int64_t *);
+extern void format_export(uint32_t, const int64_t *, uint8_t *, uint32_t);
+extern int64_t format_max(uint32_t);
+extern void format_maximum(const int64_t *, int64_t *, uint32_t, uint32_t, int8_t);
+extern void format_remix(int64_t *, uint32_t, uint32_t, uint32_t);
+extern void format_silence(uint32_t, uint8_t *, uint32_t);
+
+extern void *virtual_oss_process(void *);
+
+/* Audio Delay prototypes */
+extern uint32_t voss_ad_last_delay;
+extern uint32_t voss_dsp_rx_refresh;
+extern uint32_t voss_dsp_tx_refresh;
+extern uint8_t voss_ad_enabled;
+extern uint8_t voss_ad_output_signal;
+extern uint8_t voss_ad_input_channel;
+extern uint8_t voss_ad_output_channel;
+extern void voss_ad_reset(void);
+extern void voss_ad_init(uint32_t);
+extern double voss_ad_getput_sample(double);
+
+/* Add audio options prototype */
+extern void voss_add_options(char *);
+
+/* Get current timestamp */
+extern uint64_t virtual_oss_delay_ns(void);
+extern void virtual_oss_wait(void);
+extern uint64_t virtual_oss_timestamp(void);
+
+/* Fast array multiplication */
+extern void voss_x3_multiply_double(const int64_t *, const double *, double *, const size_t);
+
+/* Equalizer support */
+extern void vclient_tx_equalizer(struct virtual_client *, int64_t *, size_t);
+extern void vclient_rx_equalizer(struct virtual_client *, int64_t *, size_t);
+extern int vclient_eq_alloc(struct virtual_client *);
+extern void vclient_eq_free(struct virtual_client *);
+
+/* Internal utilities */
+extern int bt_speaker_main(int argc, char **argv);
+
+/* Internal compressor */
+extern void voss_compressor(int64_t *, double *, const struct virtual_compressor *,
+ const unsigned, const unsigned, const int64_t);
+
+/* HTTP daemon support */
+extern const char *voss_httpd_start(vprofile_t *);
+
+#endif /* _VIRTUAL_INT_H_ */
diff --git a/usr.sbin/virtual_oss/virtual_oss/main.c b/usr.sbin/virtual_oss/virtual_oss/main.c
new file mode 100644
--- /dev/null
+++ b/usr.sbin/virtual_oss/virtual_oss/main.c
@@ -0,0 +1,2625 @@
+/*-
+ * Copyright (c) 2012-2022 Hans Petter Selasky
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/queue.h>
+#include <sys/types.h>
+#include <sys/filio.h>
+#include <sys/rtprio.h>
+#include <sys/nv.h>
+#include <sys/sndstat.h>
+#include <sys/soundcard.h>
+
+#include <dlfcn.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <err.h>
+#include <sysexits.h>
+#include <signal.h>
+#include <fcntl.h>
+#include <paths.h>
+
+#include <cuse.h>
+#include <pthread.h>
+
+#include "backend.h"
+#include "int.h"
+#include "utils.h"
+#include "virtual_oss.h"
+
+pthread_mutex_t atomic_mtx;
+pthread_cond_t atomic_cv;
+
+static void
+atomic_init(void)
+{
+ if (pthread_mutex_init(&atomic_mtx, NULL) != 0)
+ err(1, "pthread_mutex_init");
+ if (pthread_cond_init(&atomic_cv, NULL) != 0)
+ err(1, "pthread_cond_init");
+}
+
+uint32_t
+vclient_sample_bytes(vclient_t *pvc)
+{
+ uint32_t fmt = pvc->format;
+
+ if (fmt & AFMT_16BIT)
+ return (2);
+ else if (fmt & AFMT_24BIT)
+ return (3);
+ else if (fmt & AFMT_32BIT)
+ return (4);
+ else if (fmt & AFMT_8BIT)
+ return (1);
+ else
+ return (0);
+ /* TODO AFMT_BPS */
+}
+
+static uint32_t
+vclient_output_delay(vclient_t *pvc)
+{
+ uint64_t size;
+ uint64_t mod;
+
+ if (pvc->tx_busy == 0)
+ vclient_import_write_locked(pvc);
+
+ mod = pvc->channels * vclient_sample_bytes(pvc);
+
+ size = vring_total_read_len(&pvc->tx_ring[0]);
+ size = (size / 8) * vclient_sample_bytes(pvc);
+
+ size = (size * (uint64_t)pvc->sample_rate) /
+ (uint64_t)voss_dsp_sample_rate;
+ size += vring_total_read_len(&pvc->tx_ring[1]);
+ size -= size % mod;
+
+ return (size);
+}
+
+static uint32_t
+vclient_input_delay(vclient_t *pvc)
+{
+ if (pvc->rx_busy == 0)
+ vclient_export_read_locked(pvc);
+ return (vring_total_read_len(&pvc->rx_ring[1]));
+}
+
+uint32_t
+vclient_bufsize_scaled(vclient_t *pvc)
+{
+ uint32_t samples_scaled = ((uint64_t)voss_dsp_samples *
+ (uint64_t)pvc->sample_rate) / (uint64_t)voss_dsp_sample_rate;
+ if (samples_scaled == 0)
+ samples_scaled = 1;
+ return (pvc->channels * samples_scaled * vclient_sample_bytes(pvc));
+}
+
+static uint64_t
+vclient_bufsize_consumed(vclient_t *pvc, uint64_t ts)
+{
+ int64_t delta;
+ int64_t samples_scaled;
+ int64_t retval;
+
+ delta = virtual_oss_timestamp() - ts;
+ if (delta < 0)
+ delta = 0;
+ samples_scaled = (delta * (uint64_t)pvc->sample_rate) / 1000000000ULL;
+ if (samples_scaled < 0)
+ samples_scaled = 0;
+ retval = pvc->channels * samples_scaled * vclient_sample_bytes(pvc);
+ if (retval < 0)
+ retval = 0;
+ return (retval);
+}
+
+/*
+ * VLC and some other audio player use this value for jitter
+ * computations and expect it to be very accurate. VirtualOSS is block
+ * based and does not have sample accuracy. Use the system clock to
+ * update this value as we go along instead:
+ */
+static uint32_t
+vclient_output_delay_adjusted(vclient_t *pvc)
+{
+ int64_t retval = vclient_output_delay(pvc) -
+ vclient_bufsize_consumed(pvc, pvc->tx_timestamp);
+ if (retval < 0)
+ retval = 0;
+ return (retval);
+}
+
+vmonitor_t *
+vmonitor_alloc(int *pid, vmonitor_head_t *phead)
+{
+ int id = 0;
+ vmonitor_t *pvm;
+
+ TAILQ_FOREACH(pvm, phead, entry)
+ id++;
+
+ if (id >= 64) {
+ *pid = 0;
+ return (NULL);
+ }
+ pvm = malloc(sizeof(*pvm));
+ if (pvm == NULL) {
+ *pid = 0;
+ return (NULL);
+ }
+ memset(pvm, 0, sizeof(*pvm));
+
+ pvm->mute = 1;
+
+ TAILQ_INSERT_TAIL(phead, pvm, entry);
+
+ *pid = id;
+ return (pvm);
+}
+
+int64_t
+vclient_noise(uint32_t *pnoise, int64_t volume, int8_t shift)
+{
+ const uint32_t prime = 0xFFFF1DU;
+ int64_t temp;
+
+ /* compute next noise sample */
+ temp = *pnoise;
+ if (temp & 1)
+ temp += prime;
+ temp /= 2;
+ *pnoise = temp;
+
+ /* unsigned to signed conversion */
+ temp ^= 0x800000ULL;
+ if (temp & 0x800000U)
+ temp |= -0x800000ULL;
+
+ /* properly amplify */
+ temp *= volume;
+
+ /* bias shift */
+ shift -= 23 + VVOLUME_UNIT_SHIFT;
+
+ /* range check and shift noise */
+ if (__predict_false(shift < -63 || shift > 63))
+ temp = 0;
+ else if (shift < 0)
+ temp >>= -shift;
+ else
+ temp <<= shift;
+
+ return (temp);
+}
+
+static void
+vresample_free(vresample_t *pvr)
+{
+ if (pvr->state != NULL)
+ src_delete(pvr->state);
+ free(pvr->data_in);
+ free(pvr->data_out);
+ memset(pvr, 0, sizeof(*pvr));
+}
+
+static int
+vresample_setup(vclient_t *pvc, vresample_t *pvr, int samples)
+{
+ int code = 0;
+
+ if (pvr->state != NULL)
+ return (0);
+ pvr->state = src_new(voss_libsamplerate_quality, pvc->channels, &code);
+ if (pvr->state == NULL)
+ goto error;
+ pvr->data_in = malloc(sizeof(float) * samples);
+ if (pvr->data_in == NULL)
+ goto error;
+ pvr->data_out = malloc(sizeof(float) * samples);
+ if (pvr->data_out == NULL)
+ goto error;
+ pvr->data.data_in = pvr->data_in;
+ pvr->data.data_out = pvr->data_out;
+ return (0);
+error:
+ vresample_free(pvr);
+ return (CUSE_ERR_NO_MEMORY);
+}
+
+void
+vclient_free(vclient_t *pvc)
+{
+ vresample_free(&pvc->rx_resample);
+ vresample_free(&pvc->tx_resample);
+
+ /* free equalizer */
+ vclient_eq_free(pvc);
+
+ /* free ring buffers */
+ vring_free(&pvc->rx_ring[0]);
+ vring_free(&pvc->rx_ring[1]);
+ vring_free(&pvc->tx_ring[0]);
+ vring_free(&pvc->tx_ring[1]);
+
+ free(pvc);
+}
+
+vclient_t *
+vclient_alloc(void)
+{
+ vclient_t *pvc;
+
+ pvc = malloc(sizeof(*pvc));
+ if (pvc == NULL)
+ return (NULL);
+
+ memset(pvc, 0, sizeof(*pvc));
+
+ pvc->rx_noise_rem = 1;
+ pvc->tx_noise_rem = 1;
+ pvc->rx_volume = 1 << VVOLUME_UNIT_SHIFT;
+ pvc->tx_volume = 1 << VVOLUME_UNIT_SHIFT;
+
+ return (pvc);
+}
+
+int
+vclient_get_default_fmt(vprofile_t *pvp, int type)
+{
+ int retval;
+
+ if (type == VTYPE_WAV_HDR) {
+ switch (pvp->bits) {
+ case 16:
+ retval = AFMT_S16_LE;
+ break;
+ case 24:
+ retval = AFMT_S24_LE;
+ break;
+ case 32:
+ retval = AFMT_S32_LE;
+ break;
+ default:
+ retval = AFMT_S8;
+ break;
+ }
+ } else {
+ switch (pvp->bits) {
+ case 16:
+ retval = AFMT_S16_NE;
+ break;
+ case 24:
+ retval = AFMT_S24_NE;
+ break;
+ case 32:
+ retval = AFMT_S32_NE;
+ break;
+ default:
+ retval = AFMT_S8;
+ break;
+ }
+ }
+ return (retval);
+}
+
+int
+vclient_setup_buffers(vclient_t *pvc, int size, int frags,
+ int channels, int format, int sample_rate)
+{
+ size_t bufsize_internal;
+ size_t bufsize_min;
+ size_t mod_internal;
+ size_t mod;
+ uint64_t ts;
+ int bufsize;
+
+ /* check we are not busy */
+ if (pvc->rx_busy || pvc->tx_busy)
+ return (CUSE_ERR_BUSY);
+
+ /* free equalizer */
+ vclient_eq_free(pvc);
+
+ /* free existing ring buffers */
+ vring_free(&pvc->rx_ring[0]);
+ vring_free(&pvc->rx_ring[1]);
+ vring_free(&pvc->tx_ring[0]);
+ vring_free(&pvc->tx_ring[1]);
+
+ /* reset resampler */
+ vresample_free(&pvc->rx_resample);
+ vresample_free(&pvc->tx_resample);
+
+ if (sample_rate > 0)
+ pvc->sample_rate = sample_rate;
+ if (format != 0)
+ pvc->format = format;
+ if (channels > 0)
+ pvc->channels = channels;
+
+ mod = pvc->channels * vclient_sample_bytes(pvc);
+ mod_internal = pvc->channels * 8;
+
+ if (size > 0) {
+ size += mod - 1;
+ size -= size % mod;
+
+ pvc->buffer_size = size;
+ pvc->buffer_size_set = 1;
+ } else if (pvc->buffer_size_set == 0)
+ pvc->buffer_size = vclient_bufsize_scaled(pvc);
+
+ pvc->low_water = pvc->buffer_size;
+
+ if (frags > 0) {
+ pvc->buffer_frags = frags;
+ pvc->buffer_frags_set = 1;
+ } else if (pvc->buffer_frags_set == 0)
+ pvc->buffer_frags = 2;
+
+ /* sanity checks */
+ if (frags < 0 || size < 0)
+ return (CUSE_ERR_INVALID);
+ if (pvc->format == 0)
+ return (CUSE_ERR_INVALID);
+ if (pvc->buffer_frags <= 0 || pvc->buffer_frags >= 1024)
+ return (CUSE_ERR_INVALID);
+ if (pvc->buffer_size <= 0 || pvc->buffer_size >= (1024 * 1024))
+ return (CUSE_ERR_INVALID);
+ if ((pvc->buffer_size * pvc->buffer_frags) >= (128 * 1024 * 1024))
+ return (CUSE_ERR_INVALID);
+ if (pvc->channels <= 0 || pvc->channels > pvc->profile->channels)
+ return (CUSE_ERR_INVALID);
+
+ /* get buffer sizes */
+ bufsize = pvc->buffer_frags * pvc->buffer_size;
+ bufsize_internal = ((uint64_t)bufsize * (uint64_t)voss_dsp_sample_rate * 8ULL) /
+ ((uint64_t)pvc->sample_rate * (uint64_t)vclient_sample_bytes(pvc));
+
+ bufsize_min = voss_dsp_samples * pvc->channels * 8;
+
+ /* check for too small buffer size */
+ if (bufsize_internal < bufsize_min)
+ return (CUSE_ERR_INVALID);
+
+ /* allow for jitter */
+ bufsize_internal *= 2ULL;
+
+ /* align buffer size */
+ bufsize_internal += (mod_internal - 1);
+ bufsize_internal -= (bufsize_internal % mod_internal);
+
+ /* allocate new buffers */
+ if (vring_alloc(&pvc->rx_ring[0], bufsize_internal))
+ goto err_0;
+ if (vring_alloc(&pvc->rx_ring[1], bufsize))
+ goto err_1;
+ if (vring_alloc(&pvc->tx_ring[0], bufsize_internal))
+ goto err_2;
+ if (vring_alloc(&pvc->tx_ring[1], bufsize))
+ goto err_3;
+ if (vclient_eq_alloc(pvc))
+ goto err_4;
+
+ ts = virtual_oss_timestamp();
+
+ pvc->rx_samples = 0;
+ pvc->tx_samples = 0;
+ pvc->tx_timestamp = ts;
+ pvc->rx_timestamp = ts;
+
+ return (0);
+
+err_4:
+ vring_free(&pvc->tx_ring[1]);
+err_3:
+ vring_free(&pvc->tx_ring[0]);
+err_2:
+ vring_free(&pvc->rx_ring[1]);
+err_1:
+ vring_free(&pvc->rx_ring[0]);
+err_0:
+ return (CUSE_ERR_NO_MEMORY);
+}
+
+static int
+vclient_open_sub(struct cuse_dev *pdev, int fflags __unused, int type)
+{
+ vclient_t *pvc;
+ vprofile_t *pvp;
+ int error;
+
+ pvp = cuse_dev_get_priv0(pdev);
+
+ pvc = vclient_alloc();
+ if (pvc == NULL)
+ return (CUSE_ERR_NO_MEMORY);
+
+ pvc->profile = pvp;
+
+ /* setup buffers */
+ error = vclient_setup_buffers(pvc, 0, 0, pvp->channels,
+ vclient_get_default_fmt(pvp, type), voss_dsp_sample_rate);
+ if (error != 0) {
+ vclient_free(pvc);
+ return (error);
+ }
+
+ pvc->type = type;
+
+ cuse_dev_set_per_file_handle(pdev, pvc);
+
+ atomic_lock();
+ /* only allow one synchronization source at a time */
+ if (pvc->profile->synchronized) {
+ if (voss_has_synchronization != 0)
+ error = CUSE_ERR_BUSY;
+ else
+ voss_has_synchronization++;
+ }
+ if (error == 0)
+ TAILQ_INSERT_TAIL(&pvc->profile->head, pvc, entry);
+ atomic_unlock();
+
+ return (error);
+}
+
+static int
+vclient_open_wav(struct cuse_dev *pdev, int fflags)
+{
+ return (vclient_open_sub(pdev, fflags, VTYPE_WAV_HDR));
+}
+
+static int
+vclient_open_oss(struct cuse_dev *pdev, int fflags)
+{
+ return (vclient_open_sub(pdev, fflags, VTYPE_OSS_DAT));
+}
+
+static int
+vclient_close(struct cuse_dev *pdev, int fflags __unused)
+{
+ vclient_t *pvc;
+
+ pvc = cuse_dev_get_per_file_handle(pdev);
+ if (pvc == NULL)
+ return (CUSE_ERR_INVALID);
+
+ atomic_lock();
+ if (pvc->profile->synchronized) {
+ voss_has_synchronization--;
+
+ /* wait for virtual_oss_process(), if any */
+ while (pvc->sync_busy) {
+ pvc->sync_wakeup = 1;
+ atomic_wakeup();
+ atomic_wait();
+ }
+ }
+ TAILQ_REMOVE(&pvc->profile->head, pvc, entry);
+ atomic_unlock();
+
+ vclient_free(pvc);
+
+ return (0);
+}
+
+static int
+vclient_read_silence_locked(vclient_t *pvc)
+{
+ size_t size;
+ int delta_in;
+
+ delta_in = pvc->profile->rec_delay - pvc->rec_delay;
+ if (delta_in < 1)
+ return (0);
+
+ size = delta_in * pvc->channels * 8;
+ size = vring_write_zero(&pvc->rx_ring[0], size);
+ pvc->rec_delay += size / (pvc->channels * 8);
+
+ delta_in = pvc->profile->rec_delay - pvc->rec_delay;
+ if (delta_in < 1)
+ return (0);
+
+ return (1);
+}
+
+static int
+vclient_generate_wav_header_locked(vclient_t *pvc)
+{
+ uint8_t *ptr;
+ size_t mod;
+ size_t len;
+
+ vring_get_write(&pvc->rx_ring[1], &ptr, &len);
+
+ mod = pvc->channels * vclient_sample_bytes(pvc);
+
+ if (mod == 0 || len < (44 + mod - 1))
+ return (CUSE_ERR_INVALID);
+
+ /* align to next sample */
+ len = 44 + mod - 1;
+ len -= len % mod;
+
+ /* pre-advance write pointer */
+ vring_inc_write(&pvc->rx_ring[1], len);
+
+ /* clear block */
+ memset(ptr, 0, len);
+
+ /* fill out data header */
+ ptr[len - 8] = 'd';
+ ptr[len - 7] = 'a';
+ ptr[len - 6] = 't';
+ ptr[len - 5] = 'a';
+
+ /* magic for unspecified length */
+ ptr[len - 4] = 0x00;
+ ptr[len - 3] = 0xF0;
+ ptr[len - 2] = 0xFF;
+ ptr[len - 1] = 0x7F;
+
+ /* fill out header */
+ *ptr++ = 'R';
+ *ptr++ = 'I';
+ *ptr++ = 'F';
+ *ptr++ = 'F';
+
+ /* total chunk size - unknown */
+
+ *ptr++ = 0;
+ *ptr++ = 0;
+ *ptr++ = 0;
+ *ptr++ = 0;
+
+ *ptr++ = 'W';
+ *ptr++ = 'A';
+ *ptr++ = 'V';
+ *ptr++ = 'E';
+ *ptr++ = 'f';
+ *ptr++ = 'm';
+ *ptr++ = 't';
+ *ptr++ = ' ';
+
+ /* make sure header fits in PCM block */
+ len -= 28;
+
+ *ptr++ = len;
+ *ptr++ = len >> 8;
+ *ptr++ = len >> 16;
+ *ptr++ = len >> 24;
+
+ /* audioformat = PCM */
+
+ *ptr++ = 0x01;
+ *ptr++ = 0x00;
+
+ /* number of channels */
+
+ len = pvc->channels;
+
+ *ptr++ = len;
+ *ptr++ = len >> 8;
+
+ /* sample rate */
+
+ len = pvc->sample_rate;
+
+ *ptr++ = len;
+ *ptr++ = len >> 8;
+ *ptr++ = len >> 16;
+ *ptr++ = len >> 24;
+
+ /* byte rate */
+
+ len = pvc->sample_rate * pvc->channels * vclient_sample_bytes(pvc);
+
+ *ptr++ = len;
+ *ptr++ = len >> 8;
+ *ptr++ = len >> 16;
+ *ptr++ = len >> 24;
+
+ /* block align */
+
+ len = pvc->channels * vclient_sample_bytes(pvc);
+
+ *ptr++ = len;
+ *ptr++ = len >> 8;
+
+ /* bits per sample */
+
+ len = vclient_sample_bytes(pvc) * 8;
+
+ *ptr++ = len;
+ *ptr++ = len >> 8;
+
+ return (0);
+}
+
+int
+vclient_export_read_locked(vclient_t *pvc) __requires_exclusive(atomic_mtx)
+{
+ enum { MAX_FRAME = 1024 };
+ size_t dst_mod;
+ size_t src_mod;
+ int error;
+
+ if (pvc->type == VTYPE_WAV_HDR) {
+ error = vclient_generate_wav_header_locked(pvc);
+ if (error != 0)
+ return (error);
+ /* only write header once */
+ pvc->type = VTYPE_WAV_DAT;
+ }
+ error = vclient_read_silence_locked(pvc);
+ if (error != 0)
+ return (0);
+
+ dst_mod = pvc->channels * vclient_sample_bytes(pvc);
+ src_mod = pvc->channels * 8;
+
+ if (pvc->sample_rate == (int)voss_dsp_sample_rate) {
+ while (1) {
+ uint8_t *src_ptr;
+ size_t src_len;
+ uint8_t *dst_ptr;
+ size_t dst_len;
+
+ vring_get_read(&pvc->rx_ring[0], &src_ptr, &src_len);
+ vring_get_write(&pvc->rx_ring[1], &dst_ptr, &dst_len);
+
+ src_len /= src_mod;
+ dst_len /= dst_mod;
+
+ /* compare number of samples */
+ if (dst_len > src_len)
+ dst_len = src_len;
+ else
+ src_len = dst_len;
+
+ if (dst_len == 0)
+ break;
+
+ src_len *= src_mod;
+ dst_len *= dst_mod;
+
+ format_export(pvc->format,
+ (const int64_t *)(uintptr_t)src_ptr,
+ dst_ptr, dst_len);
+
+ vring_inc_read(&pvc->rx_ring[0], src_len);
+ vring_inc_write(&pvc->rx_ring[1], dst_len);
+ }
+ } else {
+ vresample_t *pvr = &pvc->rx_resample;
+
+ if (vresample_setup(pvc, pvr, MAX_FRAME * pvc->channels) != 0)
+ return (CUSE_ERR_NO_MEMORY);
+
+ while (1) {
+ uint8_t *src_ptr;
+ size_t src_len;
+ uint8_t *dst_ptr;
+ size_t dst_len;
+ int64_t temp[MAX_FRAME * pvc->channels];
+ size_t samples;
+ size_t y;
+
+ vring_get_read(&pvc->rx_ring[0], &src_ptr, &src_len);
+ vring_get_write(&pvc->rx_ring[1], &dst_ptr, &dst_len);
+
+ src_len /= src_mod;
+ dst_len /= dst_mod;
+
+ /* compare number of samples */
+ if (dst_len > src_len)
+ dst_len = src_len;
+ else
+ src_len = dst_len;
+
+ if (dst_len > MAX_FRAME)
+ dst_len = src_len = MAX_FRAME;
+
+ if (dst_len == 0)
+ break;
+
+ src_len *= src_mod;
+ dst_len *= dst_mod;
+
+ for (y = 0; y != src_len; y += 8) {
+ pvr->data_in[y / 8] =
+ *(int64_t *)(uintptr_t)(src_ptr + y);
+ }
+
+ /* setup parameters for transform */
+ pvr->data.input_frames = src_len / src_mod;
+ pvr->data.output_frames = dst_len / dst_mod;
+ pvr->data.src_ratio = (float)pvc->sample_rate / (float)voss_dsp_sample_rate;
+
+ pvc->rx_busy = 1;
+ atomic_unlock();
+ error = src_process(pvr->state, &pvr->data);
+ atomic_lock();
+ pvc->rx_busy = 0;
+
+ if (error != 0)
+ break;
+
+ src_len = pvr->data.input_frames_used * src_mod;
+ dst_len = pvr->data.output_frames_gen * dst_mod;
+
+ samples = pvr->data.output_frames_gen * pvc->channels;
+
+ for (y = 0; y != samples; y++)
+ temp[y] = pvr->data_out[y];
+
+ format_export(pvc->format, temp, dst_ptr, dst_len);
+
+ vring_inc_read(&pvc->rx_ring[0], src_len);
+ vring_inc_write(&pvc->rx_ring[1], dst_len);
+
+ /* check if no data was moved */
+ if (src_len == 0 && dst_len == 0)
+ break;
+ }
+ }
+ if (pvc->sync_busy)
+ atomic_wakeup();
+ return (0);
+}
+
+static int
+vclient_read(struct cuse_dev *pdev, int fflags,
+ void *peer_ptr, int len)
+{
+ vclient_t *pvc;
+
+ int error;
+ int retval;
+
+ pvc = cuse_dev_get_per_file_handle(pdev);
+ if (pvc == NULL)
+ return (CUSE_ERR_INVALID);
+
+ atomic_lock();
+
+ if (pvc->rx_busy) {
+ atomic_unlock();
+ return (CUSE_ERR_BUSY);
+ }
+ pvc->rx_enabled = 1;
+
+ retval = 0;
+
+ while (len > 0) {
+ uint8_t *buf_ptr;
+ size_t buf_len;
+
+ error = vclient_export_read_locked(pvc);
+ if (error != 0) {
+ retval = error;
+ break;
+ }
+
+ vring_get_read(&pvc->rx_ring[1], &buf_ptr, &buf_len);
+
+ if (buf_len == 0) {
+ /* out of data */
+ if (fflags & CUSE_FFLAG_NONBLOCK) {
+ if (retval == 0)
+ retval = CUSE_ERR_WOULDBLOCK;
+ break;
+ }
+ pvc->rx_busy = 1;
+ atomic_wait();
+ pvc->rx_busy = 0;
+ if (cuse_got_peer_signal() == 0) {
+ if (retval == 0)
+ retval = CUSE_ERR_SIGNAL;
+ break;
+ }
+ continue;
+ }
+ if ((int)buf_len > len)
+ buf_len = len;
+
+ pvc->rx_busy = 1;
+ atomic_unlock();
+ error = cuse_copy_out(buf_ptr, peer_ptr, buf_len);
+ atomic_lock();
+ pvc->rx_busy = 0;
+
+ if (error != 0) {
+ retval = error;
+ break;
+ }
+ peer_ptr = ((uint8_t *)peer_ptr) + buf_len;
+ retval += buf_len;
+ len -= buf_len;
+
+ vring_inc_read(&pvc->rx_ring[1], buf_len);
+ }
+ atomic_unlock();
+
+ return (retval);
+}
+
+void
+vclient_import_write_locked(vclient_t *pvc) __requires_exclusive(atomic_mtx)
+{
+ enum { MAX_FRAME = 1024 };
+ size_t dst_mod;
+ size_t src_mod;
+
+ dst_mod = pvc->channels * 8;
+ src_mod = pvc->channels * vclient_sample_bytes(pvc);
+
+ if (pvc->sample_rate == (int)voss_dsp_sample_rate) {
+ while (1) {
+ uint8_t *src_ptr;
+ size_t src_len;
+ uint8_t *dst_ptr;
+ size_t dst_len;
+
+ vring_get_read(&pvc->tx_ring[1], &src_ptr, &src_len);
+ vring_get_write(&pvc->tx_ring[0], &dst_ptr, &dst_len);
+
+ src_len /= src_mod;
+ dst_len /= dst_mod;
+
+ /* compare number of samples */
+ if (dst_len > src_len)
+ dst_len = src_len;
+ else
+ src_len = dst_len;
+
+ if (dst_len == 0)
+ break;
+
+ src_len *= src_mod;
+ dst_len *= dst_mod;
+
+ format_import(pvc->format, src_ptr, src_len,
+ (int64_t *)(uintptr_t)dst_ptr);
+
+ vring_inc_read(&pvc->tx_ring[1], src_len);
+ vring_inc_write(&pvc->tx_ring[0], dst_len);
+ }
+ } else {
+ vresample_t *pvr = &pvc->tx_resample;
+
+ if (vresample_setup(pvc, pvr, MAX_FRAME * pvc->channels) != 0)
+ return;
+
+ while (1) {
+ uint8_t *src_ptr;
+ size_t src_len;
+ uint8_t *dst_ptr;
+ size_t dst_len;
+ int64_t temp[MAX_FRAME * pvc->channels];
+ size_t samples;
+ size_t y;
+ int error;
+
+ vring_get_read(&pvc->tx_ring[1], &src_ptr, &src_len);
+ vring_get_write(&pvc->tx_ring[0], &dst_ptr, &dst_len);
+
+ src_len /= src_mod;
+ dst_len /= dst_mod;
+
+ /* compare number of samples */
+ if (dst_len > src_len)
+ dst_len = src_len;
+ else
+ src_len = dst_len;
+
+ if (dst_len > MAX_FRAME)
+ dst_len = src_len = MAX_FRAME;
+
+ if (dst_len == 0)
+ break;
+
+ src_len *= src_mod;
+ dst_len *= dst_mod;
+
+ format_import(pvc->format, src_ptr, src_len, temp);
+
+ src_len /= vclient_sample_bytes(pvc);
+
+ for (y = 0; y != src_len; y++)
+ pvr->data_in[y] = temp[y];
+
+ src_len *= vclient_sample_bytes(pvc);
+
+ /* setup parameters for transform */
+ pvr->data.input_frames = src_len / src_mod;
+ pvr->data.output_frames = dst_len / dst_mod;
+ pvr->data.src_ratio = (float)voss_dsp_sample_rate / (float)pvc->sample_rate;
+
+ pvc->tx_busy = 1;
+ atomic_unlock();
+ error = src_process(pvr->state, &pvr->data);
+ atomic_lock();
+ pvc->tx_busy = 0;
+
+ if (error != 0)
+ break;
+
+ src_len = pvr->data.input_frames_used * src_mod;
+ dst_len = pvr->data.output_frames_gen * dst_mod;
+
+ samples = pvr->data.output_frames_gen * pvc->channels;
+
+ for (y = 0; y != samples; y++) {
+ ((int64_t *)(uintptr_t)dst_ptr)[y] =
+ pvr->data_out[y];
+ }
+
+ vring_inc_read(&pvc->tx_ring[1], src_len);
+ vring_inc_write(&pvc->tx_ring[0], dst_len);
+
+ /* check if no data was moved */
+ if (src_len == 0 && dst_len == 0)
+ break;
+ }
+ }
+ if (pvc->sync_busy)
+ atomic_wakeup();
+}
+
+static int
+vclient_write_oss(struct cuse_dev *pdev, int fflags,
+ const void *peer_ptr, int len)
+{
+ vclient_t *pvc;
+
+ int error;
+ int retval;
+
+ pvc = cuse_dev_get_per_file_handle(pdev);
+ if (pvc == NULL)
+ return (CUSE_ERR_INVALID);
+
+ retval = 0;
+
+ atomic_lock();
+
+ if (pvc->tx_busy) {
+ atomic_unlock();
+ return (CUSE_ERR_BUSY);
+ }
+ pvc->tx_enabled = 1;
+
+ while (1) {
+ uint8_t *buf_ptr;
+ size_t buf_len;
+
+ vclient_import_write_locked(pvc);
+
+ if (len < 1)
+ break;
+
+ vring_get_write(&pvc->tx_ring[1], &buf_ptr, &buf_len);
+
+ if (buf_len == 0) {
+ /* out of data */
+ if (fflags & CUSE_FFLAG_NONBLOCK) {
+ if (retval == 0)
+ retval = CUSE_ERR_WOULDBLOCK;
+ break;
+ }
+ pvc->tx_busy = 1;
+ atomic_wait();
+ pvc->tx_busy = 0;
+ if (cuse_got_peer_signal() == 0) {
+ if (retval == 0)
+ retval = CUSE_ERR_SIGNAL;
+ break;
+ }
+ continue;
+ }
+ if ((int)buf_len > len)
+ buf_len = len;
+
+ pvc->tx_busy = 1;
+ atomic_unlock();
+ error = cuse_copy_in(peer_ptr, buf_ptr, buf_len);
+ atomic_lock();
+ pvc->tx_busy = 0;
+
+ if (error != 0) {
+ retval = error;
+ break;
+ }
+ peer_ptr = ((const uint8_t *)peer_ptr) + buf_len;
+ retval += buf_len;
+ len -= buf_len;
+
+ vring_inc_write(&pvc->tx_ring[1], buf_len);
+ }
+ atomic_unlock();
+
+ return (retval);
+}
+
+static int
+vclient_write_wav(struct cuse_dev *pdev __unused, int fflags __unused,
+ const void *peer_ptr __unused, int len __unused)
+{
+ return (CUSE_ERR_INVALID);
+}
+
+static int
+vclient_set_channels(vclient_t *pvc, int channels)
+{
+ if (pvc->channels == channels)
+ return (0);
+ return (vclient_setup_buffers(pvc, 0, 0, channels, 0, 0));
+}
+
+/* greatest common divisor, Euclid equation */
+static uint64_t
+vclient_gcd_64(uint64_t a, uint64_t b)
+{
+ uint64_t an;
+ uint64_t bn;
+
+ while (b != 0) {
+ an = b;
+ bn = a % b;
+ a = an;
+ b = bn;
+ }
+ return (a);
+}
+
+static uint64_t
+vclient_scale(uint64_t value, uint64_t mul, uint64_t div)
+{
+ uint64_t gcd = vclient_gcd_64(mul, div);
+
+ mul /= gcd;
+ div /= gcd;
+
+ return ((value * mul) / div);
+}
+
+static int
+vclient_ioctl_oss(struct cuse_dev *pdev, int fflags __unused,
+ unsigned long cmd, void *peer_data)
+{
+ union {
+ int val;
+ unsigned long long lval;
+ oss_sysinfo sysinfo;
+ oss_card_info card_info;
+ oss_audioinfo audioinfo;
+ audio_buf_info buf_info;
+ oss_count_t oss_count;
+ count_info oss_count_info;
+ audio_errinfo errinfo;
+ oss_label_t label;
+ oss_longname_t longname;
+ } data;
+
+ vclient_t *pvc;
+
+ uint64_t bytes;
+
+ int len;
+ int error;
+ int temp;
+
+ pvc = cuse_dev_get_per_file_handle(pdev);
+ if (pvc == NULL)
+ return (CUSE_ERR_INVALID);
+
+ len = IOCPARM_LEN(cmd);
+
+ if (len < 0 || len > (int)sizeof(data))
+ return (CUSE_ERR_INVALID);
+
+ if (cmd & IOC_IN) {
+ error = cuse_copy_in(peer_data, &data, len);
+ if (error)
+ return (error);
+ } else {
+ error = 0;
+ }
+
+ atomic_lock();
+
+ switch (cmd) {
+ case OSS_GETVERSION:
+ data.val = SOUND_VERSION;
+ break;
+ case SNDCTL_SYSINFO:
+ memset(&data.sysinfo, 0, sizeof(data.sysinfo));
+ strcpy(data.sysinfo.product, "VOSS");
+ strcpy(data.sysinfo.version, "1.0");
+ data.sysinfo.versionnum = SOUND_VERSION;
+ data.sysinfo.numaudios = 1;
+ data.sysinfo.numcards = 1;
+ data.sysinfo.numaudioengines = 1;
+ strcpy(data.sysinfo.license, "BSD");
+ memset(data.sysinfo.filler, -1, sizeof(data.sysinfo.filler));
+ break;
+ case SNDCTL_CARDINFO:
+ memset(&data.card_info, 0, sizeof(data.card_info));
+ strlcpy(data.card_info.shortname, pvc->profile->oss_name,
+ sizeof(data.card_info.shortname));
+ break;
+ case SNDCTL_AUDIOINFO:
+ case SNDCTL_AUDIOINFO_EX:
+ case SNDCTL_ENGINEINFO:
+ memset(&data.audioinfo, 0, sizeof(data.audioinfo));
+ strlcpy(data.audioinfo.name, pvc->profile->oss_name,
+ sizeof(data.audioinfo.name));
+ snprintf(data.audioinfo.devnode, sizeof(data.audioinfo.devnode),
+ _PATH_DEV "%s", pvc->profile->oss_name);
+ data.audioinfo.caps = DSP_CAP_INPUT | DSP_CAP_OUTPUT;
+ data.audioinfo.iformats = VSUPPORTED_AFMT;
+ data.audioinfo.oformats = VSUPPORTED_AFMT;
+ data.audioinfo.enabled = 1;
+ data.audioinfo.min_rate = (int)8000;
+ data.audioinfo.max_rate = (int)voss_dsp_sample_rate;
+ data.audioinfo.max_channels = pvc->profile->channels;
+ /* range check */
+ if (voss_libsamplerate_enable == 0 ||
+ data.audioinfo.min_rate > data.audioinfo.max_rate)
+ data.audioinfo.min_rate = data.audioinfo.max_rate;
+ data.audioinfo.nrates = 1;
+ data.audioinfo.rates[0] = (int)voss_dsp_sample_rate;
+ if (voss_libsamplerate_enable != 0 &&
+ 96000 != voss_dsp_sample_rate)
+ data.audioinfo.rates[data.audioinfo.nrates++] = 96000;
+ if (voss_libsamplerate_enable != 0 &&
+ 48000 != voss_dsp_sample_rate)
+ data.audioinfo.rates[data.audioinfo.nrates++] = 48000;
+ if (voss_libsamplerate_enable != 0 &&
+ 44100 != voss_dsp_sample_rate)
+ data.audioinfo.rates[data.audioinfo.nrates++] = 44100;
+ if (voss_libsamplerate_enable != 0 &&
+ 24000 != voss_dsp_sample_rate)
+ data.audioinfo.rates[data.audioinfo.nrates++] = 24000;
+ if (voss_libsamplerate_enable != 0 &&
+ 16000 != voss_dsp_sample_rate)
+ data.audioinfo.rates[data.audioinfo.nrates++] = 16000;
+ if (voss_libsamplerate_enable != 0 &&
+ 8000 != voss_dsp_sample_rate)
+ data.audioinfo.rates[data.audioinfo.nrates++] = 8000;
+ data.audioinfo.latency = -1;
+ break;
+ case FIONREAD:
+ data.val = vclient_input_delay(pvc);
+ break;
+ case FIONWRITE:
+ data.val = vring_total_read_len(&pvc->tx_ring[1]);
+ break;
+ case FIOASYNC:
+ case SNDCTL_DSP_NONBLOCK:
+ case FIONBIO:
+ break;
+ case SNDCTL_DSP_SETBLKSIZE:
+ case _IOWR('P', 4, int):
+ error = vclient_setup_buffers(pvc, data.val, 0, 0, 0, 0);
+ /* FALLTHROUGH */
+ case SNDCTL_DSP_GETBLKSIZE:
+ data.val = pvc->buffer_size;
+ break;
+ case SNDCTL_DSP_SETFRAGMENT:
+ if ((data.val & 0xFFFF) < 4) {
+ /* need at least 16 bytes of buffer */
+ data.val &= ~0xFFFF;
+ data.val |= 4;
+ } else if ((data.val & 0xFFFF) > 24) {
+ /* no more than 16MBytes of buffer */
+ data.val &= ~0xFFFF;
+ data.val |= 24;
+ }
+ error = vclient_setup_buffers(pvc,
+ (1 << (data.val & 0xFFFF)), (data.val >> 16), 0, 0, 0);
+ if (error) {
+ /* fallback to defaults */
+ pvc->buffer_size_set = 0;
+ pvc->buffer_frags_set = 0;
+ error = vclient_setup_buffers(pvc, 0, 0, 0, 0, 0);
+ if (error)
+ break;
+ /* figure out log2() of actual buffer size */
+ for (data.val = 0;
+ data.val < 24 && (1U << data.val) < pvc->buffer_size;
+ data.val++)
+ ;
+ /* or in the actual number of fragments */
+ data.val |= (pvc->buffer_frags << 16);
+ }
+ break;
+ case SNDCTL_DSP_RESET:
+ error = vclient_setup_buffers(pvc, 0, 0, 0, 0, 0);
+ break;
+ case SNDCTL_DSP_SYNC:
+ break;
+ case SNDCTL_DSP_SPEED:
+ if (data.val >= 8000 && data.val <= 96000 &&
+ voss_libsamplerate_enable != 0) {
+ error = vclient_setup_buffers(pvc, 0, 0, 0, 0, data.val);
+ }
+ /* return current speed */
+ data.val = (int)pvc->sample_rate;
+ break;
+ case SOUND_PCM_READ_RATE:
+ data.val = (int)pvc->sample_rate;
+ break;
+ case SNDCTL_DSP_STEREO:
+ if (data.val != 0) {
+ error = vclient_set_channels(pvc, 2);
+ } else {
+ error = vclient_set_channels(pvc, 1);
+ }
+ data.val = (pvc->channels == 2);
+ break;
+ case SOUND_PCM_WRITE_CHANNELS:
+ if (data.val < 0) {
+ data.val = 0;
+ error = CUSE_ERR_INVALID;
+ break;
+ }
+ if (data.val == 0) {
+ data.val = pvc->channels;
+ } else {
+ error = vclient_set_channels(pvc, data.val);
+ }
+ break;
+ case SOUND_PCM_READ_CHANNELS:
+ data.val = pvc->channels;
+ break;
+ case AIOGFMT:
+ case SNDCTL_DSP_GETFMTS:
+ data.val = VSUPPORTED_AFMT | AFMT_FULLDUPLEX |
+ (pvc->profile->channels > 1 ? AFMT_STEREO : 0);
+ break;
+ case AIOSFMT:
+ case SNDCTL_DSP_SETFMT:
+ if (data.val != AFMT_QUERY) {
+ temp = data.val & VSUPPORTED_AFMT;
+ if (temp == 0 || (temp & (temp - 1)) != 0) {
+ error = CUSE_ERR_INVALID;
+ } else {
+ error = vclient_setup_buffers(pvc, 0, 0, 0, temp, 0);
+ }
+ } else {
+ data.val = pvc->format;
+ }
+ break;
+ case SNDCTL_DSP_GETISPACE:
+ memset(&data.buf_info, 0, sizeof(data.buf_info));
+ data.buf_info.fragsize = pvc->buffer_size;
+ data.buf_info.fragstotal = pvc->buffer_frags;
+ bytes = (pvc->buffer_size * pvc->buffer_frags);
+ temp = vclient_input_delay(pvc);
+ if (temp < 0 || (uint64_t)temp > bytes)
+ temp = bytes;
+ data.buf_info.fragments = temp / pvc->buffer_size;
+ data.buf_info.bytes = temp;
+ break;
+ case SNDCTL_DSP_GETOSPACE:
+ memset(&data.buf_info, 0, sizeof(data.buf_info));
+ data.buf_info.fragsize = pvc->buffer_size;
+ data.buf_info.fragstotal = pvc->buffer_frags;
+ bytes = (pvc->buffer_size * pvc->buffer_frags);
+ temp = vclient_output_delay(pvc);
+ if (temp < 0 || (uint64_t)temp >= bytes) {
+ /* buffer is full */
+ data.buf_info.fragments = 0;
+ data.buf_info.bytes = 0;
+ } else {
+ /* buffer is not full */
+ bytes -= temp;
+ data.buf_info.fragments = bytes / pvc->buffer_size;
+ data.buf_info.bytes = bytes;
+ }
+ break;
+ case SNDCTL_DSP_GETCAPS:
+ data.val = PCM_CAP_REALTIME | PCM_CAP_DUPLEX |
+ PCM_CAP_INPUT | PCM_CAP_OUTPUT | PCM_CAP_TRIGGER |
+ PCM_CAP_VIRTUAL;
+ break;
+ case SOUND_PCM_READ_BITS:
+ data.val = vclient_sample_bytes(pvc) * 8;
+ break;
+ case SNDCTL_DSP_SETTRIGGER:
+ if (data.val & PCM_ENABLE_INPUT) {
+ pvc->rx_enabled = 1;
+ } else {
+ pvc->rx_enabled = 0;
+ vring_reset(&pvc->rx_ring[1]);
+ }
+
+ if (data.val & PCM_ENABLE_OUTPUT) {
+ pvc->tx_enabled = 1;
+ } else {
+ pvc->tx_enabled = 0;
+ vring_reset(&pvc->tx_ring[1]);
+ }
+ break;
+ case SNDCTL_DSP_GETTRIGGER:
+ data.val = 0;
+ if (pvc->rx_enabled)
+ data.val |= PCM_ENABLE_INPUT;
+ if (pvc->tx_enabled)
+ data.val |= PCM_ENABLE_OUTPUT;
+ break;
+ case SNDCTL_DSP_GETODELAY:
+ data.val = vclient_output_delay_adjusted(pvc);
+ break;
+ case SNDCTL_DSP_POST:
+ break;
+ case SNDCTL_DSP_SETDUPLEX:
+ break;
+ case SNDCTL_DSP_GETRECVOL:
+ temp = (pvc->rx_volume * 100) >> VVOLUME_UNIT_SHIFT;
+ data.val = (temp & 0x00FF) |
+ ((temp << 8) & 0xFF00);
+ break;
+ case SNDCTL_DSP_SETRECVOL:
+ pvc->rx_volume = ((data.val & 0xFF) << VVOLUME_UNIT_SHIFT) / 100;
+ break;
+ case SNDCTL_DSP_GETPLAYVOL:
+ temp = (pvc->tx_volume * 100) >> VVOLUME_UNIT_SHIFT;
+ data.val = (temp & 0x00FF) |
+ ((temp << 8) & 0xFF00);
+ break;
+ case SNDCTL_DSP_SETPLAYVOL:
+ pvc->tx_volume = ((data.val & 0xFF) << VVOLUME_UNIT_SHIFT) / 100;
+ break;
+ case SNDCTL_DSP_CURRENT_IPTR:
+ memset(&data.oss_count, 0, sizeof(data.oss_count));
+ /* compute input samples per channel */
+ data.oss_count.samples =
+ vclient_scale(pvc->rx_samples, pvc->sample_rate, voss_dsp_sample_rate);
+ data.oss_count.samples /= pvc->channels;
+ data.oss_count.fifo_samples =
+ vclient_input_delay(pvc) / (pvc->channels * vclient_sample_bytes(pvc));
+ break;
+ case SNDCTL_DSP_CURRENT_OPTR:
+ memset(&data.oss_count, 0, sizeof(data.oss_count));
+ /* compute output samples per channel */
+ data.oss_count.samples =
+ vclient_scale(pvc->tx_samples, pvc->sample_rate, voss_dsp_sample_rate);
+ data.oss_count.samples /= pvc->channels;
+ data.oss_count.fifo_samples =
+ vclient_output_delay(pvc) / (pvc->channels * vclient_sample_bytes(pvc));
+ break;
+ case SNDCTL_DSP_GETIPTR:
+ memset(&data.oss_count_info, 0, sizeof(data.oss_count_info));
+ /* compute input bytes */
+ bytes =
+ vclient_scale(pvc->rx_samples, pvc->sample_rate, voss_dsp_sample_rate) *
+ vclient_sample_bytes(pvc);
+ data.oss_count_info.bytes = bytes;
+ data.oss_count_info.blocks = bytes / pvc->buffer_size;
+ data.oss_count_info.ptr = bytes % (pvc->buffer_size * pvc->buffer_frags);
+ break;
+ case SNDCTL_DSP_GETOPTR:
+ memset(&data.oss_count_info, 0, sizeof(data.oss_count_info));
+ /* compute output bytes */
+ bytes =
+ vclient_scale(pvc->tx_samples, pvc->sample_rate, voss_dsp_sample_rate) *
+ vclient_sample_bytes(pvc);
+ data.oss_count_info.bytes = bytes;
+ data.oss_count_info.blocks = bytes / pvc->buffer_size;
+ data.oss_count_info.ptr = bytes % (pvc->buffer_size * pvc->buffer_frags);
+ break;
+ case SNDCTL_DSP_HALT_OUTPUT:
+ pvc->tx_enabled = 0;
+ break;
+ case SNDCTL_DSP_HALT_INPUT:
+ pvc->rx_enabled = 0;
+ break;
+ case SNDCTL_DSP_LOW_WATER:
+ if (data.val > 0 && data.val <
+ (int)(pvc->buffer_frags * pvc->buffer_size)) {
+ pvc->low_water = data.val;
+ } else {
+ error = CUSE_ERR_INVALID;
+ }
+ break;
+ case SNDCTL_DSP_GETERROR:
+ memset(&data.errinfo, 0, sizeof(data.errinfo));
+ break;
+ case SNDCTL_DSP_SYNCGROUP:
+ case SNDCTL_DSP_SYNCSTART:
+ break;
+ case SNDCTL_DSP_POLICY:
+ break;
+ case SNDCTL_DSP_COOKEDMODE:
+ break;
+ case SNDCTL_DSP_GET_CHNORDER:
+ data.lval = CHNORDER_NORMAL;
+ break;
+ case SNDCTL_DSP_GETCHANNELMASK:
+ data.val = DSP_BIND_FRONT;
+ break;
+ case SNDCTL_DSP_BIND_CHANNEL:
+ break;
+ case SNDCTL_GETLABEL:
+ memset(&data.label, 0, sizeof(data.label));
+ break;
+ case SNDCTL_SETLABEL:
+ break;
+ case SNDCTL_GETSONG:
+ memset(&data.longname, 0, sizeof(data.longname));
+ break;
+ case SNDCTL_SETSONG:
+ break;
+ case SNDCTL_SETNAME:
+ break;
+ default:
+ error = CUSE_ERR_INVALID;
+ break;
+ }
+ atomic_unlock();
+
+ if (error == 0) {
+ if (cmd & IOC_OUT)
+ error = cuse_copy_out(&data, peer_data, len);
+ }
+ return (error);
+}
+
+static int
+vclient_ioctl_wav(struct cuse_dev *pdev, int fflags __unused,
+ unsigned long cmd, void *peer_data)
+{
+ union {
+ int val;
+ } data;
+
+ vclient_t *pvc;
+ int len;
+ int error;
+
+ pvc = cuse_dev_get_per_file_handle(pdev);
+ if (pvc == NULL)
+ return (CUSE_ERR_INVALID);
+
+ len = IOCPARM_LEN(cmd);
+
+ if (len < 0 || len > (int)sizeof(data))
+ return (CUSE_ERR_INVALID);
+
+ if (cmd & IOC_IN) {
+ error = cuse_copy_in(peer_data, &data, len);
+ if (error)
+ return (error);
+ } else {
+ error = 0;
+ }
+
+ atomic_lock();
+ switch (cmd) {
+ case FIONREAD:
+ data.val = vclient_input_delay(pvc);
+ break;
+ case FIOASYNC:
+ case SNDCTL_DSP_NONBLOCK:
+ case FIONBIO:
+ break;
+ default:
+ error = CUSE_ERR_INVALID;
+ break;
+ }
+ atomic_unlock();
+
+ if (error == 0) {
+ if (cmd & IOC_OUT)
+ error = cuse_copy_out(&data, peer_data, len);
+ }
+ return (error);
+}
+
+static int
+vclient_poll(struct cuse_dev *pdev, int fflags, int events)
+{
+ vclient_t *pvc;
+
+ int retval = CUSE_POLL_NONE;
+
+ pvc = cuse_dev_get_per_file_handle(pdev);
+ if (pvc == NULL)
+ return (retval);
+
+ atomic_lock();
+ if ((events & CUSE_POLL_READ) && (fflags & CUSE_FFLAG_READ)) {
+ pvc->rx_enabled = 1;
+ if (vclient_input_delay(pvc) >= pvc->low_water)
+ retval |= CUSE_POLL_READ;
+ }
+ if ((events & CUSE_POLL_WRITE) && (fflags & CUSE_FFLAG_WRITE)) {
+ const uint32_t out_dly = vclient_output_delay(pvc);
+ const uint32_t out_buf = (pvc->buffer_frags * pvc->buffer_size);
+
+ if (out_dly < out_buf && (out_buf - out_dly) >= pvc->low_water)
+ retval |= CUSE_POLL_WRITE;
+ }
+ atomic_unlock();
+
+ return (retval);
+}
+
+static const struct cuse_methods vclient_oss_methods = {
+ .cm_open = vclient_open_oss,
+ .cm_close = vclient_close,
+ .cm_read = vclient_read,
+ .cm_write = vclient_write_oss,
+ .cm_ioctl = vclient_ioctl_oss,
+ .cm_poll = vclient_poll,
+};
+
+static const struct cuse_methods vclient_wav_methods = {
+ .cm_open = vclient_open_wav,
+ .cm_close = vclient_close,
+ .cm_read = vclient_read,
+ .cm_write = vclient_write_wav,
+ .cm_ioctl = vclient_ioctl_wav,
+ .cm_poll = vclient_poll,
+};
+
+vprofile_head_t virtual_profile_client_head;
+vprofile_head_t virtual_profile_loopback_head;
+
+vmonitor_head_t virtual_monitor_input;
+vmonitor_head_t virtual_monitor_output;
+vmonitor_head_t virtual_monitor_local;
+
+uint32_t voss_max_channels;
+uint32_t voss_mix_channels;
+uint32_t voss_dsp_samples;
+uint32_t voss_dsp_max_channels;
+uint32_t voss_dsp_sample_rate;
+uint32_t voss_dsp_bits;
+uint8_t voss_libsamplerate_enable;
+uint8_t voss_libsamplerate_quality = SRC_SINC_FASTEST;
+int voss_is_recording = 1;
+int voss_has_synchronization;
+volatile sig_atomic_t voss_exit = 0;
+
+static int voss_dsp_perm = 0666;
+static int voss_do_background;
+static const char *voss_pid_path;
+
+uint32_t voss_dsp_rx_refresh;
+uint32_t voss_dsp_tx_refresh;
+char voss_dsp_rx_device[VMAX_STRING];
+char voss_dsp_tx_device[VMAX_STRING];
+char voss_ctl_device[VMAX_STRING];
+
+uint32_t voss_jitter_up;
+uint32_t voss_jitter_down;
+
+struct voss_backend *voss_rx_backend;
+struct voss_backend *voss_tx_backend;
+
+static int voss_dups;
+static int voss_ntds;
+static pthread_t *voss_tds;
+
+/* XXX I do not like the prefix argument... */
+static struct voss_backend *
+voss_load_backend(const char *prefix, const char *name, const char *dir)
+{
+ struct voss_backend *backend;
+ void *hdl;
+ char lpath[64], bsym[64];
+
+ snprintf(lpath, sizeof(lpath), "%s/lib/virtual_oss/voss_%s.so",
+ prefix, name);
+ snprintf(bsym, sizeof(bsym), "voss_backend_%s_%s", name, dir);
+
+ if ((hdl = dlopen(lpath, RTLD_NOW)) == NULL)
+ errx(1, "%s", dlerror());
+ if ((backend = dlsym(hdl, bsym)) == NULL) {
+ warnx("%s", dlerror());
+ dlclose(hdl);
+ exit(EXIT_FAILURE);
+ }
+
+ return (backend);
+}
+
+static void
+voss_rx_backend_refresh(void)
+{
+ /* setup RX backend */
+ if (strcmp(voss_dsp_rx_device, "/dev/null") == 0) {
+ voss_rx_backend = voss_load_backend("/usr", "null", "rec");
+ } else if (strstr(voss_dsp_rx_device, "/dev/bluetooth/") == voss_dsp_rx_device) {
+ voss_rx_backend = voss_load_backend("/usr/local", "bt", "rec");
+ } else if (strstr(voss_dsp_rx_device, "/dev/sndio/") == voss_dsp_rx_device) {
+ voss_rx_backend = voss_load_backend("/usr/local", "sndio", "rec");
+ } else {
+ voss_rx_backend = voss_load_backend("/usr", "oss", "rec");
+ }
+}
+
+static void
+voss_tx_backend_refresh(void)
+{
+ /* setup TX backend */
+ if (strcmp(voss_dsp_tx_device, "/dev/null") == 0) {
+ voss_tx_backend = voss_load_backend("/usr", "null", "play");
+ } else if (strstr(voss_dsp_tx_device, "/dev/bluetooth/") == voss_dsp_tx_device) {
+ voss_tx_backend = voss_load_backend("/usr/local", "bt", "play");
+ } else if (strstr(voss_dsp_tx_device, "/dev/sndio/") == voss_dsp_tx_device) {
+ voss_tx_backend = voss_load_backend("/usr/local", "sndio", "play");
+ } else {
+ voss_tx_backend = voss_load_backend("/usr", "oss", "play");
+ }
+}
+
+static void
+usage(void)
+{
+ fprintf(stderr, "Usage: virtual_oss [options...] [device] \\\n"
+ "\t" "-C 2 -c 2 -r 48000 -b 16 -s 100.0ms -f /dev/dsp3 \\\n"
+ "\t" "-P /dev/dsp3 -R /dev/dsp1 \\\n"
+ "\t" "-O /dev/dsp3 -R /dev/null \\\n"
+ "\t" "-c 1 -m 0,0 [-w wav.0] -d dsp100.0 \\\n"
+ "\t" "-c 1 -m 0,0 [-w wav.0] -d vdsp.0 \\\n"
+ "\t" "-c 2 -m 0,0,1,1 [-w wav.1] -d vdsp.1 \\\n"
+ "\t" "-c 2 -m 0,0,1,1 [-w wav.loopback] -l vdsp.loopback \\\n"
+ "\t" "-c 2 -m 0,0,1,1 [-w wav.loopback] -L vdsp.loopback \\\n"
+ "\t" "-B # run in background \\\n"
+ "\t" "-s <samples> or <milliseconds>ms \\\n"
+ "\t" "-S # enable automatic resampling using libsamplerate \\\n"
+ "\t" "-Q <0,1,2> # quality of resampling 0=best,1=medium,2=fastest (default) \\\n"
+ "\t" "-b <bits> \\\n"
+ "\t" "-r <rate> \\\n"
+ "\t" "-i <rtprio> \\\n"
+ "\t" "-a <amp -63..63> \\\n"
+ "\t" "-a i,<rx_amp -63..63> \\\n"
+ "\t" "-a o,<tx_amp -63..63> \\\n"
+ "\t" "-g <knee,attack,decay> # enable device RX compressor\\\n"
+ "\t" "-x <knee,attack,decay> # enable output compressor\\\n"
+ "\t" "-p <pol 0..1> \\\n"
+ "\t" "-e <rxtx_mute 0..1> \\\n"
+ "\t" "-e <rx_mute 0..1>,<tx_mute 0..1> \\\n"
+ "\t" "-m <mapping> \\\n"
+ "\t" "-m <rx0,tx0,rx1,tx1...rxN,txN> \\\n"
+ "\t" "-C <mixchans>\\\n"
+ "\t" "-c <dspchans> \\\n"
+ "\t" "-M <monitorfilter> \\\n"
+ "\t" "-M i,<src>,<dst>,<pol>,<mute>,<amp> \\\n"
+ "\t" "-M o,<src>,<dst>,<pol>,<mute>,<amp> \\\n"
+ "\t" "-M x,<src>,<dst>,<pol>,<mute>,<amp> \\\n"
+ "\t" "-F <rx_filter_samples> or <milliseconds>ms \\\n"
+ "\t" "-G <tx_filter_samples> or <milliseconds>ms \\\n"
+ "\t" "-E <enable_recording, 0 or 1> \\\n"
+ "\t" "-N <max HTTP connections, default is 1> \\\n"
+ "\t" "-H <bind HTTP server to this host> \\\n"
+ "\t" "-o <bind HTTP server to this port, default is 80> \\\n"
+ "\t" "-J <bind RTP server to this network interface> \\\n"
+ "\t" "-k <bind RTP server to this port, default is 8080> \\\n"
+ "\t" "-t vdsp.ctl \n"
+ "\t" "Left channel = 0\n"
+ "\t" "Right channel = 1\n"
+ "\t" "Max channels = %d\n", VMAX_CHAN);
+
+ exit(EX_USAGE);
+}
+
+static void
+init_compressor(struct virtual_profile *pvp)
+{
+ int x;
+
+ memset(&pvp->rx_compressor_param, 0, sizeof(pvp->rx_compressor_param));
+
+ pvp->rx_compressor_param.knee = 85;
+ pvp->rx_compressor_param.attack = 3;
+ pvp->rx_compressor_param.decay = 20;
+
+ for (x = 0; x != VMAX_CHAN; x++)
+ pvp->rx_compressor_gain[x] = 1.0;
+}
+
+static void
+init_mapping(struct virtual_profile *pvp)
+{
+ int x;
+
+ for (x = 0; x != VMAX_CHAN; x++) {
+ pvp->rx_src[x] = x;
+ pvp->tx_dst[x] = x;
+ }
+}
+
+static void
+init_sndstat(vprofile_t *ptr)
+{
+ int err;
+ nvlist_t *nvl;
+ nvlist_t *di = NULL, *dichild = NULL;
+ struct sndstioc_nv_arg arg;
+ unsigned int min_rate, max_rate;
+
+ nvl = nvlist_create(0);
+ if (nvl == NULL) {
+ warn("Failed to create nvlist");
+ goto done;
+ }
+
+ di = nvlist_create(0);
+ if (di == NULL) {
+ warn("Failed to create nvlist");
+ goto done;
+ }
+
+ dichild = nvlist_create(0);
+ if (dichild == NULL) {
+ warn("Failed to create nvlist");
+ goto done;
+ }
+
+ nvlist_add_string(di, SNDST_DSPS_PROVIDER, "virtual_oss");
+ nvlist_add_string(di, SNDST_DSPS_DESC, "virtual_oss device");
+ nvlist_add_number(di, SNDST_DSPS_PCHAN, 1);
+ nvlist_add_number(di, SNDST_DSPS_RCHAN, 1);
+ min_rate = 8000;
+ max_rate = voss_dsp_sample_rate;
+ if (voss_libsamplerate_enable == 0 ||
+ min_rate > max_rate)
+ min_rate = max_rate;
+ if (voss_libsamplerate_enable != 0 && max_rate < 96000)
+ max_rate = 96000;
+ nvlist_add_number(dichild, SNDST_DSPS_INFO_MIN_RATE, min_rate);
+ nvlist_add_number(dichild, SNDST_DSPS_INFO_MAX_RATE, max_rate);
+ nvlist_add_number(dichild, SNDST_DSPS_INFO_FORMATS, VSUPPORTED_AFMT);
+ nvlist_add_number(dichild, SNDST_DSPS_INFO_MIN_CHN, ptr->channels);
+ nvlist_add_number(dichild, SNDST_DSPS_INFO_MAX_CHN, ptr->channels);
+ nvlist_add_nvlist(di, SNDST_DSPS_INFO_PLAY, dichild);
+ nvlist_add_nvlist(di, SNDST_DSPS_INFO_REC, dichild);
+
+ nvlist_add_string(di, SNDST_DSPS_DEVNODE,
+ ptr->oss_name);
+ nvlist_append_nvlist_array(nvl, SNDST_DSPS, di);
+
+ if (nvlist_error(nvl)) {
+ warn("Failed building nvlist");
+ goto done;
+ }
+
+ arg.buf = nvlist_pack(nvl, &arg.nbytes);
+ if (arg.buf == NULL) {
+ warn("Failed to pack nvlist");
+ goto done;
+ }
+ err = ioctl(ptr->fd_sta, SNDSTIOC_ADD_USER_DEVS, &arg);
+ free(arg.buf);
+ if (err != 0) {
+ warn("Failed to issue ioctl(SNDSTIOC_ADD_USER_DEVS)");
+ goto done;
+ }
+
+done:
+ nvlist_destroy(di);
+ nvlist_destroy(dichild);
+ nvlist_destroy(nvl);
+}
+
+static const char *
+dup_profile(vprofile_t *pvp, int *pamp, int pol, int rx_mute,
+ int tx_mute, int synchronized, int is_client)
+{
+ vprofile_t *ptr;
+ struct cuse_dev *pdev;
+ int x;
+
+ rx_mute = rx_mute ? 1 : 0;
+ tx_mute = tx_mute ? 1 : 0;
+ pol = pol ? 1 : 0;
+
+ /* Range check amplitude argument. */
+ for (x = 0; x != 2; x++) {
+ if (pamp[x] < -63)
+ pamp[x] = -63;
+ else if (pamp[x] > 63)
+ pamp[x] = 63;
+ }
+
+ ptr = malloc(sizeof(*ptr));
+ if (ptr == NULL)
+ return ("Out of memory");
+
+ memcpy(ptr, pvp, sizeof(*ptr));
+
+ ptr->synchronized = synchronized;
+ ptr->fd_sta = -1;
+ TAILQ_INIT(&ptr->head);
+
+ for (x = 0; x != ptr->channels; x++) {
+ ptr->tx_mute[x] = tx_mute;
+ ptr->rx_mute[x] = rx_mute;
+ ptr->tx_shift[x] = pamp[1];
+ ptr->rx_shift[x] = pamp[0];
+ ptr->tx_pol[x] = pol;
+ ptr->rx_pol[x] = pol;
+ }
+
+ /* create DSP device */
+ if (ptr->oss_name[0] != 0) {
+ /*
+ * Detect /dev/dsp creation and try to disable system
+ * basename cloning automatically:
+ */
+ if (strcmp(ptr->oss_name, "dsp") == 0)
+ system("sysctl hw.snd.basename_clone=0");
+
+ /* create DSP character device */
+ pdev = cuse_dev_create(&vclient_oss_methods, ptr, NULL,
+ 0, 0, voss_dsp_perm, ptr->oss_name);
+ if (pdev == NULL) {
+ free(ptr);
+ return ("Could not create CUSE DSP device");
+ }
+
+ /* register to sndstat */
+ ptr->fd_sta = open("/dev/sndstat", O_WRONLY);
+ if (ptr->fd_sta < 0) {
+ warn("Could not open /dev/sndstat");
+ } else {
+ init_sndstat(ptr);
+ }
+ }
+ /* create WAV device */
+ if (ptr->wav_name[0] != 0) {
+ pdev = cuse_dev_create(&vclient_wav_methods, ptr, NULL,
+ 0, 0, voss_dsp_perm, ptr->wav_name);
+ if (pdev == NULL) {
+ free(ptr);
+ return ("Could not create CUSE WAV device");
+ }
+ }
+
+ atomic_lock();
+ if (is_client)
+ TAILQ_INSERT_TAIL(&virtual_profile_client_head, ptr, entry);
+ else
+ TAILQ_INSERT_TAIL(&virtual_profile_loopback_head, ptr, entry);
+ atomic_unlock();
+
+ voss_dups++;
+
+ /* need new names next time */
+ memset(pvp->oss_name, 0, sizeof(pvp->oss_name));
+ memset(pvp->wav_name, 0, sizeof(pvp->wav_name));
+
+ /* need to set new filter sizes */
+ pvp->rx_filter_size = 0;
+ pvp->tx_filter_size = 0;
+
+ /* need to specify new HTTP parameters next time */
+ pvp->http.host = NULL;
+ pvp->http.port = NULL;
+ pvp->http.nstate = 0;
+ pvp->http.rtp_ifname = NULL;
+ pvp->http.rtp_port = NULL;
+
+ /* need to specify new amplification next time */
+ pamp[0] = 0;
+ pamp[1] = 0;
+
+ /* need to set new compressor parameters next time */
+ init_compressor(pvp);
+
+ return (voss_httpd_start(ptr));
+}
+
+static void
+virtual_pipe(int sig __unused)
+{
+ voss_dsp_tx_refresh = 1;
+ voss_dsp_rx_refresh = 1;
+}
+
+static void
+virtual_cuse_hup(int sig __unused)
+{
+ atomic_wakeup();
+}
+
+static void *
+virtual_cuse_process(void *arg __unused)
+{
+ signal(SIGHUP, &virtual_cuse_hup);
+
+ while (1) {
+ if (cuse_wait_and_process() != 0)
+ break;
+ }
+ return (NULL);
+}
+
+static void
+virtual_cuse_init_profile(struct virtual_profile *pvp)
+{
+ memset(pvp, 0, sizeof(*pvp));
+
+ init_compressor(pvp);
+ init_mapping(pvp);
+}
+
+static void
+virtual_sig_exit(int sig __unused)
+{
+ voss_exit = 1;
+}
+
+static const char *
+parse_options(int narg, char **pparg, int is_main)
+{
+ const char *ptr;
+ int a, b, c;
+ int val;
+ int idx;
+ int type;
+ int opt_mute[2] = {0, 0};
+ int opt_amp[2] = {0, 0};
+ int opt_pol = 0;
+ const char *optstr;
+ struct virtual_profile profile;
+ struct rtprio rtp;
+ float samples_ms;
+
+ if (is_main)
+ optstr = "N:J:k:H:o:F:G:w:e:p:a:C:c:r:b:f:g:x:i:m:M:d:l:L:s:t:h?O:P:Q:R:SBD:E:";
+ else
+ optstr = "F:G:w:e:p:a:c:b:f:m:M:d:l:L:s:O:P:R:E:";
+
+ virtual_cuse_init_profile(&profile);
+
+ /* reset getopt parsing */
+ optreset = 1;
+ optind = 1;
+
+ while ((c = getopt(narg, pparg, optstr)) != -1) {
+ switch (c) {
+ case 'B':
+ voss_do_background = 1;
+ break;
+ case 'D':
+ voss_pid_path = optarg;
+ break;
+ case 'C':
+ if (voss_mix_channels != 0) {
+ return ("The -C argument may only be used once");
+ }
+ voss_mix_channels = atoi(optarg);
+ if (voss_mix_channels >= VMAX_CHAN) {
+ return ("Number of mixing channels is too high");
+ }
+ break;
+ case 'a':
+ switch (optarg[0]) {
+ case '-':
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ opt_amp[0] = -(opt_amp[1] = atoi(optarg));
+ break;
+ case 'i':
+ if (optarg[1] != ',')
+ return ("Expected comma after 'i'");
+ opt_amp[0] = atoi(optarg + 2);
+ break;
+ case 'o':
+ if (optarg[1] != ',')
+ return ("Expected comma after 'o'");
+ opt_amp[1] = atoi(optarg + 2);
+ break;
+ default:
+ return ("Invalid syntax for amplitude argument");
+ }
+ break;
+ case 'E':
+ voss_is_recording = (atoi(optarg) != 0);
+ break;
+ case 'e':
+ idx = 0;
+ ptr = optarg;
+ memset(opt_mute, 0, sizeof(opt_mute));
+ while (1) {
+ c = *ptr++;
+ if (c == ',' || c == 0) {
+ idx++;
+ if (c == 0)
+ break;
+ continue;
+ }
+ if (idx < 2 && c >= '0' && c <= '1') {
+ opt_mute[idx] = c - '0';
+ } else {
+ return ("Invalid -e parameter");
+ }
+ }
+ switch (idx) {
+ case 1:
+ opt_mute[1] = opt_mute[0];
+ break;
+ case 2:
+ break;
+ default:
+ return ("Invalid -e parameter");
+ }
+ break;
+ case 'p':
+ opt_pol = atoi(optarg);
+ break;
+ case 'c':
+ profile.channels = atoi(optarg);
+ if (profile.channels == 0)
+ return ("Number of channels is zero");
+ if (profile.channels > VMAX_CHAN)
+ return ("Number of channels is too high");
+ break;
+ case 'r':
+ voss_dsp_sample_rate = atoi(optarg);
+ if (voss_dsp_sample_rate < 8000)
+ return ("Sample rate is too low, 8000 Hz");
+ if (voss_dsp_sample_rate > 0xFFFFFF)
+ return ("Sample rate is too high");
+ break;
+ case 'i':
+ memset(&rtp, 0, sizeof(rtp));
+ rtp.type = RTP_PRIO_REALTIME;
+ rtp.prio = atoi(optarg);
+ if (rtprio(RTP_SET, getpid(), &rtp) != 0)
+ printf("Cannot set realtime priority\n");
+ break;
+ case 'b':
+ profile.bits = atoi(optarg);
+ switch (profile.bits) {
+ case 8:
+ case 16:
+ case 24:
+ case 32:
+ break;
+ default:
+ return ("Invalid number of sample bits");
+ }
+ break;
+ case 'g':
+ if (profile.rx_compressor_param.enabled)
+ return ("Compressor already enabled for this device");
+ if (sscanf(optarg, "%d,%d,%d", &a, &b, &c) != 3 ||
+ a < VIRTUAL_OSS_KNEE_MIN ||
+ a > VIRTUAL_OSS_KNEE_MAX ||
+ b < VIRTUAL_OSS_ATTACK_MIN ||
+ b > VIRTUAL_OSS_ATTACK_MAX ||
+ c < VIRTUAL_OSS_DECAY_MIN ||
+ c > VIRTUAL_OSS_DECAY_MAX)
+ return ("Invalid device compressor argument(s)");
+ profile.rx_compressor_param.enabled = 1;
+ profile.rx_compressor_param.knee = a;
+ profile.rx_compressor_param.attack = b;
+ profile.rx_compressor_param.decay = c;
+ break;
+ case 'x':
+ if (voss_output_compressor_param.enabled)
+ return ("Compressor already enabled for output");
+ if (sscanf(optarg, "%d,%d,%d", &a, &b, &c) != 3 ||
+ a < VIRTUAL_OSS_KNEE_MIN ||
+ a > VIRTUAL_OSS_KNEE_MAX ||
+ b < VIRTUAL_OSS_ATTACK_MIN ||
+ b > VIRTUAL_OSS_ATTACK_MAX ||
+ c < VIRTUAL_OSS_DECAY_MIN ||
+ c > VIRTUAL_OSS_DECAY_MAX)
+ return ("Invalid output compressor argument(s)");
+ voss_output_compressor_param.enabled = 1;
+ voss_output_compressor_param.knee = a;
+ voss_output_compressor_param.attack = b;
+ voss_output_compressor_param.decay = c;
+ break;
+ case 'f':
+ case 'O':
+ case 'P':
+ case 'R':
+ if (voss_dsp_sample_rate == 0 || voss_dsp_samples == 0)
+ return ("Missing -r or -s parameters");
+ if (voss_dsp_bits == 0) {
+ if (profile.bits == 0)
+ return ("Missing -b parameter");
+ voss_dsp_bits = profile.bits;
+ }
+ if (voss_dsp_max_channels == 0) {
+ if (profile.channels == 0)
+ return ("Missing -c parameter");
+ voss_dsp_max_channels = profile.channels;
+ }
+ if (c == 'f' || c == 'R') {
+ if (strlen(optarg) > VMAX_STRING - 1)
+ return ("Device name too long");
+ strncpy(voss_dsp_rx_device, optarg, sizeof(voss_dsp_rx_device));
+ voss_rx_backend_refresh();
+ voss_dsp_rx_refresh = 1;
+ }
+ if (c == 'f' || c == 'P' || c == 'O') {
+ if (strlen(optarg) > VMAX_STRING - 1)
+ return ("Device name too long");
+ strncpy(voss_dsp_tx_device, optarg, sizeof(voss_dsp_tx_device));
+ voss_tx_backend_refresh();
+ voss_dsp_tx_refresh = 1;
+
+ if (c == 'O' && voss_has_synchronization == 0)
+ voss_has_synchronization++;
+ }
+ break;
+ case 'w':
+ if (strlen(optarg) > VMAX_STRING - 1)
+ return ("Device name too long");
+ strncpy(profile.wav_name, optarg, sizeof(profile.wav_name));
+ break;
+ case 'd':
+ if (strlen(optarg) > VMAX_STRING - 1)
+ return ("Device name too long");
+ strncpy(profile.oss_name, optarg, sizeof(profile.oss_name));
+
+ if (profile.bits == 0 || voss_dsp_sample_rate == 0 ||
+ profile.channels == 0 || voss_dsp_samples == 0)
+ return ("Missing -b, -r, -c or -s parameters");
+
+ val = (voss_dsp_samples *
+ profile.bits * profile.channels) / 8;
+ if (val <= 0 || val >= (1024 * 1024))
+ return ("-s option value is too big");
+
+ ptr = dup_profile(&profile, opt_amp, opt_pol,
+ opt_mute[0], opt_mute[1], 0, 1);
+ if (ptr != NULL)
+ return (ptr);
+ break;
+ case 'L':
+ case 'l':
+ if (strlen(optarg) > VMAX_STRING - 1)
+ return ("Device name too long");
+ strncpy(profile.oss_name, optarg, sizeof(profile.oss_name));
+
+ if (profile.bits == 0 || voss_dsp_sample_rate == 0 ||
+ profile.channels == 0 || voss_dsp_samples == 0)
+ return ("Missing -b, -r, -r or -s parameters");
+
+ val = (voss_dsp_samples *
+ profile.bits * profile.channels) / 8;
+ if (val <= 0 || val >= (1024 * 1024))
+ return ("-s option value is too big");
+
+ ptr = dup_profile(&profile, opt_amp, opt_pol,
+ opt_mute[0], opt_mute[1], c == 'L', 0);
+ if (ptr != NULL)
+ return (ptr);
+ break;
+ case 'S':
+ voss_libsamplerate_enable = 1;
+ break;
+ case 'Q':
+ c = atoi(optarg);
+ switch (c) {
+ case 0:
+ voss_libsamplerate_quality = SRC_SINC_BEST_QUALITY;
+ break;
+ case 1:
+ voss_libsamplerate_quality = SRC_SINC_MEDIUM_QUALITY;
+ break;
+ default:
+ voss_libsamplerate_quality = SRC_SINC_FASTEST;
+ break;
+ }
+ break;
+ case 's':
+ if (voss_dsp_samples != 0)
+ return ("-s option may only be used once");
+ if (profile.bits == 0 || profile.channels == 0)
+ return ("-s option requires -b and -c options");
+ if (strlen(optarg) > 2 &&
+ sscanf(optarg, "%f", &samples_ms) == 1 &&
+ strcmp(optarg + strlen(optarg) - 2, "ms") == 0) {
+ if (voss_dsp_sample_rate == 0)
+ return ("-s <X>ms option requires -r option");
+ if (samples_ms < 0.125 || samples_ms >= 1000.0)
+ return ("-s <X>ms option has invalid value");
+ voss_dsp_samples = voss_dsp_sample_rate * samples_ms / 1000.0;
+ } else {
+ voss_dsp_samples = atoi(optarg);
+ }
+ if (voss_dsp_samples >= (1U << 24))
+ return ("-s option requires a non-zero positive value");
+ break;
+ case 't':
+ if (voss_ctl_device[0])
+ return ("-t parameter may only be used once");
+
+ strncpy(voss_ctl_device, optarg, sizeof(voss_ctl_device));
+ break;
+ case 'm':
+ ptr = optarg;
+ val = 0;
+ idx = 0;
+ init_mapping(&profile);
+ while (1) {
+ c = *ptr++;
+ if (c == ',' || c == 0) {
+ if (idx >= (2 * VMAX_CHAN))
+ return ("Too many channels in mask");
+ if (idx & 1)
+ profile.tx_dst[idx / 2] = val;
+ else
+ profile.rx_src[idx / 2] = val;
+ if (c == 0)
+ break;
+ val = 0;
+ idx++;
+ continue;
+ }
+ if (c >= '0' && c <= '9') {
+ val *= 10;
+ val += c - '0';
+ }
+ }
+ break;
+ case 'M':
+ ptr = optarg;
+ type = *ptr;
+ if (type == 'i' || type == 'o' || type == 'x') {
+ vmonitor_t *pvm;
+
+ int src = 0;
+ int dst = 0;
+ int pol = 0;
+ int mute = 0;
+ int amp = 0;
+ int neg;
+
+ ptr++;
+ if (*ptr == ',')
+ ptr++;
+ else if (type == 'i')
+ return ("Expected comma after 'i'");
+ else if (type == 'o')
+ return ("Expected comma after 'o'");
+ else
+ return ("Expected comma after 'x'");
+
+ val = 0;
+ neg = 0;
+ idx = 0;
+ while (1) {
+ c = *ptr++;
+ if (c == '-') {
+ neg = 1;
+ continue;
+ }
+ if (c == ',' || c == 0) {
+ switch (idx) {
+ case 0:
+ src = val;
+ break;
+ case 1:
+ dst = val;
+ break;
+ case 2:
+ pol = val ? 1 : 0;
+ break;
+ case 3:
+ mute = val ? 1 : 0;
+ break;
+ case 4:
+ if (val > 31) {
+ return ("Absolute amplitude "
+ "for -M parameter "
+ "cannot exceed 31");
+ }
+ amp = neg ? -val : val;
+ break;
+ default:
+ break;
+ }
+ if (c == 0)
+ break;
+ val = 0;
+ neg = 0;
+ idx++;
+ continue;
+ }
+ if (c >= '0' && c <= '9') {
+ val *= 10;
+ val += c - '0';
+ }
+ }
+ if (idx < 4)
+ return ("Too few parameters for -M");
+
+ pvm = vmonitor_alloc(&idx,
+ (type == 'i') ? &virtual_monitor_input :
+ (type == 'x') ? &virtual_monitor_local :
+ &virtual_monitor_output);
+
+ if (pvm == NULL)
+ return ("Out of memory");
+
+ pvm->src_chan = src;
+ pvm->dst_chan = dst;
+ pvm->pol = pol;
+ pvm->mute = mute;
+ pvm->shift = amp;
+ } else {
+ return ("Invalid -M parameter");
+ }
+ break;
+ case 'F':
+ if (strlen(optarg) > 2 &&
+ sscanf(optarg, "%f", &samples_ms) == 1 &&
+ strcmp(optarg + strlen(optarg) - 2, "ms") == 0) {
+ if (voss_dsp_sample_rate == 0)
+ return ("-F <X>ms option requires -r option");
+ if (samples_ms < 0.125 || samples_ms >= 1000.0)
+ return ("-F <X>ms option has invalid value");
+ profile.rx_filter_size = voss_dsp_sample_rate * samples_ms / 1000.0;
+ } else {
+ profile.rx_filter_size = atoi(optarg);
+ }
+ /* make value power of two */
+ while ((profile.rx_filter_size - 1) & profile.rx_filter_size)
+ profile.rx_filter_size += ~(profile.rx_filter_size - 1) & profile.rx_filter_size;
+ /* range check */
+ if (profile.rx_filter_size > VIRTUAL_OSS_FILTER_MAX)
+ return ("Invalid -F parameter is out of range");
+ break;
+ case 'G':
+ if (strlen(optarg) > 2 &&
+ sscanf(optarg, "%f", &samples_ms) == 1 &&
+ strcmp(optarg + strlen(optarg) - 2, "ms") == 0) {
+ if (voss_dsp_sample_rate == 0)
+ return ("-G <X>ms option requires -r option");
+ if (samples_ms < 0.125 || samples_ms >= 1000.0)
+ return ("-G <X>ms option has invalid value");
+ profile.tx_filter_size = voss_dsp_sample_rate * samples_ms / 1000.0;
+ } else {
+ profile.tx_filter_size = atoi(optarg);
+ }
+ /* make value power of two */
+ while ((profile.tx_filter_size - 1) & profile.tx_filter_size)
+ profile.tx_filter_size += ~(profile.tx_filter_size - 1) & profile.tx_filter_size;
+ /* range check */
+ if (profile.tx_filter_size > VIRTUAL_OSS_FILTER_MAX)
+ return ("Invalid -F parameter is out of range");
+ break;
+ case 'N':
+ profile.http.nstate = atoi(optarg);
+ break;
+ case 'H':
+ profile.http.host = optarg;
+ if (profile.http.port == NULL)
+ profile.http.port = "80";
+ if (profile.http.nstate == 0)
+ profile.http.nstate = 1;
+ break;
+ case 'o':
+ profile.http.port = optarg;
+ break;
+ case 'J':
+ profile.http.rtp_ifname = optarg;
+ if (profile.http.rtp_port == NULL)
+ profile.http.rtp_port = "8080";
+ break;
+ case 'k':
+ profile.http.rtp_port = optarg;
+ break;
+ default:
+ if (is_main)
+ usage();
+ else
+ return ("Invalid option detected");
+ break;
+ }
+ }
+ return (NULL);
+}
+
+static void
+create_threads(void)
+{
+ int idx;
+
+ /* Give each DSP device 4 threads */
+ voss_ntds = voss_dups * 4;
+ voss_tds = malloc(voss_ntds * sizeof(pthread_t));
+ if (voss_tds == NULL)
+ err(1, "malloc");
+
+ for (idx = 0; idx < voss_ntds; idx++) {
+ if (pthread_create(&voss_tds[idx], NULL, &virtual_cuse_process,
+ NULL) != 0)
+ err(1, "pthread_create");
+ }
+
+ /* Reset until next time called */
+ voss_dups = 0;
+}
+
+static void
+destroy_threads(void)
+{
+ int idx;
+
+ for (idx = 0; idx < voss_ntds; idx++)
+ pthread_cancel(voss_tds[idx]);
+ free(voss_tds);
+}
+
+void
+voss_add_options(char *str)
+{
+ static char name[] = { "virtual_oss" };
+ const char sep[] = "\t ";
+ const char *ptrerr;
+ char *parg[64];
+ char *word;
+ char *brkt;
+ int narg = 0;
+
+ parg[narg++] = name;
+
+ for (word = strtok_r(str, sep, &brkt); word != NULL;
+ word = strtok_r(NULL, sep, &brkt)) {
+ if (narg >= 64) {
+ ptrerr = "Too many arguments";
+ goto done;
+ }
+ parg[narg++] = word;
+ }
+ ptrerr = parse_options(narg, parg, 0);
+done:
+ if (ptrerr != NULL) {
+ strlcpy(str, ptrerr, VIRTUAL_OSS_OPTIONS_MAX);
+ } else {
+ str[0] = 0;
+ create_threads();
+ }
+}
+
+int
+main(int argc, char **argv)
+{
+ const char *ptrerr;
+ struct sigaction sa;
+ struct cuse_dev *pdev;
+
+ TAILQ_INIT(&virtual_profile_client_head);
+ TAILQ_INIT(&virtual_profile_loopback_head);
+
+ TAILQ_INIT(&virtual_monitor_input);
+ TAILQ_INIT(&virtual_monitor_output);
+ TAILQ_INIT(&virtual_monitor_local);
+
+ atomic_init();
+
+ /* automagically load the cuse.ko module, if any */
+ if (feature_present("cuse") == 0) {
+ if (system("kldload cuse") == -1)
+ warn("Failed to kldload cuse");
+ }
+
+ if (cuse_init() != 0)
+ errx(EX_USAGE, "Could not connect to cuse module");
+
+ signal(SIGPIPE, &virtual_pipe);
+
+ memset(&sa, 0, sizeof(sa));
+ sigfillset(&sa.sa_mask);
+ sa.sa_handler = virtual_sig_exit;
+ if (sigaction(SIGINT, &sa, NULL) < 0)
+ err(1, "sigaction(SIGINT)");
+ if (sigaction(SIGTERM, &sa, NULL) < 0)
+ err(1, "sigaction(SIGTERM)");
+
+ ptrerr = parse_options(argc, argv, 1);
+ if (ptrerr != NULL)
+ errx(EX_USAGE, "%s", ptrerr);
+
+ if (voss_dsp_rx_device[0] == 0 || voss_dsp_tx_device[0] == 0)
+ errx(EX_USAGE, "Missing -f argument");
+
+ /* use DSP channels as default */
+ if (voss_mix_channels == 0)
+ voss_mix_channels = voss_dsp_max_channels;
+
+ if (voss_mix_channels > voss_dsp_max_channels)
+ voss_max_channels = voss_mix_channels;
+ else
+ voss_max_channels = voss_dsp_max_channels;
+
+ if (voss_dsp_samples > (voss_dsp_sample_rate / 4))
+ errx(EX_USAGE, "Too many buffer samples given by -s argument");
+
+ /* check if daemon mode is requested */
+ if (voss_do_background != 0 && daemon(0, 0) != 0)
+ errx(EX_SOFTWARE, "Cannot become daemon");
+
+ if (voss_pid_path != NULL) {
+ int pidfile = open(voss_pid_path, O_RDWR | O_CREAT | O_TRUNC, 0600);
+ pid_t mypid = getpid();
+ char mypidstr[8];
+ snprintf(mypidstr, sizeof(mypidstr), "%d\n", mypid);
+ if (pidfile < 0)
+ errx(EX_SOFTWARE, "Cannot create PID file '%s'", voss_pid_path);
+ if (write(pidfile, mypidstr, strlen(mypidstr)) !=
+ (ssize_t)strlen(mypidstr))
+ errx(EX_SOFTWARE, "Cannot write PID file");
+ close(pidfile);
+ }
+
+ /* setup audio delay unit */
+ voss_ad_init(voss_dsp_sample_rate);
+
+ /* Create CTL device */
+
+ if (voss_ctl_device[0] != 0) {
+ pdev = cuse_dev_create(&vctl_methods, NULL, NULL,
+ 0, 0, voss_dsp_perm, voss_ctl_device);
+ if (pdev == NULL)
+ errx(EX_USAGE, "Could not create '/dev/%s'", voss_ctl_device);
+
+ voss_dups++;
+ }
+
+ /* Create worker threads */
+ create_threads();
+
+ /* Run DSP threads */
+
+ virtual_oss_process(NULL);
+
+ destroy_threads();
+
+ if (voss_ctl_device[0] != 0)
+ cuse_dev_destroy(pdev);
+
+ return (0);
+}
diff --git a/usr.sbin/virtual_oss/virtual_oss/mul.c b/usr.sbin/virtual_oss/virtual_oss/mul.c
new file mode 100644
--- /dev/null
+++ b/usr.sbin/virtual_oss/virtual_oss/mul.c
@@ -0,0 +1,175 @@
+/*-
+ * Copyright (c) 2017 Hans Petter Selasky
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/queue.h>
+
+#include <stdint.h>
+#include <string.h>
+
+#include "int.h"
+
+#ifndef VOSS_X3_LOG2_COMBA
+#define VOSS_X3_LOG2_COMBA 5
+#endif
+
+#if (VOSS_X3_LOG2_COMBA < 2)
+#error "VOSS_X3_LOG2_COMBA must be greater than 1"
+#endif
+
+struct voss_x3_input_double {
+ double a;
+ double b;
+} __aligned(16);
+
+/*
+ * <input size> = "stride"
+ * <output size> = 2 * "stride"
+ */
+static void
+voss_x3_multiply_sub_double(struct voss_x3_input_double *input, double *ptr_low, double *ptr_high,
+ const size_t stride, const uint8_t toggle)
+{
+ size_t x;
+ size_t y;
+
+ if (stride >= (1UL << VOSS_X3_LOG2_COMBA)) {
+ const size_t strideh = stride >> 1;
+
+ if (toggle) {
+
+ /* inverse step */
+ for (x = 0; x != strideh; x++) {
+ double a, b, c, d;
+
+ a = ptr_low[x];
+ b = ptr_low[x + strideh];
+ c = ptr_high[x];
+ d = ptr_high[x + strideh];
+
+ ptr_low[x + strideh] = a + b;
+ ptr_high[x] = a + b + c + d;
+ }
+
+ voss_x3_multiply_sub_double(input, ptr_low, ptr_low + strideh, strideh, 1);
+
+ for (x = 0; x != strideh; x++)
+ ptr_low[x + strideh] = -ptr_low[x + strideh];
+
+ voss_x3_multiply_sub_double(input + strideh, ptr_low + strideh, ptr_high + strideh, strideh, 1);
+
+ /* forward step */
+ for (x = 0; x != strideh; x++) {
+ double a, b, c, d;
+
+ a = ptr_low[x];
+ b = ptr_low[x + strideh];
+ c = ptr_high[x];
+ d = ptr_high[x + strideh];
+
+ ptr_low[x + strideh] = -a - b;
+ ptr_high[x] = c + b - d;
+
+ input[x + strideh].a += input[x].a;
+ input[x + strideh].b += input[x].b;
+ }
+
+ voss_x3_multiply_sub_double(input + strideh, ptr_low + strideh, ptr_high, strideh, 0);
+ } else {
+ voss_x3_multiply_sub_double(input + strideh, ptr_low + strideh, ptr_high, strideh, 1);
+
+ /* inverse step */
+ for (x = 0; x != strideh; x++) {
+ double a, b, c, d;
+
+ a = ptr_low[x];
+ b = ptr_low[x + strideh];
+ c = ptr_high[x];
+ d = ptr_high[x + strideh];
+
+ ptr_low[x + strideh] = -a - b;
+ ptr_high[x] = a + b + c + d;
+
+ input[x + strideh].a -= input[x].a;
+ input[x + strideh].b -= input[x].b;
+ }
+
+ voss_x3_multiply_sub_double(input + strideh, ptr_low + strideh, ptr_high + strideh, strideh, 0);
+
+ for (x = 0; x != strideh; x++)
+ ptr_low[x + strideh] = -ptr_low[x + strideh];
+
+ voss_x3_multiply_sub_double(input, ptr_low, ptr_low + strideh, strideh, 0);
+
+ /* forward step */
+ for (x = 0; x != strideh; x++) {
+ double a, b, c, d;
+
+ a = ptr_low[x];
+ b = ptr_low[x + strideh];
+ c = ptr_high[x];
+ d = ptr_high[x + strideh];
+
+ ptr_low[x + strideh] = b - a;
+ ptr_high[x] = c - b - d;
+ }
+ }
+ } else {
+ for (x = 0; x != stride; x++) {
+ double value = input[x].a;
+
+ for (y = 0; y != (stride - x); y++) {
+ ptr_low[x + y] += input[y].b * value;
+ }
+
+ for (; y != stride; y++) {
+ ptr_high[x + y - stride] += input[y].b * value;
+ }
+ }
+ }
+}
+
+/*
+ * <input size> = "max"
+ * <output size> = 2 * "max"
+ */
+void
+voss_x3_multiply_double(const int64_t *va, const double *vb, double *pc, const size_t max)
+{
+ struct voss_x3_input_double input[max];
+ size_t x;
+
+ /* check for non-power of two */
+ if (max & (max - 1))
+ return;
+
+ /* setup input vector */
+ for (x = 0; x != max; x++) {
+ input[x].a = va[x];
+ input[x].b = vb[x];
+ }
+
+ /* do multiplication */
+ voss_x3_multiply_sub_double(input, pc, pc + max, max, 1);
+}
diff --git a/usr.sbin/virtual_oss/virtual_oss/ring.c b/usr.sbin/virtual_oss/virtual_oss/ring.c
new file mode 100644
--- /dev/null
+++ b/usr.sbin/virtual_oss/virtual_oss/ring.c
@@ -0,0 +1,213 @@
+/*-
+ * Copyright (c) 2018 Hans Petter Selasky
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/queue.h>
+#include <sys/types.h>
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <time.h>
+
+#include "int.h"
+
+int
+vring_alloc(struct virtual_ring *pvr, size_t size)
+{
+
+ if (pvr->buf_start != NULL)
+ return (EBUSY);
+ pvr->buf_start = malloc(size);
+ if (pvr->buf_start == NULL)
+ return (ENOMEM);
+ pvr->pos_read = 0;
+ pvr->total_size = size;
+ pvr->len_write = 0;
+ return (0);
+}
+
+void
+vring_free(struct virtual_ring *pvr)
+{
+
+ if (pvr->buf_start != NULL) {
+ free(pvr->buf_start);
+ pvr->buf_start = NULL;
+ }
+}
+
+void
+vring_reset(struct virtual_ring *pvr)
+{
+ pvr->pos_read = 0;
+ pvr->len_write = 0;
+}
+
+void
+vring_get_read(struct virtual_ring *pvr, uint8_t **pptr, size_t *plen)
+{
+ uint32_t delta;
+
+ if (pvr->buf_start == NULL) {
+ *pptr = NULL;
+ *plen = 0;
+ return;
+ }
+ delta = pvr->total_size - pvr->pos_read;
+ if (delta > pvr->len_write)
+ delta = pvr->len_write;
+
+ *pptr = pvr->buf_start + pvr->pos_read;
+ *plen = delta;
+}
+
+void
+vring_get_write(struct virtual_ring *pvr, uint8_t **pptr, size_t *plen)
+{
+ uint32_t delta;
+ uint32_t len_read;
+ uint32_t pos_write;
+
+ if (pvr->buf_start == NULL) {
+ *pptr = NULL;
+ *plen = 0;
+ return;
+ }
+ pos_write = pvr->pos_read + pvr->len_write;
+ if (pos_write >= pvr->total_size)
+ pos_write -= pvr->total_size;
+
+ len_read = pvr->total_size - pvr->len_write;
+
+ delta = pvr->total_size - pos_write;
+ if (delta > len_read)
+ delta = len_read;
+
+ *pptr = pvr->buf_start + pos_write;
+ *plen = delta;
+}
+
+void
+vring_inc_read(struct virtual_ring *pvr, size_t len)
+{
+
+ pvr->pos_read += len;
+ pvr->len_write -= len;
+
+ /* check for wrap-around */
+ if (pvr->pos_read == pvr->total_size)
+ pvr->pos_read = 0;
+}
+
+void
+vring_inc_write(struct virtual_ring *pvr, size_t len)
+{
+
+ pvr->len_write += len;
+}
+
+size_t
+vring_total_read_len(struct virtual_ring *pvr)
+{
+
+ return (pvr->len_write);
+}
+
+size_t
+vring_total_write_len(struct virtual_ring *pvr)
+{
+
+ return (pvr->total_size - pvr->len_write);
+}
+
+size_t
+vring_write_linear(struct virtual_ring *pvr, const uint8_t *src, size_t total)
+{
+ uint8_t *buf_ptr;
+ size_t buf_len;
+ size_t sum = 0;
+
+ while (total != 0) {
+ vring_get_write(pvr, &buf_ptr, &buf_len);
+ if (buf_len == 0)
+ break;
+ if (buf_len > total)
+ buf_len = total;
+ memcpy(buf_ptr, src, buf_len);
+ vring_inc_write(pvr, buf_len);
+ src += buf_len;
+ sum += buf_len;
+ total -= buf_len;
+ }
+ return (sum);
+}
+
+size_t
+vring_read_linear(struct virtual_ring *pvr, uint8_t *dst, size_t total)
+{
+ uint8_t *buf_ptr;
+ size_t buf_len;
+ size_t sum = 0;
+
+ if (total > vring_total_read_len(pvr))
+ return (0);
+
+ while (total != 0) {
+ vring_get_read(pvr, &buf_ptr, &buf_len);
+ if (buf_len == 0)
+ break;
+ if (buf_len > total)
+ buf_len = total;
+ memcpy(dst, buf_ptr, buf_len);
+ vring_inc_read(pvr, buf_len);
+ dst += buf_len;
+ sum += buf_len;
+ total -= buf_len;
+ }
+ return (sum);
+}
+
+size_t
+vring_write_zero(struct virtual_ring *pvr, size_t total)
+{
+ uint8_t *buf_ptr;
+ size_t buf_len;
+ size_t sum = 0;
+
+ while (total != 0) {
+ vring_get_write(pvr, &buf_ptr, &buf_len);
+ if (buf_len == 0)
+ break;
+ if (buf_len > total)
+ buf_len = total;
+ memset(buf_ptr, 0, buf_len);
+ vring_inc_write(pvr, buf_len);
+ sum += buf_len;
+ total -= buf_len;
+ }
+ return (sum);
+}
diff --git a/usr.sbin/virtual_oss/virtual_oss/utils.h b/usr.sbin/virtual_oss/virtual_oss/utils.h
new file mode 100644
--- /dev/null
+++ b/usr.sbin/virtual_oss/virtual_oss/utils.h
@@ -0,0 +1,31 @@
+/*-
+ * Copyright (c) 2019 Hans Petter Selasky
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef _VIRTUAL_UTILS_H_
+#define _VIRTUAL_UTILS_H_
+
+int bt_speaker_main(int argc, char **argv);
+
+#endif /* _VIRTUAL_UTILS_H_ */
diff --git a/usr.sbin/virtual_oss/virtual_oss/virtual_oss.h b/usr.sbin/virtual_oss/virtual_oss/virtual_oss.h
new file mode 100644
--- /dev/null
+++ b/usr.sbin/virtual_oss/virtual_oss/virtual_oss.h
@@ -0,0 +1,206 @@
+/*-
+ * Copyright (c) 2012-2022 Hans Petter Selasky
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef _VIRTUAL_OSS_H_
+#define _VIRTUAL_OSS_H_
+
+#include <sys/ioccom.h>
+
+#define VIRTUAL_OSS_NAME_MAX 32
+#define VIRTUAL_OSS_VERSION 0x00010008
+#define VIRTUAL_OSS_OPTIONS_MAX 1024 /* bytes */
+#define VIRTUAL_OSS_FILTER_MAX 65536 /* samples */
+
+#define VIRTUAL_OSS_GET_VERSION _IOR('O', 0, int)
+
+struct virtual_oss_io_info {
+ int number; /* must be first */
+ int channel;
+ char name[VIRTUAL_OSS_NAME_MAX];
+ int bits;
+ int rx_amp;
+ int tx_amp;
+ int rx_chan;
+ int tx_chan;
+ int rx_mute;
+ int tx_mute;
+ int rx_pol;
+ int tx_pol;
+ int rx_delay; /* in samples */
+ int rx_delay_limit; /* in samples */
+};
+
+#define VIRTUAL_OSS_GET_DEV_INFO _IOWR('O', 1, struct virtual_oss_io_info)
+#define VIRTUAL_OSS_SET_DEV_INFO _IOW('O', 2, struct virtual_oss_io_info)
+
+#define VIRTUAL_OSS_GET_LOOP_INFO _IOWR('O', 3, struct virtual_oss_io_info)
+#define VIRTUAL_OSS_SET_LOOP_INFO _IOW('O', 4, struct virtual_oss_io_info)
+
+struct virtual_oss_mon_info {
+ int number;
+ int bits;
+ int src_chan;
+ int dst_chan;
+ int pol;
+ int mute;
+ int amp;
+};
+
+#define VIRTUAL_OSS_GET_INPUT_MON_INFO _IOWR('O', 5, struct virtual_oss_mon_info)
+#define VIRTUAL_OSS_SET_INPUT_MON_INFO _IOW('O', 6, struct virtual_oss_mon_info)
+
+#define VIRTUAL_OSS_GET_OUTPUT_MON_INFO _IOWR('O', 7, struct virtual_oss_mon_info)
+#define VIRTUAL_OSS_SET_OUTPUT_MON_INFO _IOW('O', 8, struct virtual_oss_mon_info)
+
+#define VIRTUAL_OSS_GET_LOCAL_MON_INFO _IOWR('O', 43, struct virtual_oss_mon_info)
+#define VIRTUAL_OSS_SET_LOCAL_MON_INFO _IOW('O', 44, struct virtual_oss_mon_info)
+
+struct virtual_oss_io_peak {
+ int number; /* must be first */
+ int channel;
+ char name[VIRTUAL_OSS_NAME_MAX];
+ int bits;
+ long long rx_peak_value;
+ long long tx_peak_value;
+};
+
+#define VIRTUAL_OSS_GET_DEV_PEAK _IOWR('O', 9, struct virtual_oss_io_peak)
+#define VIRTUAL_OSS_GET_LOOP_PEAK _IOWR('O', 10, struct virtual_oss_io_peak)
+
+struct virtual_oss_mon_peak {
+ int number;
+ int bits;
+ long long peak_value;
+};
+
+#define VIRTUAL_OSS_GET_INPUT_MON_PEAK _IOWR('O', 11, struct virtual_oss_mon_peak)
+#define VIRTUAL_OSS_GET_OUTPUT_MON_PEAK _IOWR('O', 12, struct virtual_oss_mon_peak)
+#define VIRTUAL_OSS_GET_LOCAL_MON_PEAK _IOWR('O', 45, struct virtual_oss_mon_peak)
+
+#define VIRTUAL_OSS_ADD_INPUT_MON _IOR('O', 13, int)
+#define VIRTUAL_OSS_ADD_OUTPUT_MON _IOR('O', 14, int)
+#define VIRTUAL_OSS_ADD_LOCAL_MON _IOR('O', 46, int)
+
+struct virtual_oss_compressor {
+ int enabled;
+ int knee;
+#define VIRTUAL_OSS_KNEE_MAX 255 /* inclusive */
+#define VIRTUAL_OSS_KNEE_MIN 0
+ int attack;
+#define VIRTUAL_OSS_ATTACK_MAX 62 /* inclusive */
+#define VIRTUAL_OSS_ATTACK_MIN 0
+ int decay;
+#define VIRTUAL_OSS_DECAY_MAX 62 /* inclusive */
+#define VIRTUAL_OSS_DECAY_MIN 0
+ int gain; /* read only */
+#define VIRTUAL_OSS_GAIN_MAX 1000 /* inclusive */
+#define VIRTUAL_OSS_GAIN_MIN 0
+};
+
+#define VIRTUAL_OSS_SET_OUTPUT_LIMIT _IOW('O', 17, struct virtual_oss_compressor)
+#define VIRTUAL_OSS_GET_OUTPUT_LIMIT _IOWR('O', 18, struct virtual_oss_compressor)
+
+struct virtual_oss_io_limit {
+ int number; /* must be first */
+ struct virtual_oss_compressor param;
+};
+
+#define VIRTUAL_OSS_SET_DEV_LIMIT _IOW('O', 19, struct virtual_oss_io_limit)
+#define VIRTUAL_OSS_GET_DEV_LIMIT _IOWR('O', 20, struct virtual_oss_io_limit)
+
+#define VIRTUAL_OSS_SET_LOOP_LIMIT _IOW('O', 21, struct virtual_oss_io_limit)
+#define VIRTUAL_OSS_GET_LOOP_LIMIT _IOWR('O', 22, struct virtual_oss_io_limit)
+
+struct virtual_oss_master_peak {
+ int channel;
+ int bits;
+ long long peak_value;
+};
+
+#define VIRTUAL_OSS_GET_OUTPUT_PEAK _IOWR('O', 23, struct virtual_oss_master_peak)
+#define VIRTUAL_OSS_GET_INPUT_PEAK _IOWR('O', 24, struct virtual_oss_master_peak)
+
+#define VIRTUAL_OSS_SET_RECORDING _IOW('O', 25, int)
+#define VIRTUAL_OSS_GET_RECORDING _IOR('O', 26, int)
+
+struct virtual_oss_audio_delay_locator {
+ int channel_output;
+ int channel_input;
+ int channel_last;
+ int signal_output_level; /* 2**n */
+ int signal_input_delay; /* in samples, roundtrip */
+ int signal_delay_hz; /* in samples, HZ */
+ int locator_enabled;
+};
+
+#define VIRTUAL_OSS_SET_AUDIO_DELAY_LOCATOR _IOW('O', 27, struct virtual_oss_audio_delay_locator)
+#define VIRTUAL_OSS_GET_AUDIO_DELAY_LOCATOR _IOR('O', 28, struct virtual_oss_audio_delay_locator)
+#define VIRTUAL_OSS_RST_AUDIO_DELAY_LOCATOR _IO('O', 29)
+
+struct virtual_oss_midi_delay_locator {
+ int channel_output;
+ int channel_input;
+ int signal_delay;
+ int signal_delay_hz; /* in samples, HZ */
+ int locator_enabled;
+};
+
+#define VIRTUAL_OSS_SET_MIDI_DELAY_LOCATOR _IOW('O', 30, struct virtual_oss_midi_delay_locator)
+#define VIRTUAL_OSS_GET_MIDI_DELAY_LOCATOR _IOR('O', 31, struct virtual_oss_midi_delay_locator)
+#define VIRTUAL_OSS_RST_MIDI_DELAY_LOCATOR _IO('O', 32)
+
+#define VIRTUAL_OSS_ADD_OPTIONS _IOWR('O', 33, char [VIRTUAL_OSS_OPTIONS_MAX])
+
+struct virtual_oss_fir_filter {
+ int number; /* must be first */
+ int channel;
+ int filter_size;
+ double *filter_data;
+};
+
+#define VIRTUAL_OSS_GET_RX_DEV_FIR_FILTER _IOWR('O', 34, struct virtual_oss_fir_filter)
+#define VIRTUAL_OSS_SET_RX_DEV_FIR_FILTER _IOWR('O', 35, struct virtual_oss_fir_filter)
+#define VIRTUAL_OSS_GET_TX_DEV_FIR_FILTER _IOWR('O', 36, struct virtual_oss_fir_filter)
+#define VIRTUAL_OSS_SET_TX_DEV_FIR_FILTER _IOWR('O', 37, struct virtual_oss_fir_filter)
+#define VIRTUAL_OSS_GET_RX_LOOP_FIR_FILTER _IOWR('O', 38, struct virtual_oss_fir_filter)
+#define VIRTUAL_OSS_SET_RX_LOOP_FIR_FILTER _IOWR('O', 39, struct virtual_oss_fir_filter)
+#define VIRTUAL_OSS_GET_TX_LOOP_FIR_FILTER _IOWR('O', 40, struct virtual_oss_fir_filter)
+#define VIRTUAL_OSS_SET_TX_LOOP_FIR_FILTER _IOWR('O', 41, struct virtual_oss_fir_filter)
+
+#define VIRTUAL_OSS_GET_SAMPLE_RATE _IOR('O', 42, int)
+
+struct virtual_oss_system_info {
+ unsigned tx_jitter_up;
+ unsigned tx_jitter_down;
+ unsigned sample_rate;
+ unsigned sample_bits;
+ unsigned sample_channels;
+ char rx_device_name[64];
+ char tx_device_name[64];
+};
+
+#define VIRTUAL_OSS_GET_SYSTEM_INFO _IOR('O', 43, struct virtual_oss_system_info)
+
+#endif /* _VIRTUAL_OSS_H_ */
diff --git a/usr.sbin/virtual_oss/virtual_oss/virtual_oss.8 b/usr.sbin/virtual_oss/virtual_oss/virtual_oss.8
new file mode 100644
--- /dev/null
+++ b/usr.sbin/virtual_oss/virtual_oss/virtual_oss.8
@@ -0,0 +1,355 @@
+.\"
+.\" Copyright (c) 2017-2022 Hans Petter Selasky <hselasky@freebsd.org>
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\" notice, this list of conditions and the following disclaimer.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\" notice, this list of conditions and the following disclaimer in the
+.\" documentation and/or other materials provided with the distribution.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+.\" ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+.\" SUCH DAMAGE.
+.\"
+.\"
+.Dd September 3, 2024
+.Dt VIRTUAL_OSS 8
+.Os
+.Sh NAME
+.Nm virtual_oss
+.Nd daemon to multiplex and demultiplex an OSS device
+.Sh SYNOPSIS
+.Nm
+.Op Fl h
+.Sh DESCRIPTION
+.Nm
+is an audio mixing application that multiplexes and demultiplexes a
+single OSS device into multiple customizable OSS compatible devices
+using character devices from userspace.
+These devices can be used to record played back audio and mix the individual
+channels in multiple ways.
+.Pp
+.Nm
+requires the
+.Xr cuse 3
+kernel module.
+To load the driver as a module at boot time, place the following line in
+.Xr loader.conf 5 :
+.Pp
+ cuse_load="YES"
+.Pp
+All channel numbers start at zero.
+Left channel is zero and right channel is one.
+.Pp
+The following options are available:
+.Bl -tag -width indent
+.It Fl B
+Run program in background.
+.It Fl S
+Enable automatic DSP rate resampling.
+.It Fl Q Ar quality
+Set resampling quality: 0=best, 1=medium and 2=fastest (default).
+.It Fl b Ar bits
+Set sample depth to
+.Fa bits
+for the subsequent commands.
+Valid values are 8, 16, 24 and 32.
+.It Fl r Ar rate
+Set default sample-rate for the subsequent commands.
+.It Fl s Ar value
+Set default buffer size to
+.Fa value .
+If the argument is suffixed by "ms" it is interpreted as milliseconds.
+Else the argument gives number of samples.
+The buffer size specified is per channel.
+If there are multiple channels, the total buffer size will be larger.
+.It Fl i Ar priority
+Set real-time priority to
+.Fa priority .
+Refer to
+.Xr rtprio 1
+for more information.
+.It Fl a Ar log2_amp
+Set the default DSP output and input device amplification to
+.Fa log2_amp .
+The specified amplification is logarithmic.
+Valid values range from -63 to 63 inclusivly.
+The device input amplification gets set to minus
+.Fa log2_amp
+and the device output amplification gets set to
+.Fa log2_amp .
+.It Fl a Ar i,log2_amp
+Set the default DSP input device amplification to
+.Fa log2_amp .
+The specified amplification is logarithmic.
+Valid values range from -63 to 63 inclusivly.
+.It Fl a Ar o,log2_amp
+Set default DSP output device amplification to
+.Fa log2_amp .
+The specified amplification is logarithmic.
+Valid values range from -63 to 63 inclusivly.
+.It Fl p Ar polarity
+Set default polarity of DSP device.
+A value of zero means normal polarity.
+A value of one means negative polarity.
+.It Fl e Ar rx_mute,tx_mute
+Set default mute state of DSP device.
+A value of zero means unmuted.
+A value of one means muted.
+.It Fl m Ar rx_ch,tx_ch,....
+Set default channel mapping of DSP device, as a comma separated list of
+integers.
+The first integer selects the receive channel, the second value selects the
+transmit channel and then it repeats.
+A value of zero indicates the first receive or transmit channel.
+.It Fl C Ar num
+Set the maximum number of mix channels to
+.Fa num .
+.It Fl c Ar num
+Set mix channels for the subsequent commands.
+.It Fl M Ar type,src_ch,dst_ch,pol,mute,log2_gain
+Add a monitoring filter.
+The filter consists of a list of comma separated arguments.
+The first argument indicates the type of monitoring filter:
+.Bl -tag -width indent
+.It i
+Feedback one mix input channel into another mix output channel, for remote
+feedback.
+.It o
+Add one mix output channel into another mix output channel, for creating a mix
+of multiple output channels.
+.It x
+Feedback one mix output channel into another mix input channel, for local
+feedback.
+.El
+The second argument gives the source mix channel.
+The third argument gives the destination mix channel.
+The fourth argument gives the polarity, default is zero.
+The fifth argument gives the mute state, default is one or muted.
+The sixth argument gives the amplitude, default is zero or no gain.
+.It Fl t Ar devname
+Set control device name.
+.It Fl P Ar devname
+Set playback DSP device only.
+Specifying /dev/null is magic and means no playback device.
+Specifying a
+.Xr sndio 7
+device descriptor prefixed by "/dev/sndio/" is also magic, and will use a sndio
+backend rather than an OSS device.
+.It Fl O Ar devname
+Set playback DSP device only which acts as a master device.
+This option is used in conjunction with -R /dev/null .
+.It Fl R Ar devname
+Set recording DSP device only.
+Specifying /dev/null is magic and means no recording device.
+.It Fl f Ar devname
+Set both playback and recording DSP device
+.It Fl w Ar name
+Create a WAV file format compatible companion device by given name.
+This option should be specified before the -d and -l options.
+.It Fl d Ar name
+Create an OSS device by given name.
+.It Fl l Ar name
+Create a loopback OSS device by given name.
+.It Fl L Ar name
+Create a loopback OSS device which acts as a master device.
+This option is used in conjunction with -f /dev/null .
+.It Fl F Ar size
+Set receive filter size in number of samples or <milliseconds>ms for the next
+device to be created.
+.It Fl G Ar size
+Set transmit filter size in number of samples or <milliseconds>ms for the next
+device to be created.
+.It Fl D Ar file
+Write process ID of virtual_oss to file.
+.It Fl g Ar knee,attack,decay
+Enable device compressor in receive direction.
+See description of -x option.
+.It Fl x Ar knee,attack,decay
+Enable output compressor and set knee, attack and decay.
+Knee is in the range 0..255, while attack and decay are between 0 and 62.
+Samples having an absolute value lower than the knee are transmitted
+unchanged.
+Sample values over the knee are lowered "a little bit".
+You can think about attack and decay as a measure of how fast or slow the
+gain of the compressor will work.
+It is advised that attack is low, so it reacts fast once too high
+sample values appear.
+It is also advised that the decay value is higher than the attack value so
+that the gain reduction is gradually removed.
+The reasoning behind this is that the compressor should react almost
+immediately when high volume signals arrive to protect the hardware,
+but it slowly changes gain when there are no loud signals to avoid
+distorting the signal.
+The default values are 85,3,20 .
+.It Fl E Ar enable_recording
+If the value passed is non-zero, recording is enabled.
+Else recording is disabled.
+This can be used to synchronize multiple recording streams.
+.It Fl h
+Show usage and all available options.
+.El
+.Sh EXAMPLES
+Split a 2-channel OSS compatible sound device into multiple subdevices:
+.Bd -literal -offset indent
+virtual_oss \\
+ -S \\
+ -c 2 -r 48000 -b 16 -s 4ms -f /dev/dspX \\
+ -a 0 -b 16 -c 2 -m 0,0,1,1 -d vdsp.zyn \\
+ -a 0 -b 16 -c 2 -m 0,0,1,1 -d vdsp.fld \\
+ -a 0 -b 16 -c 2 -m 0,0,1,1 -d dsp \\
+ -a 0 -b 16 -c 2 -m 0,0,1,1 -w vdsp.jack.wav -d vdsp.jack \\
+ -a 0 -b 16 -c 2 -m 0,0,1,1 -w vdsp.rec.wav -l vdsp.rec \\
+ -M i,0,0,0,1,0 \\
+ -M i,0,0,0,1,0 \\
+ -M i,0,0,0,1,0 \\
+ -M i,0,0,0,1,0 \\
+ -t vdsp.ctl
+.Ed
+.Pp
+Split an 8-channel 24-bit OSS compatible sound device into multiple subdevices:
+.Bd -literal -offset indent
+sysctl dev.pcm.X.rec.vchanformat=s24le:7.1
+sysctl dev.pcm.X.rec.vchanrate=48000
+sysctl dev.pcm.X.play.vchanformat=s24le:7.1
+sysctl dev.pcm.X.play.vchanrate=48000
+sysctl dev.pcm.X.bitperfect=1
+
+mixer vol.volume=1 pcm.volume=1
+
+virtual_oss \\
+ -S \\
+ -i 8 \\
+ -x 85,3,20 \\
+ -C 16 -c 8 -r 48000 -b 32 -s 4ms -f /dev/dspX \\
+ -a 12 -b 16 -c 2 -m 0,4,1,5 -d dsp \\
+ -a 12 -b 16 -c 2 -m 8,8,9,9 -d vdsp \\
+ -a 13 -b 16 -c 2 -m 10,10,11,11 -d vdsp.fld \\
+ -a 0 -b 32 -c 4 -m 4,2,5,3,6,4,7,5 -d vdsp.jack \\
+ -a -3 -b 32 -c 2 -m 14,14,15,15 -d vdsp.zyn \\
+ -e 0,1 \\
+ -a 0 -b 32 -c 8 -m 0,8,1,9,2,8,3,9,4,8,5,9,6,8,7,9 -w vdsp.rec.mic.wav -d vdsp.rec.mic \\
+ -a 0 -b 32 -c 2 -m 0,8,1,9 -w vdsp.rec.master.wav -d vdsp.master.mic \\
+ -a 0 -b 32 -c 2 -m 10,10,11,11 -w vdsp.rec.fld.wav -l vdsp.rec.fld \\
+ -a 0 -b 32 -c 2 -m 12,12,13,13 -w vdsp.rec.jack.wav -l vdsp.rec.jack \\
+ -a 0 -b 32 -c 2 -m 14,14,15,15 -w vdsp.rec.zyn.wav -l vdsp.rec.zyn \\
+ -M o,8,0,0,0,0 \\
+ -M o,9,1,0,0,0 \\
+ -M o,10,0,0,0,0 \\
+ -M o,11,1,0,0,0 \\
+ -M o,12,0,0,0,0 \\
+ -M o,13,1,0,0,0 \\
+ -M o,14,0,0,0,0 \\
+ -M o,15,1,0,0,0 \\
+ -M i,14,14,0,1,0 \\
+ -M i,15,15,0,1,0 \\
+ -M x,8,0,0,1,0 \\
+ -M x,8,1,0,1,0 \\
+ -t vdsp.ctl
+
+.Ed
+.Pp
+Create a secondary audio device sending its output audio into both
+input and output channels of the main DSP device.
+.Bd -literal -offset indent
+virtual_oss \\
+ -C 4 -c 2 \\
+ -r 48000 \\
+ -b 24 \\
+ -s 4ms \\
+ -f /dev/dsp3 \\
+ -c 2 \\
+ -d dsp \\
+ -m 2,2,3,3 \\
+ -d dsp.speech \\
+ -M o,2,0,0,0,0 \\
+ -M o,3,1,0,0,0 \\
+ -M x,2,0,0,0,0 \\
+ -M x,3,1,0,0,0
+.Ed
+.Pp
+Connect to a bluetooth audio headset, playback only:
+.Bd -literal -offset indent
+virtual_oss \\
+ -C 2 -c 2 -r 48000 -b 16 -s 4ms \\
+ -R /dev/null -P /dev/bluetooth/xx:xx:xx:xx:xx:xx -d dsp
+.Ed
+.Pp
+Connect to a bluetooth audio headset, playback and recording:
+.Bd -literal -offset indent
+virtual_oss \\
+ -C 2 -c 2 -r 48000 -b 16 -s 4ms \\
+ -f /dev/bluetooth/xx:xx:xx:xx:xx:xx -d dsp
+.Ed
+.Pp
+Create recording device which outputs a WAV-formatted file:
+.Bd -literal -offset indent
+virtual_oss \\
+ -C 2 -c 2 -r 48000 -b 16 -s 4ms \\
+ -f /dev/dspX -w dsp.wav -d dsp
+.Ed
+.Pp
+Create a device named dsp.virtual which mix the samples written by all
+clients and outputs the result for further processing into
+dsp.virtual_out:
+.Bd -literal -offset indent
+virtual_oss \\
+ -S -Q 0 -b 16 -c 2 -r 96000 -s 100ms -i 20 \\
+ -f /dev/null -d dsp.virtual -L dsp.virtual_out
+.Ed
+.Pp
+Create a playback-only audio device which sends its output to a remote
+.Xr sndio 7
+server:
+.Bd -literal -offset indent
+virtual_oss \\
+ -b 16 -c 2 -r 44100 -s 50ms \\
+ -R /dev/null -O /dev/sndio/snd@remotehost/0 -d dsp
+.Ed
+.Pp
+Create a full-duplex audio device exchanging audio using the default
+.Xr sndio 7
+server:
+.Bd -literal -offset indent
+virtual_oss -S -b 16 -C 2 -c 2 -r 48000 -s 4ms \\
+ -f /dev/sndio/default -d dsp
+.Ed
+.Pp
+How to set intel based CPUs in performance mode:
+.Bd -literal -offset indent
+sysctl -aN | fgrep dev.hwpstate | fgrep epp | \
+while read OID
+do
+sysctl ${OID}=0
+done
+
+sysctl kern.sched.preempt_thresh=224
+.Ed
+.Sh NOTES
+All character devices are created using the 0666 mode which gives
+everyone in the system access.
+.Sh SEE ALSO
+.Xr cuse 3 ,
+.Xr sound 4 ,
+.Xr loader.conf 5 ,
+.Xr sndio 7 ,
+.Xr mixer 8 ,
+.Xr sysctl 8 ,
+.Xr virtual_bt_speaker 8 ,
+.Xr virtual_equalizer 8 ,
+.Xr virtual_oss_cmd 8
+.Sh AUTHORS
+.Nm
+was written by
+.An Hans Petter Selasky hselasky@freebsd.org .
diff --git a/usr.sbin/virtual_oss/virtual_oss/virtual_oss.c b/usr.sbin/virtual_oss/virtual_oss/virtual_oss.c
new file mode 100644
--- /dev/null
+++ b/usr.sbin/virtual_oss/virtual_oss/virtual_oss.c
@@ -0,0 +1,914 @@
+/*-
+ * Copyright (c) 2012-2022 Hans Petter Selasky
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/queue.h>
+#include <sys/types.h>
+#include <sys/soundcard.h>
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <err.h>
+#include <time.h>
+#include <assert.h>
+
+#include "backend.h"
+#include "int.h"
+
+uint64_t
+virtual_oss_delay_ns(void)
+{
+ uint64_t delay;
+
+ delay = voss_dsp_samples;
+ delay *= 1000000000ULL;
+ delay /= voss_dsp_sample_rate;
+
+ return (delay);
+}
+
+void
+virtual_oss_wait(void)
+{
+ struct timespec ts;
+ uint64_t delay;
+ uint64_t nsec;
+
+ clock_gettime(CLOCK_MONOTONIC, &ts);
+
+ nsec = ts.tv_sec * 1000000000ULL + ts.tv_nsec;
+
+ /* TODO use virtual_oss_delay_ns() */
+ delay = voss_dsp_samples;
+ delay *= 1000000000ULL;
+ delay /= voss_dsp_sample_rate;
+
+ usleep((delay - (nsec % delay)) / 1000);
+}
+
+uint64_t
+virtual_oss_timestamp(void)
+{
+ struct timespec ts;
+ uint64_t nsec;
+
+ clock_gettime(CLOCK_MONOTONIC, &ts);
+
+ nsec = ts.tv_sec * 1000000000ULL + ts.tv_nsec;
+ return (nsec);
+}
+
+static size_t
+vclient_read_linear(struct virtual_client *pvc, struct virtual_ring *pvr,
+ int64_t *dst, size_t total) __requires_exclusive(atomic_mtx)
+{
+ size_t total_read = 0;
+
+ pvc->sync_busy = 1;
+ while (1) {
+ size_t read = vring_read_linear(pvr, (uint8_t *)dst, 8 * total) / 8;
+
+ total_read += read;
+ dst += read;
+ total -= read;
+
+ if (!pvc->profile->synchronized || pvc->sync_wakeup ||
+ total == 0) {
+ /* fill rest of buffer with silence, if any */
+ if (total_read != 0 && total != 0)
+ memset(dst, 0, 8 * total);
+ break;
+ }
+ atomic_wait();
+ }
+ pvc->sync_busy = 0;
+ if (pvc->sync_wakeup)
+ atomic_wakeup();
+
+ vclient_tx_equalizer(pvc, dst - total_read, total_read);
+
+ return (total_read);
+}
+
+static size_t
+vclient_write_linear(struct virtual_client *pvc, struct virtual_ring *pvr,
+ int64_t *src, size_t total) __requires_exclusive(atomic_mtx)
+{
+ size_t total_written = 0;
+
+ vclient_rx_equalizer(pvc, src, total);
+
+ pvc->sync_busy = 1;
+ while (1) {
+ size_t written = vring_write_linear(pvr, (uint8_t *)src, total * 8) / 8;
+
+ total_written += written;
+ src += written;
+ total -= written;
+
+ if (!pvc->profile->synchronized || pvc->sync_wakeup ||
+ total == 0)
+ break;
+ atomic_wait();
+ }
+ pvc->sync_busy = 0;
+ if (pvc->sync_wakeup)
+ atomic_wakeup();
+
+ return (total_written);
+}
+
+static inline void
+virtual_oss_mixer_core_sub(const int64_t *src, int64_t *dst,
+ uint32_t *pnoise, int src_chan, int dst_chan, int num,
+ int64_t volume, int shift, int shift_orig, bool pol,
+ bool assign)
+{
+ if (pol)
+ volume = -volume;
+
+ if (shift < 0) {
+ shift = -shift;
+ while (num--) {
+ if (assign)
+ *dst = (*src * volume) >> shift;
+ else
+ *dst += (*src * volume) >> shift;
+ if (__predict_true(pnoise != NULL))
+ *dst += vclient_noise(pnoise, volume, shift_orig);
+ src += src_chan;
+ dst += dst_chan;
+ }
+ } else {
+ while (num--) {
+ if (assign)
+ *dst = (*src * volume) << shift;
+ else
+ *dst += (*src * volume) << shift;
+ if (__predict_true(pnoise != NULL))
+ *dst += vclient_noise(pnoise, volume, shift_orig);
+ src += src_chan;
+ dst += dst_chan;
+ }
+ }
+}
+
+static inline void
+virtual_oss_mixer_core(const int64_t *src, int64_t *dst,
+ uint32_t *pnoise, int src_chan, int dst_chan, int num,
+ int64_t volume, int shift, int shift_orig, bool pol,
+ bool assign)
+{
+ const uint8_t selector = (shift_orig > 0) + assign * 2;
+
+ /* optimize some cases */
+ switch (selector) {
+ case 0:
+ virtual_oss_mixer_core_sub(src, dst, NULL, src_chan, dst_chan,
+ num, volume, shift, shift_orig, pol, false);
+ break;
+ case 1:
+ virtual_oss_mixer_core_sub(src, dst, pnoise, src_chan, dst_chan,
+ num, volume, shift, shift_orig, pol, false);
+ break;
+ case 2:
+ virtual_oss_mixer_core_sub(src, dst, NULL, src_chan, dst_chan,
+ num, volume, shift, shift_orig, pol, true);
+ break;
+ case 3:
+ virtual_oss_mixer_core_sub(src, dst, pnoise, src_chan, dst_chan,
+ num, volume, shift, shift_orig, pol, true);
+ break;
+ }
+}
+
+void *
+virtual_oss_process(void *arg __unused)
+{
+ vprofile_t *pvp;
+ vclient_t *pvc;
+ vmonitor_t *pvm;
+ struct voss_backend *rx_be = voss_rx_backend;
+ struct voss_backend *tx_be = voss_tx_backend;
+ int rx_fmt;
+ int tx_fmt;
+ int rx_chn;
+ int tx_chn;
+ int off;
+ int src_chans;
+ int dst_chans;
+ int src;
+ int len;
+ int samples;
+ int shift;
+ int shift_orig;
+ int shift_fmt;
+ int buffer_dsp_max_size;
+ int buffer_dsp_half_size;
+ int buffer_dsp_rx_sample_size;
+ int buffer_dsp_rx_size;
+ int buffer_dsp_tx_size_ref;
+ int buffer_dsp_tx_size;
+ uint64_t nice_timeout = 0;
+ uint64_t last_timestamp;
+ int blocks;
+ int volume;
+ int x_off;
+ int x;
+ int y;
+
+ uint8_t *buffer_dsp;
+ int64_t *buffer_monitor;
+ int64_t *buffer_temp;
+ int64_t *buffer_data;
+ int64_t *buffer_local;
+ int64_t *buffer_orig;
+
+ bool need_delay = false;
+
+ buffer_dsp_max_size = voss_dsp_samples *
+ voss_dsp_max_channels * (voss_dsp_bits / 8);
+ buffer_dsp_half_size = (voss_dsp_samples / 2) *
+ voss_dsp_max_channels * (voss_dsp_bits / 8);
+
+ buffer_dsp = malloc(buffer_dsp_max_size);
+ buffer_temp = malloc(voss_dsp_samples * voss_max_channels * 8);
+ buffer_monitor = malloc(voss_dsp_samples * voss_max_channels * 8);
+ buffer_local = malloc(voss_dsp_samples * voss_max_channels * 8);
+ buffer_data = malloc(voss_dsp_samples * voss_max_channels * 8);
+ buffer_orig = malloc(voss_dsp_samples * voss_max_channels * 8);
+
+ if (buffer_dsp == NULL || buffer_temp == NULL ||
+ buffer_monitor == NULL || buffer_local == NULL ||
+ buffer_data == NULL || buffer_orig == NULL)
+ errx(1, "Cannot allocate buffer memory");
+
+ while (1) {
+ rx_be->close(rx_be);
+ tx_be->close(tx_be);
+
+ if (voss_exit)
+ break;
+ if (need_delay)
+ sleep(2);
+
+ voss_dsp_rx_refresh = 0;
+ voss_dsp_tx_refresh = 0;
+
+ rx_be = voss_rx_backend;
+ tx_be = voss_tx_backend;
+
+ switch (voss_dsp_bits) {
+ case 8:
+ rx_fmt = tx_fmt =
+ AFMT_S8 | AFMT_U8;
+ break;
+ case 16:
+ rx_fmt = tx_fmt =
+ AFMT_S16_BE | AFMT_S16_LE |
+ AFMT_U16_BE | AFMT_U16_LE;
+ break;
+ case 24:
+ rx_fmt = tx_fmt =
+ AFMT_S24_BE | AFMT_S24_LE |
+ AFMT_U24_BE | AFMT_U24_LE;
+ break;
+ case 32:
+ rx_fmt = tx_fmt =
+ AFMT_S32_BE | AFMT_S32_LE |
+ AFMT_U32_BE | AFMT_U32_LE |
+ AFMT_F32_BE | AFMT_F32_LE;
+ break;
+ default:
+ rx_fmt = tx_fmt = 0;
+ break;
+ }
+
+ rx_chn = voss_dsp_max_channels;
+
+ if (rx_be->open(rx_be, voss_dsp_rx_device, voss_dsp_sample_rate,
+ buffer_dsp_half_size, &rx_chn, &rx_fmt) < 0) {
+ need_delay = true;
+ continue;
+ }
+
+ buffer_dsp_rx_sample_size = rx_chn * (voss_dsp_bits / 8);
+ buffer_dsp_rx_size = voss_dsp_samples * buffer_dsp_rx_sample_size;
+
+ tx_chn = voss_dsp_max_channels;
+ if (tx_be->open(tx_be, voss_dsp_tx_device, voss_dsp_sample_rate,
+ buffer_dsp_max_size, &tx_chn, &tx_fmt) < 0) {
+ need_delay = true;
+ continue;
+ }
+
+ buffer_dsp_tx_size_ref = voss_dsp_samples *
+ tx_chn * (voss_dsp_bits / 8);
+
+ /* reset compressor gain */
+ for (x = 0; x != VMAX_CHAN; x++)
+ voss_output_compressor_gain[x] = 1.0;
+
+ /* reset local buffer */
+ memset(buffer_local, 0, 8 * voss_dsp_samples * voss_max_channels);
+
+ while (1) {
+ uint64_t delta_time;
+
+ /* Check if DSP device should be re-opened */
+ if (voss_exit)
+ break;
+ if (voss_dsp_rx_refresh || voss_dsp_tx_refresh) {
+ need_delay = false;
+ break;
+ }
+ delta_time = nice_timeout - virtual_oss_timestamp();
+
+ /* Don't service more than 2x sample rate */
+ nice_timeout = virtual_oss_delay_ns() / 2;
+ if (delta_time >= 1000 && delta_time <= nice_timeout) {
+ /* convert from ns to us */
+ usleep(delta_time / 1000);
+ }
+ /* Compute next timeout */
+ nice_timeout += virtual_oss_timestamp();
+
+ /* Read in samples */
+ len = rx_be->transfer(rx_be, buffer_dsp, buffer_dsp_rx_size);
+ if (len < 0 || (len % buffer_dsp_rx_sample_size) != 0) {
+ need_delay = true;
+ break;
+ }
+ if (len == 0)
+ continue;
+
+ /* Convert to 64-bit samples */
+ format_import(rx_fmt, buffer_dsp, len, buffer_data);
+
+ samples = len / buffer_dsp_rx_sample_size;
+ src_chans = voss_mix_channels;
+
+ /* Compute master input peak values */
+ format_maximum(buffer_data, voss_input_peak, rx_chn, samples, 0);
+
+ /* Remix format */
+ format_remix(buffer_data, rx_chn, src_chans, samples);
+
+ /* Refresh timestamp */
+ last_timestamp = virtual_oss_timestamp();
+
+ atomic_lock();
+
+ if (TAILQ_FIRST(&virtual_monitor_input) != NULL) {
+ /* make a copy of the input data, in case of remote monitoring */
+ memcpy(buffer_monitor, buffer_data, 8 * samples * src_chans);
+ }
+
+ /* (0) Check for local monitoring of output data */
+
+ TAILQ_FOREACH(pvm, &virtual_monitor_local, entry) {
+
+ int64_t val;
+
+ if (pvm->mute != 0 || pvm->src_chan >= src_chans ||
+ pvm->dst_chan >= src_chans)
+ continue;
+
+ src = pvm->src_chan;
+ shift = pvm->shift;
+ x = pvm->dst_chan;
+
+ if (pvm->pol) {
+ if (shift < 0) {
+ shift = -shift;
+ for (y = 0; y != samples; y++) {
+ val = -(buffer_local[(y * src_chans) + src] >> shift);
+ buffer_data[(y * src_chans) + x] += val;
+ if (val < 0)
+ val = -val;
+ if (val > pvm->peak_value)
+ pvm->peak_value = val;
+ }
+ } else {
+ for (y = 0; y != samples; y++) {
+ val = -(buffer_local[(y * src_chans) + src] << shift);
+ buffer_data[(y * src_chans) + x] += val;
+ if (val < 0)
+ val = -val;
+ if (val > pvm->peak_value)
+ pvm->peak_value = val;
+ }
+ }
+ } else {
+ if (shift < 0) {
+ shift = -shift;
+ for (y = 0; y != samples; y++) {
+ val = (buffer_local[(y * src_chans) + src] >> shift);
+ buffer_data[(y * src_chans) + x] += val;
+ if (val < 0)
+ val = -val;
+ if (val > pvm->peak_value)
+ pvm->peak_value = val;
+ }
+ } else {
+ for (y = 0; y != samples; y++) {
+ val = (buffer_local[(y * src_chans) + src] << shift);
+ buffer_data[(y * src_chans) + x] += val;
+ if (val < 0)
+ val = -val;
+ if (val > pvm->peak_value)
+ pvm->peak_value = val;
+ }
+ }
+ }
+ }
+
+ /* make a copy of the input data */
+ memcpy(buffer_orig, buffer_data, 8 * samples * src_chans);
+
+ /* (1) Distribute input samples to all clients */
+
+ TAILQ_FOREACH(pvp, &virtual_profile_client_head, entry) {
+
+ if (TAILQ_FIRST(&pvp->head) == NULL)
+ continue;
+
+ /* check if compressor should be applied */
+ voss_compressor(buffer_data, pvp->rx_compressor_gain,
+ &pvp->rx_compressor_param, samples * src_chans,
+ src_chans, (1ULL << (pvp->bits - 1)) - 1ULL);
+
+ TAILQ_FOREACH(pvc, &pvp->head, entry) {
+
+ dst_chans = pvc->channels;
+
+ if (dst_chans > (int)voss_max_channels)
+ continue;
+
+ shift_fmt = pvp->bits - (vclient_sample_bytes(pvc) * 8);
+
+ for (x = 0; x != dst_chans; x++) {
+ src = pvp->rx_src[x];
+ shift_orig = pvp->rx_shift[x] - shift_fmt;
+ shift = shift_orig - VVOLUME_UNIT_SHIFT;
+ volume = pvc->rx_volume;
+
+ if (pvp->rx_mute[x] || src >= src_chans || volume == 0) {
+ for (y = 0; y != (samples * dst_chans); y += dst_chans)
+ buffer_temp[y + x] = 0;
+ continue;
+ }
+
+ virtual_oss_mixer_core(buffer_data + src, buffer_temp + x,
+ &pvc->rx_noise_rem, src_chans, dst_chans, samples,
+ volume, shift, shift_orig, pvp->rx_pol[x], true);
+ }
+
+ format_maximum(buffer_temp, pvp->rx_peak_value,
+ dst_chans, samples, shift_fmt);
+
+ /* check if recording is disabled */
+ if (pvc->rx_enabled == 0 ||
+ (voss_is_recording == 0 && pvc->type != VTYPE_OSS_DAT))
+ continue;
+
+ pvc->rx_timestamp = last_timestamp;
+ pvc->rx_samples += samples * dst_chans;
+
+ /* store data into ring buffer */
+ vclient_write_linear(pvc, &pvc->rx_ring[0],
+ buffer_temp, samples * dst_chans);
+ }
+
+ /* restore buffer, if any */
+ if (pvp->rx_compressor_param.enabled)
+ memcpy(buffer_data, buffer_orig, 8 * samples * src_chans);
+ }
+
+ /* fill main output buffer with silence */
+
+ memset(buffer_temp, 0, sizeof(buffer_temp[0]) *
+ samples * src_chans);
+
+ /* (2) Run audio delay locator */
+
+ if (voss_ad_enabled != 0) {
+ y = (samples * voss_mix_channels);
+ for (x = 0; x != y; x += voss_mix_channels) {
+ buffer_temp[x + voss_ad_output_channel] +=
+ voss_ad_getput_sample(buffer_data
+ [x + voss_ad_input_channel]);
+ }
+ }
+
+ /* (3) Load output samples from all clients */
+
+ TAILQ_FOREACH(pvp, &virtual_profile_client_head, entry) {
+ TAILQ_FOREACH(pvc, &pvp->head, entry) {
+
+ if (pvc->tx_enabled == 0)
+ continue;
+
+ dst_chans = pvc->channels;
+
+ if (dst_chans > (int)voss_max_channels)
+ continue;
+
+ /* update counters regardless of data presence */
+ pvc->tx_timestamp = last_timestamp;
+ pvc->tx_samples += samples * dst_chans;
+
+ /* read data from ring buffer */
+ if (vclient_read_linear(pvc, &pvc->tx_ring[0],
+ buffer_data, samples * dst_chans) == 0)
+ continue;
+
+ shift_fmt = pvp->bits - (vclient_sample_bytes(pvc) * 8);
+
+ format_maximum(buffer_data, pvp->tx_peak_value,
+ dst_chans, samples, shift_fmt);
+
+ for (x = 0; x != pvp->channels; x++) {
+ src = pvp->tx_dst[x];
+ shift_orig = pvp->tx_shift[x] + shift_fmt;
+ shift = shift_orig - VVOLUME_UNIT_SHIFT;
+ volume = pvc->tx_volume;
+
+ if (pvp->tx_mute[x] || src >= src_chans || volume == 0)
+ continue;
+
+ /*
+ * Automagically re-map
+ * channels when the client is
+ * requesting fewer channels
+ * than specified in the
+ * profile. This typically
+ * allows automagic mono to
+ * stereo conversion.
+ */
+ if (__predict_false(x >= dst_chans))
+ x_off = x % dst_chans;
+ else
+ x_off = x;
+
+ virtual_oss_mixer_core(buffer_data + x_off, buffer_temp + src,
+ &pvc->tx_noise_rem, dst_chans, src_chans, samples,
+ volume, shift, shift_orig, pvp->tx_pol[x], false);
+ }
+ }
+ }
+
+ /* (4) Load output samples from all loopbacks */
+
+ TAILQ_FOREACH(pvp, &virtual_profile_loopback_head, entry) {
+ TAILQ_FOREACH(pvc, &pvp->head, entry) {
+
+ if (pvc->tx_enabled == 0)
+ continue;
+
+ dst_chans = pvc->channels;
+
+ if (dst_chans > (int)voss_max_channels)
+ continue;
+
+ /* read data from ring buffer */
+ if (vclient_read_linear(pvc, &pvc->tx_ring[0],
+ buffer_data, samples * dst_chans) == 0)
+ continue;
+
+ pvc->tx_timestamp = last_timestamp;
+ pvc->tx_samples += samples * dst_chans;
+
+ shift_fmt = pvp->bits - (vclient_sample_bytes(pvc) * 8);
+
+ format_maximum(buffer_data, pvp->tx_peak_value,
+ dst_chans, samples, shift_fmt);
+
+ for (x = 0; x != pvp->channels; x++) {
+ src = pvp->tx_dst[x];
+ shift_orig = pvp->tx_shift[x] + shift_fmt;
+ shift = shift_orig - VVOLUME_UNIT_SHIFT;
+ volume = pvc->tx_volume;
+
+ if (pvp->tx_mute[x] || src >= src_chans || volume == 0)
+ continue;
+
+ /*
+ * Automagically re-map
+ * channels when the client is
+ * requesting fewer channels
+ * than specified in the
+ * profile. This typically
+ * allows automagic mono to
+ * stereo conversion.
+ */
+ if (__predict_false(x >= dst_chans))
+ x_off = x % dst_chans;
+ else
+ x_off = x;
+
+ virtual_oss_mixer_core(buffer_data + x_off, buffer_temp + src,
+ &pvc->tx_noise_rem, dst_chans, src_chans, samples,
+ volume, shift, shift_orig, pvp->tx_pol[x], false);
+ }
+ }
+ }
+
+ /* (5) Check for input monitoring */
+
+ TAILQ_FOREACH(pvm, &virtual_monitor_input, entry) {
+
+ int64_t val;
+
+ if (pvm->mute != 0 || pvm->src_chan >= src_chans ||
+ pvm->dst_chan >= src_chans)
+ continue;
+
+ src = pvm->src_chan;
+ shift = pvm->shift;
+ x = pvm->dst_chan;
+
+ if (pvm->pol) {
+ if (shift < 0) {
+ shift = -shift;
+ for (y = 0; y != samples; y++) {
+ val = -(buffer_monitor[(y * src_chans) + src] >> shift);
+ buffer_temp[(y * src_chans) + x] += val;
+ if (val < 0)
+ val = -val;
+ if (val > pvm->peak_value)
+ pvm->peak_value = val;
+ }
+ } else {
+ for (y = 0; y != samples; y++) {
+ val = -(buffer_monitor[(y * src_chans) + src] << shift);
+ buffer_temp[(y * src_chans) + x] += val;
+ if (val < 0)
+ val = -val;
+ if (val > pvm->peak_value)
+ pvm->peak_value = val;
+ }
+ }
+ } else {
+ if (shift < 0) {
+ shift = -shift;
+ for (y = 0; y != samples; y++) {
+ val = (buffer_monitor[(y * src_chans) + src] >> shift);
+ buffer_temp[(y * src_chans) + x] += val;
+ if (val < 0)
+ val = -val;
+ if (val > pvm->peak_value)
+ pvm->peak_value = val;
+ }
+ } else {
+ for (y = 0; y != samples; y++) {
+ val = (buffer_monitor[(y * src_chans) + src] << shift);
+ buffer_temp[(y * src_chans) + x] += val;
+ if (val < 0)
+ val = -val;
+ if (val > pvm->peak_value)
+ pvm->peak_value = val;
+ }
+ }
+ }
+ }
+
+ if (TAILQ_FIRST(&virtual_monitor_output) != NULL) {
+ memcpy(buffer_monitor, buffer_temp,
+ 8 * samples * src_chans);
+ }
+
+ /* (6) Check for output monitoring */
+
+ TAILQ_FOREACH(pvm, &virtual_monitor_output, entry) {
+
+ int64_t val;
+
+ if (pvm->mute != 0 || pvm->src_chan >= src_chans ||
+ pvm->dst_chan >= src_chans)
+ continue;
+
+ src = pvm->src_chan;
+ shift = pvm->shift;
+ x = pvm->dst_chan;
+
+ if (pvm->pol) {
+ if (shift < 0) {
+ shift = -shift;
+ for (y = 0; y != samples; y++) {
+ val = -(buffer_monitor[(y * src_chans) + src] >> shift);
+ buffer_temp[(y * src_chans) + x] += val;
+ if (val < 0)
+ val = -val;
+ if (val > pvm->peak_value)
+ pvm->peak_value = val;
+ }
+ } else {
+ for (y = 0; y != samples; y++) {
+ val = -(buffer_monitor[(y * src_chans) + src] << shift);
+ buffer_temp[(y * src_chans) + x] += val;
+ if (val < 0)
+ val = -val;
+ if (val > pvm->peak_value)
+ pvm->peak_value = val;
+ }
+ }
+ } else {
+ if (shift < 0) {
+ shift = -shift;
+ for (y = 0; y != samples; y++) {
+ val = (buffer_monitor[(y * src_chans) + src] >> shift);
+ buffer_temp[(y * src_chans) + x] += val;
+ if (val < 0)
+ val = -val;
+ if (val > pvm->peak_value)
+ pvm->peak_value = val;
+ }
+ } else {
+ for (y = 0; y != samples; y++) {
+ val = (buffer_monitor[(y * src_chans) + src] << shift);
+ buffer_temp[(y * src_chans) + x] += val;
+ if (val < 0)
+ val = -val;
+ if (val > pvm->peak_value)
+ pvm->peak_value = val;
+ }
+ }
+ }
+ }
+
+ /* make a copy of the output data */
+ memcpy(buffer_data, buffer_temp, 8 * samples * src_chans);
+
+ /* make a copy for local monitoring, if any */
+ if (TAILQ_FIRST(&virtual_monitor_local) != NULL) {
+ const int end = src_chans * (voss_dsp_samples - samples);
+ const int offs = src_chans * samples;
+
+ assert(end >= 0);
+
+ /* shift down samples */
+ for (int xx = 0; xx != end; xx++)
+ buffer_local[xx] = buffer_local[xx + offs];
+ /* copy in new ones */
+ memcpy(buffer_local + end, buffer_temp, 8 * samples * src_chans);
+ }
+
+ /* (7) Check for output recording */
+
+ TAILQ_FOREACH(pvp, &virtual_profile_loopback_head, entry) {
+
+ if (TAILQ_FIRST(&pvp->head) == NULL)
+ continue;
+
+ /* check if compressor should be applied */
+ voss_compressor(buffer_temp, pvp->rx_compressor_gain,
+ &pvp->rx_compressor_param, samples,
+ samples * src_chans, (1ULL << (pvp->bits - 1)) - 1ULL);
+
+ TAILQ_FOREACH(pvc, &pvp->head, entry) {
+
+ dst_chans = pvc->channels;
+
+ if (dst_chans > (int)voss_max_channels)
+ continue;
+
+ shift_fmt = pvp->bits - (vclient_sample_bytes(pvc) * 8);
+
+ for (x = 0; x != dst_chans; x++) {
+ src = pvp->rx_src[x];
+ shift_orig = pvp->rx_shift[x] - shift_fmt;
+ shift = shift_orig - VVOLUME_UNIT_SHIFT;
+ volume = pvc->rx_volume;
+
+ if (pvp->rx_mute[x] || src >= src_chans || volume == 0) {
+ for (y = 0; y != (samples * dst_chans); y += dst_chans)
+ buffer_monitor[y + x] = 0;
+ continue;
+ }
+
+ virtual_oss_mixer_core(buffer_temp + src, buffer_monitor + x,
+ &pvc->rx_noise_rem, src_chans, dst_chans, samples,
+ volume, shift, shift_orig, pvp->rx_pol[x], true);
+ }
+
+ format_maximum(buffer_monitor, pvp->rx_peak_value,
+ dst_chans, samples, shift_fmt);
+
+ /* check if recording is disabled */
+ if (pvc->rx_enabled == 0 ||
+ (voss_is_recording == 0 && pvc->type != VTYPE_OSS_DAT))
+ continue;
+
+ pvc->rx_timestamp = last_timestamp;
+ pvc->rx_samples += samples * dst_chans;
+
+ /* store data into ring buffer */
+ vclient_write_linear(pvc, &pvc->rx_ring[0],
+ buffer_monitor, samples * dst_chans);
+ }
+
+ /* restore buffer, if any */
+ if (pvp->rx_compressor_param.enabled)
+ memcpy(buffer_temp, buffer_data, 8 * samples * src_chans);
+ }
+
+ atomic_wakeup();
+
+ format_remix(buffer_temp, voss_mix_channels, tx_chn, samples);
+
+ /* Compute master output peak values */
+
+ format_maximum(buffer_temp, voss_output_peak,
+ tx_chn, samples, 0);
+
+ /* Apply compressor, if any */
+
+ voss_compressor(buffer_temp, voss_output_compressor_gain,
+ &voss_output_compressor_param, samples * tx_chn,
+ tx_chn, format_max(tx_fmt));
+
+ /* Recompute buffer DSP transmit size according to received number of samples */
+
+ buffer_dsp_tx_size = samples * tx_chn * (voss_dsp_bits / 8);
+
+ /* Export and transmit resulting audio */
+
+ format_export(tx_fmt, buffer_temp, buffer_dsp,
+ buffer_dsp_tx_size);
+
+ atomic_unlock();
+
+ /* Get output delay in bytes */
+ tx_be->delay(tx_be, &blocks);
+
+ /*
+ * Simple fix for jitter: Repeat data when too
+ * little. Skip data when too much. This
+ * should not happen during normal operation.
+ */
+ if (blocks == 0) {
+ blocks = 2; /* buffer is empty */
+ voss_jitter_up++;
+ } else if (blocks >= (3 * buffer_dsp_tx_size_ref)) {
+ blocks = 0; /* too much data */
+ voss_jitter_down++;
+ } else {
+ blocks = 1; /* normal */
+ }
+
+ len = 0;
+ while (blocks--) {
+ off = 0;
+ while (off < (int)buffer_dsp_tx_size) {
+ len = tx_be->transfer(tx_be, buffer_dsp + off,
+ buffer_dsp_tx_size - off);
+ if (len <= 0)
+ break;
+ off += len;
+ }
+ if (len <= 0)
+ break;
+ }
+
+ /* check for error only */
+ if (len < 0) {
+ need_delay = true;
+ break;
+ }
+ }
+ }
+
+ free(buffer_dsp);
+ free(buffer_temp);
+ free(buffer_monitor);
+ free(buffer_local);
+ free(buffer_data);
+ free(buffer_orig);
+
+ return (NULL);
+}
diff --git a/usr.sbin/virtual_oss/virtual_oss_cmd/Makefile b/usr.sbin/virtual_oss/virtual_oss_cmd/Makefile
new file mode 100644
--- /dev/null
+++ b/usr.sbin/virtual_oss/virtual_oss_cmd/Makefile
@@ -0,0 +1,8 @@
+PROG= virtual_oss_cmd
+MAN= ${PROG}.8
+
+SRCS= command.c
+
+CFLAGS+= -I${SRCTOP}/usr.sbin/virtual_oss/virtual_oss
+
+.include <bsd.prog.mk>
diff --git a/usr.sbin/virtual_oss/virtual_oss_cmd/command.c b/usr.sbin/virtual_oss/virtual_oss_cmd/command.c
new file mode 100644
--- /dev/null
+++ b/usr.sbin/virtual_oss/virtual_oss_cmd/command.c
@@ -0,0 +1,113 @@
+/*-
+ * Copyright (c) 2021-2022 Hans Petter Selasky
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <err.h>
+#include <sysexits.h>
+#include <stdarg.h>
+#include <fcntl.h>
+
+#include "virtual_oss.h"
+
+static void
+message(const char *fmt, ...)
+{
+ va_list list;
+
+ va_start(list, fmt);
+ vfprintf(stderr, fmt, list);
+ va_end(list);
+}
+
+static void
+usage(void)
+{
+ message("Usage: virtual_oss_cmd /dev/vdsp.ctl [command line arguments to pass to virtual_oss]\n");
+ exit(EX_USAGE);
+}
+
+int
+main(int argc, char **argv)
+{
+ char options[VIRTUAL_OSS_OPTIONS_MAX] = {};
+ size_t offset = 0;
+ size_t len = VIRTUAL_OSS_OPTIONS_MAX - 1;
+ int fd;
+
+ /* check if no options */
+ if (argc < 2)
+ usage();
+
+ fd = open(argv[1], O_RDWR);
+ if (fd < 0)
+ errx(EX_SOFTWARE, "Could not open '%s'", argv[1]);
+
+ for (int x = 2; x != argc; x++) {
+ size_t tmp = strlen(argv[x]) + 1;
+ if (tmp > len)
+ errx(EX_SOFTWARE, "Too many options passed");
+ memcpy(options + offset, argv[x], tmp);
+ options[offset + tmp - 1] = ' ';
+ offset += tmp;
+ len -= tmp;
+ }
+
+ if (options[0] == 0) {
+ struct virtual_oss_system_info info;
+ if (ioctl(fd, VIRTUAL_OSS_GET_SYSTEM_INFO, &info) < 0)
+ errx(EX_SOFTWARE, "Cannot get system information");
+
+ info.rx_device_name[sizeof(info.rx_device_name) - 1] = 0;
+ info.tx_device_name[sizeof(info.tx_device_name) - 1] = 0;
+
+ printf("Sample rate: %u Hz\n"
+ "Sample width: %u bits\n"
+ "Sample channels: %u\n"
+ "Output jitter: %u / %u\n"
+ "Input device name: %s\n"
+ "Output device name: %s\n",
+ info.sample_rate,
+ info.sample_bits,
+ info.sample_channels,
+ info.tx_jitter_down,
+ info.tx_jitter_up,
+ info.rx_device_name,
+ info.tx_device_name);
+ } else {
+ /* execute options */
+ if (ioctl(fd, VIRTUAL_OSS_ADD_OPTIONS, options) < 0)
+ errx(EX_SOFTWARE, "One or more invalid options");
+ /* show error, if any */
+ if (options[0] != '\0')
+ errx(EX_SOFTWARE, "%s", options);
+ }
+
+ close(fd);
+ return (0);
+}
diff --git a/usr.sbin/virtual_oss/virtual_oss_cmd/virtual_oss_cmd.8 b/usr.sbin/virtual_oss/virtual_oss_cmd/virtual_oss_cmd.8
new file mode 100644
--- /dev/null
+++ b/usr.sbin/virtual_oss/virtual_oss_cmd/virtual_oss_cmd.8
@@ -0,0 +1,103 @@
+.\"
+.\" Copyright (c) 2021-2022 Hans Petter Selasky <hselasky@freebsd.org>
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\" notice, this list of conditions and the following disclaimer.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\" notice, this list of conditions and the following disclaimer in the
+.\" documentation and/or other materials provided with the distribution.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+.\" ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+.\" SUCH DAMAGE.
+.\"
+.\"
+.Dd February 12, 2025
+.Dt VIRTUAL_OSS_CMD 8
+.Os
+.Sh NAME
+.Nm virtual_oss_cmd
+.Nd modify a running
+.Xr virtual_oss 8
+instance's options
+.Sh SYNOPSIS
+.Nm
+.Sh DESCRIPTION
+.Nm
+pass additional command line arguments to a running
+.Xr virtual_oss 8
+instance via its control device.
+Supported command line arguments:
+.Bl -tag -width indent
+.It Fl E Ar xxx
+.It Fl F Ar xxx
+.It Fl G Ar xxx
+.It Fl L Ar xxx
+.It Fl M Ar xxx
+.It Fl O Ar xxx
+.It Fl P Ar xxx
+.It Fl R Ar xxx
+.It Fl a Ar xxx
+.It Fl b Ar xxx
+.It Fl c Ar xxx
+.It Fl d Ar xxx
+.It Fl e Ar xxx
+.It Fl f Ar xxx
+.It Fl l Ar xxx
+.It Fl m Ar xxx
+.It Fl p Ar xxx
+.It Fl s Ar xxx
+.It Fl w Ar xxx
+.El
+.Pp
+Refer to
+.Xr virtual_oss 8
+for a detailed description of the command line arguments.
+.Sh EXAMPLES
+To change the recording device:
+.Bd -literal -offset indent
+virtual_oss_cmd /dev/vdsp.ctl -R /dev/dsp4
+
+.Ed
+To change the playback device:
+.Bd -literal -offset indent
+virtual_oss_cmd /dev/vdsp.ctl -P /dev/dsp4
+
+.Ed
+To enable recording:
+.Bd -literal -offset indent
+virtual_oss_cmd /dev/vdsp.ctl -E 1
+
+.Ed
+To disable recording:
+.Bd -literal -offset indent
+virtual_oss_cmd /dev/vdsp.ctl -E 0
+
+.Ed
+To create a new DSP device on the fly:
+.Bd -literal -offset indent
+virtual_oss_cmd /dev/vdsp.ctl -b 16 -c 2 -d dsp.new
+
+.Ed
+To show system information:
+.Bd -literal -offset indent
+virtual_oss_cmd /dev/vdsp.ctl
+
+.Ed
+.Sh SEE ALSO
+.Xr virtual_oss 8
+.Sh AUTHORS
+.Nm
+was written by
+.An Hans Petter Selasky hselasky@freebsd.org .

File Metadata

Mime Type
text/plain
Expires
Sat, May 16, 12:00 PM (18 h, 45 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
33065212
Default Alt Text
D52308.id162980.diff (341 KB)

Event Timeline