/*

 * ossaudiodev -- Python interface to the OSS (Open Sound System) API.

 *                This is the standard audio API for Linux and some

 *                flavours of BSD [XXX which ones?]; it is also available

 *                for a wide range of commercial Unices.

 *

 * Originally written by Peter Bosch, March 2000, as linuxaudiodev.

 *

 * Renamed to ossaudiodev and rearranged/revised/hacked up

 * by Greg Ward <gward@python.net>, November 2002.

 * Mixer interface by Nicholas FitzRoy-Dale <wzdd@lardcave.net>, Dec 2002.

 *

 * (c) 2000 Peter Bosch.  All Rights Reserved.

 * (c) 2002 Gregory P. Ward.  All Rights Reserved.

 * (c) 2002 Python Software Foundation.  All Rights Reserved.

 *

 * XXX need a license statement

 *

 * $Id: ossaudiodev.c 64048 2008-06-09 04:58:54Z gregory.p.smith $

 */

#include "Python.h"

#include "structmember.h"

#ifdef HAVE_FCNTL_H

#include <fcntl.h>

#else

#define O_RDONLY 00

#define O_WRONLY 01

#endif

#include <sys/ioctl.h>

#include <sys/soundcard.h>

#if defined(linux)

#ifndef HAVE_STDINT_H

typedef unsigned long uint32_t;

#endif

#elif defined(__FreeBSD__)

# ifndef SNDCTL_DSP_CHANNELS

#  define SNDCTL_DSP_CHANNELS SOUND_PCM_WRITE_CHANNELS

# endif

#endif

typedef struct {

    PyObject_HEAD

    char    *devicename;              /* name of the device file */

    int      fd;                      /* file descriptor */

    int      mode;                    /* file mode (O_RDONLY, etc.) */

    int      icount;                  /* input count */

    int      ocount;                  /* output count */

    uint32_t afmts;                   /* audio formats supported by hardware */

} oss_audio_t;

typedef struct {

    PyObject_HEAD

    int      fd;                      /* The open mixer device */

} oss_mixer_t;

static PyTypeObject OSSAudioType;

static PyTypeObject OSSMixerType;

static PyObject *OSSAudioError;

/* ----------------------------------------------------------------------

 * DSP object initialization/deallocation

 */

static oss_audio_t *

newossobject(PyObject *arg)

{

    oss_audio_t *self;

    int fd, afmts, imode;

    char *devicename = NULL;

    char *mode = NULL;

    /* Two ways to call open():

         open(device, mode) (for consistency with builtin open())

         open(mode)         (for backwards compatibility)

       because the *first* argument is optional, parsing args is

       a wee bit tricky. */

    if (!PyArg_ParseTuple(arg, "s|s:open", &devicename, &mode))

       return NULL;

    if (mode == NULL) {                 /* only one arg supplied */

       mode = devicename;

       devicename = NULL;

    }

    if (strcmp(mode, "r") == 0)

        imode = O_RDONLY;

    else if (strcmp(mode, "w") == 0)

        imode = O_WRONLY;

    else if (strcmp(mode, "rw") == 0)

        imode = O_RDWR;

    else {

        PyErr_SetString(OSSAudioError, "mode must be 'r', 'w', or 'rw'");

        return NULL;

    }

    /* Open the correct device: either the 'device' argument,

       or the AUDIODEV environment variable, or "/dev/dsp". */

    if (devicename == NULL) {              /* called with one arg */

       devicename = getenv("AUDIODEV");

       if (devicename == NULL)             /* $AUDIODEV not set */

          devicename = "/dev/dsp";

    }

    /* Open with O_NONBLOCK to avoid hanging on devices that only allow

       one open at a time.  This does *not* affect later I/O; OSS

       provides a special ioctl() for non-blocking read/write, which is

       exposed via oss_nonblock() below. */

    if ((fd = open(devicename, imode|O_NONBLOCK)) == -1) {

        PyErr_SetFromErrnoWithFilename(PyExc_IOError, devicename);

        return NULL;

    }

    /* And (try to) put it back in blocking mode so we get the

       expected write() semantics. */

    if (fcntl(fd, F_SETFL, 0) == -1) {

        close(fd);

        PyErr_SetFromErrnoWithFilename(PyExc_IOError, devicename);

        return NULL;

    }

    if (ioctl(fd, SNDCTL_DSP_GETFMTS, &afmts) == -1) {

        PyErr_SetFromErrnoWithFilename(PyExc_IOError, devicename);

        return NULL;

    }

    /* Create and initialize the object */

    if ((self = PyObject_New(oss_audio_t, &OSSAudioType)) == NULL) {

        close(fd);

        return NULL;

    }

    self->devicename = devicename;

    self->fd = fd;

    self->mode = imode;

    self->icount = self->ocount = 0;

    self->afmts  = afmts;

    return self;

}

