* Copyright (c) 1997-2021 The NetBSD Foundation, Inc.

/* $NetBSD: oss_dsp.c,v 1.2 2021/06/08 19:26:48 nia Exp $ */

/*-
* Copyright (c) 1997-2021 The NetBSD Foundation, Inc.
* 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/cdefs.h>
__RCSID("$NetBSD: oss_dsp.c,v 1.2 2021/06/08 19:26:48 nia Exp $");

#include <sys/audioio.h>
#include <stdbool.h>
#include <errno.h>
#include "internal.h"

#define GETPRINFO(info, name) \
(((info)->mode == AUMODE_RECORD) \
? (info)->record.name : (info)->play.name)

static int encoding_to_format(u_int, u_int);
static int format_to_encoding(int, struct audio_info *);

static int get_vol(u_int, u_char);
static void set_vol(int, int, bool);

static void set_channels(int, int, int);

oss_private int
_oss_dsp_ioctl(int fd, unsigned long com, void *argp)
{

struct audio_info tmpinfo, hwfmt;
struct audio_offset tmpoffs;
struct audio_buf_info bufinfo;
struct audio_errinfo *tmperrinfo;
struct count_info cntinfo;
struct audio_encoding tmpenc;
u_int u;
int perrors, rerrors;
static int totalperrors = 0;
static int totalrerrors = 0;
oss_mixer_enuminfo *ei;
oss_count_t osscount;
int idat;
int retval;

idat = 0;

switch (com) {
case SNDCTL_DSP_HALT_INPUT:
case SNDCTL_DSP_HALT_OUTPUT:
case SNDCTL_DSP_RESET:
retval = ioctl(fd, AUDIO_FLUSH, 0);
if (retval < 0)
return retval;
break;
case SNDCTL_DSP_SYNC:
retval = ioctl(fd, AUDIO_DRAIN, 0);
if (retval < 0)
return retval;
break;
case SNDCTL_DSP_GETERROR:
tmperrinfo = (struct audio_errinfo *)argp;
if (tmperrinfo == NULL) {
errno = EINVAL;
return -1;
}
memset(tmperrinfo, 0, sizeof(struct audio_errinfo));
if ((retval = ioctl(fd, AUDIO_GETBUFINFO, &tmpinfo)) < 0)
return retval;
/*
* OSS requires that we return counters that are relative to
* the last call. We must maintain state here...
*/
if (ioctl(fd, AUDIO_PERROR, &perrors) != -1) {
perrors /= ((tmpinfo.play.precision / NBBY) *
tmpinfo.play.channels);
tmperrinfo->play_underruns =
(perrors / tmpinfo.blocksize) - totalperrors;
totalperrors += tmperrinfo->play_underruns;
}
if (ioctl(fd, AUDIO_RERROR, &rerrors) != -1) {
rerrors /= ((tmpinfo.record.precision / NBBY) *
tmpinfo.record.channels);
tmperrinfo->rec_overruns =
(rerrors / tmpinfo.blocksize) - totalrerrors;
totalrerrors += tmperrinfo->rec_overruns;
}
break;
case SNDCTL_DSP_COOKEDMODE:
/*
* NetBSD is always running in "cooked mode" - the kernel
* always performs format conversions.
*/
INTARG = 1;
break;
case SNDCTL_DSP_POST:
/* This call is merely advisory, and may be a nop. */
break;
case SNDCTL_DSP_SPEED:
/*
* In Solaris, 0 is used a special value to query the
* current rate. This seems useful to support.
*/
if (INTARG == 0) {
retval = ioctl(fd, AUDIO_GETBUFINFO, &tmpinfo);
if (retval < 0)
return retval;
retval = ioctl(fd, AUDIO_GETFORMAT, &hwfmt);
if (retval < 0)
return retval;
INTARG = (tmpinfo.mode == AUMODE_RECORD) ?
hwfmt.record.sample_rate :
hwfmt.play.sample_rate;
}
/*
* Conform to kernel limits.
* NetBSD will reject unsupported sample rates, but OSS
* applications need to be able to negotiate a supported one.
*/
if (INTARG < 1000)
INTARG = 1000;
if (INTARG > 192000)
INTARG = 192000;
AUDIO_INITINFO(&tmpinfo);
tmpinfo.play.sample_rate =
tmpinfo.record.sample_rate = INTARG;
retval = ioctl(fd, AUDIO_SETINFO, &tmpinfo);
if (retval < 0)
return retval;
/* FALLTHRU */
case SOUND_PCM_READ_RATE:
retval = ioctl(fd, AUDIO_GETBUFINFO, &tmpinfo);
if (retval < 0)
return retval;
INTARG = GETPRINFO(&tmpinfo, sample_rate);
break;
case SNDCTL_DSP_STEREO:
AUDIO_INITINFO(&tmpinfo);
tmpinfo.play.channels =
tmpinfo.record.channels = INTARG ? 2 : 1;
(void) ioctl(fd, AUDIO_SETINFO, &tmpinfo);
retval = ioctl(fd, AUDIO_GETBUFINFO, &tmpinfo);
if (retval < 0)
return retval;
INTARG = GETPRINFO(&tmpinfo, channels) - 1;
break;
case SNDCTL_DSP_GETBLKSIZE:
retval = ioctl(fd, AUDIO_GETBUFINFO, &tmpinfo);
if (retval < 0)
return retval;
INTARG = tmpinfo.blocksize;
break;
case SNDCTL_DSP_SETFMT:
AUDIO_INITINFO(&tmpinfo);
retval = format_to_encoding(INTARG, &tmpinfo);
if (retval < 0) {
/*
* OSSv4 specifies that if an invalid format is chosen
* by an application then a sensible format supported
* by the hardware is returned.
*
* In this case, we pick the current hardware format.
*/
retval = ioctl(fd, AUDIO_GETFORMAT, &hwfmt);
if (retval < 0)
return retval;
retval = ioctl(fd, AUDIO_GETINFO, &tmpinfo);
if (retval < 0)
return retval;
tmpinfo.play.encoding =
tmpinfo.record.encoding =
(tmpinfo.mode == AUMODE_RECORD) ?
hwfmt.record.encoding : hwfmt.play.encoding;
tmpinfo.play.precision =
tmpinfo.record.precision =
(tmpinfo.mode == AUMODE_RECORD) ?
hwfmt.record.precision : hwfmt.play.precision ;
}
/*
* In the post-kernel-mixer world, assume that any error means
* it's fatal rather than an unsupported format being selected.
*/
retval = ioctl(fd, AUDIO_SETINFO, &tmpinfo);
if (retval < 0)
return retval;
/* FALLTHRU */
case SOUND_PCM_READ_BITS:
retval = ioctl(fd, AUDIO_GETBUFINFO, &tmpinfo);
if (retval < 0)
return retval;
if (tmpinfo.mode == AUMODE_RECORD)
retval = encoding_to_format(tmpinfo.record.encoding,
tmpinfo.record.precision);
else
retval = encoding_to_format(tmpinfo.play.encoding,
tmpinfo.play.precision);
if (retval < 0) {
errno = EINVAL;
return retval;
}
INTARG = retval;
break;
case SNDCTL_DSP_CHANNELS:
retval = ioctl(fd, AUDIO_GETBUFINFO, &tmpinfo);
if (retval < 0)
return retval;
set_channels(fd, tmpinfo.mode, INTARG);
/* FALLTHRU */
case SOUND_PCM_READ_CHANNELS:
retval = ioctl(fd, AUDIO_GETBUFINFO, &tmpinfo);
if (retval < 0)
return retval;
INTARG = GETPRINFO(&tmpinfo, channels);
break;
case SOUND_PCM_WRITE_FILTER:
case SOUND_PCM_READ_FILTER:
errno = EINVAL;
return -1; /* XXX unimplemented */
case SNDCTL_DSP_SUBDIVIDE:
retval = ioctl(fd, AUDIO_GETBUFINFO, &tmpinfo);
if (retval < 0)
return retval;
idat = INTARG;
if (idat == 0)
idat = tmpinfo.play.buffer_size / tmpinfo.blocksize;
idat = (tmpinfo.play.buffer_size / idat) & -4;
AUDIO_INITINFO(&tmpinfo);
tmpinfo.blocksize = idat;
retval = ioctl(fd, AUDIO_SETINFO, &tmpinfo);
if (retval < 0)
return retval;
INTARG = tmpinfo.play.buffer_size / tmpinfo.blocksize;
break;
case SNDCTL_DSP_SETFRAGMENT:
AUDIO_INITINFO(&tmpinfo);
idat = INTARG;
tmpinfo.blocksize = 1 << (idat & 0xffff);
tmpinfo.hiwat = ((unsigned)idat >> 16) & 0x7fff;
if (tmpinfo.hiwat == 0) /* 0 means set to max */
tmpinfo.hiwat = 65536;
(void) ioctl(fd, AUDIO_SETINFO, &tmpinfo);
retval = ioctl(fd, AUDIO_GETBUFINFO, &tmpinfo);
if (retval < 0)
return retval;
u = tmpinfo.blocksize;
for(idat = 0; u > 1; idat++, u >>= 1)
;
idat |= (tmpinfo.hiwat & 0x7fff) << 16;
INTARG = idat;
break;
case SNDCTL_DSP_GETFMTS:
for(idat = 0, tmpenc.index = 0;
ioctl(fd, AUDIO_GETENC, &tmpenc) == 0;
tmpenc.index++) {
retval = encoding_to_format(tmpenc.encoding,
tmpenc.precision);
if (retval != -1)
idat |= retval;
}
INTARG = idat;
break;
case SNDCTL_DSP_GETOSPACE:
retval = ioctl(fd, AUDIO_GETBUFINFO, &tmpinfo);
if (retval < 0)
return retval;
bufinfo.fragsize = tmpinfo.blocksize;
bufinfo.fragments = tmpinfo.hiwat - (tmpinfo.play.seek
+ tmpinfo.blocksize - 1) / tmpinfo.blocksize;
bufinfo.fragstotal = tmpinfo.hiwat;
bufinfo.bytes = tmpinfo.hiwat * tmpinfo.blocksize
- tmpinfo.play.seek;
*(struct audio_buf_info *)argp = bufinfo;
break;
case SNDCTL_DSP_GETISPACE:
retval = ioctl(fd, AUDIO_GETBUFINFO, &tmpinfo);
if (retval < 0)
return retval;
bufinfo.fragsize = tmpinfo.blocksize;
bufinfo.fragments = tmpinfo.record.seek / tmpinfo.blocksize;
bufinfo.fragstotal =
tmpinfo.record.buffer_size / tmpinfo.blocksize;
bufinfo.bytes = tmpinfo.record.seek;
*(struct audio_buf_info *)argp = bufinfo;
break;
case SNDCTL_DSP_NONBLOCK:
idat = 1;
retval = ioctl(fd, FIONBIO, &idat);
if (retval < 0)
return retval;
break;
case SNDCTL_DSP_GETCAPS:
retval = _oss_get_caps(fd, (int *)argp);
if (retval < 0)
return retval;
break;
case SNDCTL_DSP_SETTRIGGER:
retval = ioctl(fd, AUDIO_GETBUFINFO, &tmpinfo);
if (retval < 0)
return retval;
AUDIO_INITINFO(&tmpinfo);
if (tmpinfo.mode & AUMODE_PLAY)
tmpinfo.play.pause = (INTARG & PCM_ENABLE_OUTPUT) == 0;
if (tmpinfo.mode & AUMODE_RECORD)
tmpinfo.record.pause = (INTARG & PCM_ENABLE_INPUT) == 0;
(void)ioctl(fd, AUDIO_SETINFO, &tmpinfo);
/* FALLTHRU */
case SNDCTL_DSP_GETTRIGGER:
retval = ioctl(fd, AUDIO_GETBUFINFO, &tmpinfo);
if (retval < 0)
return retval;
idat = 0;
if ((tmpinfo.mode & AUMODE_PLAY) && !tmpinfo.play.pause)
idat |= PCM_ENABLE_OUTPUT;
if ((tmpinfo.mode & AUMODE_RECORD) && !tmpinfo.record.pause)
idat |= PCM_ENABLE_INPUT;
INTARG = idat;
break;
case SNDCTL_DSP_GETIPTR:
retval = ioctl(fd, AUDIO_GETIOFFS, &tmpoffs);
if (retval < 0)
return retval;
cntinfo.bytes = tmpoffs.samples;
cntinfo.blocks = tmpoffs.deltablks;
cntinfo.ptr = tmpoffs.offset;
*(struct count_info *)argp = cntinfo;
break;
case SNDCTL_DSP_CURRENT_IPTR:
retval = ioctl(fd, AUDIO_GETBUFINFO, &tmpinfo);
if (retval < 0)
return retval;
/* XXX: 'samples' may wrap */
memset(osscount.filler, 0, sizeof(osscount.filler));
osscount.samples = tmpinfo.record.samples /
((tmpinfo.record.precision / NBBY) *
tmpinfo.record.channels);
osscount.fifo_samples = tmpinfo.record.seek /
((tmpinfo.record.precision / NBBY) *
tmpinfo.record.channels);
*(oss_count_t *)argp = osscount;
break;
case SNDCTL_DSP_GETOPTR:
retval = ioctl(fd, AUDIO_GETOOFFS, &tmpoffs);
if (retval < 0)
return retval;
cntinfo.bytes = tmpoffs.samples;
cntinfo.blocks = tmpoffs.deltablks;
cntinfo.ptr = tmpoffs.offset;
*(struct count_info *)argp = cntinfo;
break;
case SNDCTL_DSP_CURRENT_OPTR:
retval = ioctl(fd, AUDIO_GETBUFINFO, &tmpinfo);
if (retval < 0)
return retval;
/* XXX: 'samples' may wrap */
memset(osscount.filler, 0, sizeof(osscount.filler));
osscount.samples = tmpinfo.play.samples /
((tmpinfo.play.precision / NBBY) *
tmpinfo.play.channels);
osscount.fifo_samples = tmpinfo.play.seek /
((tmpinfo.play.precision / NBBY) *
tmpinfo.play.channels);
*(oss_count_t *)argp = osscount;
break;
case SNDCTL_DSP_SETPLAYVOL:
set_vol(fd, INTARG, false);
/* FALLTHRU */
case SNDCTL_DSP_GETPLAYVOL:
retval = ioctl(fd, AUDIO_GETINFO, &tmpinfo);
if (retval < 0)
return retval;
INTARG = get_vol(tmpinfo.play.gain, tmpinfo.play.balance);
break;
case SNDCTL_DSP_SETRECVOL:
set_vol(fd, INTARG, true);
/* FALLTHRU */
case SNDCTL_DSP_GETRECVOL:
retval = ioctl(fd, AUDIO_GETINFO, &tmpinfo);
if (retval < 0)
return retval;
INTARG = get_vol(tmpinfo.record.gain, tmpinfo.record.balance);
break;
case SNDCTL_DSP_SKIP:
case SNDCTL_DSP_SILENCE:
errno = EINVAL;
return -1;
case SNDCTL_DSP_SETDUPLEX:
idat = 1;
retval = ioctl(fd, AUDIO_SETFD, &idat);
if (retval < 0)
return retval;
break;
case SNDCTL_DSP_GETODELAY:
retval = ioctl(fd, AUDIO_GETBUFINFO, &tmpinfo);
if (retval < 0)
return retval;
idat = tmpinfo.play.seek + tmpinfo.blocksize / 2;
INTARG = idat;
break;
case SNDCTL_DSP_PROFILE:
/* This gives just a hint to the driver,
* implementing it as a NOP is ok
*/
break;
case SNDCTL_DSP_MAPINBUF:
case SNDCTL_DSP_MAPOUTBUF:
case SNDCTL_DSP_SETSYNCRO:
errno = EINVAL;
return -1; /* XXX unimplemented */
case SNDCTL_DSP_GET_PLAYTGT_NAMES:
case SNDCTL_DSP_GET_RECSRC_NAMES:
ei = (oss_mixer_enuminfo *)argp;
ei->nvalues = 1;
ei->version = 0;
ei->strindex[0] = 0;
strlcpy(ei->strings, "primary", OSS_ENUM_STRINGSIZE);
break;
case SNDCTL_DSP_SET_PLAYTGT:
case SNDCTL_DSP_SET_RECSRC:
case SNDCTL_DSP_GET_PLAYTGT:
case SNDCTL_DSP_GET_RECSRC:
/* We have one recording source and play target. */
INTARG = 0;
break;
default:
errno = EINVAL;
return -1;
}

