385 lines
8.3 KiB
C
385 lines
8.3 KiB
C
/* $NetBSD: audiodev.c,v 1.15 2019/08/24 07:39:42 isaki Exp $ */
|
|
|
|
/*
|
|
* Copyright (c) 2010 Jared D. McNeill <jmcneill@invisible.ca>
|
|
* 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 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/queue.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/drvctlio.h>
|
|
|
|
#include <err.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <paths.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
#include "audiodev.h"
|
|
#include "drvctl.h"
|
|
#include "dtmf.h"
|
|
|
|
static int audiodev_test_chmask(struct audiodev *, unsigned int,
|
|
audio_info_t *);
|
|
|
|
static TAILQ_HEAD(audiodevhead, audiodev) audiodevlist =
|
|
TAILQ_HEAD_INITIALIZER(audiodevlist);
|
|
|
|
static int
|
|
audiodev_getinfo(struct audiodev *adev)
|
|
{
|
|
struct stat st;
|
|
struct audiofmt *f;
|
|
audio_format_query_t query;
|
|
int i;
|
|
|
|
if (stat(adev->ctlpath, &st) == -1)
|
|
return -1;
|
|
adev->dev = st.st_rdev;
|
|
|
|
if (stat(_PATH_AUDIOCTL, &st) != -1 && st.st_rdev == adev->dev)
|
|
adev->defaultdev = true;
|
|
|
|
adev->ctlfd = open(adev->ctlpath, O_RDONLY);
|
|
if (adev->ctlfd == -1) {
|
|
return -1;
|
|
}
|
|
if (ioctl(adev->ctlfd, AUDIO_GETDEV, &adev->audio_device) == -1) {
|
|
close(adev->ctlfd);
|
|
return -1;
|
|
}
|
|
|
|
for (i = 0; ;i++) {
|
|
memset(&query, 0, sizeof(query));
|
|
query.index = i;
|
|
if (ioctl(adev->ctlfd, AUDIO_QUERYFORMAT, &query) == -1) {
|
|
if (errno == ENODEV) {
|
|
/* QUERYFORMAT not supported. */
|
|
break;
|
|
}
|
|
if (errno == EINVAL)
|
|
break;
|
|
close(adev->ctlfd);
|
|
return -1;
|
|
}
|
|
|
|
f = calloc(1, sizeof(*f));
|
|
f->fmt = query.fmt;
|
|
TAILQ_INSERT_TAIL(&adev->formats, f, next);
|
|
}
|
|
|
|
if (ioctl(adev->ctlfd, AUDIO_GETFORMAT, &adev->hwinfo) == -1) {
|
|
close(adev->ctlfd);
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
audiodev_add(const char *pdev, const char *dev, unsigned int unit)
|
|
{
|
|
struct audiodev *adev;
|
|
|
|
adev = calloc(1, sizeof(*adev));
|
|
if (adev == NULL)
|
|
return -1;
|
|
|
|
strlcpy(adev->pxname, pdev, sizeof(adev->pxname));
|
|
strlcpy(adev->xname, dev, sizeof(adev->xname));
|
|
snprintf(adev->path, sizeof(adev->path), "/dev/%s", dev);
|
|
snprintf(adev->ctlpath, sizeof(adev->ctlpath), "/dev/audioctl%d", unit);
|
|
adev->unit = unit;
|
|
TAILQ_INIT(&adev->formats);
|
|
|
|
if (audiodev_getinfo(adev) == -1) {
|
|
free(adev);
|
|
return -1;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
printf("DEBUG: [%c] %s(%s): %s\n", adev->defaultdev ? '*' : ' ',
|
|
adev->path, adev->ctlpath, adev->audio_device.name);
|
|
struct audiofmt *f;
|
|
TAILQ_FOREACH(f, &adev->formats, next) {
|
|
printf("DEBUG: enc%d, %d/%d, %dch\n",
|
|
f->fmt.encoding,
|
|
f->fmt.validbits,
|
|
f->fmt.precision,
|
|
f->fmt.channels);
|
|
}
|
|
#endif
|
|
|
|
TAILQ_INSERT_TAIL(&audiodevlist, adev, next);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
audiodev_cb(void *args, const char *pdev, const char *dev, unsigned int unit)
|
|
{
|
|
audiodev_add(pdev, dev, unit);
|
|
}
|
|
|
|
int
|
|
audiodev_refresh(void)
|
|
{
|
|
struct audiodev *adev;
|
|
int fd, error;
|
|
|
|
fd = open(DRVCTLDEV, O_RDONLY);
|
|
if (fd == -1) {
|
|
warn("open %s", DRVCTLDEV);
|
|
return -1;
|
|
}
|
|
|
|
while (!TAILQ_EMPTY(&audiodevlist)) {
|
|
adev = TAILQ_FIRST(&audiodevlist);
|
|
if (adev->ctlfd != -1)
|
|
close(adev->ctlfd);
|
|
TAILQ_REMOVE(&audiodevlist, adev, next);
|
|
free(adev);
|
|
}
|
|
|
|
error = drvctl_foreach(fd, "audio", audiodev_cb, NULL);
|
|
if (error == -1) {
|
|
warnx("drvctl failed");
|
|
return -1;
|
|
}
|
|
|
|
close(fd);
|
|
|
|
return 0;
|
|
}
|
|
|
|
unsigned int
|
|
audiodev_count(void)
|
|
{
|
|
struct audiodev *adev;
|
|
unsigned int n;
|
|
|
|
n = 0;
|
|
TAILQ_FOREACH(adev, &audiodevlist, next)
|
|
++n;
|
|
|
|
return n;
|
|
}
|
|
|
|
struct audiodev *
|
|
audiodev_get(unsigned int i)
|
|
{
|
|
struct audiodev *adev;
|
|
unsigned int n;
|
|
|
|
n = 0;
|
|
TAILQ_FOREACH(adev, &audiodevlist, next) {
|
|
if (n == i)
|
|
return adev;
|
|
++n;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
int
|
|
audiodev_set_default(struct audiodev *adev)
|
|
{
|
|
char audiopath[PATH_MAX+1];
|
|
char soundpath[PATH_MAX+1];
|
|
char audioctlpath[PATH_MAX+1];
|
|
char mixerpath[PATH_MAX+1];
|
|
|
|
snprintf(audiopath, sizeof(audiopath),
|
|
_PATH_AUDIO "%u", adev->unit);
|
|
snprintf(soundpath, sizeof(soundpath),
|
|
_PATH_SOUND "%u", adev->unit);
|
|
snprintf(audioctlpath, sizeof(audioctlpath),
|
|
_PATH_AUDIOCTL "%u", adev->unit);
|
|
snprintf(mixerpath, sizeof(mixerpath),
|
|
_PATH_MIXER "%u", adev->unit);
|
|
|
|
unlink(_PATH_AUDIO);
|
|
unlink(_PATH_SOUND);
|
|
unlink(_PATH_AUDIOCTL);
|
|
unlink(_PATH_MIXER);
|
|
|
|
if (symlink(audiopath, _PATH_AUDIO) == -1) {
|
|
warn("symlink %s", _PATH_AUDIO);
|
|
return -1;
|
|
}
|
|
if (symlink(soundpath, _PATH_SOUND) == -1) {
|
|
warn("symlink %s", _PATH_SOUND);
|
|
return -1;
|
|
}
|
|
if (symlink(audioctlpath, _PATH_AUDIOCTL) == -1) {
|
|
warn("symlink %s", _PATH_AUDIOCTL);
|
|
return -1;
|
|
}
|
|
if (symlink(mixerpath, _PATH_MIXER) == -1) {
|
|
warn("symlink %s", _PATH_MIXER);
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
audiodev_set_param(struct audiodev *adev, int mode,
|
|
const char *encname, unsigned int prec, unsigned int ch, unsigned int freq)
|
|
{
|
|
audio_info_t ai;
|
|
int setmode;
|
|
u_int enc;
|
|
|
|
setmode = 0;
|
|
ai = adev->hwinfo;
|
|
|
|
for (enc = 0; enc < encoding_max; enc++) {
|
|
if (strcmp(encname, encoding_names[enc]) == 0)
|
|
break;
|
|
}
|
|
if (enc >= encoding_max) {
|
|
warnx("unknown encoding name: %s", encname);
|
|
return -1;
|
|
}
|
|
|
|
if ((ai.mode & mode & AUMODE_PLAY)) {
|
|
setmode |= AUMODE_PLAY;
|
|
ai.play.encoding = enc;
|
|
ai.play.precision = prec;
|
|
ai.play.channels = ch;
|
|
ai.play.sample_rate = freq;
|
|
}
|
|
if ((ai.mode & mode & AUMODE_RECORD)) {
|
|
setmode |= AUMODE_RECORD;
|
|
ai.record.encoding = enc;
|
|
ai.record.precision = prec;
|
|
ai.record.channels = ch;
|
|
ai.record.sample_rate = freq;
|
|
}
|
|
|
|
ai.mode = setmode;
|
|
printf("setting %s to %s:%u, %uch, %uHz\n",
|
|
adev->xname, encname, prec, ch, freq);
|
|
if (ioctl(adev->ctlfd, AUDIO_SETFORMAT, &ai) == -1) {
|
|
warn("ioctl AUDIO_SETFORMAT");
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
audiodev_test(struct audiodev *adev)
|
|
{
|
|
audio_info_t info;
|
|
unsigned int i;
|
|
int rv;
|
|
|
|
rv = -1;
|
|
|
|
adev->fd = open(adev->path, O_WRONLY);
|
|
if (adev->fd == -1) {
|
|
warn("open %s", adev->path);
|
|
return -1;
|
|
}
|
|
|
|
AUDIO_INITINFO(&info);
|
|
info.play.sample_rate = adev->hwinfo.play.sample_rate;
|
|
info.play.channels = adev->hwinfo.play.channels;
|
|
info.play.precision = 16;
|
|
info.play.encoding = AUDIO_ENCODING_SLINEAR_LE;
|
|
info.mode = AUMODE_PLAY;
|
|
if (ioctl(adev->fd, AUDIO_SETINFO, &info) == -1) {
|
|
warn("ioctl AUDIO_SETINFO");
|
|
goto done;
|
|
}
|
|
if (ioctl(adev->fd, AUDIO_GETBUFINFO, &info) == -1) {
|
|
warn("ioctl AUDIO_GETBUFINFO");
|
|
goto done;
|
|
}
|
|
|
|
for (i = 0; i < adev->hwinfo.play.channels; i++) {
|
|
printf(" testing channel %u...", i);
|
|
fflush(stdout);
|
|
if (audiodev_test_chmask(adev, 1 << i, &info) == -1)
|
|
goto done;
|
|
printf(" done\n");
|
|
}
|
|
|
|
rv = 0;
|
|
done:
|
|
close(adev->fd);
|
|
return rv;
|
|
}
|
|
|
|
static int
|
|
audiodev_test_chmask(struct audiodev *adev, unsigned int chanmask,
|
|
audio_info_t *info)
|
|
{
|
|
int16_t *buf;
|
|
size_t buflen;
|
|
off_t off;
|
|
int rv;
|
|
|
|
rv = -1;
|
|
|
|
dtmf_new(&buf, &buflen, adev->hwinfo.play.sample_rate, 2,
|
|
adev->hwinfo.play.channels, chanmask, 350.0, 440.0);
|
|
if (buf == NULL) {
|
|
return -1;
|
|
}
|
|
|
|
off = 0;
|
|
while (buflen > 0) {
|
|
size_t wlen;
|
|
ssize_t ret;
|
|
|
|
wlen = info->play.buffer_size;
|
|
if (wlen > buflen)
|
|
wlen = buflen;
|
|
ret = write(adev->fd, (char *)buf + off, wlen);
|
|
if (ret == -1) {
|
|
warn("write");
|
|
goto done;
|
|
}
|
|
wlen = ret;
|
|
off += wlen;
|
|
buflen -= wlen;
|
|
}
|
|
|
|
if (ioctl(adev->fd, AUDIO_DRAIN) == -1) {
|
|
warn("ioctl AUDIO_DRAIN");
|
|
goto done;
|
|
}
|
|
|
|
rv = 0;
|
|
done:
|
|
free(buf);
|
|
return rv;
|
|
}
|