xref: /src/lib/libossaudio/oss4_mixer.c

/*	$NetBSD: oss4_mixer.c,v 1.1 2021/06/08 18:43:54 nia Exp $	*/

/*-
 * Copyright (c) 2020-2021 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Nia Alarie.
 *
 * 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/audioio.h>
#include <sys/fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <limits.h>
#include <stdio.h>
#include <unistd.h>
#include "internal.h"

static int get_audio_count(void);
static int get_mixer_count(void);
static int get_mixer_control_count(int);

oss_private int
_oss4_mixer_ioctl(int fd, unsigned long com, void *argp)
{
	oss_audioinfo *tmpai;
	oss_card_info *cardinfo;
	oss_mixext *ext;
	oss_mixext_root root;
	oss_mixer_enuminfo *ei;
	oss_mixer_value *mv;
	oss_mixerinfo *mi;
	oss_sysinfo sysinfo;
	dev_t devno;
	struct stat tmpstat;
	struct audio_device dev;
	struct audio_format_query fmtq;
	struct mixer_devinfo mdi;
	struct mixer_ctrl mc;
	char devname[32];
	size_t len;
	int newfd = -1, tmperrno;
	int i, noffs;
	int retval;

	/*
	 * Note: it is difficult to translate the NetBSD concept of a "set"
	 * mixer control type to the OSSv4 API, as far as I can tell.
	 *
	 * This means they are treated like enums, i.e. only one entry in the
	 * set can be selected at a time.
	 */

	switch (com) {
	case SNDCTL_AUDIOINFO:
	/*
	 * SNDCTL_AUDIOINFO_EX is intended for underlying hardware devices
	 * that are to be opened in "exclusive mode" (bypassing the normal
	 * kernel mixer for exclusive control). NetBSD does not support
	 * bypassing the kernel mixer, so it's an alias of SNDCTL_AUDIOINFO.
	 */
	case SNDCTL_AUDIOINFO_EX:
	case SNDCTL_ENGINEINFO:
		devno = 0;
		tmpai = (struct oss_audioinfo*)argp;
		if (tmpai == NULL) {
			errno = EINVAL;
			return -1;
		}

		/*
		 * If the input device is -1, guess the device related to
		 * the open mixer device.
		 */
		if (tmpai->dev < 0) {
			fstat(fd, &tmpstat);
			if ((tmpstat.st_rdev & 0xff00) == 0x2a00)
				devno = tmpstat.st_rdev & 0xff;
			if (devno >= 0x80)
				tmpai->dev = devno & 0x7f;
		}
		if (tmpai->dev < 0)
			tmpai->dev = 0;

		snprintf(tmpai->devnode, sizeof(tmpai->devnode),
		    "/dev/audio%d", tmpai->dev);

		if ((newfd = open(tmpai->devnode, O_WRONLY)) < 0) {
			if ((newfd = open(tmpai->devnode, O_RDONLY)) < 0) {
				return newfd;
			}
		}

		retval = ioctl(newfd, AUDIO_GETDEV, &dev);
		if (retval < 0) {
			tmperrno = errno;
			close(newfd);
			errno = tmperrno;
			return retval;
		}
		if (_oss_get_caps(newfd, &tmpai->caps) < 0) {
			tmperrno = errno;
			close(newfd);
			errno = tmperrno;
			return retval;
		}
		snprintf(tmpai->name, sizeof(tmpai->name),
		    "%s %s", dev.name, dev.version);
		tmpai->busy = 0;
		tmpai->pid = -1;
		_oss_dsp_ioctl(newfd, SNDCTL_DSP_GETFMTS, &tmpai->iformats);
		tmpai->oformats = tmpai->iformats;
		tmpai->magic = -1; /* reserved for "internal use" */
		memset(tmpai->cmd, 0, sizeof(tmpai->cmd));
		tmpai->card_number = -1;
		memset(tmpai->song_name, 0,
		    sizeof(tmpai->song_name));
		memset(tmpai->label, 0, sizeof(tmpai->label));
		tmpai->port_number = 0;
		tmpai->mixer_dev = tmpai->dev;
		tmpai->legacy_device = tmpai->dev;
		tmpai->enabled = 1;
		tmpai->flags = -1; /* reserved for "future versions" */
		tmpai->min_rate = 1000;
		tmpai->max_rate = 192000;
		tmpai->nrates = 0;
		tmpai->min_channels = 1;
		tmpai->max_channels = 2;
		for (fmtq.index = 0;
		    ioctl(newfd, AUDIO_QUERYFORMAT, &fmtq) != -1; ++fmtq.index) {
			if (fmtq.fmt.channels > (unsigned)tmpai->max_channels)
				tmpai->max_channels = fmtq.fmt.channels;
		}
		tmpai->binding = -1; /* reserved for "future versions" */
		tmpai->rate_source = -1;
		/*
		 * 'handle' is supposed to be globally unique. The closest
		 * we have to that is probably device nodes.
		 */
		strlcpy(tmpai->handle, tmpai->devnode,
		    sizeof(tmpai->handle));
		tmpai->next_play_engine = 0;
		tmpai->next_rec_engine = 0;
		argp = tmpai;
		close(newfd);
		break;
	case SNDCTL_CARDINFO:
		cardinfo = (oss_card_info *)argp;
		if (cardinfo == NULL) {
			errno = EINVAL;
			return -1;
		}
		if (cardinfo->card != -1) {
			snprintf(devname, sizeof(devname),
			    "/dev/audio%d", cardinfo->card);
			newfd = open(devname, O_RDONLY);
			if (newfd < 0)
				return newfd;
		} else {
			newfd = fd;
		}
		retval = ioctl(newfd, AUDIO_GETDEV, &dev);
		tmperrno = errno;
		if (newfd != fd)
			close(newfd);
		if (retval < 0) {
			errno = tmperrno;
			return retval;
		}
		strlcpy(cardinfo->shortname, dev.name,
		    sizeof(cardinfo->shortname));
		snprintf(cardinfo->longname, sizeof(cardinfo->longname),
		    "%s %s %s", dev.name, dev.version, dev.config);
		memset(cardinfo->hw_info, 0, sizeof(cardinfo->hw_info));
		/*
		 * OSSv4 does not document this ioctl, and claims it should
		 * not be used by applications and is provided for "utiltiy
		 * programs included in OSS". We follow the Solaris
		 * implementation (which is documented) and leave these fields
		 * unset.
		 */
		cardinfo->flags = 0;
		cardinfo->intr_count = 0;
		cardinfo->ack_count = 0;
		break;
	case SNDCTL_SYSINFO:
		memset(&sysinfo, 0, sizeof(sysinfo));
		strlcpy(sysinfo.product,
		    "OSS/NetBSD", sizeof(sysinfo.product));
		strlcpy(sysinfo.version,
		    "4.01", sizeof(sysinfo.version));
		strlcpy(sysinfo.license,
		    "BSD", sizeof(sysinfo.license));
		sysinfo.versionnum = SOUND_VERSION;
		sysinfo.numaudios =
		    sysinfo.numcards =
			get_audio_count();
		sysinfo.numaudioengines = 1;
		sysinfo.numsynths = 1;
		sysinfo.nummidis = -1;
		sysinfo.numtimers = -1;
		sysinfo.nummixers = get_mixer_count();
		*(struct oss_sysinfo *)argp = sysinfo;
		break;
	case SNDCTL_MIXERINFO:
		mi = (oss_mixerinfo *)argp;
		if (mi == NULL) {
			errno = EINVAL;
			return -1;
		}
		snprintf(devname, sizeof(devname), "/dev/mixer%d", mi->dev);
		if ((newfd = open(devname, O_RDONLY)) < 0)
			return newfd;
		retval = ioctl(newfd, AUDIO_GETDEV, &dev);
		if (retval < 0) {
			tmperrno = errno;
			close(newfd);
			errno = tmperrno;
			return retval;
		}
		strlcpy(mi->id, devname, sizeof(mi->id));
		strlcpy(mi->handle, devname, sizeof(mi->handle));
		snprintf(mi->name, sizeof(mi->name),
		    "%s %s", dev.name, dev.version);
		mi->card_number = mi->dev;
		mi->port_number = 0;
		mi->magic = 0;
		mi->enabled = 1;
		mi->caps = 0;
		mi->flags = 0;
		mi->nrext = get_mixer_control_count(newfd) + 1;
		mi->priority = UCHAR_MAX - mi->dev;
		strlcpy(mi->devnode, devname, sizeof(mi->devnode));
		mi->legacy_device = mi->dev;
		break;
	case SNDCTL_MIX_DESCRIPTION:
		/* No description available. */
		errno = ENOSYS;
		return -1;
	case SNDCTL_MIX_NRMIX:
		INTARG = get_mixer_count();
		break;
	case SNDCTL_MIX_NREXT:
		snprintf(devname, sizeof(devname), "/dev/mixer%d", INTARG);
		if ((newfd = open(devname, O_RDONLY)) < 0)
			return newfd;
		INTARG = get_mixer_control_count(newfd) + 1;
		close(newfd);
		break;
	case SNDCTL_MIX_EXTINFO:
		ext = (oss_mixext *)argp;
		snprintf(devname, sizeof(devname), "/dev/mixer%d", ext->dev);
		if ((newfd = open(devname, O_RDONLY)) < 0)
			return newfd;
		if (ext->ctrl == 0) {
			/*
			 * NetBSD has no concept of a "root mixer control", but
 			 * OSSv4 requires one to work. We fake one at 0 and
			 * simply add 1 to all real control indexes.
			 */
			retval = ioctl(newfd, AUDIO_GETDEV, &dev);
			tmperrno = errno;
			close(newfd);
			if (retval < 0) {
				errno = tmperrno;
				return -1;
			}
			memset(&root, 0, sizeof(root));
			strlcpy(root.id, devname, sizeof(root.id));
			snprintf(root.name, sizeof(root.name),
			    "%s %s", dev.name, dev.version);
			strlcpy(ext->id, devname, sizeof(ext->id));
			snprintf(ext->extname, sizeof(ext->extname),
			    "%s %s", dev.name, dev.version);
			strlcpy(ext->extname, "root", sizeof(ext->extname));
			ext->type = MIXT_DEVROOT;
			ext->minvalue = 0;
			ext->maxvalue = 0;
			ext->flags = 0;
			ext->parent = -1;
			ext->control_no = -1;
			ext->update_counter = 0;
			ext->rgbcolor = 0;
			memcpy(&ext->data, &root,
			    sizeof(root) > sizeof(ext->data) ?
			    sizeof(ext->data) : sizeof(root));
			return 0;
		}
		mdi.index = ext->ctrl - 1;
		retval = ioctl(newfd, AUDIO_MIXER_DEVINFO, &mdi);
		if (retval < 0) {
			tmperrno = errno;
			close(newfd);
			errno = tmperrno;
			return retval;
		}
		ext->flags = MIXF_READABLE | MIXF_WRITEABLE | MIXF_POLL;
		ext->parent = mdi.mixer_class + 1;
		strlcpy(ext->id, mdi.label.name, sizeof(ext->id));
		strlcpy(ext->extname, mdi.label.name, sizeof(ext->extname));
		len = strlen(ext->extname);
		memset(ext->data, 0, sizeof(ext->data));
		ext->control_no = -1;
		ext->update_counter = 0;
		ext->rgbcolor = 0;
		switch (mdi.type) {
		case AUDIO_MIXER_CLASS:
			ext->type = MIXT_GROUP;
			ext->parent = 0;
			ext->minvalue = 0;
			ext->maxvalue = 0;
			break;
		case AUDIO_MIXER_ENUM:
			ext->maxvalue = mdi.un.e.num_mem;
			ext->minvalue = 0;
			for (i = 0; i < mdi.un.e.num_mem; ++i) {
				ext->enum_present[i / 8] |= (1 << (i % 8));
			}
			if (mdi.un.e.num_mem == 2) {
				if (!strcmp(mdi.un.e.member[0].label.name, AudioNoff) &&
				    !strcmp(mdi.un.e.member[1].label.name, AudioNon)) {
					ext->type = MIXT_MUTE;
				} else {
					ext->type = MIXT_ENUM;
				}
			} else {
				ext->type = MIXT_ENUM;
			}
			break;
		case AUDIO_MIXER_SET:
			ext->maxvalue = mdi.un.s.num_mem;
			ext->minvalue = 0;
#ifdef notyet
			/*
			 * XXX: This is actually the correct type for "set"
			 * controls, but it seems no real world software
			 * supports it. The only documentation exists in
			 * the OSSv4 headers and describes it as "reserved
			 * for Sun's implementation".
			 */
			ext->type = MIXT_ENUM_MULTI;
#else
			ext->type = MIXT_ENUM;
#endif
			for (i = 0; i < mdi.un.s.num_mem; ++i) {
				ext->enum_present[i / 8] |= (1 << (i % 8));
			}
			break;
		case AUDIO_MIXER_VALUE:
			ext->maxvalue = UCHAR_MAX + 1;
			ext->minvalue = 0;
			if (mdi.un.v.num_channels == 2) {
				ext->type = MIXT_STEREOSLIDER;
			} else {
				ext->type = MIXT_MONOSLIDER;
			}
			break;
		}
		close(newfd);
		break;
	case SNDCTL_MIX_ENUMINFO:
		ei = (oss_mixer_enuminfo *)argp;
		if (ei == NULL) {
			errno = EINVAL;
			return -1;
		}
		if (ei->ctrl == 0) {
			errno = EINVAL;
			return -1;
		}
		snprintf(devname, sizeof(devname), "/dev/mixer%d", ei->dev);
		if ((newfd = open(devname, O_RDONLY)) < 0)
			return newfd;
		mdi.index = ei->ctrl - 1;
		retval = ioctl(newfd, AUDIO_MIXER_DEVINFO, &mdi);
		tmperrno = errno;
		close(newfd);
		if (retval < 0) {
			errno = tmperrno;
			return retval;
		}
		ei->version = 0;
		switch (mdi.type) {
		case AUDIO_MIXER_ENUM:
			ei->nvalues = mdi.un.e.num_mem;
			noffs = 0;
			for (i = 0; i < ei->nvalues; ++i) {
				ei->strindex[i] = noffs;
				len = strlen(mdi.un.e.member[i].label.name) + 1;
				if ((noffs + len) >= sizeof(ei->strings)) {
				    errno = ENOMEM;
				    return -1;
				}
				memcpy(ei->strings + noffs,
				    mdi.un.e.member[i].label.name, len);
				noffs += len;
			}
			break;
		case AUDIO_MIXER_SET:
			ei->nvalues = mdi.un.s.num_mem;
			noffs = 0;
			for (i = 0; i < ei->nvalues; ++i) {
				ei->strindex[i] = noffs;
				len = strlen(mdi.un.s.member[i].label.name) + 1;
				if ((noffs + len) >= sizeof(ei->strings)) {
				    errno = ENOMEM;
				    return -1;
				}
				memcpy(ei->strings + noffs,
				    mdi.un.s.member[i].label.name, len);
				noffs += len;
			}
			break;
		default:
			errno = EINVAL;
			return -1;
		}
		break;
	case SNDCTL_MIX_WRITE:
		mv = (oss_mixer_value *)argp;
		if (mv == NULL) {
			errno = EINVAL;
			return -1;
		}
		if (mv->ctrl == 0) {
			errno = EINVAL;
			return -1;
		}
		snprintf(devname, sizeof(devname), "/dev/mixer%d", mv->dev);
		if ((newfd = open(devname, O_RDWR)) < 0)
			return newfd;
		mdi.index = mc.dev = mv->ctrl - 1;
		retval = ioctl(newfd, AUDIO_MIXER_DEVINFO, &mdi);
		if (retval < 0) {
			tmperrno = errno;
			close(newfd);
			errno = tmperrno;
			return retval;
		}
		mc.type = mdi.type;
		switch (mdi.type) {
		case AUDIO_MIXER_ENUM:
			if (mv->value >= mdi.un.e.num_mem) {
				close(newfd);
				errno = EINVAL;
				return -1;
			}
			mc.un.ord = mdi.un.e.member[mv->value].ord;
			break;
		case AUDIO_MIXER_SET:
			if (mv->value >= mdi.un.s.num_mem) {
				close(newfd);
				errno = EINVAL;
				return -1;
			}
#ifdef notyet
			mc.un.mask = 0;
			for (i = 0; i < mdi.un.s.num_mem; ++i) {
				if (mv->value & (1 << i)) {
					mc.un.mask |= mdi.un.s.member[mv->value].mask;
				}
			}
#else
			mc.un.mask = mdi.un.s.member[mv->value].mask;
#endif
			break;
		case AUDIO_MIXER_VALUE:
			mc.un.value.num_channels = mdi.un.v.num_channels;
			if (mdi.un.v.num_channels != 2) {
				for (i = 0; i < mdi.un.v.num_channels; ++i) {
					mc.un.value.level[i] = mv->value;
				}
			} else {
			    mc.un.value.level[AUDIO_MIXER_LEVEL_LEFT] =
				(mv->value >> 0) & 0xFF;
			    mc.un.value.level[AUDIO_MIXER_LEVEL_RIGHT] =
				(mv->value >> 8) & 0xFF;
			}
			break;
		}
		retval = ioctl(newfd, AUDIO_MIXER_WRITE, &mc);
		if (retval < 0) {
			tmperrno = errno;
			close(newfd);
			errno = tmperrno;
			return retval;
		}
		close(newfd);
		break;
	case SNDCTL_MIX_READ:
		mv = (oss_mixer_value *)argp;
		if (mv == NULL) {
			errno = EINVAL;
			return -1;
		}
		if (mv->ctrl == 0) {
			errno = EINVAL;
			return -1;
		}
		snprintf(devname, sizeof(devname), "/dev/mixer%d", mv->dev);
		if ((newfd = open(devname, O_RDWR)) < 0)
			return newfd;
		mdi.index = mc.dev = (mv->ctrl - 1);
		retval = ioctl(newfd, AUDIO_MIXER_DEVINFO, &mdi);
		if (retval < 0) {
			tmperrno = errno;
			close(newfd);
			errno = tmperrno;
			return retval;
		}
		mc.dev = mdi.index;
		mc.type = mdi.type;
		if (mdi.type == AUDIO_MIXER_VALUE)
			mc.un.value.num_channels = mdi.un.v.num_channels;
		retval = ioctl(newfd, AUDIO_MIXER_READ, &mc);
		if (retval < 0) {
			tmperrno = errno;
			close(newfd);
			errno = tmperrno;
			return retval;
		}
		close(newfd);
		mv->value = 0;
		switch (mdi.type) {
		case AUDIO_MIXER_ENUM:
			for (i = 0; i < mdi.un.e.num_mem; ++i) {
				if (mc.un.ord == mdi.un.e.member[i].ord) {
					mv->value = i;
					break;
				}
			}
			break;
		case AUDIO_MIXER_SET:
			for (i = 0; i < mdi.un.s.num_mem; ++i) {
#ifdef notyet
				if (mc.un.mask & mdi.un.s.member[i].mask)
					mv->value |= (1 << i);
#else
				if (mc.un.mask == mdi.un.s.member[i].mask) {
					mv->value = i;
					break;
				}
#endif
			}
			break;
		case AUDIO_MIXER_VALUE:
			if (mdi.un.v.num_channels != 2) {
				mv->value = mc.un.value.level[0];
			} else {
				mv->value = \
				    ((mc.un.value.level[1] & 0xFF) << 8) |
				    ((mc.un.value.level[0] & 0xFF) << 0);
			}
			break;
		default:
			errno = EINVAL;
			return -1;
		}
		break;
	default:
		errno = EINVAL;
		return -1;
	}
	return 0;
}