static void

oss_dealloc(oss_audio_t *self)

{

    /* if already closed, don't reclose it */

    if (self->fd != -1)

        close(self->fd);

    PyObject_Del(self);

}

/* ----------------------------------------------------------------------

 * Mixer object initialization/deallocation

 */

static oss_mixer_t *

newossmixerobject(PyObject *arg)

{

    char *devicename = NULL;

    int fd;

    oss_mixer_t *self;

    if (!PyArg_ParseTuple(arg, "|s", &devicename)) {

        return NULL;

    }

    if (devicename == NULL) {

        devicename = getenv("MIXERDEV");

        if (devicename == NULL)            /* MIXERDEV not set */

            devicename = "/dev/mixer";

    }

    if ((fd = open(devicename, O_RDWR)) == -1) {

        PyErr_SetFromErrnoWithFilename(PyExc_IOError, devicename);

        return NULL;

    }

    if ((self = PyObject_New(oss_mixer_t, &OSSMixerType)) == NULL) {

        close(fd);

        return NULL;

    }

    self->fd = fd;

    return self;

}

static void

oss_mixer_dealloc(oss_mixer_t *self)

{

    /* if already closed, don't reclose it */

    if (self->fd != -1)

        close(self->fd);

    PyObject_Del(self);

}

/* Methods to wrap the OSS ioctls.  The calling convention is pretty

   simple:

     nonblock()        -> ioctl(fd, SNDCTL_DSP_NONBLOCK)

     fmt = setfmt(fmt) -> ioctl(fd, SNDCTL_DSP_SETFMT, &fmt)

     etc.

*/

/* ----------------------------------------------------------------------

 * Helper functions

 */

/* _do_ioctl_1() is a private helper function used for the OSS ioctls --

   SNDCTL_DSP_{SETFMT,CHANNELS,SPEED} -- that that are called from C

   like this:

     ioctl(fd, SNDCTL_DSP_cmd, &arg)

   where arg is the value to set, and on return the driver sets arg to

   the value that was actually set.  Mapping this to Python is obvious:

     arg = dsp.xxx(arg)

*/

static PyObject *

_do_ioctl_1(int fd, PyObject *args, char *fname, int cmd)

{

    char argfmt[33] = "i:";

    int arg;

    assert(strlen(fname) <= 30);

    strcat(argfmt, fname);

    if (!PyArg_ParseTuple(args, argfmt, &arg))

        return NULL;

    if (ioctl(fd, cmd, &arg) == -1)

        return PyErr_SetFromErrno(PyExc_IOError);

    return PyInt_FromLong(arg);

}

/* _do_ioctl_1_internal() is a wrapper for ioctls that take no inputs

   but return an output -- ie. we need to pass a pointer to a local C

   variable so the driver can write its output there, but from Python

   all we see is the return value.  For example,

   SOUND_MIXER_READ_DEVMASK returns a bitmask of available mixer

   devices, but does not use the value of the parameter passed-in in any

   way.

*/

static PyObject *

_do_ioctl_1_internal(int fd, PyObject *args, char *fname, int cmd)

{

    char argfmt[32] = ":";

    int arg = 0;

    assert(strlen(fname) <= 30);

    strcat(argfmt, fname);

    if (!PyArg_ParseTuple(args, argfmt, &arg))

        return NULL;

    if (ioctl(fd, cmd, &arg) == -1)

        return PyErr_SetFromErrno(PyExc_IOError);

    return PyInt_FromLong(arg);

}