return 0;
}

static int
get_vol(u_int gain, u_char balance)
{
u_int l, r;

if (balance == AUDIO_MID_BALANCE) {
l = r = gain;
} else if (balance < AUDIO_MID_BALANCE) {
l = gain;
r = (balance * gain) / AUDIO_MID_BALANCE;
} else {
r = gain;
l = ((AUDIO_RIGHT_BALANCE - balance) * gain)
/ AUDIO_MID_BALANCE;
}

return TO_OSSVOL(l) | (TO_OSSVOL(r) << 8);
}

static void
set_vol(int fd, int volume, bool record)
{
u_int lgain, rgain;
struct audio_info tmpinfo;
struct audio_prinfo *prinfo;

AUDIO_INITINFO(&tmpinfo);
prinfo = record ? &tmpinfo.record : &tmpinfo.play;

lgain = FROM_OSSVOL((volume >> 0) & 0xff);
rgain = FROM_OSSVOL((volume >> 8) & 0xff);

if (lgain == rgain) {
prinfo->gain = lgain;
prinfo->balance = AUDIO_MID_BALANCE;
} else if (lgain < rgain) {
prinfo->gain = rgain;
prinfo->balance = AUDIO_RIGHT_BALANCE -
(AUDIO_MID_BALANCE * lgain) / rgain;
} else {
prinfo->gain = lgain;
prinfo->balance = (AUDIO_MID_BALANCE * rgain) / lgain;
}

(void)ioctl(fd, AUDIO_SETINFO, &tmpinfo);
}

