* Don't put the device in non-blocking mode at open() time; this makes

  it impossible to access blocking mode!

* Rename write() to writeall(), and add a write() method that just
  does one write().

* Rearrange/simplify writeall(): in particular, don't supply a timeout
  to select().  Let it block forever if it has to.

* Add a bunch of simple ioctl() wrappers: nonblock(), setfmt(),
  getfmts(), channels(), speed(), sync(), reset(), post().  These
  wrap, respectively, SNDCTL_DSP_NONBLOCK, SNDCTL_DSP_SETFMT,
  SNDCTL_DSP_GETFMTS, etc.

* Reduce flush() (which was a wrapper for the SNDCTL_DSP_SYNC ioctl) to
  an alias for sync().

* Rearrange the lad_methods list to reflect the order in which the
  methods are defined, and add some grouping comments.

1 files changed, 184 insertions, 46 deletions

diff --git a/Modules/ossaudiodev.c b/Modules/ossaudiodev.c
index 96f54af29b..7e9088b733 100644
--- a/Modules/ossaudiodev.c
+++ b/Modules/ossaudiodev.c
@@ -127,10 +127,6 @@ newladobject(PyObject *arg)
         PyErr_SetFromErrnoWithFilename(LinuxAudioError, basedev);
         return NULL;
     }
-    if (imode == O_WRONLY && ioctl(fd, SNDCTL_DSP_NONBLOCK, NULL) == -1) {
-        PyErr_SetFromErrnoWithFilename(LinuxAudioError, basedev);
-        return NULL;
-    }
     if (ioctl(fd, SNDCTL_DSP_GETFMTS, &afmts) == -1) {
         PyErr_SetFromErrnoWithFilename(LinuxAudioError, basedev);
         return NULL;
@@ -156,6 +152,123 @@ lad_dealloc(lad_t *xp)
     PyObject_Del(xp);
 }
 