/* _do_ioctl_0() is a private helper for the no-argument ioctls:

   SNDCTL_DSP_{SYNC,RESET,POST}. */

static PyObject *

_do_ioctl_0(int fd, PyObject *args, char *fname, int cmd)

{

    char argfmt[32] = ":";

    int rv;

    assert(strlen(fname) <= 30);

    strcat(argfmt, fname);

    if (!PyArg_ParseTuple(args, argfmt))

        return NULL;

    /* According to hannu@opensound.com, all three of the ioctls that

       use this function can block, so release the GIL.  This is

       especially important for SYNC, which can block for several

       seconds. */

    Py_BEGIN_ALLOW_THREADS

    rv = ioctl(fd, cmd, 0);

    Py_END_ALLOW_THREADS

    if (rv == -1)

        return PyErr_SetFromErrno(PyExc_IOError);

    Py_INCREF(Py_None);

    return Py_None;

}

/* ----------------------------------------------------------------------

 * Methods of DSP objects (OSSAudioType)

 */

static PyObject *

oss_nonblock(oss_audio_t *self, PyObject *unused)

{

    /* Hmmm: it doesn't appear to be possible to return to blocking

       mode once we're in non-blocking mode! */

    if (ioctl(self->fd, SNDCTL_DSP_NONBLOCK, NULL) == -1)

        return PyErr_SetFromErrno(PyExc_IOError);

    Py_INCREF(Py_None);

    return Py_None;

}

static PyObject *

oss_setfmt(oss_audio_t *self, PyObject *args)

{

    return _do_ioctl_1(self->fd, args, "setfmt", SNDCTL_DSP_SETFMT);

}

static PyObject *

oss_getfmts(oss_audio_t *self, PyObject *unused)

{

    int mask;

    if (ioctl(self->fd, SNDCTL_DSP_GETFMTS, &mask) == -1)

        return PyErr_SetFromErrno(PyExc_IOError);

    return PyInt_FromLong(mask);

}

static PyObject *

oss_channels(oss_audio_t *self, PyObject *args)

{

    return _do_ioctl_1(self->fd, args, "channels", SNDCTL_DSP_CHANNELS);

}

static PyObject *

oss_speed(oss_audio_t *self, PyObject *args)

{

    return _do_ioctl_1(self->fd, args, "speed", SNDCTL_DSP_SPEED);

}

static PyObject *

oss_sync(oss_audio_t *self, PyObject *args)

{

    return _do_ioctl_0(self->fd, args, "sync", SNDCTL_DSP_SYNC);

}

static PyObject *

oss_reset(oss_audio_t *self, PyObject *args)

{

    return _do_ioctl_0(self->fd, args, "reset", SNDCTL_DSP_RESET);

}

static PyObject *

oss_post(oss_audio_t *self, PyObject *args)

{

    return _do_ioctl_0(self->fd, args, "post", SNDCTL_DSP_POST);

}

/* Regular file methods: read(), write(), close(), etc. as well

   as one convenience method, writeall(). */

static PyObject *

oss_read(oss_audio_t *self, PyObject *args)

{

    int size, count;

    char *cp;

    PyObject *rv;

    if (!PyArg_ParseTuple(args, "i:read", &size))

        return NULL;

    rv = PyString_FromStringAndSize(NULL, size);

    if (rv == NULL)

        return NULL;

    cp = PyString_AS_STRING(rv);

    Py_BEGIN_ALLOW_THREADS

    count = read(self->fd, cp, size);

    Py_END_ALLOW_THREADS

    if (count < 0) {

        PyErr_SetFromErrno(PyExc_IOError);

        Py_DECREF(rv);

        return NULL;

    }

    self->icount += count;

    _PyString_Resize(&rv, count);

    return rv;

}

static PyObject *

oss_write(oss_audio_t *self, PyObject *args)

{

    char *cp;

    int rv, size;

    if (!PyArg_ParseTuple(args, "s#:write", &cp, &size)) {

        return NULL;

    }

    Py_BEGIN_ALLOW_THREADS

    rv = write(self->fd, cp, size);

    Py_END_ALLOW_THREADS

    if (rv == -1) {

        return PyErr_SetFromErrno(PyExc_IOError);

    } else {

        self->ocount += rv;

    }

    return PyInt_FromLong(rv);

}