/*
* When AUDIO_SETINFO fails to set a channel count, the application's chosen
* number is out of range of what the kernel allows.
*
* When this happens, we use the current hardware settings. This is just in
* case an application is abusing SNDCTL_DSP_CHANNELS - OSSv4 always sets and
* returns a reasonable value, even if it wasn't what the user requested.
*
* Solaris guarantees this behaviour if nchannels = 0.
*
* XXX: If a device is opened for both playback and recording, and supports
* fewer channels for recording than playback, applications that do both will
* behave very strangely. OSS doesn't allow for reporting separate channel
* counts for recording and playback. This could be worked around by always
* mixing recorded data up to the same number of channels as is being used
* for playback.
*/
static void
set_channels(int fd, int mode, int nchannels)
{
struct audio_info tmpinfo, hwfmt;

if (ioctl(fd, AUDIO_GETFORMAT, &hwfmt) < 0) {
errno = 0;
hwfmt.record.channels = hwfmt.play.channels = 2;
}

if (mode & AUMODE_PLAY) {
AUDIO_INITINFO(&tmpinfo);
tmpinfo.play.channels = nchannels;
if (ioctl(fd, AUDIO_SETINFO, &tmpinfo) < 0) {
errno = 0;
AUDIO_INITINFO(&tmpinfo);
tmpinfo.play.channels = hwfmt.play.channels;
(void)ioctl(fd, AUDIO_SETINFO, &tmpinfo);
}
}

if (mode & AUMODE_RECORD) {
AUDIO_INITINFO(&tmpinfo);
tmpinfo.record.channels = nchannels;
if (ioctl(fd, AUDIO_SETINFO, &tmpinfo) < 0) {
errno = 0;
AUDIO_INITINFO(&tmpinfo);
tmpinfo.record.channels = hwfmt.record.channels;
(void)ioctl(fd, AUDIO_SETINFO, &tmpinfo);
}
}
}