static int
get_audio_count(void)
{
	char devname[32];
	int ndevs = 0;
	int tmpfd;
	int tmperrno = errno;

	do {
		snprintf(devname, sizeof(devname),
		    "/dev/audio%d", ndevs);
		if ((tmpfd = open(devname, O_RDONLY)) != -1 ||
		    (tmpfd = open(devname, O_WRONLY)) != -1) {
			ndevs++;
			close(tmpfd);
		}
	} while (tmpfd != -1);
	errno = tmperrno;
	return ndevs;
}

static int
get_mixer_count(void)
{
	char devname[32];
	int ndevs = 0;
	int tmpfd;
	int tmperrno = errno;

	do {
		snprintf(devname, sizeof(devname),
		    "/dev/mixer%d", ndevs);
		if ((tmpfd = open(devname, O_RDONLY)) != -1) {
			ndevs++;
			close(tmpfd);
		}
	} while (tmpfd != -1);
	errno = tmperrno;
	return ndevs;
}

static int
get_mixer_control_count(int fd)
{
	struct mixer_devinfo mdi;
	int ndevs = 0;

	do {
		mdi.index = ndevs++;
	} while (ioctl(fd, AUDIO_MIXER_DEVINFO, &mdi) != -1);

	return ndevs > 0 ? ndevs - 1 : 0;
}