static PyObject *

oss_writeall(oss_audio_t *self, PyObject *args)

{

    char *cp;

    int rv, size;

    fd_set write_set_fds;

    int select_rv;

    /* NB. writeall() is only useful in non-blocking mode: according to

       Guenter Geiger <geiger@xdv.org> on the linux-audio-dev list

       (http://eca.cx/lad/2002/11/0380.html), OSS guarantees that

       write() in blocking mode consumes the whole buffer.  In blocking

       mode, the behaviour of write() and writeall() from Python is

       indistinguishable. */

    if (!PyArg_ParseTuple(args, "s#:write", &cp, &size))

        return NULL;

    /* use select to wait for audio device to be available */

    FD_ZERO(&write_set_fds);

    FD_SET(self->fd, &write_set_fds);

    while (size > 0) {

        Py_BEGIN_ALLOW_THREADS

        select_rv = select(self->fd+1, NULL, &write_set_fds, NULL, NULL);

        Py_END_ALLOW_THREADS

        assert(select_rv != 0);         /* no timeout, can't expire */

        if (select_rv == -1)

            return PyErr_SetFromErrno(PyExc_IOError);

        Py_BEGIN_ALLOW_THREADS

        rv = write(self->fd, cp, size);

        Py_END_ALLOW_THREADS

        if (rv == -1) {

            if (errno == EAGAIN) {      /* buffer is full, try again */

                errno = 0;

                continue;

            } else                      /* it's a real error */

                return PyErr_SetFromErrno(PyExc_IOError);

        } else {                        /* wrote rv bytes */

            self->ocount += rv;

            size -= rv;

            cp += rv;

        }

    }

    Py_INCREF(Py_None);

    return Py_None;

}

static PyObject *

oss_close(oss_audio_t *self, PyObject *unused)

{

    if (self->fd >= 0) {

        Py_BEGIN_ALLOW_THREADS

        close(self->fd);

        Py_END_ALLOW_THREADS

        self->fd = -1;

    }

    Py_INCREF(Py_None);

    return Py_None;

}

static PyObject *

oss_fileno(oss_audio_t *self, PyObject *unused)

{

    return PyInt_FromLong(self->fd);

}

/* Convenience methods: these generally wrap a couple of ioctls into one

   common task. */

static PyObject *

oss_setparameters(oss_audio_t *self, PyObject *args)

{

    int wanted_fmt, wanted_channels, wanted_rate, strict=0;

    int fmt, channels, rate;

    PyObject * rv;                    /* return tuple (fmt, channels, rate) */

    if (!PyArg_ParseTuple(args, "iii|i:setparameters",

                          &wanted_fmt, &wanted_channels, &wanted_rate,

                          &strict))

        return NULL;

    fmt = wanted_fmt;

    if (ioctl(self->fd, SNDCTL_DSP_SETFMT, &fmt) == -1) {

        return PyErr_SetFromErrno(PyExc_IOError);

    }

    if (strict && fmt != wanted_fmt) {

        return PyErr_Format

            (OSSAudioError,

             "unable to set requested format (wanted %d, got %d)",

             wanted_fmt, fmt);

    }

    channels = wanted_channels;

    if (ioctl(self->fd, SNDCTL_DSP_CHANNELS, &channels) == -1) {

        return PyErr_SetFromErrno(PyExc_IOError);

    }

    if (strict && channels != wanted_channels) {

        return PyErr_Format

            (OSSAudioError,

             "unable to set requested channels (wanted %d, got %d)",

             wanted_channels, channels);

    }

    rate = wanted_rate;

    if (ioctl(self->fd, SNDCTL_DSP_SPEED, &rate) == -1) {

        return PyErr_SetFromErrno(PyExc_IOError);

    }

    if (strict && rate != wanted_rate) {

        return PyErr_Format

            (OSSAudioError,

             "unable to set requested rate (wanted %d, got %d)",

             wanted_rate, rate);

    }

    /* Construct the return value: a (fmt, channels, rate) tuple that

       tells what the audio hardware was actually set to. */

    rv = PyTuple_New(3);