/* Convert a NetBSD "encoding" to a OSS "format". */
static int
encoding_to_format(u_int encoding, u_int precision)
{
switch(encoding) {
case AUDIO_ENCODING_ULAW:
return AFMT_MU_LAW;
case AUDIO_ENCODING_ALAW:
return AFMT_A_LAW;
case AUDIO_ENCODING_SLINEAR:
if (precision == 32)
return AFMT_S32_NE;
else if (precision == 24)
return AFMT_S24_NE;
else if (precision == 16)
return AFMT_S16_NE;
return AFMT_S8;
case AUDIO_ENCODING_SLINEAR_LE:
if (precision == 32)
return AFMT_S32_LE;
else if (precision == 24)
return AFMT_S24_LE;
else if (precision == 16)
return AFMT_S16_LE;
return AFMT_S8;
case AUDIO_ENCODING_SLINEAR_BE:
if (precision == 32)
return AFMT_S32_BE;
else if (precision == 24)
return AFMT_S24_BE;
else if (precision == 16)
return AFMT_S16_BE;
return AFMT_S8;
case AUDIO_ENCODING_ULINEAR:
if (precision == 16)
return AFMT_U16_NE;
return AFMT_U8;
case AUDIO_ENCODING_ULINEAR_LE:
if (precision == 16)
return AFMT_U16_LE;
return AFMT_U8;
case AUDIO_ENCODING_ULINEAR_BE:
if (precision == 16)
return AFMT_U16_BE;
return AFMT_U8;
case AUDIO_ENCODING_ADPCM:
return AFMT_IMA_ADPCM;
case AUDIO_ENCODING_AC3:
return AFMT_AC3;
}
return -1;
}

