Stowage/cpython
2
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-10-31 13:41:24 +00:00
Code Issues Projects Releases Packages Wiki Activity
cpython/Modules/almodule.c
Guido van Rossum 09ac088152 The call to PyArg_ParseTuple in al_Connect had one too few arguments. 
This fixes PR#157.
1999-12-10 15:12:11 +00:00

3418 lines
81 KiB
C
Raw Blame History

/***********************************************************
Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
The Netherlands.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the names of Stichting Mathematisch
Centrum or CWI or Corporation for National Research Initiatives or
CNRI not be used in advertising or publicity pertaining to
distribution of the software without specific, written prior
permission.
While CWI is the initial source for this software, a modified version
is made available by the Corporation for National Research Initiatives
(CNRI) at the Internet address ftp://ftp.python.org.
STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
******************************************************************/
#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_Length(value);
param->value.ptr = PyMem_NEW(int, param->sizeIn);
stepsize = sizeof(int);
break;
case AL_INT64_ELEM:
case AL_FIXED_ELEM:
param->sizeIn = PySequence_Length(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(self, args, func)
alcobject *self;
PyObject *args;
int (*func)(ALconfig, int);
{
int par;
if (!PyArg_ParseTuple(args, "i", &par))
return NULL;
if ((*func)(self->config, par) == -1)
return NULL;
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
GetConfig(self, args, func)
alcobject *self;
PyObject *args;
int (*func)(ALconfig);
{
int par;
if (!PyArg_ParseTuple(args, ""))
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(self, args)
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(self, args)
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(self, args)
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(self, args)
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(self, args)
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(self, args)
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(self, args)
alcobject *self;
PyObject *args;
{
double maximum_value;
if (!PyArg_ParseTuple(args, "d", &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(self, args)
alcobject *self;
PyObject *args;
{
double maximum_value;
if (!PyArg_ParseTuple(args, ""))
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(self, args)
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(self, args)
alcobject *self;
PyObject *args;
{
return GetConfig(self, args, alGetDevice);
}
static char alc_SetQueueSize__doc__[] =
"alSetQueueSize: set audio port buffer size."
;
static PyObject *
alc_SetQueueSize(self, args)
alcobject *self;
PyObject *args;
{
return SetConfig(self, args, alSetQueueSize);
}
static char alc_GetQueueSize__doc__[] =
"alGetQueueSize: get audio port buffer size."
;
static PyObject *
alc_GetQueueSize(self, args)
alcobject *self;
PyObject *args;
{
return GetConfig(self, args, alGetQueueSize);
}
#endif /* AL_NO_ELEM */
static PyObject *
setconfig(self, args, func)
alcobject *self;
PyObject *args;
int (*func)(ALconfig, long);
{
long par;
if (!PyArg_ParseTuple(args, "l", &par))
return NULL;
if ((*func)(self->config, par) == -1)
return NULL;
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
getconfig(self, args, func)
alcobject *self;
PyObject *args;
long (*func)(ALconfig);
{
long par;
if (!PyArg_ParseTuple(args, ""))
return NULL;
if ((par = (*func)(self->config)) == -1)
return NULL;
return PyInt_FromLong((long) par);
}
static PyObject *
alc_setqueuesize (self, args)
alcobject *self;
PyObject *args;
{
return setconfig(self, args, ALsetqueuesize);
}
static PyObject *
alc_getqueuesize (self, args)
alcobject *self;
PyObject *args;
{
return getconfig(self, args, ALgetqueuesize);
}
static PyObject *
alc_setwidth (self, args)
alcobject *self;
PyObject *args;
{
return setconfig(self, args, ALsetwidth);
}
static PyObject *
alc_getwidth (self, args)
alcobject *self;
PyObject *args;
{
return getconfig(self, args, ALgetwidth);
}
static PyObject *
alc_getchannels (self, args)
alcobject *self;
PyObject *args;
{
return getconfig(self, args, ALgetchannels);
}
static PyObject *
alc_setchannels (self, args)
alcobject *self;
PyObject *args;
{
return setconfig(self, args, ALsetchannels);
}
#ifdef AL_405
static PyObject *
alc_getsampfmt (self, args)
alcobject *self;
PyObject *args;
{
return getconfig(self, args, ALgetsampfmt);
}
static PyObject *
alc_setsampfmt (self, args)
alcobject *self;
PyObject *args;
{
return setconfig(self, args, ALsetsampfmt);
}
static PyObject *
alc_getfloatmax(self, args)
alcobject *self;
PyObject *args;
{
double arg;
if (!PyArg_ParseTuple(args, ""))
return 0;
if ((arg = ALgetfloatmax(self->config)) == 0)
return NULL;
return PyFloat_FromDouble(arg);
}
static PyObject *
alc_setfloatmax(self, args)
alcobject *self;
PyObject *args;
{
double arg;
if (!PyArg_ParseTuple(args, "d", &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(self)
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
PyMem_DEL(self);
}
static PyObject *
alc_getattr(self, name)
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*/
"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(self, args)
alpobject *self;
PyObject *args;
{
alcobject *config;
if (!PyArg_ParseTuple(args, "O!", &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(self, args)
alpobject *self;
PyObject *args;
{
ALconfig config;
if (!PyArg_ParseTuple(args, ""))
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(self, args)
alpobject *self;
PyObject *args;
{
int resource;
if (!PyArg_ParseTuple(args, ""))
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(self, args)
alpobject *self;
PyObject *args;
{
int fd;
if (!PyArg_ParseTuple(args, ""))
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(self, args)
alpobject *self;
PyObject *args;
{
int filled;
if (!PyArg_ParseTuple(args, ""))
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(self, args)
alpobject *self;
PyObject *args;
{
int fillable;
if (!PyArg_ParseTuple(args, ""))
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(self, args)
alpobject *self;
PyObject *args;
{
void *samples;
int framecount;
PyObject *v;
int size;
int ch;
ALconfig c;
if (!PyArg_ParseTuple(args, "i", &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(self, args)
alpobject *self;
PyObject *args;
{
int framecount;
if (!PyArg_ParseTuple(args, "i", &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(self, args)
alpobject *self;
PyObject *args;
{
int framecount;
if (!PyArg_ParseTuple(args, "i", &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(self, args)
alpobject *self;
PyObject *args;
{
int fillpoint;
if (!PyArg_ParseTuple(args, "i", &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(self, args)
alpobject *self;
PyObject *args;
{
int fillpoint;
if (!PyArg_ParseTuple(args, ""))
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(self, args)
alpobject *self;
PyObject *args;
{
stamp_t fnum;
if (!PyArg_ParseTuple(args, ""))
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(self, args)
alpobject *self;
PyObject *args;
{
stamp_t fnum, time;
PyObject *ret, *v0, *v1;
if (!PyArg_ParseTuple(args, ""))
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(self, args)
alpobject *self;
PyObject *args;
{
char *samples;
int length;
int size, ch;
ALconfig c;
if (!PyArg_ParseTuple(args, "s#", &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__[] =
"alClosePort: close an audio port."
;
static PyObject *
alp_ClosePort(self, args)
alpobject *self;
PyObject *args;
{
if (!PyArg_ParseTuple(args, ""))
return NULL;
if (alClosePort(self->port) < 0)
return NULL;
self->port = NULL;
Py_INCREF(Py_None);
return Py_None;
}
#endif /* AL_NO_ELEM */
#ifdef OLD_INTERFACE
static PyObject *
alp_closeport(self, args)
alpobject *self;
PyObject *args;
{
if (!PyArg_ParseTuple(args, ""))
return NULL;
if (ALcloseport(self->port) < 0)
return NULL;
self->port = NULL;
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
alp_getfd (self, args)
alpobject *self;
PyObject *args;
{
int fd;
if (!PyArg_ParseTuple(args, ""))
return NULL;
if ((fd = ALgetfd(self-> port)) == -1)
return NULL;
return PyInt_FromLong(fd);
}
static PyObject *
alp_getfilled(self, args)
alpobject *self;
PyObject *args;
{
long count;
if (!PyArg_ParseTuple(args, ""))
return NULL;
if ((count = ALgetfilled(self-> port)) == -1)
return NULL;
return PyInt_FromLong(count);
}
static PyObject *
alp_getfillable(self, args)
alpobject *self;
PyObject *args;
{
long count;
if (!PyArg_ParseTuple(args, ""))
return NULL;
if ((count = ALgetfillable(self-> port)) == -1)
return NULL;
return PyInt_FromLong (count);
}
static PyObject *
alp_readsamps(self, args)
alpobject *self;
PyObject *args;
{
long count;
PyObject *v;
ALconfig c;
int width;
int ret;
if (!PyArg_ParseTuple(args, "l", &count))
return NULL;
if (count <= 0) {
PyErr_SetString(ErrorObject, "al.readsamps : arg <= 0");
return NULL;
}
c = ALgetconfig(self->port);
#ifdef AL_405
width = ALgetsampfmt(c);
if (width == AL_SAMPFMT_FLOAT)
width = sizeof(float);
else if (width == AL_SAMPFMT_DOUBLE)
width = sizeof(double);
else
width = ALgetwidth(c);
#else
width = ALgetwidth(c);
#endif /* AL_405 */
ALfreeconfig(c);
v = PyString_FromStringAndSize((char *)NULL, width * count);
if (v == NULL)
return NULL;
Py_BEGIN_ALLOW_THREADS
ret = ALreadsamps(self->port, (void *) PyString_AsString(v), count);
Py_END_ALLOW_THREADS
if (ret == -1) {
Py_DECREF(v);
return NULL;
}
return (v);
}
static PyObject *
alp_writesamps(self, args)
alpobject *self;
PyObject *args;
{
char *buf;
int size, width;
ALconfig c;
int ret;
if (!PyArg_ParseTuple(args, "s#", &buf, &size))
return NULL;
c = ALgetconfig(self->port);
#ifdef AL_405
width = ALgetsampfmt(c);
if (width == AL_SAMPFMT_FLOAT)
width = sizeof(float);
else if (width == AL_SAMPFMT_DOUBLE)
width = sizeof(double);
else
width = ALgetwidth(c);
#else
width = ALgetwidth(c);
#endif /* AL_405 */
ALfreeconfig(c);
Py_BEGIN_ALLOW_THREADS
ret = ALwritesamps (self->port, (void *) buf, (long) size / width);
Py_END_ALLOW_THREADS
if (ret == -1)
return NULL;
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
alp_getfillpoint(self, args)
alpobject *self;
PyObject *args;
{
long count;
if (!PyArg_ParseTuple(args, ""))
return NULL;
if ((count = ALgetfillpoint(self->port)) == -1)
return NULL;
return PyInt_FromLong(count);
}
static PyObject *
alp_setfillpoint (self, args)
alpobject *self;
PyObject *args;
{
long count;
if (!PyArg_ParseTuple(args, "l", &count))
return NULL;
if (ALsetfillpoint(self->port, count) == -1)
return NULL;
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
alp_setconfig(self, args)
alpobject *self;
PyObject *args;
{
alcobject *config;
if (!PyArg_ParseTuple(args, "O!", &Alctype, &config))
return NULL;
if (ALsetconfig(self->port, config->config) == -1)
return NULL;
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
alp_getconfig(self, args)
alpobject *self;
PyObject *args;
{
ALconfig config;
if (!PyArg_ParseTuple(args, ""))
return NULL;
config = ALgetconfig(self->port);
if (config == NULL)
return NULL;
return newalcobject(config);
}
#ifdef AL_405
static PyObject *
alp_getstatus(self, args)
alpobject *self;
PyObject *args;
{
PyObject *list, *v;
long *PVbuffer;
long length;
int i;
if (!PyArg_Parse(args, "O!", &PyList_Type, &list))
return NULL;
length = PyList_Size(list);
PVbuffer = PyMem_NEW(long, length);
if (PVbuffer == NULL)
return PyErr_NoMemory();
for (i = 0; i < length; i++) {
v = PyList_GetItem(list, i);
if (!PyInt_Check(v)) {
PyMem_DEL(PVbuffer);
PyErr_BadArgument();
return NULL;
}
PVbuffer[i] = PyInt_AsLong(v);
}
if (ALgetstatus(self->port, PVbuffer, length) == -1)
return NULL;
for (i = 0; i < length; i++)
PyList_SetItem(list, i, PyInt_FromLong(PVbuffer[i]));
PyMem_DEL(PVbuffer);
Py_INCREF(Py_None);
return Py_None;
}
#endif /* AL_405 */
#endif /* OLD_INTERFACE */
static struct PyMethodDef alp_methods[] = {
#ifdef AL_NO_ELEM /* IRIX 6 */
{"SetConfig", (PyCFunction)alp_SetConfig, METH_VARARGS, alp_SetConfig__doc__},
{"GetConfig", (PyCFunction)alp_GetConfig, METH_VARARGS, alp_GetConfig__doc__},
{"GetResource", (PyCFunction)alp_GetResource, METH_VARARGS, alp_GetResource__doc__},
{"GetFD", (PyCFunction)alp_GetFD, METH_VARARGS, alp_GetFD__doc__},
{"GetFilled", (PyCFunction)alp_GetFilled, METH_VARARGS, alp_GetFilled__doc__},
{"GetFillable", (PyCFunction)alp_GetFillable, METH_VARARGS, alp_GetFillable__doc__},
{"ReadFrames", (PyCFunction)alp_ReadFrames, METH_VARARGS, alp_ReadFrames__doc__},
{"DiscardFrames", (PyCFunction)alp_DiscardFrames, METH_VARARGS, alp_DiscardFrames__doc__},
{"ZeroFrames", (PyCFunction)alp_ZeroFrames, METH_VARARGS, alp_ZeroFrames__doc__},
{"SetFillPoint", (PyCFunction)alp_SetFillPoint, METH_VARARGS, alp_SetFillPoint__doc__},
{"GetFillPoint", (PyCFunction)alp_GetFillPoint, METH_VARARGS, alp_GetFillPoint__doc__},
{"GetFrameNumber", (PyCFunction)alp_GetFrameNumber, METH_VARARGS, alp_GetFrameNumber__doc__},
{"GetFrameTime", (PyCFunction)alp_GetFrameTime, METH_VARARGS, alp_GetFrameTime__doc__},
{"WriteFrames", (PyCFunction)alp_WriteFrames, METH_VARARGS, alp_WriteFrames__doc__},
{"ClosePort", (PyCFunction)alp_ClosePort, METH_VARARGS, alp_ClosePort__doc__},
#endif /* AL_NO_ELEM */
#ifdef OLD_INTERFACE
{"closeport", (PyCFunction)alp_closeport, METH_VARARGS},
{"getfd", (PyCFunction)alp_getfd, METH_VARARGS},
{"fileno", (PyCFunction)alp_getfd, METH_VARARGS},
{"getfilled", (PyCFunction)alp_getfilled, METH_VARARGS},
{"getfillable", (PyCFunction)alp_getfillable, METH_VARARGS},
{"readsamps", (PyCFunction)alp_readsamps, METH_VARARGS},
{"writesamps", (PyCFunction)alp_writesamps, METH_VARARGS},
{"setfillpoint", (PyCFunction)alp_setfillpoint, METH_VARARGS},
{"getfillpoint", (PyCFunction)alp_getfillpoint, METH_VARARGS},
{"setconfig", (PyCFunction)alp_setconfig, METH_VARARGS},
{"getconfig", (PyCFunction)alp_getconfig, METH_VARARGS},
#ifdef AL_405
{"getstatus", (PyCFunction)alp_getstatus, METH_VARARGS},
#endif /* AL_405 */
#endif /* OLD_INTERFACE */
{NULL, NULL} /* sentinel */
};
/* ---------- */
static PyObject *
newalpobject(ALport port)
{
alpobject *self;
self = PyObject_NEW(alpobject, &Alptype);
if (self == NULL)
return NULL;
/* XXXX Add your own initializers here */
self->port = port;
return (PyObject *) self;
}
static void
alp_dealloc(self)
alpobject *self;
{
/* XXXX Add your own cleanup code here */
if (self->port) {
#ifdef AL_NO_ELEM /* IRIX 6 */
alClosePort(self->port);
#else
ALcloseport(self->port);
#endif
}
PyMem_DEL(self);
}
static PyObject *
alp_getattr(self, name)
alpobject *self;
char *name;
{
/* XXXX Add your own getattr code here */
if (self->port == NULL) {
PyErr_SetString(ErrorObject, "port already closed");
return NULL;
}
return Py_FindMethod(alp_methods, (PyObject *)self, name);
}
static char Alptype__doc__[] =
""
;
static PyTypeObject Alptype = {
PyObject_HEAD_INIT(&PyType_Type)
0, /*ob_size*/
"port", /*tp_name*/
sizeof(alpobject), /*tp_basicsize*/
0, /*tp_itemsize*/
/* methods */
(destructor)alp_dealloc, /*tp_dealloc*/
(printfunc)0, /*tp_print*/
(getattrfunc)alp_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,
Alptype__doc__ /* Documentation string */
};
/* End of code for port objects */
/* -------------------------------------------------------- */
#ifdef AL_NO_ELEM /* IRIX 6 */
static char al_NewConfig__doc__[] =
"alNewConfig: create and initialize an audio ALconfig structure."
;
static PyObject *
al_NewConfig(self, args)
PyObject *self; /* Not used */
PyObject *args;
{
ALconfig config;
if (!PyArg_ParseTuple(args, ""))
return NULL;
if ((config = alNewConfig()) == NULL)
return NULL;
return newalcobject(config);
}
static char al_OpenPort__doc__[] =
"alOpenPort: open an audio port."
;
static PyObject *
al_OpenPort(self, args)
PyObject *self; /* Not used */
PyObject *args;
{
ALport port;
char *name, *dir;
alcobject *config = NULL;
if (!PyArg_ParseTuple(args, "ss|O!", &name, &dir, &Alctype, &config))
return NULL;
if ((port = alOpenPort(name, dir, config ? config->config : NULL)) == NULL)
return NULL;
return newalpobject(port);
}
static char al_Connect__doc__[] =
"alConnect: connect two audio I/O resources."
;
static PyObject *
al_Connect(self, args)
PyObject *self; /* Not used */
PyObject *args;
{
int source, dest, nprops = 0, id, i;
ALpv *props = NULL;
ALparamInfo *propinfo = NULL;
PyObject *propobj = NULL;
if (!PyArg_ParseTuple(args, "ii|O!", &source, &dest, &PyList_Type, &propobj))
return NULL;
if (propobj != NULL) {
nprops = python2params(source, dest, propobj, &props, &propinfo);
if (nprops < 0)
return NULL;
}
id = alConnect(source, dest, props, nprops);
if (props) {
for (i = 0; i < nprops; i++) {
switch (propinfo[i].valueType) {
case AL_SET_VAL:
case AL_VECTOR_VAL:
PyMem_DEL(props[i].value.ptr);
break;
}
}
PyMem_DEL(props);
PyMem_DEL(propinfo);
}
if (id < 0)
return NULL;
return PyInt_FromLong((long) id);
}
static char al_Disconnect__doc__[] =
"alDisconnect: delete a connection between two audio I/O resources."
;
static PyObject *
al_Disconnect(self, args)
PyObject *self; /* Not used */
PyObject *args;
{
int res;
if (!PyArg_ParseTuple(args, "i", &res))
return NULL;
if (alDisconnect(res) < 0)
return NULL;
Py_INCREF(Py_None);
return Py_None;
}
static char al_GetParams__doc__[] =
"alGetParams: get the values of audio resource parameters."
;
static PyObject *
al_GetParams(self, args)
PyObject *self; /* Not used */
PyObject *args;
{
int resource;
PyObject *pvslist, *item = NULL, *v = NULL;
ALpv *pvs;
int i, j, npvs;
ALparamInfo *pinfo;
if (!PyArg_ParseTuple(args, "iO!", &resource, &PyList_Type, &pvslist))
return NULL;
npvs = PyList_Size(pvslist);
pvs = PyMem_NEW(ALpv, npvs);
pinfo = PyMem_NEW(ALparamInfo, npvs);
for (i = 0; i < npvs; i++) {
item = PyList_GetItem(pvslist, i);
if (!PyInt_Check(item)) {
item = NULL;
PyErr_SetString(ErrorObject, "list of integers expected");
goto error;
}
pvs[i].param = (int) PyInt_AsLong(item);
item = NULL; /* not needed anymore */
if (alGetParamInfo(resource, pvs[i].param, &pinfo[i]) < 0)
goto error;
switch (pinfo[i].valueType) {
case AL_NO_VAL:
break;
case AL_MATRIX_VAL:
pinfo[i].maxElems *= pinfo[i].maxElems2;
/* fall through */
case AL_STRING_VAL:
case AL_SET_VAL:
case AL_VECTOR_VAL:
switch (pinfo[i].elementType) {
case AL_INT32_ELEM:
case AL_RESOURCE_ELEM:
case AL_ENUM_ELEM:
pvs[i].value.ptr = PyMem_NEW(int, pinfo[i].maxElems);
pvs[i].sizeIn = pinfo[i].maxElems;
break;
case AL_INT64_ELEM:
case AL_FIXED_ELEM:
pvs[i].value.ptr = PyMem_NEW(long long, pinfo[i].maxElems);
pvs[i].sizeIn = pinfo[i].maxElems;
break;
case AL_CHAR_ELEM:
pvs[i].value.ptr = PyMem_NEW(char, 32);
pvs[i].sizeIn = 32;
break;
case AL_NO_ELEM:
case AL_PTR_ELEM:
default:
PyErr_SetString(ErrorObject, "internal error");
goto error;
}
break;
case AL_SCALAR_VAL:
break;
default:
PyErr_SetString(ErrorObject, "internal error");
goto error;
}
if (pinfo[i].valueType == AL_MATRIX_VAL) {
pinfo[i].maxElems /= pinfo[i].maxElems2;
pvs[i].sizeIn /= pinfo[i].maxElems2;
pvs[i].size2In = pinfo[i].maxElems2;
}
}
if (alGetParams(resource, pvs, npvs) < 0)
goto error;
v = PyList_New(npvs);
for (i = 0; i < npvs; i++) {
if (pvs[i].sizeOut < 0) {
char buf[32];
sprintf(buf, "problem with param %d", i);
PyErr_SetString(ErrorObject, buf);
goto error;
}
switch (pinfo[i].valueType) {
case AL_NO_VAL:
item = Py_None;
Py_INCREF(item);
break;
case AL_STRING_VAL:
item = PyString_FromString(pvs[i].value.ptr);
PyMem_DEL(pvs[i].value.ptr);
break;
case AL_MATRIX_VAL:
/* XXXX this is not right */
pvs[i].sizeOut *= pvs[i].size2Out;
/* fall through */
case AL_SET_VAL:
case AL_VECTOR_VAL:
item = PyList_New(pvs[i].sizeOut);
for (j = 0; j < pvs[i].sizeOut; j++) {
switch (pinfo[i].elementType) {
case AL_INT32_ELEM:
case AL_RESOURCE_ELEM:
case AL_ENUM_ELEM:
PyList_SetItem(item, j, PyInt_FromLong((long) ((int *) pvs[i].value.ptr)[j]));
break;
case AL_INT64_ELEM:
PyList_SetItem(item, j, PyLong_FromLongLong(((long long *) pvs[i].value.ptr)[j]));
break;
case AL_FIXED_ELEM:
PyList_SetItem(item, j, PyFloat_FromDouble(alFixedToDouble(((long long *) pvs[i].value.ptr)[j])));
break;
default:
PyErr_SetString(ErrorObject, "internal error");
goto error;
}
}
PyMem_DEL(pvs[i].value.ptr);
break;
case AL_SCALAR_VAL:
item = param2python(resource, pvs[i].param, pvs[i].value, &pinfo[i]);
break;
}
if (PyErr_Occurred() ||
PyList_SetItem(v, i, Py_BuildValue("(iO)", pvs[i].param,
item)) < 0 ||
PyErr_Occurred())
goto error;
Py_DECREF(item);
}
PyMem_DEL(pvs);
PyMem_DEL(pinfo);
return v;
error:
Py_XDECREF(v);
Py_XDECREF(item);
if (pvs)
PyMem_DEL(pvs);
if (pinfo)
PyMem_DEL(pinfo);
return NULL;
}
static char al_SetParams__doc__[] =
"alSetParams: set the values of audio resource parameters."
;
static PyObject *
al_SetParams(self, args)
PyObject *self; /* Not used */
PyObject *args;
{
int resource;
PyObject *pvslist, *item;
ALpv *pvs;
ALparamInfo *pinfo;
int npvs, i;
if (!PyArg_ParseTuple(args, "iO!", &resource, &PyList_Type, &pvslist))
return NULL;
npvs = python2params(resource, -1, pvslist, &pvs, &pinfo);
if (npvs < 0)
return NULL;
if (alSetParams(resource, pvs, npvs) < 0)
goto error;
/* cleanup */
for (i = 0; i < npvs; i++) {
switch (pinfo[i].valueType) {
case AL_SET_VAL:
case AL_VECTOR_VAL:
PyMem_DEL(pvs[i].value.ptr);
break;
}
}
PyMem_DEL(pvs);
PyMem_DEL(pinfo);
Py_INCREF(Py_None);
return Py_None;
error:
/* XXXX we should clean up everything */
if (pvs)
PyMem_DEL(pvs);
if (pinfo)
PyMem_DEL(pinfo);
return NULL;
}
static char al_QueryValues__doc__[] =
"alQueryValues: get the set of possible values for a parameter."
;
static PyObject *
al_QueryValues(self, args)
PyObject *self; /* Not used */
PyObject *args;
{
int resource, param;
ALvalue *return_set = NULL;
int setsize = 32, qualsize = 0, nvals, i;
ALpv *quals = NULL;
ALparamInfo pinfo;
ALparamInfo *qualinfo = NULL;
PyObject *qualobj = NULL;
PyObject *res = NULL, *item;
if (!PyArg_ParseTuple(args, "ii|O!", &resource, &param,
&PyList_Type, &qualobj))
return NULL;
if (qualobj != NULL) {
qualsize = python2params(resource, param, qualobj, &quals, &qualinfo);
if (qualsize < 0)
return NULL;
}
setsize = 32;
return_set = PyMem_NEW(ALvalue, setsize);
if (return_set == NULL) {
PyErr_NoMemory();
goto cleanup;
}
retry:
nvals = alQueryValues(resource, param, return_set, setsize, quals, qualsize);
if (nvals < 0)
goto cleanup;
if (nvals > setsize) {
setsize = nvals;
PyMem_RESIZE(return_set, ALvalue, setsize);
if (return_set == NULL) {
PyErr_NoMemory();
goto cleanup;
}
goto retry;
}
if (alGetParamInfo(resource, param, &pinfo) < 0)
goto cleanup;
res = PyList_New(nvals);
if (res == NULL)
goto cleanup;
for (i = 0; i < nvals; i++) {
item = param2python(resource, param, return_set[i], &pinfo);
if (item == NULL ||
PyList_SetItem(res, i, item) < 0) {
Py_DECREF(res);
res = NULL;
goto cleanup;
}
}
cleanup:
if (return_set)
PyMem_DEL(return_set);
if (quals) {
for (i = 0; i < qualsize; i++) {
switch (qualinfo[i].valueType) {
case AL_SET_VAL:
case AL_VECTOR_VAL:
PyMem_DEL(quals[i].value.ptr);
break;
}
}
PyMem_DEL(quals);
PyMem_DEL(qualinfo);
}
return res;
}
static char al_GetParamInfo__doc__[] =
"alGetParamInfo: get information about a parameter on a particular audio resource."
;
static PyObject *
al_GetParamInfo(self, args)
PyObject *self; /* Not used */
PyObject *args;
{
int res, param;
ALparamInfo pinfo;
PyObject *v, *item;;
if (!PyArg_ParseTuple(args, "ii", &res, &param))
return NULL;
if (alGetParamInfo(res, param, &pinfo) < 0)
return NULL;
v = PyDict_New();
item = PyInt_FromLong((long) pinfo.resource);
PyDict_SetItemString(v, "resource", item);
Py_DECREF(item);
item = PyInt_FromLong((long) pinfo.param);
PyDict_SetItemString(v, "param", item);
Py_DECREF(item);
item = PyInt_FromLong((long) pinfo.valueType);
PyDict_SetItemString(v, "valueType", item);
Py_DECREF(item);
if (pinfo.valueType != AL_NO_VAL && pinfo.valueType != AL_SCALAR_VAL) {
/* multiple values */
item = PyInt_FromLong((long) pinfo.maxElems);
PyDict_SetItemString(v, "maxElems", item);
Py_DECREF(item);
if (pinfo.valueType == AL_MATRIX_VAL) {
/* 2 dimensional */
item = PyInt_FromLong((long) pinfo.maxElems2);
PyDict_SetItemString(v, "maxElems2", item);
Py_DECREF(item);
}
}
item = PyInt_FromLong((long) pinfo.elementType);
PyDict_SetItemString(v, "elementType", item);
Py_DECREF(item);
item = PyString_FromString(pinfo.name);
PyDict_SetItemString(v, "name", item);
Py_DECREF(item);
item = param2python(res, param, pinfo.initial, &pinfo);
PyDict_SetItemString(v, "initial", item);
Py_DECREF(item);
if (pinfo.elementType != AL_ENUM_ELEM &&
pinfo.elementType != AL_RESOURCE_ELEM &&
pinfo.elementType != AL_CHAR_ELEM) {
/* range param */
item = param2python(res, param, pinfo.min, &pinfo);
PyDict_SetItemString(v, "min", item);
Py_DECREF(item);
item = param2python(res, param, pinfo.max, &pinfo);
PyDict_SetItemString(v, "max", item);
Py_DECREF(item);
item = param2python(res, param, pinfo.minDelta, &pinfo);
PyDict_SetItemString(v, "minDelta", item);
Py_DECREF(item);
item = param2python(res, param, pinfo.maxDelta, &pinfo);
PyDict_SetItemString(v, "maxDelta", item);
Py_DECREF(item);
item = PyInt_FromLong((long) pinfo.specialVals);
PyDict_SetItemString(v, "specialVals", item);
Py_DECREF(item);
}
return v;
}
static char al_GetResourceByName__doc__[] =
"alGetResourceByName: find an audio resource by name."
;
static PyObject *
al_GetResourceByName(self, args)
PyObject *self; /* Not used */
PyObject *args;
{
int res, start_res, type;
char *name;
if (!PyArg_ParseTuple(args, "isi", &start_res, &name, &type))
return NULL;
if ((res = alGetResourceByName(start_res, name, type)) == 0)
return NULL;
return PyInt_FromLong((long) res);
}
static char al_IsSubtype__doc__[] =
"alIsSubtype: indicate if one resource type is a subtype of another."
;
static PyObject *
al_IsSubtype(self, args)
PyObject *self; /* Not used */
PyObject *args;
{
int type, subtype;
if (!PyArg_ParseTuple(args, "ii", &type, &subtype))
return NULL;
return PyInt_FromLong((long) alIsSubtype(type, subtype));
}
static char al_SetErrorHandler__doc__[] =
""
;
static PyObject *
al_SetErrorHandler(self, args)
PyObject *self; /* Not used */
PyObject *args;
{
if (!PyArg_ParseTuple(args, ""))
return NULL;
Py_INCREF(Py_None);
return Py_None;
}
#endif /* AL_NO_ELEM */
#ifdef OLD_INTERFACE
static PyObject *
al_openport(self, args)
PyObject *self, *args;
{
char *name, *dir;
ALport port;
alcobject *config = NULL;
if (!PyArg_ParseTuple(args, "ss|O!", &name, &dir, &Alctype, &config))
return NULL;
if ((port = ALopenport(name, dir, config ? config->config : NULL)) == NULL)
return NULL;
return newalpobject(port);
}
static PyObject *
al_newconfig(self, args)
PyObject *self, *args;
{
ALconfig config;
if (!PyArg_ParseTuple(args, ""))
return NULL;
if ((config = ALnewconfig ()) == NULL)
return NULL;
return newalcobject(config);
}
static PyObject *
al_queryparams(self, args)
PyObject *self, *args;
{
long device;
long length;
long *PVbuffer;
long PVdummy[2];
PyObject *v = NULL;
int i;
if (!PyArg_ParseTuple(args, "l", &device))
return NULL;
if ((length = ALqueryparams(device, PVdummy, 2L)) == -1)
return NULL;
if ((PVbuffer = PyMem_NEW(long, length)) == NULL)
return PyErr_NoMemory();
if (ALqueryparams(device, PVbuffer, length) >= 0 &&
(v = PyList_New((int)length)) != NULL) {
for (i = 0; i < length; i++)
PyList_SetItem(v, i, PyInt_FromLong(PVbuffer[i]));
}
PyMem_DEL(PVbuffer);
return v;
}
static PyObject *
doParams(args, func, modified)
PyObject *args;
int (*func)(long, long *, long);
int modified;
{
long device;
PyObject *list, *v;
long *PVbuffer;
long length;
int i;
if (!PyArg_ParseTuple(args, "lO!", &device, &PyList_Type, &list))
return NULL;
length = PyList_Size(list);
PVbuffer = PyMem_NEW(long, length);
if (PVbuffer == NULL)
return PyErr_NoMemory();
for (i = 0; i < length; i++) {
v = PyList_GetItem(list, i);
if (!PyInt_Check(v)) {
PyMem_DEL(PVbuffer);
PyErr_BadArgument();
return NULL;
}
PVbuffer[i] = PyInt_AsLong(v);
}
if ((*func)(device, PVbuffer, length) == -1) {
PyMem_DEL(PVbuffer);
return NULL;
}
if (modified) {
for (i = 0; i < length; i++)
PyList_SetItem(list, i, PyInt_FromLong(PVbuffer[i]));
}
PyMem_DEL(PVbuffer);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
al_getparams(self, args)
PyObject *self, *args;
{
return doParams(args, ALgetparams, 1);
}
static PyObject *
al_setparams(self, args)
PyObject *self, *args;
{
return doParams(args, ALsetparams, 0);
}
static PyObject *
al_getname(self, args)
PyObject *self, *args;
{
long device, descriptor;
char *name;
if (!PyArg_ParseTuple(args, "ll", &device, &descriptor))
return NULL;
if ((name = ALgetname(device, descriptor)) == NULL)
return NULL;
return PyString_FromString(name);
}
static PyObject *
al_getdefault(self, args)
PyObject *self, *args;
{
long device, descriptor, value;
if (!PyArg_ParseTuple(args, "ll", &device, &descriptor))
return NULL;
if ((value = ALgetdefault(device, descriptor)) == -1)
return NULL;
return PyLong_FromLong(value);
}
static PyObject *
al_getminmax(self, args)
PyObject *self, *args;
{
long device, descriptor, min, max;
if (!PyArg_ParseTuple(args, "ll", &device, &descriptor))
return NULL;
min = -1;
max = -1;
if (ALgetminmax(device, descriptor, &min, &max) == -1)
return NULL;
return Py_BuildValue("ll", min, max);
}
#endif /* OLD_INTERFACE */
/* List of methods defined in the module */
static struct PyMethodDef al_methods[] = {
#ifdef AL_NO_ELEM /* IRIX 6 */
{"NewConfig", (PyCFunction)al_NewConfig, METH_VARARGS, al_NewConfig__doc__},
{"OpenPort", (PyCFunction)al_OpenPort, METH_VARARGS, al_OpenPort__doc__},
{"Connect", (PyCFunction)al_Connect, METH_VARARGS, al_Connect__doc__},
{"Disconnect", (PyCFunction)al_Disconnect, METH_VARARGS, al_Disconnect__doc__},
{"GetParams", (PyCFunction)al_GetParams, METH_VARARGS, al_GetParams__doc__},
{"SetParams", (PyCFunction)al_SetParams, METH_VARARGS, al_SetParams__doc__},
{"QueryValues", (PyCFunction)al_QueryValues, METH_VARARGS, al_QueryValues__doc__},
{"GetParamInfo", (PyCFunction)al_GetParamInfo, METH_VARARGS, al_GetParamInfo__doc__},
{"GetResourceByName", (PyCFunction)al_GetResourceByName, METH_VARARGS, al_GetResourceByName__doc__},
{"IsSubtype", (PyCFunction)al_IsSubtype, METH_VARARGS, al_IsSubtype__doc__},
#if 0
/* this one not supported */
{"SetErrorHandler", (PyCFunction)al_SetErrorHandler, METH_VARARGS, al_SetErrorHandler__doc__},
#endif
#endif /* AL_NO_ELEM */
#ifdef OLD_INTERFACE
{"openport", (PyCFunction)al_openport, METH_VARARGS},
{"newconfig", (PyCFunction)al_newconfig, METH_VARARGS},
{"queryparams", (PyCFunction)al_queryparams, METH_VARARGS},
{"getparams", (PyCFunction)al_getparams, METH_VARARGS},
{"setparams", (PyCFunction)al_setparams, METH_VARARGS},
{"getname", (PyCFunction)al_getname, METH_VARARGS},
{"getdefault", (PyCFunction)al_getdefault, METH_VARARGS},
{"getminmax", (PyCFunction)al_getminmax, METH_VARARGS},
#endif /* OLD_INTERFACE */
{NULL, (PyCFunction)NULL, 0, NULL} /* sentinel */
};
/* Initialization function for the module (*must* be called inital) */
static char al_module_documentation[] =
""
;
void
inital()
{
PyObject *m, *d, *x;
/* Create the module and add the functions */
m = Py_InitModule4("al", al_methods,
al_module_documentation,
(PyObject*)NULL,PYTHON_API_VERSION);
/* Add some symbolic constants to the module */
d = PyModule_GetDict(m);
ErrorObject = PyString_FromString("al.error");
PyDict_SetItemString(d, "error", ErrorObject);
/* XXXX Add constants here */
#ifdef AL_4CHANNEL
x = PyInt_FromLong((long) AL_4CHANNEL);
if (x == NULL || PyDict_SetItemString(d, "FOURCHANNEL", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_ADAT_IF_TYPE
x = PyInt_FromLong((long) AL_ADAT_IF_TYPE);
if (x == NULL || PyDict_SetItemString(d, "ADAT_IF_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_ADAT_MCLK_TYPE
x = PyInt_FromLong((long) AL_ADAT_MCLK_TYPE);
if (x == NULL || PyDict_SetItemString(d, "ADAT_MCLK_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_AES_IF_TYPE
x = PyInt_FromLong((long) AL_AES_IF_TYPE);
if (x == NULL || PyDict_SetItemString(d, "AES_IF_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_AES_MCLK_TYPE
x = PyInt_FromLong((long) AL_AES_MCLK_TYPE);
if (x == NULL || PyDict_SetItemString(d, "AES_MCLK_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_ANALOG_IF_TYPE
x = PyInt_FromLong((long) AL_ANALOG_IF_TYPE);
if (x == NULL || PyDict_SetItemString(d, "ANALOG_IF_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_ASSOCIATE
x = PyInt_FromLong((long) AL_ASSOCIATE);
if (x == NULL || PyDict_SetItemString(d, "ASSOCIATE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_BAD_BUFFER_NULL
x = PyInt_FromLong((long) AL_BAD_BUFFER_NULL);
if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_NULL", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_BAD_BUFFERLENGTH
x = PyInt_FromLong((long) AL_BAD_BUFFERLENGTH);
if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERLENGTH", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_BAD_BUFFERLENGTH_NEG
x = PyInt_FromLong((long) AL_BAD_BUFFERLENGTH_NEG);
if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERLENGTH_NEG", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_BAD_BUFFERLENGTH_ODD
x = PyInt_FromLong((long) AL_BAD_BUFFERLENGTH_ODD);
if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERLENGTH_ODD", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_BAD_CHANNELS
x = PyInt_FromLong((long) AL_BAD_CHANNELS);
if (x == NULL || PyDict_SetItemString(d, "BAD_CHANNELS", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_BAD_CONFIG
x = PyInt_FromLong((long) AL_BAD_CONFIG);
if (x == NULL || PyDict_SetItemString(d, "BAD_CONFIG", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_BAD_COUNT_NEG
x = PyInt_FromLong((long) AL_BAD_COUNT_NEG);
if (x == NULL || PyDict_SetItemString(d, "BAD_COUNT_NEG", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_BAD_DEVICE
x = PyInt_FromLong((long) AL_BAD_DEVICE);
if (x == NULL || PyDict_SetItemString(d, "BAD_DEVICE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_BAD_DEVICE_ACCESS
x = PyInt_FromLong((long) AL_BAD_DEVICE_ACCESS);
if (x == NULL || PyDict_SetItemString(d, "BAD_DEVICE_ACCESS", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_BAD_DIRECTION
x = PyInt_FromLong((long) AL_BAD_DIRECTION);
if (x == NULL || PyDict_SetItemString(d, "BAD_DIRECTION", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_BAD_FILLPOINT
x = PyInt_FromLong((long) AL_BAD_FILLPOINT);
if (x == NULL || PyDict_SetItemString(d, "BAD_FILLPOINT", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_BAD_FLOATMAX
x = PyInt_FromLong((long) AL_BAD_FLOATMAX);
if (x == NULL || PyDict_SetItemString(d, "BAD_FLOATMAX", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_BAD_ILLEGAL_STATE
x = PyInt_FromLong((long) AL_BAD_ILLEGAL_STATE);
if (x == NULL || PyDict_SetItemString(d, "BAD_ILLEGAL_STATE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_BAD_NO_PORTS
x = PyInt_FromLong((long) AL_BAD_NO_PORTS);
if (x == NULL || PyDict_SetItemString(d, "BAD_NO_PORTS", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_BAD_NOT_FOUND
x = PyInt_FromLong((long) AL_BAD_NOT_FOUND);
if (x == NULL || PyDict_SetItemString(d, "BAD_NOT_FOUND", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_BAD_NOT_IMPLEMENTED
x = PyInt_FromLong((long) AL_BAD_NOT_IMPLEMENTED);
if (x == NULL || PyDict_SetItemString(d, "BAD_NOT_IMPLEMENTED", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_BAD_OUT_OF_MEM
x = PyInt_FromLong((long) AL_BAD_OUT_OF_MEM);
if (x == NULL || PyDict_SetItemString(d, "BAD_OUT_OF_MEM", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_BAD_PARAM
x = PyInt_FromLong((long) AL_BAD_PARAM);
if (x == NULL || PyDict_SetItemString(d, "BAD_PARAM", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_BAD_PERMISSIONS
x = PyInt_FromLong((long) AL_BAD_PERMISSIONS);
if (x == NULL || PyDict_SetItemString(d, "BAD_PERMISSIONS", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_BAD_PORT
x = PyInt_FromLong((long) AL_BAD_PORT);
if (x == NULL || PyDict_SetItemString(d, "BAD_PORT", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_BAD_PORTSTYLE
x = PyInt_FromLong((long) AL_BAD_PORTSTYLE);
if (x == NULL || PyDict_SetItemString(d, "BAD_PORTSTYLE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_BAD_PVBUFFER
x = PyInt_FromLong((long) AL_BAD_PVBUFFER);
if (x == NULL || PyDict_SetItemString(d, "BAD_PVBUFFER", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_BAD_QSIZE
x = PyInt_FromLong((long) AL_BAD_QSIZE);
if (x == NULL || PyDict_SetItemString(d, "BAD_QSIZE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_BAD_RATE
x = PyInt_FromLong((long) AL_BAD_RATE);
if (x == NULL || PyDict_SetItemString(d, "BAD_RATE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_BAD_RESOURCE
x = PyInt_FromLong((long) AL_BAD_RESOURCE);
if (x == NULL || PyDict_SetItemString(d, "BAD_RESOURCE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_BAD_SAMPFMT
x = PyInt_FromLong((long) AL_BAD_SAMPFMT);
if (x == NULL || PyDict_SetItemString(d, "BAD_SAMPFMT", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_BAD_TRANSFER_SIZE
x = PyInt_FromLong((long) AL_BAD_TRANSFER_SIZE);
if (x == NULL || PyDict_SetItemString(d, "BAD_TRANSFER_SIZE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_BAD_WIDTH
x = PyInt_FromLong((long) AL_BAD_WIDTH);
if (x == NULL || PyDict_SetItemString(d, "BAD_WIDTH", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_CHANNEL_MODE
x = PyInt_FromLong((long) AL_CHANNEL_MODE);
if (x == NULL || PyDict_SetItemString(d, "CHANNEL_MODE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_CHANNELS
x = PyInt_FromLong((long) AL_CHANNELS);
if (x == NULL || PyDict_SetItemString(d, "CHANNELS", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_CHAR_ELEM
x = PyInt_FromLong((long) AL_CHAR_ELEM);
if (x == NULL || PyDict_SetItemString(d, "CHAR_ELEM", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_CLOCK_GEN
x = PyInt_FromLong((long) AL_CLOCK_GEN);
if (x == NULL || PyDict_SetItemString(d, "CLOCK_GEN", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_CLOCKGEN_TYPE
x = PyInt_FromLong((long) AL_CLOCKGEN_TYPE);
if (x == NULL || PyDict_SetItemString(d, "CLOCKGEN_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_CONNECT
x = PyInt_FromLong((long) AL_CONNECT);
if (x == NULL || PyDict_SetItemString(d, "CONNECT", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_CONNECTION_TYPE
x = PyInt_FromLong((long) AL_CONNECTION_TYPE);
if (x == NULL || PyDict_SetItemString(d, "CONNECTION_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_CONNECTIONS
x = PyInt_FromLong((long) AL_CONNECTIONS);
if (x == NULL || PyDict_SetItemString(d, "CONNECTIONS", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_CRYSTAL_MCLK_TYPE
x = PyInt_FromLong((long) AL_CRYSTAL_MCLK_TYPE);
if (x == NULL || PyDict_SetItemString(d, "CRYSTAL_MCLK_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_DEFAULT_DEVICE
x = PyInt_FromLong((long) AL_DEFAULT_DEVICE);
if (x == NULL || PyDict_SetItemString(d, "DEFAULT_DEVICE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_DEFAULT_INPUT
x = PyInt_FromLong((long) AL_DEFAULT_INPUT);
if (x == NULL || PyDict_SetItemString(d, "DEFAULT_INPUT", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_DEFAULT_OUTPUT
x = PyInt_FromLong((long) AL_DEFAULT_OUTPUT);
if (x == NULL || PyDict_SetItemString(d, "DEFAULT_OUTPUT", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_DEST
x = PyInt_FromLong((long) AL_DEST);
if (x == NULL || PyDict_SetItemString(d, "DEST", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_DEVICE_TYPE
x = PyInt_FromLong((long) AL_DEVICE_TYPE);
if (x == NULL || PyDict_SetItemString(d, "DEVICE_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_DEVICES
x = PyInt_FromLong((long) AL_DEVICES);
if (x == NULL || PyDict_SetItemString(d, "DEVICES", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_DIGITAL_IF_TYPE
x = PyInt_FromLong((long) AL_DIGITAL_IF_TYPE);
if (x == NULL || PyDict_SetItemString(d, "DIGITAL_IF_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_DIGITAL_INPUT_RATE
x = PyInt_FromLong((long) AL_DIGITAL_INPUT_RATE);
if (x == NULL || PyDict_SetItemString(d, "DIGITAL_INPUT_RATE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_DISCONNECT
x = PyInt_FromLong((long) AL_DISCONNECT);
if (x == NULL || PyDict_SetItemString(d, "DISCONNECT", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_ENUM_ELEM
x = PyInt_FromLong((long) AL_ENUM_ELEM);
if (x == NULL || PyDict_SetItemString(d, "ENUM_ELEM", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_ENUM_VALUE
x = PyInt_FromLong((long) AL_ENUM_VALUE);
if (x == NULL || PyDict_SetItemString(d, "ENUM_VALUE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_ERROR_INPUT_OVERFLOW
x = PyInt_FromLong((long) AL_ERROR_INPUT_OVERFLOW);
if (x == NULL || PyDict_SetItemString(d, "ERROR_INPUT_OVERFLOW", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_ERROR_LENGTH
x = PyInt_FromLong((long) AL_ERROR_LENGTH);
if (x == NULL || PyDict_SetItemString(d, "ERROR_LENGTH", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_ERROR_LOCATION_LSP
x = PyInt_FromLong((long) AL_ERROR_LOCATION_LSP);
if (x == NULL || PyDict_SetItemString(d, "ERROR_LOCATION_LSP", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_ERROR_LOCATION_MSP
x = PyInt_FromLong((long) AL_ERROR_LOCATION_MSP);
if (x == NULL || PyDict_SetItemString(d, "ERROR_LOCATION_MSP", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_ERROR_NUMBER
x = PyInt_FromLong((long) AL_ERROR_NUMBER);
if (x == NULL || PyDict_SetItemString(d, "ERROR_NUMBER", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_ERROR_OUTPUT_UNDERFLOW
x = PyInt_FromLong((long) AL_ERROR_OUTPUT_UNDERFLOW);
if (x == NULL || PyDict_SetItemString(d, "ERROR_OUTPUT_UNDERFLOW", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_ERROR_TYPE
x = PyInt_FromLong((long) AL_ERROR_TYPE);
if (x == NULL || PyDict_SetItemString(d, "ERROR_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_FIXED_ELEM
x = PyInt_FromLong((long) AL_FIXED_ELEM);
if (x == NULL || PyDict_SetItemString(d, "FIXED_ELEM", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_FIXED_MCLK_TYPE
x = PyInt_FromLong((long) AL_FIXED_MCLK_TYPE);
if (x == NULL || PyDict_SetItemString(d, "FIXED_MCLK_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_GAIN
x = PyInt_FromLong((long) AL_GAIN);
if (x == NULL || PyDict_SetItemString(d, "GAIN", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_GAIN_REF
x = PyInt_FromLong((long) AL_GAIN_REF);
if (x == NULL || PyDict_SetItemString(d, "GAIN_REF", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_HRB_TYPE
x = PyInt_FromLong((long) AL_HRB_TYPE);
if (x == NULL || PyDict_SetItemString(d, "HRB_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_INPUT_COUNT
x = PyInt_FromLong((long) AL_INPUT_COUNT);
if (x == NULL || PyDict_SetItemString(d, "INPUT_COUNT", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_INPUT_DEVICE_TYPE
x = PyInt_FromLong((long) AL_INPUT_DEVICE_TYPE);
if (x == NULL || PyDict_SetItemString(d, "INPUT_DEVICE_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_INPUT_DIGITAL
x = PyInt_FromLong((long) AL_INPUT_DIGITAL);
if (x == NULL || PyDict_SetItemString(d, "INPUT_DIGITAL", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_INPUT_HRB_TYPE
x = PyInt_FromLong((long) AL_INPUT_HRB_TYPE);
if (x == NULL || PyDict_SetItemString(d, "INPUT_HRB_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_INPUT_LINE
x = PyInt_FromLong((long) AL_INPUT_LINE);
if (x == NULL || PyDict_SetItemString(d, "INPUT_LINE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_INPUT_MIC
x = PyInt_FromLong((long) AL_INPUT_MIC);
if (x == NULL || PyDict_SetItemString(d, "INPUT_MIC", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_INPUT_PORT_TYPE
x = PyInt_FromLong((long) AL_INPUT_PORT_TYPE);
if (x == NULL || PyDict_SetItemString(d, "INPUT_PORT_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_INPUT_RATE
x = PyInt_FromLong((long) AL_INPUT_RATE);
if (x == NULL || PyDict_SetItemString(d, "INPUT_RATE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_INPUT_SOURCE
x = PyInt_FromLong((long) AL_INPUT_SOURCE);
if (x == NULL || PyDict_SetItemString(d, "INPUT_SOURCE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_INT32_ELEM
x = PyInt_FromLong((long) AL_INT32_ELEM);
if (x == NULL || PyDict_SetItemString(d, "INT32_ELEM", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_INT64_ELEM
x = PyInt_FromLong((long) AL_INT64_ELEM);
if (x == NULL || PyDict_SetItemString(d, "INT64_ELEM", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_INTERFACE
x = PyInt_FromLong((long) AL_INTERFACE);
if (x == NULL || PyDict_SetItemString(d, "INTERFACE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_INTERFACE_TYPE
x = PyInt_FromLong((long) AL_INTERFACE_TYPE);
if (x == NULL || PyDict_SetItemString(d, "INTERFACE_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_INVALID_PARAM
x = PyInt_FromLong((long) AL_INVALID_PARAM);
if (x == NULL || PyDict_SetItemString(d, "INVALID_PARAM", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_INVALID_VALUE
x = PyInt_FromLong((long) AL_INVALID_VALUE);
if (x == NULL || PyDict_SetItemString(d, "INVALID_VALUE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_JITTER
x = PyInt_FromLong((long) AL_JITTER);
if (x == NULL || PyDict_SetItemString(d, "JITTER", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_LABEL
x = PyInt_FromLong((long) AL_LABEL);
if (x == NULL || PyDict_SetItemString(d, "LABEL", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_LEFT_INPUT_ATTEN
x = PyInt_FromLong((long) AL_LEFT_INPUT_ATTEN);
if (x == NULL || PyDict_SetItemString(d, "LEFT_INPUT_ATTEN", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_LEFT_MONITOR_ATTEN
x = PyInt_FromLong((long) AL_LEFT_MONITOR_ATTEN);
if (x == NULL || PyDict_SetItemString(d, "LEFT_MONITOR_ATTEN", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_LEFT_SPEAKER_GAIN
x = PyInt_FromLong((long) AL_LEFT_SPEAKER_GAIN);
if (x == NULL || PyDict_SetItemString(d, "LEFT_SPEAKER_GAIN", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_LEFT1_INPUT_ATTEN
x = PyInt_FromLong((long) AL_LEFT1_INPUT_ATTEN);
if (x == NULL || PyDict_SetItemString(d, "LEFT1_INPUT_ATTEN", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_LEFT2_INPUT_ATTEN
x = PyInt_FromLong((long) AL_LEFT2_INPUT_ATTEN);
if (x == NULL || PyDict_SetItemString(d, "LEFT2_INPUT_ATTEN", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_LINE_IF_TYPE
x = PyInt_FromLong((long) AL_LINE_IF_TYPE);
if (x == NULL || PyDict_SetItemString(d, "LINE_IF_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_MASTER_CLOCK
x = PyInt_FromLong((long) AL_MASTER_CLOCK);
if (x == NULL || PyDict_SetItemString(d, "MASTER_CLOCK", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_MATRIX_VAL
x = PyInt_FromLong((long) AL_MATRIX_VAL);
if (x == NULL || PyDict_SetItemString(d, "MATRIX_VAL", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_MAX_ERROR
x = PyInt_FromLong((long) AL_MAX_ERROR);
if (x == NULL || PyDict_SetItemString(d, "MAX_ERROR", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_MAX_EVENT_PARAM
x = PyInt_FromLong((long) AL_MAX_EVENT_PARAM);
if (x == NULL || PyDict_SetItemString(d, "MAX_EVENT_PARAM", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_MAX_PBUFSIZE
x = PyInt_FromLong((long) AL_MAX_PBUFSIZE);
if (x == NULL || PyDict_SetItemString(d, "MAX_PBUFSIZE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_MAX_PORTS
x = PyInt_FromLong((long) AL_MAX_PORTS);
if (x == NULL || PyDict_SetItemString(d, "MAX_PORTS", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_MAX_RESOURCE_ID
x = PyInt_FromLong((long) AL_MAX_RESOURCE_ID);
if (x == NULL || PyDict_SetItemString(d, "MAX_RESOURCE_ID", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_MAX_SETSIZE
x = PyInt_FromLong((long) AL_MAX_SETSIZE);
if (x == NULL || PyDict_SetItemString(d, "MAX_SETSIZE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_MAX_STRLEN
x = PyInt_FromLong((long) AL_MAX_STRLEN);
if (x == NULL || PyDict_SetItemString(d, "MAX_STRLEN", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_MCLK_TYPE
x = PyInt_FromLong((long) AL_MCLK_TYPE);
if (x == NULL || PyDict_SetItemString(d, "MCLK_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_MIC_IF_TYPE
x = PyInt_FromLong((long) AL_MIC_IF_TYPE);
if (x == NULL || PyDict_SetItemString(d, "MIC_IF_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_MONITOR_CTL
x = PyInt_FromLong((long) AL_MONITOR_CTL);
if (x == NULL || PyDict_SetItemString(d, "MONITOR_CTL", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_MONITOR_OFF
x = PyInt_FromLong((long) AL_MONITOR_OFF);
if (x == NULL || PyDict_SetItemString(d, "MONITOR_OFF", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_MONITOR_ON
x = PyInt_FromLong((long) AL_MONITOR_ON);
if (x == NULL || PyDict_SetItemString(d, "MONITOR_ON", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_MONO
x = PyInt_FromLong((long) AL_MONO);
if (x == NULL || PyDict_SetItemString(d, "MONO", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_MUTE
x = PyInt_FromLong((long) AL_MUTE);
if (x == NULL || PyDict_SetItemString(d, "MUTE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_NAME
x = PyInt_FromLong((long) AL_NAME);
if (x == NULL || PyDict_SetItemString(d, "NAME", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_NEG_INFINITY
x = PyInt_FromLong((long) AL_NEG_INFINITY);
if (x == NULL || PyDict_SetItemString(d, "NEG_INFINITY", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_NEG_INFINITY_BIT
x = PyInt_FromLong((long) AL_NEG_INFINITY_BIT);
if (x == NULL || PyDict_SetItemString(d, "NEG_INFINITY_BIT", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_NO_CHANGE
x = PyInt_FromLong((long) AL_NO_CHANGE);
if (x == NULL || PyDict_SetItemString(d, "NO_CHANGE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_NO_CHANGE_BIT
x = PyInt_FromLong((long) AL_NO_CHANGE_BIT);
if (x == NULL || PyDict_SetItemString(d, "NO_CHANGE_BIT", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_NO_ELEM
x = PyInt_FromLong((long) AL_NO_ELEM);
if (x == NULL || PyDict_SetItemString(d, "NO_ELEM", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_NO_ERRORS
x = PyInt_FromLong((long) AL_NO_ERRORS);
if (x == NULL || PyDict_SetItemString(d, "NO_ERRORS", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_NO_OP
x = PyInt_FromLong((long) AL_NO_OP);
if (x == NULL || PyDict_SetItemString(d, "NO_OP", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_NO_VAL
x = PyInt_FromLong((long) AL_NO_VAL);
if (x == NULL || PyDict_SetItemString(d, "NO_VAL", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_NULL_RESOURCE
x = PyInt_FromLong((long) AL_NULL_RESOURCE);
if (x == NULL || PyDict_SetItemString(d, "NULL_RESOURCE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_OUTPUT_COUNT
x = PyInt_FromLong((long) AL_OUTPUT_COUNT);
if (x == NULL || PyDict_SetItemString(d, "OUTPUT_COUNT", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_OUTPUT_DEVICE_TYPE
x = PyInt_FromLong((long) AL_OUTPUT_DEVICE_TYPE);
if (x == NULL || PyDict_SetItemString(d, "OUTPUT_DEVICE_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_OUTPUT_HRB_TYPE
x = PyInt_FromLong((long) AL_OUTPUT_HRB_TYPE);
if (x == NULL || PyDict_SetItemString(d, "OUTPUT_HRB_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_OUTPUT_PORT_TYPE
x = PyInt_FromLong((long) AL_OUTPUT_PORT_TYPE);
if (x == NULL || PyDict_SetItemString(d, "OUTPUT_PORT_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_OUTPUT_RATE
x = PyInt_FromLong((long) AL_OUTPUT_RATE);
if (x == NULL || PyDict_SetItemString(d, "OUTPUT_RATE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_PARAM_BIT
x = PyInt_FromLong((long) AL_PARAM_BIT);
if (x == NULL || PyDict_SetItemString(d, "PARAM_BIT", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_PARAMS
x = PyInt_FromLong((long) AL_PARAMS);
if (x == NULL || PyDict_SetItemString(d, "PARAMS", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_PORT_COUNT
x = PyInt_FromLong((long) AL_PORT_COUNT);
if (x == NULL || PyDict_SetItemString(d, "PORT_COUNT", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_PORT_TYPE
x = PyInt_FromLong((long) AL_PORT_TYPE);
if (x == NULL || PyDict_SetItemString(d, "PORT_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_PORTS
x = PyInt_FromLong((long) AL_PORTS);
if (x == NULL || PyDict_SetItemString(d, "PORTS", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_PORTSTYLE_DIRECT
x = PyInt_FromLong((long) AL_PORTSTYLE_DIRECT);
if (x == NULL || PyDict_SetItemString(d, "PORTSTYLE_DIRECT", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_PORTSTYLE_SERIAL
x = PyInt_FromLong((long) AL_PORTSTYLE_SERIAL);
if (x == NULL || PyDict_SetItemString(d, "PORTSTYLE_SERIAL", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_PRINT_ERRORS
x = PyInt_FromLong((long) AL_PRINT_ERRORS);
if (x == NULL || PyDict_SetItemString(d, "PRINT_ERRORS", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_PTR_ELEM
x = PyInt_FromLong((long) AL_PTR_ELEM);
if (x == NULL || PyDict_SetItemString(d, "PTR_ELEM", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RANGE_VALUE
x = PyInt_FromLong((long) AL_RANGE_VALUE);
if (x == NULL || PyDict_SetItemString(d, "RANGE_VALUE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RATE
x = PyInt_FromLong((long) AL_RATE);
if (x == NULL || PyDict_SetItemString(d, "RATE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RATE_11025
x = PyInt_FromLong((long) AL_RATE_11025);
if (x == NULL || PyDict_SetItemString(d, "RATE_11025", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RATE_16000
x = PyInt_FromLong((long) AL_RATE_16000);
if (x == NULL || PyDict_SetItemString(d, "RATE_16000", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RATE_22050
x = PyInt_FromLong((long) AL_RATE_22050);
if (x == NULL || PyDict_SetItemString(d, "RATE_22050", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RATE_32000
x = PyInt_FromLong((long) AL_RATE_32000);
if (x == NULL || PyDict_SetItemString(d, "RATE_32000", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RATE_44100
x = PyInt_FromLong((long) AL_RATE_44100);
if (x == NULL || PyDict_SetItemString(d, "RATE_44100", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RATE_48000
x = PyInt_FromLong((long) AL_RATE_48000);
if (x == NULL || PyDict_SetItemString(d, "RATE_48000", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RATE_8000
x = PyInt_FromLong((long) AL_RATE_8000);
if (x == NULL || PyDict_SetItemString(d, "RATE_8000", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RATE_AES_1
x = PyInt_FromLong((long) AL_RATE_AES_1);
if (x == NULL || PyDict_SetItemString(d, "RATE_AES_1", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RATE_AES_1s
x = PyInt_FromLong((long) AL_RATE_AES_1s);
if (x == NULL || PyDict_SetItemString(d, "RATE_AES_1s", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RATE_AES_2
x = PyInt_FromLong((long) AL_RATE_AES_2);
if (x == NULL || PyDict_SetItemString(d, "RATE_AES_2", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RATE_AES_3
x = PyInt_FromLong((long) AL_RATE_AES_3);
if (x == NULL || PyDict_SetItemString(d, "RATE_AES_3", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RATE_AES_4
x = PyInt_FromLong((long) AL_RATE_AES_4);
if (x == NULL || PyDict_SetItemString(d, "RATE_AES_4", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RATE_AES_6
x = PyInt_FromLong((long) AL_RATE_AES_6);
if (x == NULL || PyDict_SetItemString(d, "RATE_AES_6", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RATE_FRACTION_D
x = PyInt_FromLong((long) AL_RATE_FRACTION_D);
if (x == NULL || PyDict_SetItemString(d, "RATE_FRACTION_D", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RATE_FRACTION_N
x = PyInt_FromLong((long) AL_RATE_FRACTION_N);
if (x == NULL || PyDict_SetItemString(d, "RATE_FRACTION_N", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RATE_INPUTRATE
x = PyInt_FromLong((long) AL_RATE_INPUTRATE);
if (x == NULL || PyDict_SetItemString(d, "RATE_INPUTRATE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RATE_NO_DIGITAL_INPUT
x = PyInt_FromLong((long) AL_RATE_NO_DIGITAL_INPUT);
if (x == NULL || PyDict_SetItemString(d, "RATE_NO_DIGITAL_INPUT", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RATE_UNACQUIRED
x = PyInt_FromLong((long) AL_RATE_UNACQUIRED);
if (x == NULL || PyDict_SetItemString(d, "RATE_UNACQUIRED", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RATE_UNDEFINED
x = PyInt_FromLong((long) AL_RATE_UNDEFINED);
if (x == NULL || PyDict_SetItemString(d, "RATE_UNDEFINED", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_REF_0DBV
x = PyInt_FromLong((long) AL_REF_0DBV);
if (x == NULL || PyDict_SetItemString(d, "REF_0DBV", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_REF_NONE
x = PyInt_FromLong((long) AL_REF_NONE);
if (x == NULL || PyDict_SetItemString(d, "REF_NONE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RESERVED1_TYPE
x = PyInt_FromLong((long) AL_RESERVED1_TYPE);
if (x == NULL || PyDict_SetItemString(d, "RESERVED1_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RESERVED2_TYPE
x = PyInt_FromLong((long) AL_RESERVED2_TYPE);
if (x == NULL || PyDict_SetItemString(d, "RESERVED2_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RESERVED3_TYPE
x = PyInt_FromLong((long) AL_RESERVED3_TYPE);
if (x == NULL || PyDict_SetItemString(d, "RESERVED3_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RESERVED4_TYPE
x = PyInt_FromLong((long) AL_RESERVED4_TYPE);
if (x == NULL || PyDict_SetItemString(d, "RESERVED4_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RESOURCE
x = PyInt_FromLong((long) AL_RESOURCE);
if (x == NULL || PyDict_SetItemString(d, "RESOURCE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RESOURCE_ELEM
x = PyInt_FromLong((long) AL_RESOURCE_ELEM);
if (x == NULL || PyDict_SetItemString(d, "RESOURCE_ELEM", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RESOURCE_TYPE
x = PyInt_FromLong((long) AL_RESOURCE_TYPE);
if (x == NULL || PyDict_SetItemString(d, "RESOURCE_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RIGHT_INPUT_ATTEN
x = PyInt_FromLong((long) AL_RIGHT_INPUT_ATTEN);
if (x == NULL || PyDict_SetItemString(d, "RIGHT_INPUT_ATTEN", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RIGHT_MONITOR_ATTEN
x = PyInt_FromLong((long) AL_RIGHT_MONITOR_ATTEN);
if (x == NULL || PyDict_SetItemString(d, "RIGHT_MONITOR_ATTEN", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RIGHT_SPEAKER_GAIN
x = PyInt_FromLong((long) AL_RIGHT_SPEAKER_GAIN);
if (x == NULL || PyDict_SetItemString(d, "RIGHT_SPEAKER_GAIN", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RIGHT1_INPUT_ATTEN
x = PyInt_FromLong((long) AL_RIGHT1_INPUT_ATTEN);
if (x == NULL || PyDict_SetItemString(d, "RIGHT1_INPUT_ATTEN", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_RIGHT2_INPUT_ATTEN
x = PyInt_FromLong((long) AL_RIGHT2_INPUT_ATTEN);
if (x == NULL || PyDict_SetItemString(d, "RIGHT2_INPUT_ATTEN", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_SAMPFMT_DOUBLE
x = PyInt_FromLong((long) AL_SAMPFMT_DOUBLE);
if (x == NULL || PyDict_SetItemString(d, "SAMPFMT_DOUBLE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_SAMPFMT_FLOAT
x = PyInt_FromLong((long) AL_SAMPFMT_FLOAT);
if (x == NULL || PyDict_SetItemString(d, "SAMPFMT_FLOAT", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_SAMPFMT_TWOSCOMP
x = PyInt_FromLong((long) AL_SAMPFMT_TWOSCOMP);
if (x == NULL || PyDict_SetItemString(d, "SAMPFMT_TWOSCOMP", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_SAMPLE_16
x = PyInt_FromLong((long) AL_SAMPLE_16);
if (x == NULL || PyDict_SetItemString(d, "SAMPLE_16", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_SAMPLE_24
x = PyInt_FromLong((long) AL_SAMPLE_24);
if (x == NULL || PyDict_SetItemString(d, "SAMPLE_24", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_SAMPLE_8
x = PyInt_FromLong((long) AL_SAMPLE_8);
if (x == NULL || PyDict_SetItemString(d, "SAMPLE_8", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_SCALAR_VAL
x = PyInt_FromLong((long) AL_SCALAR_VAL);
if (x == NULL || PyDict_SetItemString(d, "SCALAR_VAL", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_SET_VAL
x = PyInt_FromLong((long) AL_SET_VAL);
if (x == NULL || PyDict_SetItemString(d, "SET_VAL", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_SHORT_NAME
x = PyInt_FromLong((long) AL_SHORT_NAME);
if (x == NULL || PyDict_SetItemString(d, "SHORT_NAME", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_SOURCE
x = PyInt_FromLong((long) AL_SOURCE);
if (x == NULL || PyDict_SetItemString(d, "SOURCE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_SPEAKER_IF_TYPE
x = PyInt_FromLong((long) AL_SPEAKER_IF_TYPE);
if (x == NULL || PyDict_SetItemString(d, "SPEAKER_IF_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_SPEAKER_MUTE_CTL
x = PyInt_FromLong((long) AL_SPEAKER_MUTE_CTL);
if (x == NULL || PyDict_SetItemString(d, "SPEAKER_MUTE_CTL", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_SPEAKER_MUTE_OFF
x = PyInt_FromLong((long) AL_SPEAKER_MUTE_OFF);
if (x == NULL || PyDict_SetItemString(d, "SPEAKER_MUTE_OFF", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_SPEAKER_MUTE_ON
x = PyInt_FromLong((long) AL_SPEAKER_MUTE_ON);
if (x == NULL || PyDict_SetItemString(d, "SPEAKER_MUTE_ON", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_SPEAKER_PLUS_LINE_IF_TYPE
x = PyInt_FromLong((long) AL_SPEAKER_PLUS_LINE_IF_TYPE);
if (x == NULL || PyDict_SetItemString(d, "SPEAKER_PLUS_LINE_IF_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_STEREO
x = PyInt_FromLong((long) AL_STEREO);
if (x == NULL || PyDict_SetItemString(d, "STEREO", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_STRING_VAL
x = PyInt_FromLong((long) AL_STRING_VAL);
if (x == NULL || PyDict_SetItemString(d, "STRING_VAL", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_SUBSYSTEM
x = PyInt_FromLong((long) AL_SUBSYSTEM);
if (x == NULL || PyDict_SetItemString(d, "SUBSYSTEM", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_SUBSYSTEM_TYPE
x = PyInt_FromLong((long) AL_SUBSYSTEM_TYPE);
if (x == NULL || PyDict_SetItemString(d, "SUBSYSTEM_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_SYNC_INPUT_TO_AES
x = PyInt_FromLong((long) AL_SYNC_INPUT_TO_AES);
if (x == NULL || PyDict_SetItemString(d, "SYNC_INPUT_TO_AES", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_SYNC_OUTPUT_TO_AES
x = PyInt_FromLong((long) AL_SYNC_OUTPUT_TO_AES);
if (x == NULL || PyDict_SetItemString(d, "SYNC_OUTPUT_TO_AES", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_SYSTEM
x = PyInt_FromLong((long) AL_SYSTEM);
if (x == NULL || PyDict_SetItemString(d, "SYSTEM", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_SYSTEM_TYPE
x = PyInt_FromLong((long) AL_SYSTEM_TYPE);
if (x == NULL || PyDict_SetItemString(d, "SYSTEM_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_TEST_IF_TYPE
x = PyInt_FromLong((long) AL_TEST_IF_TYPE);
if (x == NULL || PyDict_SetItemString(d, "TEST_IF_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_TYPE
x = PyInt_FromLong((long) AL_TYPE);
if (x == NULL || PyDict_SetItemString(d, "TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_TYPE_BIT
x = PyInt_FromLong((long) AL_TYPE_BIT);
if (x == NULL || PyDict_SetItemString(d, "TYPE_BIT", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_UNUSED_COUNT
x = PyInt_FromLong((long) AL_UNUSED_COUNT);
if (x == NULL || PyDict_SetItemString(d, "UNUSED_COUNT", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_UNUSED_PORTS
x = PyInt_FromLong((long) AL_UNUSED_PORTS);
if (x == NULL || PyDict_SetItemString(d, "UNUSED_PORTS", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_VARIABLE_MCLK_TYPE
x = PyInt_FromLong((long) AL_VARIABLE_MCLK_TYPE);
if (x == NULL || PyDict_SetItemString(d, "VARIABLE_MCLK_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_VECTOR_VAL
x = PyInt_FromLong((long) AL_VECTOR_VAL);
if (x == NULL || PyDict_SetItemString(d, "VECTOR_VAL", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_VIDEO_MCLK_TYPE
x = PyInt_FromLong((long) AL_VIDEO_MCLK_TYPE);
if (x == NULL || PyDict_SetItemString(d, "VIDEO_MCLK_TYPE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_WORDSIZE
x = PyInt_FromLong((long) AL_WORDSIZE);
if (x == NULL || PyDict_SetItemString(d, "WORDSIZE", x) < 0)
goto error;
Py_DECREF(x);
#endif
#ifdef AL_NO_ELEM /* IRIX 6 */
(void) alSetErrorHandler(ErrorHandler);
#endif /* AL_NO_ELEM */
#ifdef OLD_INTERFACE
(void) ALseterrorhandler(ErrorHandler);
#endif /* OLD_INTERFACE */
/* Check for errors */
if (PyErr_Occurred()) {
error:
Py_FatalError("can't initialize module al");
}
}
Reference in a new issue View git blame Copy permalink