+
+/* 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.
+*/
+
+
+/* _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(lad_t *self, PyObject *args, char *fname, int cmd)
+{
+    char argfmt[13] = "i:";
+    int arg;
+
+    assert(strlen(fname) <= 10);
+    strcat(argfmt, fname);
+    if (!PyArg_ParseTuple(args, argfmt, &arg))
+	return NULL;
+
+    if (ioctl(self->x_fd, cmd, &arg) == -1)
+        return PyErr_SetFromErrno(LinuxAudioError);
+    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(lad_t *self, PyObject *args, char *fname, int cmd)
+{
+    char argfmt[12] = ":";
+
+    assert(strlen(fname) <= 10);
+    strcat(argfmt, fname);
+    if (!PyArg_ParseTuple(args, argfmt))
+	return NULL;
+
+    if (ioctl(self->x_fd, cmd, 0) == -1)
+        return PyErr_SetFromErrno(LinuxAudioError);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+
+static PyObject *
+lad_nonblock(lad_t *self, PyObject *args)
+{
+    /* Hmmm: it doesn't appear to be possible to return to blocking
+       mode once we're in non-blocking mode! */
+    if (!PyArg_ParseTuple(args, ":nonblock"))
+	return NULL;
+    if (ioctl(self->x_fd, SNDCTL_DSP_NONBLOCK, NULL) == -1)
+        return PyErr_SetFromErrno(LinuxAudioError);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+lad_setfmt(lad_t *self, PyObject *args)
+{
+    return _do_ioctl_1(self, args, "setfmt", SNDCTL_DSP_SETFMT);
+}
+
+static PyObject *
+lad_getfmts(lad_t *self, PyObject *args)
+{
+    int mask;
+    if (!PyArg_ParseTuple(args, ":getfmts"))
+	return NULL;
+    if (ioctl(self->x_fd, SNDCTL_DSP_GETFMTS, &mask) == -1)
+        return PyErr_SetFromErrno(LinuxAudioError);
+    return PyInt_FromLong(mask);
+}
+
+static PyObject *
+lad_channels(lad_t *self, PyObject *args)
+{
+    return _do_ioctl_1(self, args, "channels", SNDCTL_DSP_CHANNELS);
+}
+
+static PyObject *
+lad_speed(lad_t *self, PyObject *args)
+{
+    return _do_ioctl_1(self, args, "speed", SNDCTL_DSP_SPEED);
+}
+
+static PyObject *
+lad_sync(lad_t *self, PyObject *args)
+{
+    return _do_ioctl_0(self, args, "sync", SNDCTL_DSP_SYNC);
+}
+    
+static PyObject *
+lad_reset(lad_t *self, PyObject *args)
+{
+    return _do_ioctl_0(self, args, "reset", SNDCTL_DSP_RESET);
+}
+    
+static PyObject *
+lad_post(lad_t *self, PyObject *args)
+{
+    return _do_ioctl_0(self, args, "post", SNDCTL_DSP_POST);
+}
+
+
+/* Regular file methods: read(), write(), close(), etc. as well
+   as one convenience method, writeall(). */
+
 static PyObject *
 lad_read(lad_t *self, PyObject *args)
 {
@@ -184,40 +297,58 @@ lad_write(lad_t *self, PyObject *args)
 {
     char *cp;
     int rv, size;
+
+    if (!PyArg_ParseTuple(args, "s#:write", &cp, &size)) {
+	return NULL;
+    }
+    if ((rv = write(self->x_fd, cp, size)) == -1) {
+        return PyErr_SetFromErrno(LinuxAudioError);
+    } else {
+        self->x_ocount += rv;
+    }
+    return PyInt_FromLong(rv);
+}
+
+static PyObject *
+lad_writeall(lad_t *self, PyObject *args)
+{
+    char *cp;
+    int rv, size;
     fd_set write_set_fds;
-    struct timeval tv;
-    int select_retval;
+    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;
+        return NULL;
 
     /* use select to wait for audio device to be available */
     FD_ZERO(&write_set_fds);
     FD_SET(self->x_fd, &write_set_fds);
-    tv.tv_sec = 4; /* timeout values */
-    tv.tv_usec = 0; 
 
     while (size > 0) {
-      select_retval = select(self->x_fd+1, NULL, &write_set_fds, NULL, &tv);
-      tv.tv_sec = 1; tv.tv_usec = 0; /* willing to wait this long next time*/
-      if (select_retval) {
-        if ((rv = write(self->x_fd, cp, size)) == -1) {
-	  if (errno != EAGAIN) {
-	    PyErr_SetFromErrno(LinuxAudioError);
-	    return NULL;
-	  } else {
-	    errno = 0; /* EAGAIN: buffer is full, try again */
-	  }
-        } else {
-	  self->x_ocount += rv;
-	  size -= rv;
-	  cp += rv;
-	}
-      } else {
-	/* printf("Not able to write to linux audio device within %ld seconds\n", tv.tv_sec); */
-	PyErr_SetFromErrno(LinuxAudioError);
-	return NULL;
-      }
+        select_rv = select(self->x_fd+1, NULL, &write_set_fds, NULL, NULL);
+        assert(select_rv != 0);         /* no timeout, can't expire */
+        if (select_rv == -1)
+            return PyErr_SetFromErrno(LinuxAudioError);
+
+        rv = write(self->x_fd, cp, size);
+        if (rv == -1) {
+            if (errno == EAGAIN) {      /* buffer is full, try again */
+                errno = 0;
+                continue;
+            } else                      /* it's a real error */
+                return PyErr_SetFromErrno(LinuxAudioError);
+        } else {                        /* wrote rv bytes */
+            self->x_ocount += rv;
+            size -= rv;
+            cp += rv;
+        }
     }
     Py_INCREF(Py_None);
     return Py_None;
@@ -245,6 +376,10 @@ lad_fileno(lad_t *self, PyObject *args)
     return PyInt_FromLong(self->x_fd);
 }
 
+
+/* Convenience methods: these generally wrap a couple of ioctls into one
+   common task. */
+
 static PyObject *
 lad_setparameters(lad_t *self, PyObject *args)
 {
@@ -410,20 +545,6 @@ lad_obuffree(lad_t *self, PyObject *args)
     return PyInt_FromLong(ai.bytes / (ssize * nchannels));
 }
 
-/* Flush the device */
-static PyObject *
-lad_flush(lad_t *self, PyObject *args)
-{
-    if (!PyArg_ParseTuple(args, ":flush")) return NULL;
-
-    if (ioctl(self->x_fd, SNDCTL_DSP_SYNC, NULL) == -1) {
-        PyErr_SetFromErrno(LinuxAudioError);
-        return NULL;
-    }
-    Py_INCREF(Py_None);
-    return Py_None;
-}
-
 static PyObject *
 lad_getptr(lad_t *self, PyObject *args)
 {
@@ -445,16 +566,33 @@ lad_getptr(lad_t *self, PyObject *args)
 }
 
 static PyMethodDef lad_methods[] = {
+    /* Regular file methods */
     { "read",		(PyCFunction)lad_read, METH_VARARGS },
     { "write",		(PyCFunction)lad_write, METH_VARARGS },
+    { "writeall",	(PyCFunction)lad_writeall, METH_VARARGS },
+    { "close",		(PyCFunction)lad_close, METH_VARARGS },
+    { "fileno",     	(PyCFunction)lad_fileno, METH_VARARGS },
+
+    /* Simple ioctl wrappers */
+    { "nonblock",       (PyCFunction)lad_nonblock, METH_VARARGS },
+    { "setfmt",		(PyCFunction)lad_setfmt, METH_VARARGS },
+    { "getfmts",        (PyCFunction)lad_getfmts, METH_VARARGS },
+    { "channels",       (PyCFunction)lad_channels, METH_VARARGS },
+    { "speed",          (PyCFunction)lad_speed, METH_VARARGS },
+    { "sync", 		(PyCFunction)lad_sync, METH_VARARGS },
+    { "reset", 		(PyCFunction)lad_reset, METH_VARARGS },
+    { "post", 		(PyCFunction)lad_post, METH_VARARGS },
+
+    /* Convenience methods -- wrap a couple of ioctls together */
     { "setparameters",	(PyCFunction)lad_setparameters, METH_VARARGS },
     { "bufsize",	(PyCFunction)lad_bufsize, METH_VARARGS },
     { "obufcount",	(PyCFunction)lad_obufcount, METH_VARARGS },
     { "obuffree",	(PyCFunction)lad_obuffree, METH_VARARGS },
-    { "flush",		(PyCFunction)lad_flush, METH_VARARGS },
-    { "close",		(PyCFunction)lad_close, METH_VARARGS },
-    { "fileno",     	(PyCFunction)lad_fileno, METH_VARARGS },
     { "getptr",         (PyCFunction)lad_getptr, METH_VARARGS },
+
+    /* Aliases for backwards compatibility */
+    { "flush",		(PyCFunction)lad_sync, METH_VARARGS },
+
     { NULL,		NULL}		/* sentinel */
 };