/* Convert an OSS "format" to a NetBSD "encoding". */
static int
format_to_encoding(int fmt, struct audio_info *tmpinfo)
{
switch (fmt) {
case AFMT_MU_LAW:
tmpinfo->record.precision =
tmpinfo->play.precision = 8;
tmpinfo->record.encoding =
tmpinfo->play.encoding = AUDIO_ENCODING_ULAW;
return 0;
case AFMT_A_LAW:
tmpinfo->record.precision =
tmpinfo->play.precision = 8;
tmpinfo->record.encoding =
tmpinfo->play.encoding = AUDIO_ENCODING_ALAW;
return 0;
case AFMT_U8:
tmpinfo->record.precision =
tmpinfo->play.precision = 8;
tmpinfo->record.encoding =
tmpinfo->play.encoding = AUDIO_ENCODING_ULINEAR;
return 0;
case AFMT_S8:
tmpinfo->record.precision =
tmpinfo->play.precision = 8;
tmpinfo->record.encoding =
tmpinfo->play.encoding = AUDIO_ENCODING_SLINEAR;
return 0;
case AFMT_S16_LE:
tmpinfo->record.precision =
tmpinfo->play.precision = 16;
tmpinfo->record.encoding =
tmpinfo->play.encoding = AUDIO_ENCODING_SLINEAR_LE;
return 0;
case AFMT_S16_BE:
tmpinfo->record.precision =
tmpinfo->play.precision = 16;
tmpinfo->record.encoding =
tmpinfo->play.encoding = AUDIO_ENCODING_SLINEAR_BE;
return 0;
case AFMT_U16_LE:
tmpinfo->record.precision =
tmpinfo->play.precision = 16;
tmpinfo->record.encoding =
tmpinfo->play.encoding = AUDIO_ENCODING_ULINEAR_LE;
return 0;
case AFMT_U16_BE:
tmpinfo->record.precision =
tmpinfo->play.precision = 16;
tmpinfo->record.encoding =
tmpinfo->play.encoding = AUDIO_ENCODING_ULINEAR_BE;
return 0;
/*
* XXX: When the kernel supports 24-bit LPCM by default,
* the 24-bit formats should be handled properly instead
* of falling back to 32 bits.
*/
case AFMT_S24_PACKED:
case AFMT_S24_LE:
case AFMT_S32_LE:
tmpinfo->record.precision =
tmpinfo->play.precision = 32;
tmpinfo->record.encoding =
tmpinfo->play.encoding = AUDIO_ENCODING_SLINEAR_LE;
return 0;
case AFMT_S24_BE:
case AFMT_S32_BE:
tmpinfo->record.precision =
tmpinfo->play.precision = 32;
tmpinfo->record.encoding =
tmpinfo->play.encoding = AUDIO_ENCODING_SLINEAR_BE;
return 0;
case AFMT_AC3:
tmpinfo->record.precision =
tmpinfo->play.precision = 16;
tmpinfo->record.encoding =
tmpinfo->play.encoding = AUDIO_ENCODING_AC3;
return 0;
}
return -1;
}