#define OLD_INTERFACE /* define for pre-Irix 6 interface */

#include "Python.h"

#include "stringobject.h"

#include <audio.h>

#include <stdarg.h>

#ifndef AL_NO_ELEM

#ifndef OLD_INTERFACE

#define OLD_INTERFACE

#endif /* OLD_INTERFACE */

#endif /* AL_NO_ELEM */

static PyObject *ErrorObject;

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

/* Declarations for objects of type port */

typedef struct {

PyObject_HEAD

/* XXXX Add your own stuff here */

ALport port;

} alpobject;

staticforward PyTypeObject Alptype;

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

/* Declarations for objects of type config */

typedef struct {

PyObject_HEAD

/* XXXX Add your own stuff here */

ALconfig config;

} alcobject;

staticforward PyTypeObject Alctype;

static void

ErrorHandler(long code, const char *fmt, ...)

{

va_list args;

char buf[128];

va_start(args, fmt);

vsprintf(buf, fmt, args);

va_end(args);

PyErr_SetString(ErrorObject, buf);

}

#ifdef AL_NO_ELEM /* IRIX 6 */

static PyObject *

param2python(int resource, int param, ALvalue value, ALparamInfo *pinfo)

{

ALparamInfo info;

PyObject *v;

if (pinfo == NULL) {

pinfo = &info;

if (alGetParamInfo(resource, param, &info) < 0)

return NULL;

}

switch (pinfo->elementType) {

case AL_PTR_ELEM:

/* XXXX don't know how to handle this */

case AL_NO_ELEM:

Py_INCREF(Py_None);

return Py_None;

case AL_INT32_ELEM:

case AL_RESOURCE_ELEM:

case AL_ENUM_ELEM:

return PyInt_FromLong((long) value.i);

case AL_INT64_ELEM:

return PyLong_FromLongLong(value.ll);

case AL_FIXED_ELEM:

return PyFloat_FromDouble(alFixedToDouble(value.ll));

case AL_CHAR_ELEM:

if (value.ptr == NULL) {

Py_INCREF(Py_None);

return Py_None;

}

return PyString_FromString((char *) value.ptr);

default:

PyErr_SetString(ErrorObject, "unknown element type");

return NULL;

}

}

static int

python2elem(PyObject *item, void *ptr, int elementType)

{

switch (elementType) {

case AL_INT32_ELEM:

case AL_RESOURCE_ELEM:

case AL_ENUM_ELEM:

if (!PyInt_Check(item)) {

PyErr_BadArgument();

return -1;

}

*((int *) ptr) = PyInt_AsLong(item);

break;

case AL_INT64_ELEM:

if (PyInt_Check(item))

*((long long *) ptr) = PyInt_AsLong(item);

else if (PyLong_Check(item))

*((long long *) ptr) = PyLong_AsLongLong(item);

else {

PyErr_BadArgument();

return -1;

}

break;

case AL_FIXED_ELEM:

if (PyInt_Check(item))

*((long long *) ptr) = alDoubleToFixed((double) PyInt_AsLong(item));

else if (PyFloat_Check(item))

*((long long *) ptr) = alDoubleToFixed(PyFloat_AsDouble(item));

else {

PyErr_BadArgument();

return -1;

}

break;

default:

PyErr_SetString(ErrorObject, "unknown element type");

return -1;

}

return 0;

}

static int

python2param(int resource, ALpv *param, PyObject *value, ALparamInfo *pinfo)

