/*      $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;
}