641 lines
16 KiB
C
641 lines
16 KiB
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;
|
|
}
|