{

ALparamInfo info;

int i, stepsize;

PyObject *item;

if (pinfo == NULL) {

pinfo = &info;

if (alGetParamInfo(resource, param->param, &info) < 0)

return -1;

}

switch (pinfo->valueType) {

case AL_STRING_VAL:

if (pinfo->elementType != AL_CHAR_ELEM) {

PyErr_SetString(ErrorObject, "unknown element type");

return -1;

}

if (!PyString_Check(value)) {

PyErr_BadArgument();

return -1;

}

param->value.ptr = PyString_AS_STRING(value);

param->sizeIn = PyString_GET_SIZE(value)+1; /*account for NUL*/

break;

case AL_SET_VAL:

case AL_VECTOR_VAL:

if (!PyList_Check(value) && !PyTuple_Check(value)) {

PyErr_BadArgument();

return -1;

}

switch (pinfo->elementType) {

case AL_INT32_ELEM:

case AL_RESOURCE_ELEM:

case AL_ENUM_ELEM:

param->sizeIn = PySequence_Size(value);

param->value.ptr = PyMem_NEW(int, param->sizeIn);

stepsize = sizeof(int);

break;

case AL_INT64_ELEM:

case AL_FIXED_ELEM:

param->sizeIn = PySequence_Size(value);

param->value.ptr = PyMem_NEW(long long, param->sizeIn);

stepsize = sizeof(long long);

break;

}

for (i = 0; i < param->sizeIn; i++) {

item = PySequence_GetItem(value, i);

if (python2elem(item, (void *) ((char *) param->value.ptr + i*stepsize), pinfo->elementType) < 0) {

PyMem_DEL(param->value.ptr);

return -1;

}

}

break;

case AL_SCALAR_VAL:

switch (pinfo->elementType) {

case AL_INT32_ELEM:

case AL_RESOURCE_ELEM:

case AL_ENUM_ELEM:

return python2elem(value, (void *) &param->value.i,

pinfo->elementType);

case AL_INT64_ELEM:

case AL_FIXED_ELEM:

return python2elem(value, (void *) &param->value.ll,

pinfo->elementType);

default:

PyErr_SetString(ErrorObject, "unknown element type");

return -1;

}

}

return 0;

}

static int

python2params(int resource1, int resource2, PyObject *list, ALpv **pvsp, ALparamInfo **pinfop)

{

PyObject *item;

ALpv *pvs;

ALparamInfo *pinfo;

int npvs, i;

npvs = PyList_Size(list);

pvs = PyMem_NEW(ALpv, npvs);

pinfo = PyMem_NEW(ALparamInfo, npvs);

for (i = 0; i < npvs; i++) {

item = PyList_GetItem(list, i);

if (!PyArg_ParseTuple(item, "iO", &pvs[i].param, &item))

goto error;

if (alGetParamInfo(resource1, pvs[i].param, &pinfo[i]) < 0 &&

alGetParamInfo(resource2, pvs[i].param, &pinfo[i]) < 0)

goto error;

if (python2param(resource1, &pvs[i], item, &pinfo[i]) < 0)

goto error;

}

*pvsp = pvs;

*pinfop = pinfo;

return npvs;

error:

/* XXXX we should clean up everything */

if (pvs)

PyMem_DEL(pvs);

if (pinfo)

PyMem_DEL(pinfo);

return -1;

}

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

static PyObject *

SetConfig(alcobject *self, PyObject *args, int (*func)(ALconfig, int))

