Modules/almodule.c

/***********************************************************
Copyright (c) 2000, BeOpen.com.
Copyright (c) 1995-2000, Corporation for National Research Initiatives.
Copyright (c) 1990-1995, Stichting Mathematisch Centrum.
All rights reserved.

See the file "Misc/COPYRIGHT" for information on usage and
redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES.
******************************************************************/

#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:SetConfig", &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, ":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(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: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(self, args)
	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(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:SetConfig", &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, ":GetConfig"))
		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, ":GetFloatMax"))
		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: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(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
	PyObject_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!: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(self, args)
	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(self, args)
	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(self, args)
	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(self, args)
	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(self, args)
	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(self, args)
	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(self, args)
	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(self, args)
	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(self, args)
	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(self, args)
	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(self, args)
	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(self, args)
	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(self, args)
	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__[] = 
"alClosePort: close an audio port."
;

static PyObject *
alp_ClosePort(self, args)
	alpobject *self;
	PyObject *args;
{
	if (!PyArg_ParseTuple(args, ":ClosePort"))
		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, ":ClosePort"))
		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, ":GetFD"))
		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, ":GetFilled"))
		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, ":GetFillable"))
		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:readsamps", &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#:writesamps", &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, ":GetFillPoint"))
		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:SetFillPoint", &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!:SetConfig", &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, ":GetConfig"))
		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
	}
	PyObject_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, ":NewConfig"))
		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!:OpenPort", &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!:Connect", &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:Disconnect", &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!:GetParams", &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!:SetParams", &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!:QueryValues", &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:GetParamInfo", &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:GetResourceByName", &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:IsSubtype", &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, ":SetErrorHandler"))
		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!:OpenPort", &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, ":NewConfig"))
		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:queryparams", &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:getname", &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:getdefault", &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:getminmax", &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 = PyErr_NewException("al.error", NULL, NULL);
	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");
	}
}