{

int par;

if (!PyArg_ParseTuple(args, "i:SetConfig", &par))

return NULL;

if ((*func)(self->config, par) == -1)

return NULL;

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *

GetConfig(alcobject *self, PyObject *args, int (*func)(ALconfig))

{

int par;

if (!PyArg_ParseTuple(args, ":GetConfig"))

return NULL;

if ((par = (*func)(self->config)) == -1)

return NULL;

return PyInt_FromLong((long) par);

}

static char alc_SetWidth__doc__[] =

"alSetWidth: set the wordsize for integer audio data."

;

static PyObject *

alc_SetWidth(alcobject *self, PyObject *args)

{

return SetConfig(self, args, alSetWidth);

}

static char alc_GetWidth__doc__[] =

"alGetWidth: get the wordsize for integer audio data."

;

static PyObject *

alc_GetWidth(alcobject *self, PyObject *args)

{

return GetConfig(self, args, alGetWidth);

}

static char alc_SetSampFmt__doc__[] =

"alSetSampFmt: set the sample format setting in an audio ALconfig structure."

;

static PyObject *

alc_SetSampFmt(alcobject *self, PyObject *args)

{

return SetConfig(self, args, alSetSampFmt);

}

static char alc_GetSampFmt__doc__[] =

"alGetSampFmt: get the sample format setting in an audio ALconfig structure."

;

static PyObject *

alc_GetSampFmt(alcobject *self, PyObject *args)

{

return GetConfig(self, args, alGetSampFmt);

}

static char alc_SetChannels__doc__[] =

"alSetChannels: set the channel settings in an audio ALconfig."

;

static PyObject *

alc_SetChannels(alcobject *self, PyObject *args)

{

return SetConfig(self, args, alSetChannels);

}

static char alc_GetChannels__doc__[] =

"alGetChannels: get the channel settings in an audio ALconfig."

;

static PyObject *

alc_GetChannels(alcobject *self, PyObject *args)

{

return GetConfig(self, args, alGetChannels);

}

static char alc_SetFloatMax__doc__[] =

"alSetFloatMax: set the maximum value of floating point sample data."

;

static PyObject *

alc_SetFloatMax(alcobject *self, PyObject *args)

{

double maximum_value;

if (!PyArg_ParseTuple(args, "d:SetFloatMax", &maximum_value))

return NULL;

if (alSetFloatMax(self->config, maximum_value) < 0)

return NULL;

Py_INCREF(Py_None);

return Py_None;

}

static char alc_GetFloatMax__doc__[] =

"alGetFloatMax: get the maximum value of floating point sample data."

;

static PyObject *

alc_GetFloatMax(alcobject *self, PyObject *args)

{

double maximum_value;

if (!PyArg_ParseTuple(args, ":GetFloatMax"))

return NULL;

if ((maximum_value = alGetFloatMax(self->config)) == 0)

return NULL;

return PyFloat_FromDouble(maximum_value);

}

static char alc_SetDevice__doc__[] =

"alSetDevice: set the device setting in an audio ALconfig structure."

;

static PyObject *

alc_SetDevice(alcobject *self, PyObject *args)

{

return SetConfig(self, args, alSetDevice);

}

static char alc_GetDevice__doc__[] =

"alGetDevice: get the device setting in an audio ALconfig structure."

;

static PyObject *

alc_GetDevice(alcobject *self, PyObject *args)

{

return GetConfig(self, args, alGetDevice);

}

static char alc_SetQueueSize__doc__[] =

"alSetQueueSize: set audio port buffer size."

;

static PyObject *

alc_SetQueueSize(alcobject *self, PyObject *args)

{

return SetConfig(self, args, alSetQueueSize);

}

static char alc_GetQueueSize__doc__[] =

"alGetQueueSize: get audio port buffer size."

;

static PyObject *

alc_GetQueueSize(alcobject *self, PyObject *args)

{

return GetConfig(self, args, alGetQueueSize);

}

#endif /* AL_NO_ELEM */

static PyObject *

setconfig(alcobject *self, PyObject *args, int (*func)(ALconfig, long))

{

long par;

if (!PyArg_ParseTuple(args, "l:SetConfig", &par))

return NULL;

if ((*func)(self->config, par) == -1)

return NULL;

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *

getconfig(alcobject *self, PyObject *args, long (*func)(ALconfig))

{

long par;

if (!PyArg_ParseTuple(args, ":GetConfig"))

return NULL;

if ((par = (*func)(self->config)) == -1)

return NULL;

return PyInt_FromLong((long) par);

}

static PyObject *

alc_setqueuesize (alcobject *self, PyObject *args)

{

return setconfig(self, args, ALsetqueuesize);

}

static PyObject *

alc_getqueuesize (alcobject *self, PyObject *args)

{

return getconfig(self, args, ALgetqueuesize);

}

static PyObject *

alc_setwidth (alcobject *self, PyObject *args)

{

return setconfig(self, args, ALsetwidth);

}

static PyObject *

alc_getwidth (alcobject *self, PyObject *args)

{

return getconfig(self, args, ALgetwidth);

}

static PyObject *

alc_getchannels (alcobject *self, PyObject *args)

{

return getconfig(self, args, ALgetchannels);

}

static PyObject *

alc_setchannels (alcobject *self, PyObject *args)

{

return setconfig(self, args, ALsetchannels);

}

#ifdef AL_405

static PyObject *

alc_getsampfmt (alcobject *self, PyObject *args)

{

return getconfig(self, args, ALgetsampfmt);

}

static PyObject *

alc_setsampfmt (alcobject *self, PyObject *args)

{

return setconfig(self, args, ALsetsampfmt);

}

static PyObject *

alc_getfloatmax(alcobject *self, PyObject *args)

{

double arg;

if (!PyArg_ParseTuple(args, ":GetFloatMax"))

return 0;

if ((arg = ALgetfloatmax(self->config)) == 0)

return NULL;

return PyFloat_FromDouble(arg);

}

static PyObject *

alc_setfloatmax(alcobject *self, PyObject *args)

{

double arg;

if (!PyArg_ParseTuple(args, "d:SetFloatMax", &arg))

return 0;

if (ALsetfloatmax(self->config, arg) == -1)

return NULL;

Py_INCREF(Py_None);

return Py_None;

}

#endif /* AL_405 */

static struct PyMethodDef alc_methods[] = {

#ifdef AL_NO_ELEM /* IRIX 6 */

{"SetWidth", (PyCFunction)alc_SetWidth, METH_VARARGS, alc_SetWidth__doc__},

{"GetWidth", (PyCFunction)alc_GetWidth, METH_VARARGS, alc_GetWidth__doc__},

{"SetSampFmt", (PyCFunction)alc_SetSampFmt, METH_VARARGS, alc_SetSampFmt__doc__},

{"GetSampFmt", (PyCFunction)alc_GetSampFmt, METH_VARARGS, alc_GetSampFmt__doc__},

{"SetChannels", (PyCFunction)alc_SetChannels, METH_VARARGS, alc_SetChannels__doc__},

{"GetChannels", (PyCFunction)alc_GetChannels, METH_VARARGS, alc_GetChannels__doc__},

{"SetFloatMax", (PyCFunction)alc_SetFloatMax, METH_VARARGS, alc_SetFloatMax__doc__},

{"GetFloatMax", (PyCFunction)alc_GetFloatMax, METH_VARARGS, alc_GetFloatMax__doc__},

{"SetDevice", (PyCFunction)alc_SetDevice, METH_VARARGS, alc_SetDevice__doc__},

{"GetDevice", (PyCFunction)alc_GetDevice, METH_VARARGS, alc_GetDevice__doc__},

{"SetQueueSize", (PyCFunction)alc_SetQueueSize, METH_VARARGS, alc_SetQueueSize__doc__},

{"GetQueueSize", (PyCFunction)alc_GetQueueSize, METH_VARARGS, alc_GetQueueSize__doc__},

#endif /* AL_NO_ELEM */

{"getqueuesize", (PyCFunction)alc_getqueuesize, METH_VARARGS},

{"setqueuesize", (PyCFunction)alc_setqueuesize, METH_VARARGS},

{"getwidth", (PyCFunction)alc_getwidth, METH_VARARGS},

{"setwidth", (PyCFunction)alc_setwidth, METH_VARARGS},

{"getchannels", (PyCFunction)alc_getchannels, METH_VARARGS},

{"setchannels", (PyCFunction)alc_setchannels, METH_VARARGS},

#ifdef AL_405

{"getsampfmt", (PyCFunction)alc_getsampfmt, METH_VARARGS},

{"setsampfmt", (PyCFunction)alc_setsampfmt, METH_VARARGS},

{"getfloatmax", (PyCFunction)alc_getfloatmax, METH_VARARGS},

{"setfloatmax", (PyCFunction)alc_setfloatmax, METH_VARARGS},

#endif /* AL_405 */

{NULL, NULL} /* sentinel */

};

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

static PyObject *

newalcobject(ALconfig config)

{

alcobject *self;

self = PyObject_New(alcobject, &Alctype);

if (self == NULL)

return NULL;

/* XXXX Add your own initializers here */

self->config = config;

return (PyObject *) self;

}

static void

alc_dealloc(alcobject *self)

{

/* XXXX Add your own cleanup code here */

#ifdef AL_NO_ELEM /* IRIX 6 */

(void) alFreeConfig(self->config); /* ignore errors */

#else

(void) ALfreeconfig(self->config); /* ignore errors */

#endif

PyObject_Del(self);

}

static PyObject *

alc_getattr(alcobject *self, char *name)

{

/* XXXX Add your own getattr code here */

return Py_FindMethod(alc_methods, (PyObject *)self, name);

}

static char Alctype__doc__[] =

""

;

static PyTypeObject Alctype = {

PyObject_HEAD_INIT(&PyType_Type)

0, /*ob_size*/

"al.config", /*tp_name*/

sizeof(alcobject), /*tp_basicsize*/

0, /*tp_itemsize*/

/* methods */

(destructor)alc_dealloc, /*tp_dealloc*/

(printfunc)0, /*tp_print*/

(getattrfunc)alc_getattr, /*tp_getattr*/

(setattrfunc)0, /*tp_setattr*/

(cmpfunc)0, /*tp_compare*/

(reprfunc)0, /*tp_repr*/

0, /*tp_as_number*/

0, /*tp_as_sequence*/

0, /*tp_as_mapping*/

(hashfunc)0, /*tp_hash*/

(ternaryfunc)0, /*tp_call*/

(reprfunc)0, /*tp_str*/

/* Space for future expansion */

0L,0L,0L,0L,

Alctype__doc__ /* Documentation string */

};

/* End of code for config objects */

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

#ifdef AL_NO_ELEM /* IRIX 6 */

static char alp_SetConfig__doc__[] =

"alSetConfig: set the ALconfig of an audio ALport."

;

static PyObject *

alp_SetConfig(alpobject *self, PyObject *args)

{

alcobject *config;

if (!PyArg_ParseTuple(args, "O!:SetConfig", &Alctype, &config))

return NULL;

if (alSetConfig(self->port, config->config) < 0)

return NULL;

Py_INCREF(Py_None);

return Py_None;

}

static char alp_GetConfig__doc__[] =

"alGetConfig: get the ALconfig of an audio ALport."

;

static PyObject *

alp_GetConfig(alpobject *self, PyObject *args)

{

ALconfig config;

if (!PyArg_ParseTuple(args, ":GetConfig"))

return NULL;

if ((config = alGetConfig(self->port)) == NULL)

return NULL;

return newalcobject(config);

}

static char alp_GetResource__doc__[] =

"alGetResource: get the resource associated with an audio port."

;

static PyObject *

alp_GetResource(alpobject *self, PyObject *args)

{

int resource;

if (!PyArg_ParseTuple(args, ":GetResource"))

return NULL;

if ((resource = alGetResource(self->port)) == 0)

return NULL;

return PyInt_FromLong((long) resource);

}

static char alp_GetFD__doc__[] =

"alGetFD: get the file descriptor for an audio port."

;

static PyObject *

alp_GetFD(alpobject *self, PyObject *args)

{

int fd;

if (!PyArg_ParseTuple(args, ":GetFD"))

return NULL;

if ((fd = alGetFD(self->port)) < 0)

return NULL;

return PyInt_FromLong((long) fd);

}

static char alp_GetFilled__doc__[] =

"alGetFilled: return the number of filled sample frames in an audio port."

;

static PyObject *

alp_GetFilled(alpobject *self, PyObject *args)

{

int filled;

if (!PyArg_ParseTuple(args, ":GetFilled"))

return NULL;

if ((filled = alGetFilled(self->port)) < 0)

return NULL;

return PyInt_FromLong((long) filled);

}

static char alp_GetFillable__doc__[] =

"alGetFillable: report the number of unfilled sample frames in an audio port."

;

static PyObject *

alp_GetFillable(alpobject *self, PyObject *args)

{

int fillable;

if (!PyArg_ParseTuple(args, ":GetFillable"))

return NULL;

if ((fillable = alGetFillable(self->port)) < 0)

return NULL;

return PyInt_FromLong((long) fillable);

}

static char alp_ReadFrames__doc__[] =

"alReadFrames: read sample frames from an audio port."

;

static PyObject *

alp_ReadFrames(alpobject *self, PyObject *args)

{

void *samples;

int framecount;

PyObject *v;

int size;

int ch;

ALconfig c;

if (!PyArg_ParseTuple(args, "i:ReadFrames", &framecount))

return NULL;

if (framecount < 0) {

PyErr_SetString(ErrorObject, "negative framecount");

return NULL;

}

c = alGetConfig(self->port);

switch (alGetSampFmt(c)) {

case AL_SAMPFMT_TWOSCOMP:

switch (alGetWidth(c)) {

case AL_SAMPLE_8:

size = 1;

break;

case AL_SAMPLE_16:

size = 2;

break;

case AL_SAMPLE_24:

size = 4;

break;

default:

PyErr_SetString(ErrorObject, "can't determine width");

alFreeConfig(c);

return NULL;

}

break;

case AL_SAMPFMT_FLOAT:

size = 4;

break;

case AL_SAMPFMT_DOUBLE:

size = 8;

break;

default:

PyErr_SetString(ErrorObject, "can't determine format");

alFreeConfig(c);

return NULL;

}

ch = alGetChannels(c);

alFreeConfig(c);

if (ch < 0) {

PyErr_SetString(ErrorObject, "can't determine # of channels");

return NULL;

}

size *= ch;

v = PyString_FromStringAndSize((char *) NULL, size * framecount);

if (v == NULL)

return NULL;

Py_BEGIN_ALLOW_THREADS

alReadFrames(self->port, (void *) PyString_AS_STRING(v), framecount);

Py_END_ALLOW_THREADS

return v;

}

static char alp_DiscardFrames__doc__[] =

"alDiscardFrames: discard audio from an audio port."

;

static PyObject *

alp_DiscardFrames(alpobject *self, PyObject *args)

{

int framecount;

if (!PyArg_ParseTuple(args, "i:DiscardFrames", &framecount))

return NULL;

Py_BEGIN_ALLOW_THREADS

framecount = alDiscardFrames(self->port, framecount);

Py_END_ALLOW_THREADS

if (framecount < 0)

return NULL;

return PyInt_FromLong((long) framecount);

}

static char alp_ZeroFrames__doc__[] =

"alZeroFrames: write zero-valued sample frames to an audio port."

;

static PyObject *

alp_ZeroFrames(alpobject *self, PyObject *args)

{

int framecount;

if (!PyArg_ParseTuple(args, "i:ZeroFrames", &framecount))

return NULL;

if (framecount < 0) {

PyErr_SetString(ErrorObject, "negative framecount");

return NULL;

}

Py_BEGIN_ALLOW_THREADS

alZeroFrames(self->port, framecount);

Py_END_ALLOW_THREADS

Py_INCREF(Py_None);

return Py_None;

}

static char alp_SetFillPoint__doc__[] =

"alSetFillPoint: set low- or high-water mark for an audio port."

;

static PyObject *

alp_SetFillPoint(alpobject *self, PyObject *args)

{

int fillpoint;

if (!PyArg_ParseTuple(args, "i:SetFillPoint", &fillpoint))

return NULL;

if (alSetFillPoint(self->port, fillpoint) < 0)

return NULL;

Py_INCREF(Py_None);

return Py_None;

}

static char alp_GetFillPoint__doc__[] =

"alGetFillPoint: get low- or high-water mark for an audio port."

;

static PyObject *

alp_GetFillPoint(alpobject *self, PyObject *args)

{

int fillpoint;

if (!PyArg_ParseTuple(args, ":GetFillPoint"))

return NULL;

if ((fillpoint = alGetFillPoint(self->port)) < 0)

return NULL;

return PyInt_FromLong((long) fillpoint);

}

static char alp_GetFrameNumber__doc__[] =

"alGetFrameNumber: get the absolute sample frame number associated with a port."

;

static PyObject *

alp_GetFrameNumber(alpobject *self, PyObject *args)

{

stamp_t fnum;

if (!PyArg_ParseTuple(args, ":GetFrameNumber"))

return NULL;

if (alGetFrameNumber(self->port, &fnum) < 0)

return NULL;

return PyLong_FromLongLong((long long) fnum);

}

static char alp_GetFrameTime__doc__[] =

"alGetFrameTime: get the time at which a sample frame came in or will go out."

;

static PyObject *

alp_GetFrameTime(alpobject *self, PyObject *args)

{

stamp_t fnum, time;

PyObject *ret, *v0, *v1;

if (!PyArg_ParseTuple(args, ":GetFrameTime"))

return NULL;

if (alGetFrameTime(self->port, &fnum, &time) < 0)

return NULL;

v0 = PyLong_FromLongLong((long long) fnum);

v1 = PyLong_FromLongLong((long long) time);

if (PyErr_Occurred()) {

Py_XDECREF(v0);

Py_XDECREF(v1);

return NULL;

}

ret = Py_BuildValue("(OO)", v0, v1);

Py_DECREF(v0);

Py_DECREF(v1);

return ret;

}

static char alp_WriteFrames__doc__[] =

"alWriteFrames: write sample frames to an audio port."

;

static PyObject *

alp_WriteFrames(alpobject *self, PyObject *args)

{

char *samples;

int length;

int size, ch;

ALconfig c;

if (!PyArg_ParseTuple(args, "s#:WriteFrames", &samples, &length))

return NULL;

c = alGetConfig(self->port);

switch (alGetSampFmt(c)) {

case AL_SAMPFMT_TWOSCOMP:

switch (alGetWidth(c)) {

case AL_SAMPLE_8:

size = 1;

break;

case AL_SAMPLE_16:

size = 2;

break;

case AL_SAMPLE_24:

size = 4;

break;

default:

PyErr_SetString(ErrorObject, "can't determine width");

alFreeConfig(c);

return NULL;

}

break;

case AL_SAMPFMT_FLOAT:

size = 4;

break;

case AL_SAMPFMT_DOUBLE:

size = 8;

break;

default:

PyErr_SetString(ErrorObject, "can't determine format");

alFreeConfig(c);

return NULL;

}

ch = alGetChannels(c);

alFreeConfig(c);

if (ch < 0) {

PyErr_SetString(ErrorObject, "can't determine # of channels");

return NULL;

}

size *= ch;

if (length % size != 0) {

PyErr_SetString(ErrorObject,

"buffer length not whole number of frames");

return NULL;

}

Py_BEGIN_ALLOW_THREADS

alWriteFrames(self->port, (void *) samples, length / size);

Py_END_ALLOW_THREADS

Py_INCREF(Py_None);

return Py_None;

}

static char alp_ClosePort__doc__[] =