add hg and python

cinap_lenrek committed 15 years ago

Commit 4bb9e221 parent 987265c3706 files · +1228772 −-233Browse files

Showing the changes to sys/src/cmd/python/Modules/almodule.c (1 of 3706 files). Show all

Unified · Split

sys/src/cmd/python/Modules/almodule.c+3226−0

@@ -0,0 +1,3226 @@
	1	+
	2	+#define OLD_INTERFACE /* define for pre-Irix 6 interface */
	3	+
	4	+#include "Python.h"
	5	+#include "stringobject.h"
	6	+#include <audio.h>
	7	+#include <stdarg.h>
	8	+
	9	+#ifndef AL_NO_ELEM
	10	+#ifndef OLD_INTERFACE
	11	+#define OLD_INTERFACE
	12	+#endif /* OLD_INTERFACE */
	13	+#endif /* AL_NO_ELEM */
	14	+
	15	+static PyObject *ErrorObject;
	16	+
	17	+/* ----------------------------------------------------- */
	18	+
	19	+/* Declarations for objects of type port */
	20	+
	21	+typedef struct {
	22	+ PyObject_HEAD
	23	+ /* XXXX Add your own stuff here */
	24	+ ALport port;
	25	+} alpobject;
	26	+
	27	+static PyTypeObject Alptype;
	28	+
	29	+
	30	+
	31	+/* ---------------------------------------------------------------- */
	32	+
	33	+/* Declarations for objects of type config */
	34	+
	35	+typedef struct {
	36	+ PyObject_HEAD
	37	+ /* XXXX Add your own stuff here */
	38	+ ALconfig config;
	39	+} alcobject;
	40	+
	41	+static PyTypeObject Alctype;
	42	+
	43	+
	44	+static void
	45	+ErrorHandler(long code, const char *fmt, ...)
	46	+{
	47	+ va_list args;
	48	+ char buf[128];
	49	+
	50	+ va_start(args, fmt);
	51	+ vsprintf(buf, fmt, args);
	52	+ va_end(args);
	53	+ PyErr_SetString(ErrorObject, buf);
	54	+}
	55	+
	56	+#ifdef AL_NO_ELEM /* IRIX 6 */
	57	+
	58	+static PyObject *
	59	+param2python(int resource, int param, ALvalue value, ALparamInfo *pinfo)
	60	+{
	61	+ ALparamInfo info;
	62	+
	63	+ if (pinfo == NULL) {
	64	+ pinfo = &info;
	65	+ if (alGetParamInfo(resource, param, &info) < 0)
	66	+ return NULL;
	67	+ }
	68	+ switch (pinfo->elementType) {
	69	+ case AL_PTR_ELEM:
	70	+ /* XXXX don't know how to handle this */
	71	+ case AL_NO_ELEM:
	72	+ Py_INCREF(Py_None);
	73	+ return Py_None;
	74	+ case AL_INT32_ELEM:
	75	+ case AL_RESOURCE_ELEM:
	76	+ case AL_ENUM_ELEM:
	77	+ return PyInt_FromLong((long) value.i);
	78	+ case AL_INT64_ELEM:
	79	+ return PyLong_FromLongLong(value.ll);
	80	+ case AL_FIXED_ELEM:
	81	+ return PyFloat_FromDouble(alFixedToDouble(value.ll));
	82	+ case AL_CHAR_ELEM:
	83	+ if (value.ptr == NULL) {
	84	+ Py_INCREF(Py_None);
	85	+ return Py_None;
	86	+ }
	87	+ return PyString_FromString((char *) value.ptr);
	88	+ default:
	89	+ PyErr_SetString(ErrorObject, "unknown element type");
	90	+ return NULL;
	91	+ }
	92	+}
	93	+
	94	+static int
	95	+python2elem(PyObject item, void ptr, int elementType)
	96	+{
	97	+ switch (elementType) {
	98	+ case AL_INT32_ELEM:
	99	+ case AL_RESOURCE_ELEM:
	100	+ case AL_ENUM_ELEM:
	101	+ if (!PyInt_Check(item)) {
	102	+ PyErr_BadArgument();
	103	+ return -1;
	104	+ }
	105	+ ((int ) ptr) = PyInt_AsLong(item);
	106	+ break;
	107	+ case AL_INT64_ELEM:
	108	+ if (PyInt_Check(item))
	109	+ ((long long ) ptr) = PyInt_AsLong(item);
	110	+ else if (PyLong_Check(item))
	111	+ ((long long ) ptr) = PyLong_AsLongLong(item);
	112	+ else {
	113	+ PyErr_BadArgument();
	114	+ return -1;
	115	+ }
	116	+ break;
	117	+ case AL_FIXED_ELEM:
	118	+ if (PyInt_Check(item))
	119	+ ((long long ) ptr) = alDoubleToFixed((double) PyInt_AsLong(item));
	120	+ else if (PyFloat_Check(item))
	121	+ ((long long ) ptr) = alDoubleToFixed(PyFloat_AsDouble(item));
	122	+ else {
	123	+ PyErr_BadArgument();
	124	+ return -1;
	125	+ }
	126	+ break;
	127	+ default:
	128	+ PyErr_SetString(ErrorObject, "unknown element type");
	129	+ return -1;
	130	+ }
	131	+ return 0;
	132	+}
	133	+
	134	+static int
	135	+python2param(int resource, ALpv param, PyObject value, ALparamInfo *pinfo)
	136	+{
	137	+ ALparamInfo info;
	138	+ int i, stepsize;
	139	+ PyObject *item;
	140	+
	141	+ if (pinfo == NULL) {
	142	+ pinfo = &info;
	143	+ if (alGetParamInfo(resource, param->param, &info) < 0)
	144	+ return -1;
	145	+ }
	146	+ switch (pinfo->valueType) {
	147	+ case AL_STRING_VAL:
	148	+ if (pinfo->elementType != AL_CHAR_ELEM) {
	149	+ PyErr_SetString(ErrorObject, "unknown element type");
	150	+ return -1;
	151	+ }
	152	+ if (!PyString_Check(value)) {
	153	+ PyErr_BadArgument();
	154	+ return -1;
	155	+ }
	156	+ param->value.ptr = PyString_AS_STRING(value);
	157	+ param->sizeIn = PyString_GET_SIZE(value)+1; /account for NUL/
	158	+ break;
	159	+ case AL_SET_VAL:
	160	+ case AL_VECTOR_VAL:
	161	+ if (!PyList_Check(value) && !PyTuple_Check(value)) {
	162	+ PyErr_BadArgument();
	163	+ return -1;
	164	+ }
	165	+ switch (pinfo->elementType) {
	166	+ case AL_INT32_ELEM:
	167	+ case AL_RESOURCE_ELEM:
	168	+ case AL_ENUM_ELEM:
	169	+ param->sizeIn = PySequence_Size(value);
	170	+ param->value.ptr = PyMem_NEW(int, param->sizeIn);
	171	+ stepsize = sizeof(int);
	172	+ break;
	173	+ case AL_INT64_ELEM:
	174	+ case AL_FIXED_ELEM:
	175	+ param->sizeIn = PySequence_Size(value);
	176	+ param->value.ptr = PyMem_NEW(long long, param->sizeIn);
	177	+ stepsize = sizeof(long long);
	178	+ break;
	179	+ }
	180	+ for (i = 0; i < param->sizeIn; i++) {
	181	+ item = PySequence_GetItem(value, i);
	182	+ if (python2elem(item, (void ) ((char ) param->value.ptr + i*stepsize), pinfo->elementType) < 0) {
	183	+ PyMem_DEL(param->value.ptr);
	184	+ return -1;
	185	+ }
	186	+ }
	187	+ break;
	188	+ case AL_SCALAR_VAL:
	189	+ switch (pinfo->elementType) {
	190	+ case AL_INT32_ELEM:
	191	+ case AL_RESOURCE_ELEM:
	192	+ case AL_ENUM_ELEM:
	193	+ return python2elem(value, (void *) &param->value.i,
	194	+ pinfo->elementType);
	195	+ case AL_INT64_ELEM:
	196	+ case AL_FIXED_ELEM:
	197	+ return python2elem(value, (void *) &param->value.ll,
	198	+ pinfo->elementType);
	199	+ default:
	200	+ PyErr_SetString(ErrorObject, "unknown element type");
	201	+ return -1;
	202	+ }
	203	+ }
	204	+ return 0;
	205	+}
	206	+
	207	+static int
	208	+python2params(int resource1, int resource2, PyObject list, ALpv pvsp, ALparamInfo *pinfop)
	209	+{
	210	+ PyObject *item;
	211	+ ALpv *pvs;
	212	+ ALparamInfo *pinfo;
	213	+ int npvs, i;
	214	+
	215	+ npvs = PyList_Size(list);
	216	+ pvs = PyMem_NEW(ALpv, npvs);
	217	+ pinfo = PyMem_NEW(ALparamInfo, npvs);
	218	+ for (i = 0; i < npvs; i++) {
	219	+ item = PyList_GetItem(list, i);
	220	+ if (!PyArg_ParseTuple(item, "iO", &pvs[i].param, &item))
	221	+ goto error;
	222	+ if (alGetParamInfo(resource1, pvs[i].param, &pinfo[i]) < 0 &&
	223	+ alGetParamInfo(resource2, pvs[i].param, &pinfo[i]) < 0)
	224	+ goto error;
	225	+ if (python2param(resource1, &pvs[i], item, &pinfo[i]) < 0)
	226	+ goto error;
	227	+ }
	228	+
	229	+ *pvsp = pvs;
	230	+ *pinfop = pinfo;
	231	+ return npvs;
	232	+
	233	+ error:
	234	+ /* XXXX we should clean up everything */
	235	+ if (pvs)
	236	+ PyMem_DEL(pvs);
	237	+ if (pinfo)
	238	+ PyMem_DEL(pinfo);
	239	+ return -1;
	240	+}
	241	+
	242	+/* -------------------------------------------------------- */
	243	+
	244	+
	245	+static PyObject *
	246	+SetConfig(alcobject self, PyObject args, int (*func)(ALconfig, int))
	247	+{
	248	+ int par;
	249	+
	250	+ if (!PyArg_ParseTuple(args, "i:SetConfig", &par))
	251	+ return NULL;
	252	+
	253	+ if ((*func)(self->config, par) == -1)
	254	+ return NULL;
	255	+
	256	+ Py_INCREF(Py_None);
	257	+ return Py_None;
	258	+}
	259	+
	260	+static PyObject *
	261	+GetConfig(alcobject self, PyObject args, int (*func)(ALconfig))
	262	+{
	263	+ int par;
	264	+
	265	+ if (!PyArg_ParseTuple(args, ":GetConfig"))
	266	+ return NULL;
	267	+
	268	+ if ((par = (*func)(self->config)) == -1)
	269	+ return NULL;
	270	+
	271	+ return PyInt_FromLong((long) par);
	272	+}
	273	+
	274	+PyDoc_STRVAR(alc_SetWidth__doc__,
	275	+"alSetWidth: set the wordsize for integer audio data.");
	276	+
	277	+static PyObject *
	278	+alc_SetWidth(alcobject self, PyObject args)
	279	+{
	280	+ return SetConfig(self, args, alSetWidth);
	281	+}
	282	+
	283	+
	284	+PyDoc_STRVAR(alc_GetWidth__doc__,
	285	+"alGetWidth: get the wordsize for integer audio data.");
	286	+
	287	+static PyObject *
	288	+alc_GetWidth(alcobject self, PyObject args)
	289	+{
	290	+ return GetConfig(self, args, alGetWidth);
	291	+}
	292	+
	293	+
	294	+PyDoc_STRVAR(alc_SetSampFmt__doc__,
	295	+"alSetSampFmt: set the sample format setting in an audio ALconfig "
	296	+"structure.");
	297	+
	298	+static PyObject *
	299	+alc_SetSampFmt(alcobject self, PyObject args)
	300	+{
	301	+ return SetConfig(self, args, alSetSampFmt);
	302	+}
	303	+
	304	+
	305	+PyDoc_STRVAR(alc_GetSampFmt__doc__,
	306	+"alGetSampFmt: get the sample format setting in an audio ALconfig "
	307	+"structure.");
	308	+
	309	+static PyObject *
	310	+alc_GetSampFmt(alcobject self, PyObject args)
	311	+{
	312	+ return GetConfig(self, args, alGetSampFmt);
	313	+}
	314	+
	315	+
	316	+PyDoc_STRVAR(alc_SetChannels__doc__,
	317	+"alSetChannels: set the channel settings in an audio ALconfig.");
	318	+
	319	+static PyObject *
	320	+alc_SetChannels(alcobject self, PyObject args)
	321	+{
	322	+ return SetConfig(self, args, alSetChannels);
	323	+}
	324	+
	325	+
	326	+PyDoc_STRVAR(alc_GetChannels__doc__,
	327	+"alGetChannels: get the channel settings in an audio ALconfig.");
	328	+
	329	+static PyObject *
	330	+alc_GetChannels(alcobject self, PyObject args)
	331	+{
	332	+ return GetConfig(self, args, alGetChannels);
	333	+}
	334	+
	335	+
	336	+PyDoc_STRVAR(alc_SetFloatMax__doc__,
	337	+"alSetFloatMax: set the maximum value of floating point sample data.");
	338	+
	339	+static PyObject *
	340	+alc_SetFloatMax(alcobject self, PyObject args)
	341	+{
	342	+ double maximum_value;
	343	+
	344	+ if (!PyArg_ParseTuple(args, "d:SetFloatMax", &maximum_value))
	345	+ return NULL;
	346	+ if (alSetFloatMax(self->config, maximum_value) < 0)
	347	+ return NULL;
	348	+ Py_INCREF(Py_None);
	349	+ return Py_None;
	350	+}
	351	+
	352	+
	353	+PyDoc_STRVAR(alc_GetFloatMax__doc__,
	354	+"alGetFloatMax: get the maximum value of floating point sample data.");
	355	+
	356	+static PyObject *
	357	+alc_GetFloatMax(alcobject self, PyObject args)
	358	+{
	359	+ double maximum_value;
	360	+
	361	+ if (!PyArg_ParseTuple(args, ":GetFloatMax"))
	362	+ return NULL;
	363	+ if ((maximum_value = alGetFloatMax(self->config)) == 0)
	364	+ return NULL;
	365	+ return PyFloat_FromDouble(maximum_value);
	366	+}
	367	+
	368	+
	369	+PyDoc_STRVAR(alc_SetDevice__doc__,
	370	+"alSetDevice: set the device setting in an audio ALconfig structure.");
	371	+
	372	+static PyObject *
	373	+alc_SetDevice(alcobject self, PyObject args)
	374	+{
	375	+ return SetConfig(self, args, alSetDevice);
	376	+}
	377	+
	378	+
	379	+PyDoc_STRVAR(alc_GetDevice__doc__,
	380	+"alGetDevice: get the device setting in an audio ALconfig structure.");
	381	+
	382	+static PyObject *
	383	+alc_GetDevice(alcobject self, PyObject args)
	384	+{
	385	+ return GetConfig(self, args, alGetDevice);
	386	+}
	387	+
	388	+
	389	+PyDoc_STRVAR(alc_SetQueueSize__doc__,
	390	+"alSetQueueSize: set audio port buffer size.");
	391	+
	392	+static PyObject *
	393	+alc_SetQueueSize(alcobject self, PyObject args)
	394	+{
	395	+ return SetConfig(self, args, alSetQueueSize);
	396	+}
	397	+
	398	+
	399	+PyDoc_STRVAR(alc_GetQueueSize__doc__,
	400	+"alGetQueueSize: get audio port buffer size.");
	401	+
	402	+static PyObject *
	403	+alc_GetQueueSize(alcobject self, PyObject args)
	404	+{
	405	+ return GetConfig(self, args, alGetQueueSize);
	406	+}
	407	+
	408	+#endif /* AL_NO_ELEM */
	409	+
	410	+static PyObject *
	411	+setconfig(alcobject self, PyObject args, int (*func)(ALconfig, long))
	412	+{
	413	+ long par;
	414	+
	415	+ if (!PyArg_ParseTuple(args, "l:SetConfig", &par))
	416	+ return NULL;
	417	+
	418	+ if ((*func)(self->config, par) == -1)
	419	+ return NULL;
	420	+
	421	+ Py_INCREF(Py_None);
	422	+ return Py_None;
	423	+}
	424	+
	425	+static PyObject *
	426	+getconfig(alcobject self, PyObject args, long (*func)(ALconfig))
	427	+{
	428	+ long par;
	429	+
	430	+ if (!PyArg_ParseTuple(args, ":GetConfig"))
	431	+ return NULL;
	432	+
	433	+ if ((par = (*func)(self->config)) == -1)
	434	+ return NULL;
	435	+
	436	+ return PyInt_FromLong((long) par);
	437	+}
	438	+
	439	+static PyObject *
	440	+alc_setqueuesize (alcobject self, PyObject args)
	441	+{
	442	+ return setconfig(self, args, ALsetqueuesize);
	443	+}
	444	+
	445	+static PyObject *
	446	+alc_getqueuesize (alcobject self, PyObject args)
	447	+{
	448	+ return getconfig(self, args, ALgetqueuesize);
	449	+}
	450	+
	451	+static PyObject *
	452	+alc_setwidth (alcobject self, PyObject args)
	453	+{
	454	+ return setconfig(self, args, ALsetwidth);
	455	+}
	456	+
	457	+static PyObject *
	458	+alc_getwidth (alcobject self, PyObject args)
	459	+{
	460	+ return getconfig(self, args, ALgetwidth);
	461	+}
	462	+
	463	+static PyObject *
	464	+alc_getchannels (alcobject self, PyObject args)
	465	+{
	466	+ return getconfig(self, args, ALgetchannels);
	467	+}
	468	+
	469	+static PyObject *
	470	+alc_setchannels (alcobject self, PyObject args)
	471	+{
	472	+ return setconfig(self, args, ALsetchannels);
	473	+}
	474	+
	475	+#ifdef AL_405
	476	+
	477	+static PyObject *
	478	+alc_getsampfmt (alcobject self, PyObject args)
	479	+{
	480	+ return getconfig(self, args, ALgetsampfmt);
	481	+}
	482	+
	483	+static PyObject *
	484	+alc_setsampfmt (alcobject self, PyObject args)
	485	+{
	486	+ return setconfig(self, args, ALsetsampfmt);
	487	+}
	488	+
	489	+static PyObject *
	490	+alc_getfloatmax(alcobject self, PyObject args)
	491	+{
	492	+ double arg;
	493	+
	494	+ if (!PyArg_ParseTuple(args, ":GetFloatMax"))
	495	+ return 0;
	496	+ if ((arg = ALgetfloatmax(self->config)) == 0)
	497	+ return NULL;
	498	+ return PyFloat_FromDouble(arg);
	499	+}
	500	+
	501	+static PyObject *
	502	+alc_setfloatmax(alcobject self, PyObject args)
	503	+{
	504	+ double arg;
	505	+
	506	+ if (!PyArg_ParseTuple(args, "d:SetFloatMax", &arg))
	507	+ return 0;
	508	+ if (ALsetfloatmax(self->config, arg) == -1)
	509	+ return NULL;
	510	+ Py_INCREF(Py_None);
	511	+ return Py_None;
	512	+}
	513	+#endif /* AL_405 */
	514	+
	515	+static struct PyMethodDef alc_methods[] = {
	516	+#ifdef AL_NO_ELEM /* IRIX 6 */
	517	+ {"SetWidth", (PyCFunction)alc_SetWidth, METH_VARARGS, alc_SetWidth__doc__},
	518	+ {"GetWidth", (PyCFunction)alc_GetWidth, METH_VARARGS, alc_GetWidth__doc__},
	519	+ {"SetSampFmt", (PyCFunction)alc_SetSampFmt, METH_VARARGS, alc_SetSampFmt__doc__},
	520	+ {"GetSampFmt", (PyCFunction)alc_GetSampFmt, METH_VARARGS, alc_GetSampFmt__doc__},
	521	+ {"SetChannels", (PyCFunction)alc_SetChannels, METH_VARARGS, alc_SetChannels__doc__},
	522	+ {"GetChannels", (PyCFunction)alc_GetChannels, METH_VARARGS, alc_GetChannels__doc__},
	523	+ {"SetFloatMax", (PyCFunction)alc_SetFloatMax, METH_VARARGS, alc_SetFloatMax__doc__},
	524	+ {"GetFloatMax", (PyCFunction)alc_GetFloatMax, METH_VARARGS, alc_GetFloatMax__doc__},
	525	+ {"SetDevice", (PyCFunction)alc_SetDevice, METH_VARARGS, alc_SetDevice__doc__},
	526	+ {"GetDevice", (PyCFunction)alc_GetDevice, METH_VARARGS, alc_GetDevice__doc__},
	527	+ {"SetQueueSize", (PyCFunction)alc_SetQueueSize, METH_VARARGS, alc_SetQueueSize__doc__},
	528	+ {"GetQueueSize", (PyCFunction)alc_GetQueueSize, METH_VARARGS, alc_GetQueueSize__doc__},
	529	+#endif /* AL_NO_ELEM */
	530	+ {"getqueuesize", (PyCFunction)alc_getqueuesize, METH_VARARGS},
	531	+ {"setqueuesize", (PyCFunction)alc_setqueuesize, METH_VARARGS},
	532	+ {"getwidth", (PyCFunction)alc_getwidth, METH_VARARGS},
	533	+ {"setwidth", (PyCFunction)alc_setwidth, METH_VARARGS},
	534	+ {"getchannels", (PyCFunction)alc_getchannels, METH_VARARGS},
	535	+ {"setchannels", (PyCFunction)alc_setchannels, METH_VARARGS},
	536	+#ifdef AL_405
	537	+ {"getsampfmt", (PyCFunction)alc_getsampfmt, METH_VARARGS},
	538	+ {"setsampfmt", (PyCFunction)alc_setsampfmt, METH_VARARGS},
	539	+ {"getfloatmax", (PyCFunction)alc_getfloatmax, METH_VARARGS},
	540	+ {"setfloatmax", (PyCFunction)alc_setfloatmax, METH_VARARGS},
	541	+#endif /* AL_405 */
	542	+
	543	+ {NULL, NULL} /* sentinel */
	544	+};
	545	+
	546	+/* ---------- */
	547	+
	548	+
	549	+static PyObject *
	550	+newalcobject(ALconfig config)
	551	+{
	552	+ alcobject *self;
	553	+
	554	+ self = PyObject_New(alcobject, &Alctype);
	555	+ if (self == NULL)
	556	+ return NULL;
	557	+ /* XXXX Add your own initializers here */
	558	+ self->config = config;
	559	+ return (PyObject *) self;
	560	+}
	561	+
	562	+
	563	+static void
	564	+alc_dealloc(alcobject *self)
	565	+{
	566	+ /* XXXX Add your own cleanup code here */
	567	+#ifdef AL_NO_ELEM /* IRIX 6 */
	568	+ (void) alFreeConfig(self->config); /* ignore errors */
	569	+#else
	570	+ (void) ALfreeconfig(self->config); /* ignore errors */
	571	+#endif
	572	+ PyObject_Del(self);
	573	+}
	574	+
	575	+static PyObject *
	576	+alc_getattr(alcobject self, char name)
	577	+{
	578	+ /* XXXX Add your own getattr code here */
	579	+ return Py_FindMethod(alc_methods, (PyObject *)self, name);
	580	+}
	581	+
	582	+PyDoc_STRVAR(Alctype__doc__, "");
	583	+
	584	+static PyTypeObject Alctype = {
	585	+ PyObject_HEAD_INIT(&PyType_Type)
	586	+ 0, /ob_size/
	587	+ "al.config", /tp_name/
	588	+ sizeof(alcobject), /tp_basicsize/
	589	+ 0, /tp_itemsize/
	590	+ /* methods */
	591	+ (destructor)alc_dealloc, /tp_dealloc/
	592	+ (printfunc)0, /tp_print/
	593	+ (getattrfunc)alc_getattr, /tp_getattr/
	594	+ (setattrfunc)0, /tp_setattr/
	595	+ (cmpfunc)0, /tp_compare/
	596	+ (reprfunc)0, /tp_repr/
	597	+ 0, /tp_as_number/
	598	+ 0, /tp_as_sequence/
	599	+ 0, /tp_as_mapping/
	600	+ (hashfunc)0, /tp_hash/
	601	+ (ternaryfunc)0, /tp_call/
	602	+ (reprfunc)0, /tp_str/
	603	+
	604	+ /* Space for future expansion */
	605	+ 0L,0L,0L,0L,
	606	+ Alctype__doc__ /* Documentation string */
	607	+};
	608	+
	609	+/* End of code for config objects */
	610	+/* ---------------------------------------------------------------- */
	611	+
	612	+#ifdef AL_NO_ELEM /* IRIX 6 */
	613	+
	614	+PyDoc_STRVAR(alp_SetConfig__doc__,
	615	+"alSetConfig: set the ALconfig of an audio ALport.");
	616	+
	617	+static PyObject *
	618	+alp_SetConfig(alpobject self, PyObject args)
	619	+{
	620	+ alcobject *config;
	621	+ if (!PyArg_ParseTuple(args, "O!:SetConfig", &Alctype, &config))
	622	+ return NULL;
	623	+ if (alSetConfig(self->port, config->config) < 0)
	624	+ return NULL;
	625	+ Py_INCREF(Py_None);
	626	+ return Py_None;
	627	+}
	628	+
	629	+
	630	+PyDoc_STRVAR(alp_GetConfig__doc__,
	631	+"alGetConfig: get the ALconfig of an audio ALport.");
	632	+
	633	+static PyObject *
	634	+alp_GetConfig(alpobject self, PyObject args)
	635	+{
	636	+ ALconfig config;
	637	+ if (!PyArg_ParseTuple(args, ":GetConfig"))
	638	+ return NULL;
	639	+ if ((config = alGetConfig(self->port)) == NULL)
	640	+ return NULL;
	641	+ return newalcobject(config);
	642	+}
	643	+
	644	+
	645	+PyDoc_STRVAR(alp_GetResource__doc__,
	646	+"alGetResource: get the resource associated with an audio port.");
	647	+
	648	+static PyObject *
	649	+alp_GetResource(alpobject self, PyObject args)
	650	+{
	651	+ int resource;
	652	+
	653	+ if (!PyArg_ParseTuple(args, ":GetResource"))
	654	+ return NULL;
	655	+ if ((resource = alGetResource(self->port)) == 0)
	656	+ return NULL;
	657	+ return PyInt_FromLong((long) resource);
	658	+}
	659	+
	660	+
	661	+PyDoc_STRVAR(alp_GetFD__doc__,
	662	+"alGetFD: get the file descriptor for an audio port.");
	663	+
	664	+static PyObject *
	665	+alp_GetFD(alpobject self, PyObject args)
	666	+{
	667	+ int fd;
	668	+
	669	+ if (!PyArg_ParseTuple(args, ":GetFD"))
	670	+ return NULL;
	671	+
	672	+ if ((fd = alGetFD(self->port)) < 0)
	673	+ return NULL;
	674	+
	675	+ return PyInt_FromLong((long) fd);
	676	+}
	677	+
	678	+
	679	+PyDoc_STRVAR(alp_GetFilled__doc__,
	680	+"alGetFilled: return the number of filled sample frames in "
	681	+"an audio port.");
	682	+
	683	+static PyObject *
	684	+alp_GetFilled(alpobject self, PyObject args)
	685	+{
	686	+ int filled;
	687	+
	688	+ if (!PyArg_ParseTuple(args, ":GetFilled"))
	689	+ return NULL;
	690	+ if ((filled = alGetFilled(self->port)) < 0)
	691	+ return NULL;
	692	+ return PyInt_FromLong((long) filled);
	693	+}
	694	+
	695	+
	696	+PyDoc_STRVAR(alp_GetFillable__doc__,
	697	+"alGetFillable: report the number of unfilled sample frames "
	698	+"in an audio port.");
	699	+
	700	+static PyObject *
	701	+alp_GetFillable(alpobject self, PyObject args)
	702	+{
	703	+ int fillable;
	704	+
	705	+ if (!PyArg_ParseTuple(args, ":GetFillable"))
	706	+ return NULL;
	707	+ if ((fillable = alGetFillable(self->port)) < 0)
	708	+ return NULL;
	709	+ return PyInt_FromLong((long) fillable);
	710	+}
	711	+
	712	+
	713	+PyDoc_STRVAR(alp_ReadFrames__doc__,
	714	+"alReadFrames: read sample frames from an audio port.");
	715	+
	716	+static PyObject *
	717	+alp_ReadFrames(alpobject self, PyObject args)
	718	+{
	719	+ int framecount;
	720	+ PyObject *v;
	721	+ int size;
	722	+ int ch;
	723	+ ALconfig c;
	724	+
	725	+ if (!PyArg_ParseTuple(args, "i:ReadFrames", &framecount))
	726	+ return NULL;
	727	+ if (framecount < 0) {
	728	+ PyErr_SetString(ErrorObject, "negative framecount");
	729	+ return NULL;
	730	+ }
	731	+ c = alGetConfig(self->port);
	732	+ switch (alGetSampFmt(c)) {
	733	+ case AL_SAMPFMT_TWOSCOMP:
	734	+ switch (alGetWidth(c)) {
	735	+ case AL_SAMPLE_8:
	736	+ size = 1;
	737	+ break;
	738	+ case AL_SAMPLE_16:
	739	+ size = 2;
	740	+ break;
	741	+ case AL_SAMPLE_24:
	742	+ size = 4;
	743	+ break;
	744	+ default:
	745	+ PyErr_SetString(ErrorObject, "can't determine width");
	746	+ alFreeConfig(c);
	747	+ return NULL;
	748	+ }
	749	+ break;
	750	+ case AL_SAMPFMT_FLOAT:
	751	+ size = 4;
	752	+ break;
	753	+ case AL_SAMPFMT_DOUBLE:
	754	+ size = 8;
	755	+ break;
	756	+ default:
	757	+ PyErr_SetString(ErrorObject, "can't determine format");
	758	+ alFreeConfig(c);
	759	+ return NULL;
	760	+ }
	761	+ ch = alGetChannels(c);
	762	+ alFreeConfig(c);
	763	+ if (ch < 0) {
	764	+ PyErr_SetString(ErrorObject, "can't determine # of channels");
	765	+ return NULL;
	766	+ }
	767	+ size *= ch;
	768	+ v = PyString_FromStringAndSize((char ) NULL, size framecount);
	769	+ if (v == NULL)
	770	+ return NULL;
	771	+
	772	+ Py_BEGIN_ALLOW_THREADS
	773	+ alReadFrames(self->port, (void *) PyString_AS_STRING(v), framecount);
	774	+ Py_END_ALLOW_THREADS
	775	+
	776	+ return v;
	777	+}
	778	+
	779	+
	780	+PyDoc_STRVAR(alp_DiscardFrames__doc__,
	781	+"alDiscardFrames: discard audio from an audio port.");
	782	+
	783	+static PyObject *
	784	+alp_DiscardFrames(alpobject self, PyObject args)
	785	+{
	786	+ int framecount;
	787	+
	788	+ if (!PyArg_ParseTuple(args, "i:DiscardFrames", &framecount))
	789	+ return NULL;
	790	+
	791	+ Py_BEGIN_ALLOW_THREADS
	792	+ framecount = alDiscardFrames(self->port, framecount);
	793	+ Py_END_ALLOW_THREADS
	794	+
	795	+ if (framecount < 0)
	796	+ return NULL;
	797	+
	798	+ return PyInt_FromLong((long) framecount);
	799	+}
	800	+
	801	+
	802	+PyDoc_STRVAR(alp_ZeroFrames__doc__,
	803	+"alZeroFrames: write zero-valued sample frames to an audio port.");
	804	+
	805	+static PyObject *
	806	+alp_ZeroFrames(alpobject self, PyObject args)
	807	+{
	808	+ int framecount;
	809	+
	810	+ if (!PyArg_ParseTuple(args, "i:ZeroFrames", &framecount))
	811	+ return NULL;
	812	+
	813	+ if (framecount < 0) {
	814	+ PyErr_SetString(ErrorObject, "negative framecount");
	815	+ return NULL;
	816	+ }
	817	+
	818	+ Py_BEGIN_ALLOW_THREADS
	819	+ alZeroFrames(self->port, framecount);
	820	+ Py_END_ALLOW_THREADS
	821	+
	822	+ Py_INCREF(Py_None);
	823	+ return Py_None;
	824	+}
	825	+
	826	+
	827	+PyDoc_STRVAR(alp_SetFillPoint__doc__,
	828	+"alSetFillPoint: set low- or high-water mark for an audio port.");
	829	+
	830	+static PyObject *
	831	+alp_SetFillPoint(alpobject self, PyObject args)
	832	+{
	833	+ int fillpoint;
	834	+
	835	+ if (!PyArg_ParseTuple(args, "i:SetFillPoint", &fillpoint))
	836	+ return NULL;
	837	+
	838	+ if (alSetFillPoint(self->port, fillpoint) < 0)
	839	+ return NULL;
	840	+
	841	+ Py_INCREF(Py_None);
	842	+ return Py_None;
	843	+}
	844	+
	845	+
	846	+PyDoc_STRVAR(alp_GetFillPoint__doc__,
	847	+"alGetFillPoint: get low- or high-water mark for an audio port.");
	848	+
	849	+static PyObject *
	850	+alp_GetFillPoint(alpobject self, PyObject args)
	851	+{
	852	+ int fillpoint;
	853	+
	854	+ if (!PyArg_ParseTuple(args, ":GetFillPoint"))
	855	+ return NULL;
	856	+
	857	+ if ((fillpoint = alGetFillPoint(self->port)) < 0)
	858	+ return NULL;
	859	+
	860	+ return PyInt_FromLong((long) fillpoint);
	861	+}
	862	+
	863	+
	864	+PyDoc_STRVAR(alp_GetFrameNumber__doc__,
	865	+"alGetFrameNumber: get the absolute sample frame number "
	866	+"associated with a port.");
	867	+
	868	+static PyObject *
	869	+alp_GetFrameNumber(alpobject self, PyObject args)
	870	+{
	871	+ stamp_t fnum;
	872	+
	873	+ if (!PyArg_ParseTuple(args, ":GetFrameNumber"))
	874	+ return NULL;
	875	+
	876	+ if (alGetFrameNumber(self->port, &fnum) < 0)
	877	+ return NULL;
	878	+
	879	+ return PyLong_FromLongLong((long long) fnum);
	880	+}
	881	+
	882	+
	883	+PyDoc_STRVAR(alp_GetFrameTime__doc__,
	884	+"alGetFrameTime: get the time at which a sample frame came "
	885	+"in or will go out.");
	886	+
	887	+static PyObject *
	888	+alp_GetFrameTime(alpobject self, PyObject args)
	889	+{
	890	+ stamp_t fnum, time;
	891	+ PyObject ret, v0, *v1;
	892	+
	893	+ if (!PyArg_ParseTuple(args, ":GetFrameTime"))
	894	+ return NULL;
	895	+ if (alGetFrameTime(self->port, &fnum, &time) < 0)
	896	+ return NULL;
	897	+ v0 = PyLong_FromLongLong((long long) fnum);
	898	+ v1 = PyLong_FromLongLong((long long) time);
	899	+ if (PyErr_Occurred()) {
	900	+ Py_XDECREF(v0);
	901	+ Py_XDECREF(v1);
	902	+ return NULL;
	903	+ }
	904	+ ret = PyTuple_Pack(2, v0, v1);
	905	+ Py_DECREF(v0);
	906	+ Py_DECREF(v1);
	907	+ return ret;
	908	+}
	909	+
	910	+
	911	+PyDoc_STRVAR(alp_WriteFrames__doc__,
	912	+"alWriteFrames: write sample frames to an audio port.");
	913	+
	914	+static PyObject *
	915	+alp_WriteFrames(alpobject self, PyObject args)
	916	+{
	917	+ char *samples;
	918	+ int length;
	919	+ int size, ch;
	920	+ ALconfig c;
	921	+
	922	+ if (!PyArg_ParseTuple(args, "s#:WriteFrames", &samples, &length))
	923	+ return NULL;
	924	+ c = alGetConfig(self->port);
	925	+ switch (alGetSampFmt(c)) {
	926	+ case AL_SAMPFMT_TWOSCOMP:
	927	+ switch (alGetWidth(c)) {
	928	+ case AL_SAMPLE_8:
	929	+ size = 1;
	930	+ break;
	931	+ case AL_SAMPLE_16:
	932	+ size = 2;
	933	+ break;
	934	+ case AL_SAMPLE_24:
	935	+ size = 4;
	936	+ break;
	937	+ default:
	938	+ PyErr_SetString(ErrorObject, "can't determine width");
	939	+ alFreeConfig(c);
	940	+ return NULL;
	941	+ }
	942	+ break;
	943	+ case AL_SAMPFMT_FLOAT:
	944	+ size = 4;
	945	+ break;
	946	+ case AL_SAMPFMT_DOUBLE:
	947	+ size = 8;
	948	+ break;
	949	+ default:
	950	+ PyErr_SetString(ErrorObject, "can't determine format");
	951	+ alFreeConfig(c);
	952	+ return NULL;
	953	+ }
	954	+ ch = alGetChannels(c);
	955	+ alFreeConfig(c);
	956	+ if (ch < 0) {
	957	+ PyErr_SetString(ErrorObject, "can't determine # of channels");
	958	+ return NULL;
	959	+ }
	960	+ size *= ch;
	961	+ if (length % size != 0) {
	962	+ PyErr_SetString(ErrorObject,
	963	+ "buffer length not whole number of frames");
	964	+ return NULL;
	965	+ }
	966	+
	967	+ Py_BEGIN_ALLOW_THREADS
	968	+ alWriteFrames(self->port, (void *) samples, length / size);
	969	+ Py_END_ALLOW_THREADS
	970	+
	971	+ Py_INCREF(Py_None);
	972	+ return Py_None;
	973	+}
	974	+
	975	+
	976	+PyDoc_STRVAR(alp_ClosePort__doc__, "alClosePort: close an audio port.");
	977	+
	978	+static PyObject *
	979	+alp_ClosePort(alpobject self, PyObject args)
	980	+{
	981	+ if (!PyArg_ParseTuple(args, ":ClosePort"))
	982	+ return NULL;
	983	+ if (alClosePort(self->port) < 0)
	984	+ return NULL;
	985	+ self->port = NULL;
	986	+ Py_INCREF(Py_None);
	987	+ return Py_None;
	988	+}
	989	+
	990	+#endif /* AL_NO_ELEM */
	991	+
	992	+#ifdef OLD_INTERFACE
	993	+static PyObject *
	994	+alp_closeport(alpobject self, PyObject args)
	995	+{
	996	+ if (!PyArg_ParseTuple(args, ":ClosePort"))
	997	+ return NULL;
	998	+ if (ALcloseport(self->port) < 0)
	999	+ return NULL;
	1000	+ self->port = NULL;
	1001	+ Py_INCREF(Py_None);
	1002	+ return Py_None;
	1003	+}
	1004	+
	1005	+static PyObject *
	1006	+alp_getfd(alpobject self, PyObject args)
	1007	+{
	1008	+ int fd;
	1009	+
	1010	+ if (!PyArg_ParseTuple(args, ":GetFD"))
	1011	+ return NULL;
	1012	+ if ((fd = ALgetfd(self-> port)) == -1)
	1013	+ return NULL;
	1014	+ return PyInt_FromLong(fd);
	1015	+}
	1016	+
	1017	+static PyObject *
	1018	+alp_getfilled(alpobject self, PyObject args)
	1019	+{
	1020	+ long count;
	1021	+
	1022	+ if (!PyArg_ParseTuple(args, ":GetFilled"))
	1023	+ return NULL;
	1024	+ if ((count = ALgetfilled(self-> port)) == -1)
	1025	+ return NULL;
	1026	+ return PyInt_FromLong(count);
	1027	+}
	1028	+
	1029	+static PyObject *
	1030	+alp_getfillable(alpobject self, PyObject args)
	1031	+{
	1032	+ long count;
	1033	+
	1034	+ if (!PyArg_ParseTuple(args, ":GetFillable"))
	1035	+ return NULL;
	1036	+ if ((count = ALgetfillable(self-> port)) == -1)
	1037	+ return NULL;
	1038	+ return PyInt_FromLong (count);
	1039	+}
	1040	+
	1041	+static PyObject *
	1042	+alp_readsamps(alpobject self, PyObject args)
	1043	+{
	1044	+ long count;
	1045	+ PyObject *v;
	1046	+ ALconfig c;
	1047	+ int width;
	1048	+ int ret;
	1049	+
	1050	+ if (!PyArg_ParseTuple(args, "l:readsamps", &count))
	1051	+ return NULL;
	1052	+
	1053	+ if (count <= 0) {
	1054	+ PyErr_SetString(ErrorObject, "al.readsamps : arg <= 0");
	1055	+ return NULL;
	1056	+ }
	1057	+
	1058	+ c = ALgetconfig(self->port);
	1059	+#ifdef AL_405
	1060	+ width = ALgetsampfmt(c);
	1061	+ if (width == AL_SAMPFMT_FLOAT)
	1062	+ width = sizeof(float);
	1063	+ else if (width == AL_SAMPFMT_DOUBLE)
	1064	+ width = sizeof(double);
	1065	+ else
	1066	+ width = ALgetwidth(c);
	1067	+#else
	1068	+ width = ALgetwidth(c);
	1069	+#endif /* AL_405 */
	1070	+ ALfreeconfig(c);
	1071	+ v = PyString_FromStringAndSize((char )NULL, width count);
	1072	+ if (v == NULL)
	1073	+ return NULL;
	1074	+
	1075	+ Py_BEGIN_ALLOW_THREADS
	1076	+ ret = ALreadsamps(self->port, (void *) PyString_AsString(v), count);
	1077	+ Py_END_ALLOW_THREADS
	1078	+ if (ret == -1) {
	1079	+ Py_DECREF(v);
	1080	+ return NULL;
	1081	+ }
	1082	+
	1083	+ return (v);
	1084	+}
	1085	+
	1086	+static PyObject *
	1087	+alp_writesamps(alpobject self, PyObject args)
	1088	+{
	1089	+ char *buf;
	1090	+ int size, width;
	1091	+ ALconfig c;
	1092	+ int ret;
	1093	+
	1094	+ if (!PyArg_ParseTuple(args, "s#:writesamps", &buf, &size))
	1095	+ return NULL;
	1096	+
	1097	+ c = ALgetconfig(self->port);
	1098	+#ifdef AL_405
	1099	+ width = ALgetsampfmt(c);
	1100	+ if (width == AL_SAMPFMT_FLOAT)
	1101	+ width = sizeof(float);
	1102	+ else if (width == AL_SAMPFMT_DOUBLE)
	1103	+ width = sizeof(double);
	1104	+ else
	1105	+ width = ALgetwidth(c);
	1106	+#else
	1107	+ width = ALgetwidth(c);
	1108	+#endif /* AL_405 */
	1109	+ ALfreeconfig(c);
	1110	+ Py_BEGIN_ALLOW_THREADS
	1111	+ ret = ALwritesamps (self->port, (void *) buf, (long) size / width);
	1112	+ Py_END_ALLOW_THREADS
	1113	+ if (ret == -1)
	1114	+ return NULL;
	1115	+
	1116	+ Py_INCREF(Py_None);
	1117	+ return Py_None;
	1118	+}
	1119	+
	1120	+static PyObject *
	1121	+alp_getfillpoint(alpobject self, PyObject args)
	1122	+{
	1123	+ long count;
	1124	+
	1125	+ if (!PyArg_ParseTuple(args, ":GetFillPoint"))
	1126	+ return NULL;
	1127	+ if ((count = ALgetfillpoint(self->port)) == -1)
	1128	+ return NULL;
	1129	+ return PyInt_FromLong(count);
	1130	+}
	1131	+
	1132	+static PyObject *
	1133	+alp_setfillpoint(alpobject self, PyObject args)
	1134	+{
	1135	+ long count;
	1136	+
	1137	+ if (!PyArg_ParseTuple(args, "l:SetFillPoint", &count))
	1138	+ return NULL;
	1139	+ if (ALsetfillpoint(self->port, count) == -1)
	1140	+ return NULL;
	1141	+ Py_INCREF(Py_None);
	1142	+ return Py_None;
	1143	+}
	1144	+
	1145	+static PyObject *
	1146	+alp_setconfig(alpobject self, PyObject args)
	1147	+{
	1148	+ alcobject *config;
	1149	+
	1150	+ if (!PyArg_ParseTuple(args, "O!:SetConfig", &Alctype, &config))
	1151	+ return NULL;
	1152	+ if (ALsetconfig(self->port, config->config) == -1)
	1153	+ return NULL;
	1154	+ Py_INCREF(Py_None);
	1155	+ return Py_None;
	1156	+}
	1157	+
	1158	+static PyObject *
	1159	+alp_getconfig(alpobject self, PyObject args)
	1160	+{
	1161	+ ALconfig config;
	1162	+
	1163	+ if (!PyArg_ParseTuple(args, ":GetConfig"))
	1164	+ return NULL;
	1165	+ config = ALgetconfig(self->port);
	1166	+ if (config == NULL)
	1167	+ return NULL;
	1168	+ return newalcobject(config);
	1169	+}
	1170	+
	1171	+#ifdef AL_405
	1172	+static PyObject *
	1173	+alp_getstatus(alpobject self, PyObject args)
	1174	+{
	1175	+ PyObject list, v;
	1176	+ long *PVbuffer;
	1177	+ long length;
	1178	+ int i;
	1179	+
	1180	+ if (!PyArg_ParseTuple(args, "O!", &PyList_Type, &list))
	1181	+ return NULL;
	1182	+ length = PyList_Size(list);
	1183	+ PVbuffer = PyMem_NEW(long, length);
	1184	+ if (PVbuffer == NULL)
	1185	+ return PyErr_NoMemory();
	1186	+ for (i = 0; i < length; i++) {
	1187	+ v = PyList_GetItem(list, i);
	1188	+ if (!PyInt_Check(v)) {
	1189	+ PyMem_DEL(PVbuffer);
	1190	+ PyErr_BadArgument();
	1191	+ return NULL;
	1192	+ }
	1193	+ PVbuffer[i] = PyInt_AsLong(v);
	1194	+ }
	1195	+
	1196	+ if (ALgetstatus(self->port, PVbuffer, length) == -1)
	1197	+ return NULL;
	1198	+
	1199	+ for (i = 0; i < length; i++)
	1200	+ PyList_SetItem(list, i, PyInt_FromLong(PVbuffer[i]));
	1201	+
	1202	+ PyMem_DEL(PVbuffer);
	1203	+
	1204	+ Py_INCREF(Py_None);
	1205	+ return Py_None;
	1206	+}
	1207	+#endif /* AL_405 */
	1208	+
	1209	+#endif /* OLD_INTERFACE */
	1210	+
	1211	+static struct PyMethodDef alp_methods[] = {
	1212	+#ifdef AL_NO_ELEM /* IRIX 6 */
	1213	+ {"SetConfig", (PyCFunction)alp_SetConfig, METH_VARARGS, alp_SetConfig__doc__},
	1214	+ {"GetConfig", (PyCFunction)alp_GetConfig, METH_VARARGS, alp_GetConfig__doc__},
	1215	+ {"GetResource", (PyCFunction)alp_GetResource, METH_VARARGS, alp_GetResource__doc__},
	1216	+ {"GetFD", (PyCFunction)alp_GetFD, METH_VARARGS, alp_GetFD__doc__},
	1217	+ {"GetFilled", (PyCFunction)alp_GetFilled, METH_VARARGS, alp_GetFilled__doc__},
	1218	+ {"GetFillable", (PyCFunction)alp_GetFillable, METH_VARARGS, alp_GetFillable__doc__},
	1219	+ {"ReadFrames", (PyCFunction)alp_ReadFrames, METH_VARARGS, alp_ReadFrames__doc__},
	1220	+ {"DiscardFrames", (PyCFunction)alp_DiscardFrames, METH_VARARGS, alp_DiscardFrames__doc__},
	1221	+ {"ZeroFrames", (PyCFunction)alp_ZeroFrames, METH_VARARGS, alp_ZeroFrames__doc__},
	1222	+ {"SetFillPoint", (PyCFunction)alp_SetFillPoint, METH_VARARGS, alp_SetFillPoint__doc__},
	1223	+ {"GetFillPoint", (PyCFunction)alp_GetFillPoint, METH_VARARGS, alp_GetFillPoint__doc__},
	1224	+ {"GetFrameNumber", (PyCFunction)alp_GetFrameNumber, METH_VARARGS, alp_GetFrameNumber__doc__},
	1225	+ {"GetFrameTime", (PyCFunction)alp_GetFrameTime, METH_VARARGS, alp_GetFrameTime__doc__},
	1226	+ {"WriteFrames", (PyCFunction)alp_WriteFrames, METH_VARARGS, alp_WriteFrames__doc__},
	1227	+ {"ClosePort", (PyCFunction)alp_ClosePort, METH_VARARGS, alp_ClosePort__doc__},
	1228	+#endif /* AL_NO_ELEM */
	1229	+#ifdef OLD_INTERFACE
	1230	+ {"closeport", (PyCFunction)alp_closeport, METH_VARARGS},
	1231	+ {"getfd", (PyCFunction)alp_getfd, METH_VARARGS},
	1232	+ {"fileno", (PyCFunction)alp_getfd, METH_VARARGS},
	1233	+ {"getfilled", (PyCFunction)alp_getfilled, METH_VARARGS},
	1234	+ {"getfillable", (PyCFunction)alp_getfillable, METH_VARARGS},
	1235	+ {"readsamps", (PyCFunction)alp_readsamps, METH_VARARGS},
	1236	+ {"writesamps", (PyCFunction)alp_writesamps, METH_VARARGS},
	1237	+ {"setfillpoint", (PyCFunction)alp_setfillpoint, METH_VARARGS},
	1238	+ {"getfillpoint", (PyCFunction)alp_getfillpoint, METH_VARARGS},
	1239	+ {"setconfig", (PyCFunction)alp_setconfig, METH_VARARGS},
	1240	+ {"getconfig", (PyCFunction)alp_getconfig, METH_VARARGS},
	1241	+#ifdef AL_405
	1242	+ {"getstatus", (PyCFunction)alp_getstatus, METH_VARARGS},
	1243	+#endif /* AL_405 */
	1244	+#endif /* OLD_INTERFACE */
	1245	+
	1246	+ {NULL, NULL} /* sentinel */
	1247	+};
	1248	+
	1249	+/* ---------- */
	1250	+
	1251	+
	1252	+static PyObject *
	1253	+newalpobject(ALport port)
	1254	+{
	1255	+ alpobject *self;
	1256	+
	1257	+ self = PyObject_New(alpobject, &Alptype);
	1258	+ if (self == NULL)
	1259	+ return NULL;
	1260	+ /* XXXX Add your own initializers here */
	1261	+ self->port = port;
	1262	+ return (PyObject *) self;
	1263	+}
	1264	+
	1265	+
	1266	+static void
	1267	+alp_dealloc(alpobject *self)
	1268	+{
	1269	+ /* XXXX Add your own cleanup code here */
	1270	+ if (self->port) {
	1271	+#ifdef AL_NO_ELEM /* IRIX 6 */
	1272	+ alClosePort(self->port);
	1273	+#else
	1274	+ ALcloseport(self->port);
	1275	+#endif
	1276	+ }
	1277	+ PyObject_Del(self);
	1278	+}
	1279	+
	1280	+static PyObject *
	1281	+alp_getattr(alpobject self, char name)
	1282	+{
	1283	+ /* XXXX Add your own getattr code here */
	1284	+ if (self->port == NULL) {
	1285	+ PyErr_SetString(ErrorObject, "port already closed");
	1286	+ return NULL;
	1287	+ }
	1288	+ return Py_FindMethod(alp_methods, (PyObject *)self, name);
	1289	+}
	1290	+
	1291	+PyDoc_STRVAR(Alptype__doc__, "");
	1292	+
	1293	+static PyTypeObject Alptype = {
	1294	+ PyObject_HEAD_INIT(&PyType_Type)
	1295	+ 0, /ob_size/
	1296	+ "al.port", /tp_name/
	1297	+ sizeof(alpobject), /tp_basicsize/
	1298	+ 0, /tp_itemsize/
	1299	+ /* methods */
	1300	+ (destructor)alp_dealloc, /tp_dealloc/
	1301	+ (printfunc)0, /tp_print/
	1302	+ (getattrfunc)alp_getattr, /tp_getattr/
	1303	+ (setattrfunc)0, /tp_setattr/
	1304	+ (cmpfunc)0, /tp_compare/
	1305	+ (reprfunc)0, /tp_repr/
	1306	+ 0, /tp_as_number/
	1307	+ 0, /tp_as_sequence/
	1308	+ 0, /tp_as_mapping/
	1309	+ (hashfunc)0, /tp_hash/
	1310	+ (ternaryfunc)0, /tp_call/
	1311	+ (reprfunc)0, /tp_str/
	1312	+
	1313	+ /* Space for future expansion */
	1314	+ 0L,0L,0L,0L,
	1315	+ Alptype__doc__ /* Documentation string */
	1316	+};
	1317	+
	1318	+/* End of code for port objects */
	1319	+/* -------------------------------------------------------- */
	1320	+
	1321	+
	1322	+#ifdef AL_NO_ELEM /* IRIX 6 */
	1323	+
	1324	+PyDoc_STRVAR(al_NewConfig__doc__,
	1325	+"alNewConfig: create and initialize an audio ALconfig structure.");
	1326	+
	1327	+static PyObject *
	1328	+al_NewConfig(PyObject self, PyObject args)
	1329	+{
	1330	+ ALconfig config;
	1331	+
	1332	+ if (!PyArg_ParseTuple(args, ":NewConfig"))
	1333	+ return NULL;
	1334	+ if ((config = alNewConfig()) == NULL)
	1335	+ return NULL;
	1336	+ return newalcobject(config);
	1337	+}
	1338	+
	1339	+PyDoc_STRVAR(al_OpenPort__doc__,
	1340	+"alOpenPort: open an audio port.");
	1341	+
	1342	+static PyObject *
	1343	+al_OpenPort(PyObject self, PyObject args)
	1344	+{
	1345	+ ALport port;
	1346	+ char name, dir;
	1347	+ alcobject *config = NULL;
	1348	+
	1349	+ if (!PyArg_ParseTuple(args, "ss\|O!:OpenPort", &name, &dir, &Alctype, &config))
	1350	+ return NULL;
	1351	+ if ((port = alOpenPort(name, dir, config ? config->config : NULL)) == NULL)
	1352	+ return NULL;
	1353	+ return newalpobject(port);
	1354	+}
	1355	+
	1356	+PyDoc_STRVAR(al_Connect__doc__,
	1357	+"alConnect: connect two audio I/O resources.");
	1358	+
	1359	+static PyObject *
	1360	+al_Connect(PyObject self, PyObject args)
	1361	+{
	1362	+ int source, dest, nprops = 0, id, i;
	1363	+ ALpv *props = NULL;
	1364	+ ALparamInfo *propinfo = NULL;
	1365	+ PyObject *propobj = NULL;
	1366	+
	1367	+ if (!PyArg_ParseTuple(args, "ii\|O!:Connect", &source, &dest, &PyList_Type, &propobj))
	1368	+ return NULL;
	1369	+ if (propobj != NULL) {
	1370	+ nprops = python2params(source, dest, propobj, &props, &propinfo);
	1371	+ if (nprops < 0)
	1372	+ return NULL;
	1373	+ }
	1374	+
	1375	+ id = alConnect(source, dest, props, nprops);
	1376	+
	1377	+ if (props) {
	1378	+ for (i = 0; i < nprops; i++) {
	1379	+ switch (propinfo[i].valueType) {
	1380	+ case AL_SET_VAL:
	1381	+ case AL_VECTOR_VAL:
	1382	+ PyMem_DEL(props[i].value.ptr);
	1383	+ break;
	1384	+ }
	1385	+ }
	1386	+ PyMem_DEL(props);
	1387	+ PyMem_DEL(propinfo);
	1388	+ }
	1389	+
	1390	+ if (id < 0)
	1391	+ return NULL;
	1392	+ return PyInt_FromLong((long) id);
	1393	+}
	1394	+
	1395	+PyDoc_STRVAR(al_Disconnect__doc__,
	1396	+"alDisconnect: delete a connection between two audio I/O resources.");
	1397	+
	1398	+static PyObject *
	1399	+al_Disconnect(PyObject self, PyObject args)
	1400	+{
	1401	+ int res;
	1402	+
	1403	+ if (!PyArg_ParseTuple(args, "i:Disconnect", &res))
	1404	+ return NULL;
	1405	+ if (alDisconnect(res) < 0)
	1406	+ return NULL;
	1407	+ Py_INCREF(Py_None);
	1408	+ return Py_None;
	1409	+}
	1410	+
	1411	+PyDoc_STRVAR(al_GetParams__doc__,
	1412	+"alGetParams: get the values of audio resource parameters.");
	1413	+
	1414	+static PyObject *
	1415	+al_GetParams(PyObject self, PyObject args)
	1416	+{
	1417	+ int resource;
	1418	+ PyObject pvslist, item = NULL, *v = NULL;
	1419	+ ALpv *pvs;
	1420	+ int i, j, npvs;
	1421	+ ALparamInfo *pinfo;
	1422	+
	1423	+ if (!PyArg_ParseTuple(args, "iO!:GetParams", &resource, &PyList_Type, &pvslist))
	1424	+ return NULL;
	1425	+ npvs = PyList_Size(pvslist);
	1426	+ pvs = PyMem_NEW(ALpv, npvs);
	1427	+ pinfo = PyMem_NEW(ALparamInfo, npvs);
	1428	+ for (i = 0; i < npvs; i++) {
	1429	+ item = PyList_GetItem(pvslist, i);
	1430	+ if (!PyInt_Check(item)) {
	1431	+ item = NULL;
	1432	+ PyErr_SetString(ErrorObject, "list of integers expected");
	1433	+ goto error;
	1434	+ }
	1435	+ pvs[i].param = (int) PyInt_AsLong(item);
	1436	+ item = NULL; /* not needed anymore */
	1437	+ if (alGetParamInfo(resource, pvs[i].param, &pinfo[i]) < 0)
	1438	+ goto error;
	1439	+ switch (pinfo[i].valueType) {
	1440	+ case AL_NO_VAL:
	1441	+ break;
	1442	+ case AL_MATRIX_VAL:
	1443	+ pinfo[i].maxElems *= pinfo[i].maxElems2;
	1444	+ /* fall through */
	1445	+ case AL_STRING_VAL:
	1446	+ case AL_SET_VAL:
	1447	+ case AL_VECTOR_VAL:
	1448	+ switch (pinfo[i].elementType) {
	1449	+ case AL_INT32_ELEM:
	1450	+ case AL_RESOURCE_ELEM:
	1451	+ case AL_ENUM_ELEM:
	1452	+ pvs[i].value.ptr = PyMem_NEW(int, pinfo[i].maxElems);
	1453	+ pvs[i].sizeIn = pinfo[i].maxElems;
	1454	+ break;
	1455	+ case AL_INT64_ELEM:
	1456	+ case AL_FIXED_ELEM:
	1457	+ pvs[i].value.ptr = PyMem_NEW(long long, pinfo[i].maxElems);
	1458	+ pvs[i].sizeIn = pinfo[i].maxElems;
	1459	+ break;
	1460	+ case AL_CHAR_ELEM:
	1461	+ pvs[i].value.ptr = PyMem_NEW(char, 32);
	1462	+ pvs[i].sizeIn = 32;
	1463	+ break;
	1464	+ case AL_NO_ELEM:
	1465	+ case AL_PTR_ELEM:
	1466	+ default:
	1467	+ PyErr_SetString(ErrorObject, "internal error");
	1468	+ goto error;
	1469	+ }
	1470	+ break;
	1471	+ case AL_SCALAR_VAL:
	1472	+ break;
	1473	+ default:
	1474	+ PyErr_SetString(ErrorObject, "internal error");
	1475	+ goto error;
	1476	+ }
	1477	+ if (pinfo[i].valueType == AL_MATRIX_VAL) {
	1478	+ pinfo[i].maxElems /= pinfo[i].maxElems2;
	1479	+ pvs[i].sizeIn /= pinfo[i].maxElems2;
	1480	+ pvs[i].size2In = pinfo[i].maxElems2;
	1481	+ }
	1482	+ }
	1483	+ if (alGetParams(resource, pvs, npvs) < 0)
	1484	+ goto error;
	1485	+ if (!(v = PyList_New(npvs)))
	1486	+ goto error;
	1487	+ for (i = 0; i < npvs; i++) {
	1488	+ if (pvs[i].sizeOut < 0) {
	1489	+ char buf[32];
	1490	+ PyOS_snprintf(buf, sizeof(buf),
	1491	+ "problem with param %d", i);
	1492	+ PyErr_SetString(ErrorObject, buf);
	1493	+ goto error;
	1494	+ }
	1495	+ switch (pinfo[i].valueType) {
	1496	+ case AL_NO_VAL:
	1497	+ item = Py_None;
	1498	+ Py_INCREF(item);
	1499	+ break;
	1500	+ case AL_STRING_VAL:
	1501	+ item = PyString_FromString(pvs[i].value.ptr);
	1502	+ PyMem_DEL(pvs[i].value.ptr);
	1503	+ break;
	1504	+ case AL_MATRIX_VAL:
	1505	+ /* XXXX this is not right */
	1506	+ pvs[i].sizeOut *= pvs[i].size2Out;
	1507	+ /* fall through */
	1508	+ case AL_SET_VAL:
	1509	+ case AL_VECTOR_VAL:
	1510	+ item = PyList_New(pvs[i].sizeOut);
	1511	+ for (j = 0; j < pvs[i].sizeOut; j++) {
	1512	+ switch (pinfo[i].elementType) {
	1513	+ case AL_INT32_ELEM:
	1514	+ case AL_RESOURCE_ELEM:
	1515	+ case AL_ENUM_ELEM:
	1516	+ PyList_SetItem(item, j, PyInt_FromLong((long) ((int *) pvs[i].value.ptr)[j]));
	1517	+ break;
	1518	+ case AL_INT64_ELEM:
	1519	+ PyList_SetItem(item, j, PyLong_FromLongLong(((long long *) pvs[i].value.ptr)[j]));
	1520	+ break;
	1521	+ case AL_FIXED_ELEM:
	1522	+ PyList_SetItem(item, j, PyFloat_FromDouble(alFixedToDouble(((long long *) pvs[i].value.ptr)[j])));
	1523	+ break;
	1524	+ default:
	1525	+ PyErr_SetString(ErrorObject, "internal error");
	1526	+ goto error;
	1527	+ }
	1528	+ }
	1529	+ PyMem_DEL(pvs[i].value.ptr);
	1530	+ break;
	1531	+ case AL_SCALAR_VAL:
	1532	+ item = param2python(resource, pvs[i].param, pvs[i].value, &pinfo[i]);
	1533	+ break;
	1534	+ }
	1535	+ if (PyErr_Occurred() \|\|
	1536	+ PyList_SetItem(v, i, Py_BuildValue("(iO)", pvs[i].param,
	1537	+ item)) < 0 \|\|
	1538	+ PyErr_Occurred())
	1539	+ goto error;
	1540	+ Py_DECREF(item);
	1541	+ }
	1542	+ PyMem_DEL(pvs);
	1543	+ PyMem_DEL(pinfo);
	1544	+ return v;
	1545	+
	1546	+ error:
	1547	+ Py_XDECREF(v);
	1548	+ Py_XDECREF(item);
	1549	+ if (pvs)
	1550	+ PyMem_DEL(pvs);
	1551	+ if (pinfo)
	1552	+ PyMem_DEL(pinfo);
	1553	+ return NULL;
	1554	+}
	1555	+
	1556	+PyDoc_STRVAR(al_SetParams__doc__,
	1557	+"alSetParams: set the values of audio resource parameters.");
	1558	+
	1559	+static PyObject *
	1560	+al_SetParams(PyObject self, PyObject args)
	1561	+{
	1562	+ int resource;
	1563	+ PyObject *pvslist;
	1564	+ ALpv *pvs;
	1565	+ ALparamInfo *pinfo;
	1566	+ int npvs, i;
	1567	+
	1568	+ if (!PyArg_ParseTuple(args, "iO!:SetParams", &resource, &PyList_Type, &pvslist))
	1569	+ return NULL;
	1570	+ npvs = python2params(resource, -1, pvslist, &pvs, &pinfo);
	1571	+ if (npvs < 0)
	1572	+ return NULL;
	1573	+
	1574	+ if (alSetParams(resource, pvs, npvs) < 0)
	1575	+ goto error;
	1576	+
	1577	+ /* cleanup */
	1578	+ for (i = 0; i < npvs; i++) {
	1579	+ switch (pinfo[i].valueType) {
	1580	+ case AL_SET_VAL:
	1581	+ case AL_VECTOR_VAL:
	1582	+ PyMem_DEL(pvs[i].value.ptr);
	1583	+ break;
	1584	+ }
	1585	+ }
	1586	+ PyMem_DEL(pvs);
	1587	+ PyMem_DEL(pinfo);
	1588	+
	1589	+ Py_INCREF(Py_None);
	1590	+ return Py_None;
	1591	+
	1592	+ error:
	1593	+ /* XXXX we should clean up everything */
	1594	+ if (pvs)
	1595	+ PyMem_DEL(pvs);
	1596	+ if (pinfo)
	1597	+ PyMem_DEL(pinfo);
	1598	+ return NULL;
	1599	+}
	1600	+
	1601	+PyDoc_STRVAR(al_QueryValues__doc__,
	1602	+"alQueryValues: get the set of possible values for a parameter.");
	1603	+
	1604	+static PyObject *
	1605	+al_QueryValues(PyObject self, PyObject args)
	1606	+{
	1607	+ int resource, param;
	1608	+ ALvalue *return_set = NULL;
	1609	+ int setsize = 32, qualsize = 0, nvals, i;
	1610	+ ALpv *quals = NULL;
	1611	+ ALparamInfo pinfo;
	1612	+ ALparamInfo *qualinfo = NULL;
	1613	+ PyObject *qualobj = NULL;
	1614	+ PyObject res = NULL, item;
	1615	+
	1616	+ if (!PyArg_ParseTuple(args, "ii\|O!:QueryValues", &resource, &param,
	1617	+ &PyList_Type, &qualobj))
	1618	+ return NULL;
	1619	+ if (qualobj != NULL) {
	1620	+ qualsize = python2params(resource, param, qualobj, &quals, &qualinfo);
	1621	+ if (qualsize < 0)
	1622	+ return NULL;
	1623	+ }
	1624	+ setsize = 32;
	1625	+ return_set = PyMem_NEW(ALvalue, setsize);
	1626	+ if (return_set == NULL) {
	1627	+ PyErr_NoMemory();
	1628	+ goto cleanup;
	1629	+ }
	1630	+
	1631	+ retry:
	1632	+ nvals = alQueryValues(resource, param, return_set, setsize, quals, qualsize);
	1633	+ if (nvals < 0)
	1634	+ goto cleanup;
	1635	+ if (nvals > setsize) {
	1636	+ setsize = nvals;
	1637	+ PyMem_RESIZE(return_set, ALvalue, setsize);
	1638	+ if (return_set == NULL) {
	1639	+ PyErr_NoMemory();
	1640	+ goto cleanup;
	1641	+ }
	1642	+ goto retry;
	1643	+ }
	1644	+
	1645	+ if (alGetParamInfo(resource, param, &pinfo) < 0)
	1646	+ goto cleanup;
	1647	+
	1648	+ res = PyList_New(nvals);
	1649	+ if (res == NULL)
	1650	+ goto cleanup;
	1651	+ for (i = 0; i < nvals; i++) {
	1652	+ item = param2python(resource, param, return_set[i], &pinfo);
	1653	+ if (item == NULL \|\|
	1654	+ PyList_SetItem(res, i, item) < 0) {
	1655	+ Py_DECREF(res);
	1656	+ res = NULL;
	1657	+ goto cleanup;
	1658	+ }
	1659	+ }
	1660	+
	1661	+ cleanup:
	1662	+ if (return_set)
	1663	+ PyMem_DEL(return_set);
	1664	+ if (quals) {
	1665	+ for (i = 0; i < qualsize; i++) {
	1666	+ switch (qualinfo[i].valueType) {
	1667	+ case AL_SET_VAL:
	1668	+ case AL_VECTOR_VAL:
	1669	+ PyMem_DEL(quals[i].value.ptr);
	1670	+ break;
	1671	+ }
	1672	+ }
	1673	+ PyMem_DEL(quals);
	1674	+ PyMem_DEL(qualinfo);
	1675	+ }
	1676	+
	1677	+ return res;
	1678	+}
	1679	+
	1680	+PyDoc_STRVAR(al_GetParamInfo__doc__,
	1681	+"alGetParamInfo: get information about a parameter on "
	1682	+"a particular audio resource.");
	1683	+
	1684	+static PyObject *
	1685	+al_GetParamInfo(PyObject self, PyObject args)
	1686	+{
	1687	+ int res, param;
	1688	+ ALparamInfo pinfo;
	1689	+ PyObject v, item;
	1690	+
	1691	+ if (!PyArg_ParseTuple(args, "ii:GetParamInfo", &res, &param))
	1692	+ return NULL;
	1693	+ if (alGetParamInfo(res, param, &pinfo) < 0)
	1694	+ return NULL;
	1695	+ v = PyDict_New();
	1696	+ if (!v) return NULL;
	1697	+
	1698	+ item = PyInt_FromLong((long) pinfo.resource);
	1699	+ PyDict_SetItemString(v, "resource", item);
	1700	+ Py_DECREF(item);
	1701	+
	1702	+ item = PyInt_FromLong((long) pinfo.param);
	1703	+ PyDict_SetItemString(v, "param", item);
	1704	+ Py_DECREF(item);
	1705	+
	1706	+ item = PyInt_FromLong((long) pinfo.valueType);
	1707	+ PyDict_SetItemString(v, "valueType", item);
	1708	+ Py_DECREF(item);
	1709	+
	1710	+ if (pinfo.valueType != AL_NO_VAL && pinfo.valueType != AL_SCALAR_VAL) {
	1711	+ /* multiple values */
	1712	+ item = PyInt_FromLong((long) pinfo.maxElems);
	1713	+ PyDict_SetItemString(v, "maxElems", item);
	1714	+ Py_DECREF(item);
	1715	+
	1716	+ if (pinfo.valueType == AL_MATRIX_VAL) {
	1717	+ /* 2 dimensional */
	1718	+ item = PyInt_FromLong((long) pinfo.maxElems2);
	1719	+ PyDict_SetItemString(v, "maxElems2", item);
	1720	+ Py_DECREF(item);
	1721	+ }
	1722	+ }
	1723	+
	1724	+ item = PyInt_FromLong((long) pinfo.elementType);
	1725	+ PyDict_SetItemString(v, "elementType", item);
	1726	+ Py_DECREF(item);
	1727	+
	1728	+ item = PyString_FromString(pinfo.name);
	1729	+ PyDict_SetItemString(v, "name", item);
	1730	+ Py_DECREF(item);
	1731	+
	1732	+ item = param2python(res, param, pinfo.initial, &pinfo);
	1733	+ PyDict_SetItemString(v, "initial", item);
	1734	+ Py_DECREF(item);
	1735	+
	1736	+ if (pinfo.elementType != AL_ENUM_ELEM &&
	1737	+ pinfo.elementType != AL_RESOURCE_ELEM &&
	1738	+ pinfo.elementType != AL_CHAR_ELEM) {
	1739	+ /* range param */
	1740	+ item = param2python(res, param, pinfo.min, &pinfo);
	1741	+ PyDict_SetItemString(v, "min", item);
	1742	+ Py_DECREF(item);
	1743	+
	1744	+ item = param2python(res, param, pinfo.max, &pinfo);
	1745	+ PyDict_SetItemString(v, "max", item);
	1746	+ Py_DECREF(item);
	1747	+
	1748	+ item = param2python(res, param, pinfo.minDelta, &pinfo);
	1749	+ PyDict_SetItemString(v, "minDelta", item);
	1750	+ Py_DECREF(item);
	1751	+
	1752	+ item = param2python(res, param, pinfo.maxDelta, &pinfo);
	1753	+ PyDict_SetItemString(v, "maxDelta", item);
	1754	+ Py_DECREF(item);
	1755	+
	1756	+ item = PyInt_FromLong((long) pinfo.specialVals);
	1757	+ PyDict_SetItemString(v, "specialVals", item);
	1758	+ Py_DECREF(item);
	1759	+ }
	1760	+
	1761	+ return v;
	1762	+}
	1763	+
	1764	+PyDoc_STRVAR(al_GetResourceByName__doc__,
	1765	+"alGetResourceByName: find an audio resource by name.");
	1766	+
	1767	+static PyObject *
	1768	+al_GetResourceByName(PyObject self, PyObject args)
	1769	+{
	1770	+ int res, start_res, type;
	1771	+ char *name;
	1772	+
	1773	+ if (!PyArg_ParseTuple(args, "isi:GetResourceByName", &start_res, &name, &type))
	1774	+ return NULL;
	1775	+ if ((res = alGetResourceByName(start_res, name, type)) == 0)
	1776	+ return NULL;
	1777	+ return PyInt_FromLong((long) res);
	1778	+}
	1779	+
	1780	+PyDoc_STRVAR(al_IsSubtype__doc__,
	1781	+"alIsSubtype: indicate if one resource type is a subtype of another.");
	1782	+
	1783	+static PyObject *
	1784	+al_IsSubtype(PyObject self, PyObject args)
	1785	+{
	1786	+ int type, subtype;
	1787	+
	1788	+ if (!PyArg_ParseTuple(args, "ii:IsSubtype", &type, &subtype))
	1789	+ return NULL;
	1790	+ return PyInt_FromLong((long) alIsSubtype(type, subtype));
	1791	+}
	1792	+
	1793	+PyDoc_STRVAR(al_SetErrorHandler__doc__, "");
	1794	+
	1795	+static PyObject *
	1796	+al_SetErrorHandler(PyObject self, PyObject args)
	1797	+{
	1798	+
	1799	+ if (!PyArg_ParseTuple(args, ":SetErrorHandler"))
	1800	+ return NULL;
	1801	+ Py_INCREF(Py_None);
	1802	+ return Py_None;
	1803	+}
	1804	+
	1805	+#endif /* AL_NO_ELEM */
	1806	+
	1807	+#ifdef OLD_INTERFACE
	1808	+
	1809	+static PyObject *
	1810	+al_openport(PyObject self, PyObject args)
	1811	+{
	1812	+ char name, dir;
	1813	+ ALport port;
	1814	+ alcobject *config = NULL;
	1815	+
	1816	+ if (!PyArg_ParseTuple(args, "ss\|O!:OpenPort", &name, &dir, &Alctype, &config))
	1817	+ return NULL;
	1818	+ if ((port = ALopenport(name, dir, config ? config->config : NULL)) == NULL)
	1819	+ return NULL;
	1820	+ return newalpobject(port);
	1821	+}
	1822	+
	1823	+static PyObject *
	1824	+al_newconfig(PyObject self, PyObject args)
	1825	+{
	1826	+ ALconfig config;
	1827	+
	1828	+ if (!PyArg_ParseTuple(args, ":NewConfig"))
	1829	+ return NULL;
	1830	+ if ((config = ALnewconfig ()) == NULL)
	1831	+ return NULL;
	1832	+ return newalcobject(config);
	1833	+}
	1834	+
	1835	+static PyObject *
	1836	+al_queryparams(PyObject self, PyObject args)
	1837	+{
	1838	+ long device;
	1839	+ long length;
	1840	+ long *PVbuffer;
	1841	+ long PVdummy[2];
	1842	+ PyObject *v = NULL;
	1843	+ int i;
	1844	+
	1845	+ if (!PyArg_ParseTuple(args, "l:queryparams", &device))
	1846	+ return NULL;
	1847	+ if ((length = ALqueryparams(device, PVdummy, 2L)) == -1)
	1848	+ return NULL;
	1849	+ if ((PVbuffer = PyMem_NEW(long, length)) == NULL)
	1850	+ return PyErr_NoMemory();
	1851	+ if (ALqueryparams(device, PVbuffer, length) >= 0 &&
	1852	+ (v = PyList_New((int)length)) != NULL) {
	1853	+ for (i = 0; i < length; i++)
	1854	+ PyList_SetItem(v, i, PyInt_FromLong(PVbuffer[i]));
	1855	+ }
	1856	+ PyMem_DEL(PVbuffer);
	1857	+ return v;
	1858	+}
	1859	+
	1860	+static PyObject *
	1861	+doParams(PyObject args, int (func)(long, long *, long), int modified)
	1862	+{
	1863	+ long device;
	1864	+ PyObject list, v;
	1865	+ long *PVbuffer;
	1866	+ long length;
	1867	+ int i;
	1868	+
	1869	+ if (!PyArg_ParseTuple(args, "lO!", &device, &PyList_Type, &list))
	1870	+ return NULL;
	1871	+ length = PyList_Size(list);
	1872	+ PVbuffer = PyMem_NEW(long, length);
	1873	+ if (PVbuffer == NULL)
	1874	+ return PyErr_NoMemory();
	1875	+ for (i = 0; i < length; i++) {
	1876	+ v = PyList_GetItem(list, i);
	1877	+ if (!PyInt_Check(v)) {
	1878	+ PyMem_DEL(PVbuffer);
	1879	+ PyErr_BadArgument();
	1880	+ return NULL;
	1881	+ }
	1882	+ PVbuffer[i] = PyInt_AsLong(v);
	1883	+ }
	1884	+
	1885	+ if ((*func)(device, PVbuffer, length) == -1) {
	1886	+ PyMem_DEL(PVbuffer);
	1887	+ return NULL;
	1888	+ }
	1889	+
	1890	+ if (modified) {
	1891	+ for (i = 0; i < length; i++)
	1892	+ PyList_SetItem(list, i, PyInt_FromLong(PVbuffer[i]));
	1893	+ }
	1894	+
	1895	+ PyMem_DEL(PVbuffer);
	1896	+
	1897	+ Py_INCREF(Py_None);
	1898	+ return Py_None;
	1899	+}
	1900	+
	1901	+static PyObject *
	1902	+al_getparams(PyObject self, PyObject args)
	1903	+{
	1904	+ return doParams(args, ALgetparams, 1);
	1905	+}
	1906	+
	1907	+static PyObject *
	1908	+al_setparams(PyObject self, PyObject args)
	1909	+{
	1910	+ return doParams(args, ALsetparams, 0);
	1911	+}
	1912	+
	1913	+static PyObject *
	1914	+al_getname(PyObject self, PyObject args)
	1915	+{
	1916	+ long device, descriptor;
	1917	+ char *name;
	1918	+
	1919	+ if (!PyArg_ParseTuple(args, "ll:getname", &device, &descriptor))
	1920	+ return NULL;
	1921	+ if ((name = ALgetname(device, descriptor)) == NULL)
	1922	+ return NULL;
	1923	+ return PyString_FromString(name);
	1924	+}
	1925	+
	1926	+static PyObject *
	1927	+al_getdefault(PyObject self, PyObject args)
	1928	+{
	1929	+ long device, descriptor, value;
	1930	+
	1931	+ if (!PyArg_ParseTuple(args, "ll:getdefault", &device, &descriptor))
	1932	+ return NULL;
	1933	+ if ((value = ALgetdefault(device, descriptor)) == -1)
	1934	+ return NULL;
	1935	+ return PyLong_FromLong(value);
	1936	+}
	1937	+
	1938	+static PyObject *
	1939	+al_getminmax(PyObject self, PyObject args)
	1940	+{
	1941	+ long device, descriptor, min, max;
	1942	+
	1943	+ if (!PyArg_ParseTuple(args, "ll:getminmax", &device, &descriptor))
	1944	+ return NULL;
	1945	+ min = -1;
	1946	+ max = -1;
	1947	+ if (ALgetminmax(device, descriptor, &min, &max) == -1)
	1948	+ return NULL;
	1949	+ return Py_BuildValue("ll", min, max);
	1950	+}
	1951	+
	1952	+#endif /* OLD_INTERFACE */
	1953	+
	1954	+/* List of methods defined in the module */
	1955	+
	1956	+static struct PyMethodDef al_methods[] = {
	1957	+#ifdef AL_NO_ELEM /* IRIX 6 */
	1958	+ {"NewConfig", (PyCFunction)al_NewConfig, METH_VARARGS, al_NewConfig__doc__},
	1959	+ {"OpenPort", (PyCFunction)al_OpenPort, METH_VARARGS, al_OpenPort__doc__},
	1960	+ {"Connect", (PyCFunction)al_Connect, METH_VARARGS, al_Connect__doc__},
	1961	+ {"Disconnect", (PyCFunction)al_Disconnect, METH_VARARGS, al_Disconnect__doc__},
	1962	+ {"GetParams", (PyCFunction)al_GetParams, METH_VARARGS, al_GetParams__doc__},
	1963	+ {"SetParams", (PyCFunction)al_SetParams, METH_VARARGS, al_SetParams__doc__},
	1964	+ {"QueryValues", (PyCFunction)al_QueryValues, METH_VARARGS, al_QueryValues__doc__},
	1965	+ {"GetParamInfo", (PyCFunction)al_GetParamInfo, METH_VARARGS, al_GetParamInfo__doc__},
	1966	+ {"GetResourceByName", (PyCFunction)al_GetResourceByName, METH_VARARGS, al_GetResourceByName__doc__},
	1967	+ {"IsSubtype", (PyCFunction)al_IsSubtype, METH_VARARGS, al_IsSubtype__doc__},
	1968	+#if 0
	1969	+ /* this one not supported */
	1970	+ {"SetErrorHandler", (PyCFunction)al_SetErrorHandler, METH_VARARGS, al_SetErrorHandler__doc__},
	1971	+#endif
	1972	+#endif /* AL_NO_ELEM */
	1973	+#ifdef OLD_INTERFACE
	1974	+ {"openport", (PyCFunction)al_openport, METH_VARARGS},
	1975	+ {"newconfig", (PyCFunction)al_newconfig, METH_VARARGS},
	1976	+ {"queryparams", (PyCFunction)al_queryparams, METH_VARARGS},
	1977	+ {"getparams", (PyCFunction)al_getparams, METH_VARARGS},
	1978	+ {"setparams", (PyCFunction)al_setparams, METH_VARARGS},
	1979	+ {"getname", (PyCFunction)al_getname, METH_VARARGS},
	1980	+ {"getdefault", (PyCFunction)al_getdefault, METH_VARARGS},
	1981	+ {"getminmax", (PyCFunction)al_getminmax, METH_VARARGS},
	1982	+#endif /* OLD_INTERFACE */
	1983	+
	1984	+ {NULL, (PyCFunction)NULL, 0, NULL} /* sentinel */
	1985	+};
	1986	+
	1987	+
	1988	+/* Initialization function for the module (must be called inital) */
	1989	+
	1990	+PyDoc_STRVAR(al_module_documentation, "");
	1991	+
	1992	+void
	1993	+inital(void)
	1994	+{
	1995	+ PyObject m, d, *x;
	1996	+
	1997	+ /* Create the module and add the functions */
	1998	+ m = Py_InitModule4("al", al_methods,
	1999	+ al_module_documentation,
	2000	+ (PyObject*)NULL,PYTHON_API_VERSION);
	2001	+ if (m == NULL)
	2002	+ return;
	2003	+
	2004	+ /* Add some symbolic constants to the module */
	2005	+ d = PyModule_GetDict(m);
	2006	+ ErrorObject = PyErr_NewException("al.error", NULL, NULL);
	2007	+ PyDict_SetItemString(d, "error", ErrorObject);
	2008	+
	2009	+ /* XXXX Add constants here */
	2010	+#ifdef AL_4CHANNEL
	2011	+ x = PyInt_FromLong((long) AL_4CHANNEL);
	2012	+ if (x == NULL \|\| PyDict_SetItemString(d, "FOURCHANNEL", x) < 0)
	2013	+ goto error;
	2014	+ Py_DECREF(x);
	2015	+#endif
	2016	+#ifdef AL_ADAT_IF_TYPE
	2017	+ x = PyInt_FromLong((long) AL_ADAT_IF_TYPE);
	2018	+ if (x == NULL \|\| PyDict_SetItemString(d, "ADAT_IF_TYPE", x) < 0)
	2019	+ goto error;
	2020	+ Py_DECREF(x);
	2021	+#endif
	2022	+#ifdef AL_ADAT_MCLK_TYPE
	2023	+ x = PyInt_FromLong((long) AL_ADAT_MCLK_TYPE);
	2024	+ if (x == NULL \|\| PyDict_SetItemString(d, "ADAT_MCLK_TYPE", x) < 0)
	2025	+ goto error;
	2026	+ Py_DECREF(x);
	2027	+#endif
	2028	+#ifdef AL_AES_IF_TYPE
	2029	+ x = PyInt_FromLong((long) AL_AES_IF_TYPE);
	2030	+ if (x == NULL \|\| PyDict_SetItemString(d, "AES_IF_TYPE", x) < 0)
	2031	+ goto error;
	2032	+ Py_DECREF(x);
	2033	+#endif
	2034	+#ifdef AL_AES_MCLK_TYPE
	2035	+ x = PyInt_FromLong((long) AL_AES_MCLK_TYPE);
	2036	+ if (x == NULL \|\| PyDict_SetItemString(d, "AES_MCLK_TYPE", x) < 0)
	2037	+ goto error;
	2038	+ Py_DECREF(x);
	2039	+#endif
	2040	+#ifdef AL_ANALOG_IF_TYPE
	2041	+ x = PyInt_FromLong((long) AL_ANALOG_IF_TYPE);
	2042	+ if (x == NULL \|\| PyDict_SetItemString(d, "ANALOG_IF_TYPE", x) < 0)
	2043	+ goto error;
	2044	+ Py_DECREF(x);
	2045	+#endif
	2046	+#ifdef AL_ASSOCIATE
	2047	+ x = PyInt_FromLong((long) AL_ASSOCIATE);
	2048	+ if (x == NULL \|\| PyDict_SetItemString(d, "ASSOCIATE", x) < 0)
	2049	+ goto error;
	2050	+ Py_DECREF(x);
	2051	+#endif
	2052	+#ifdef AL_BAD_BUFFER_NULL
	2053	+ x = PyInt_FromLong((long) AL_BAD_BUFFER_NULL);
	2054	+ if (x == NULL \|\| PyDict_SetItemString(d, "BAD_BUFFER_NULL", x) < 0)
	2055	+ goto error;
	2056	+ Py_DECREF(x);
	2057	+#endif
	2058	+#ifdef AL_BAD_BUFFERLENGTH
	2059	+ x = PyInt_FromLong((long) AL_BAD_BUFFERLENGTH);
	2060	+ if (x == NULL \|\| PyDict_SetItemString(d, "BAD_BUFFERLENGTH", x) < 0)
	2061	+ goto error;
	2062	+ Py_DECREF(x);
	2063	+#endif
	2064	+#ifdef AL_BAD_BUFFERLENGTH_NEG
	2065	+ x = PyInt_FromLong((long) AL_BAD_BUFFERLENGTH_NEG);
	2066	+ if (x == NULL \|\| PyDict_SetItemString(d, "BAD_BUFFERLENGTH_NEG", x) < 0)
	2067	+ goto error;
	2068	+ Py_DECREF(x);
	2069	+#endif
	2070	+#ifdef AL_BAD_BUFFERLENGTH_ODD
	2071	+ x = PyInt_FromLong((long) AL_BAD_BUFFERLENGTH_ODD);
	2072	+ if (x == NULL \|\| PyDict_SetItemString(d, "BAD_BUFFERLENGTH_ODD", x) < 0)
	2073	+ goto error;
	2074	+ Py_DECREF(x);
	2075	+#endif
	2076	+#ifdef AL_BAD_CHANNELS
	2077	+ x = PyInt_FromLong((long) AL_BAD_CHANNELS);
	2078	+ if (x == NULL \|\| PyDict_SetItemString(d, "BAD_CHANNELS", x) < 0)
	2079	+ goto error;
	2080	+ Py_DECREF(x);
	2081	+#endif
	2082	+#ifdef AL_BAD_CONFIG
	2083	+ x = PyInt_FromLong((long) AL_BAD_CONFIG);
	2084	+ if (x == NULL \|\| PyDict_SetItemString(d, "BAD_CONFIG", x) < 0)
	2085	+ goto error;
	2086	+ Py_DECREF(x);
	2087	+#endif
	2088	+#ifdef AL_BAD_COUNT_NEG
	2089	+ x = PyInt_FromLong((long) AL_BAD_COUNT_NEG);
	2090	+ if (x == NULL \|\| PyDict_SetItemString(d, "BAD_COUNT_NEG", x) < 0)
	2091	+ goto error;
	2092	+ Py_DECREF(x);
	2093	+#endif
	2094	+#ifdef AL_BAD_DEVICE
	2095	+ x = PyInt_FromLong((long) AL_BAD_DEVICE);
	2096	+ if (x == NULL \|\| PyDict_SetItemString(d, "BAD_DEVICE", x) < 0)
	2097	+ goto error;
	2098	+ Py_DECREF(x);
	2099	+#endif
	2100	+#ifdef AL_BAD_DEVICE_ACCESS
	2101	+ x = PyInt_FromLong((long) AL_BAD_DEVICE_ACCESS);
	2102	+ if (x == NULL \|\| PyDict_SetItemString(d, "BAD_DEVICE_ACCESS", x) < 0)
	2103	+ goto error;
	2104	+ Py_DECREF(x);
	2105	+#endif
	2106	+#ifdef AL_BAD_DIRECTION
	2107	+ x = PyInt_FromLong((long) AL_BAD_DIRECTION);
	2108	+ if (x == NULL \|\| PyDict_SetItemString(d, "BAD_DIRECTION", x) < 0)
	2109	+ goto error;
	2110	+ Py_DECREF(x);
	2111	+#endif
	2112	+#ifdef AL_BAD_FILLPOINT
	2113	+ x = PyInt_FromLong((long) AL_BAD_FILLPOINT);
	2114	+ if (x == NULL \|\| PyDict_SetItemString(d, "BAD_FILLPOINT", x) < 0)
	2115	+ goto error;
	2116	+ Py_DECREF(x);
	2117	+#endif
	2118	+#ifdef AL_BAD_FLOATMAX
	2119	+ x = PyInt_FromLong((long) AL_BAD_FLOATMAX);
	2120	+ if (x == NULL \|\| PyDict_SetItemString(d, "BAD_FLOATMAX", x) < 0)
	2121	+ goto error;
	2122	+ Py_DECREF(x);
	2123	+#endif
	2124	+#ifdef AL_BAD_ILLEGAL_STATE
	2125	+ x = PyInt_FromLong((long) AL_BAD_ILLEGAL_STATE);
	2126	+ if (x == NULL \|\| PyDict_SetItemString(d, "BAD_ILLEGAL_STATE", x) < 0)
	2127	+ goto error;
	2128	+ Py_DECREF(x);
	2129	+#endif
	2130	+#ifdef AL_BAD_NO_PORTS
	2131	+ x = PyInt_FromLong((long) AL_BAD_NO_PORTS);
	2132	+ if (x == NULL \|\| PyDict_SetItemString(d, "BAD_NO_PORTS", x) < 0)
	2133	+ goto error;
	2134	+ Py_DECREF(x);
	2135	+#endif
	2136	+#ifdef AL_BAD_NOT_FOUND
	2137	+ x = PyInt_FromLong((long) AL_BAD_NOT_FOUND);
	2138	+ if (x == NULL \|\| PyDict_SetItemString(d, "BAD_NOT_FOUND", x) < 0)
	2139	+ goto error;
	2140	+ Py_DECREF(x);
	2141	+#endif
	2142	+#ifdef AL_BAD_NOT_IMPLEMENTED
	2143	+ x = PyInt_FromLong((long) AL_BAD_NOT_IMPLEMENTED);
	2144	+ if (x == NULL \|\| PyDict_SetItemString(d, "BAD_NOT_IMPLEMENTED", x) < 0)
	2145	+ goto error;
	2146	+ Py_DECREF(x);
	2147	+#endif
	2148	+#ifdef AL_BAD_OUT_OF_MEM
	2149	+ x = PyInt_FromLong((long) AL_BAD_OUT_OF_MEM);
	2150	+ if (x == NULL \|\| PyDict_SetItemString(d, "BAD_OUT_OF_MEM", x) < 0)
	2151	+ goto error;
	2152	+ Py_DECREF(x);
	2153	+#endif
	2154	+#ifdef AL_BAD_PARAM
	2155	+ x = PyInt_FromLong((long) AL_BAD_PARAM);
	2156	+ if (x == NULL \|\| PyDict_SetItemString(d, "BAD_PARAM", x) < 0)
	2157	+ goto error;
	2158	+ Py_DECREF(x);
	2159	+#endif
	2160	+#ifdef AL_BAD_PERMISSIONS
	2161	+ x = PyInt_FromLong((long) AL_BAD_PERMISSIONS);
	2162	+ if (x == NULL \|\| PyDict_SetItemString(d, "BAD_PERMISSIONS", x) < 0)
	2163	+ goto error;
	2164	+ Py_DECREF(x);
	2165	+#endif
	2166	+#ifdef AL_BAD_PORT
	2167	+ x = PyInt_FromLong((long) AL_BAD_PORT);
	2168	+ if (x == NULL \|\| PyDict_SetItemString(d, "BAD_PORT", x) < 0)
	2169	+ goto error;
	2170	+ Py_DECREF(x);
	2171	+#endif
	2172	+#ifdef AL_BAD_PORTSTYLE
	2173	+ x = PyInt_FromLong((long) AL_BAD_PORTSTYLE);
	2174	+ if (x == NULL \|\| PyDict_SetItemString(d, "BAD_PORTSTYLE", x) < 0)
	2175	+ goto error;
	2176	+ Py_DECREF(x);
	2177	+#endif
	2178	+#ifdef AL_BAD_PVBUFFER
	2179	+ x = PyInt_FromLong((long) AL_BAD_PVBUFFER);
	2180	+ if (x == NULL \|\| PyDict_SetItemString(d, "BAD_PVBUFFER", x) < 0)
	2181	+ goto error;
	2182	+ Py_DECREF(x);
	2183	+#endif
	2184	+#ifdef AL_BAD_QSIZE
	2185	+ x = PyInt_FromLong((long) AL_BAD_QSIZE);
	2186	+ if (x == NULL \|\| PyDict_SetItemString(d, "BAD_QSIZE", x) < 0)
	2187	+ goto error;
	2188	+ Py_DECREF(x);
	2189	+#endif
	2190	+#ifdef AL_BAD_RATE
	2191	+ x = PyInt_FromLong((long) AL_BAD_RATE);
	2192	+ if (x == NULL \|\| PyDict_SetItemString(d, "BAD_RATE", x) < 0)
	2193	+ goto error;
	2194	+ Py_DECREF(x);
	2195	+#endif
	2196	+#ifdef AL_BAD_RESOURCE
	2197	+ x = PyInt_FromLong((long) AL_BAD_RESOURCE);
	2198	+ if (x == NULL \|\| PyDict_SetItemString(d, "BAD_RESOURCE", x) < 0)
	2199	+ goto error;
	2200	+ Py_DECREF(x);
	2201	+#endif
	2202	+#ifdef AL_BAD_SAMPFMT
	2203	+ x = PyInt_FromLong((long) AL_BAD_SAMPFMT);
	2204	+ if (x == NULL \|\| PyDict_SetItemString(d, "BAD_SAMPFMT", x) < 0)
	2205	+ goto error;
	2206	+ Py_DECREF(x);
	2207	+#endif
	2208	+#ifdef AL_BAD_TRANSFER_SIZE
	2209	+ x = PyInt_FromLong((long) AL_BAD_TRANSFER_SIZE);
	2210	+ if (x == NULL \|\| PyDict_SetItemString(d, "BAD_TRANSFER_SIZE", x) < 0)
	2211	+ goto error;
	2212	+ Py_DECREF(x);
	2213	+#endif
	2214	+#ifdef AL_BAD_WIDTH
	2215	+ x = PyInt_FromLong((long) AL_BAD_WIDTH);
	2216	+ if (x == NULL \|\| PyDict_SetItemString(d, "BAD_WIDTH", x) < 0)
	2217	+ goto error;
	2218	+ Py_DECREF(x);
	2219	+#endif
	2220	+#ifdef AL_CHANNEL_MODE
	2221	+ x = PyInt_FromLong((long) AL_CHANNEL_MODE);
	2222	+ if (x == NULL \|\| PyDict_SetItemString(d, "CHANNEL_MODE", x) < 0)
	2223	+ goto error;
	2224	+ Py_DECREF(x);
	2225	+#endif
	2226	+#ifdef AL_CHANNELS
	2227	+ x = PyInt_FromLong((long) AL_CHANNELS);
	2228	+ if (x == NULL \|\| PyDict_SetItemString(d, "CHANNELS", x) < 0)
	2229	+ goto error;
	2230	+ Py_DECREF(x);
	2231	+#endif
	2232	+#ifdef AL_CHAR_ELEM
	2233	+ x = PyInt_FromLong((long) AL_CHAR_ELEM);
	2234	+ if (x == NULL \|\| PyDict_SetItemString(d, "CHAR_ELEM", x) < 0)
	2235	+ goto error;
	2236	+ Py_DECREF(x);
	2237	+#endif
	2238	+#ifdef AL_CLOCK_GEN
	2239	+ x = PyInt_FromLong((long) AL_CLOCK_GEN);
	2240	+ if (x == NULL \|\| PyDict_SetItemString(d, "CLOCK_GEN", x) < 0)
	2241	+ goto error;
	2242	+ Py_DECREF(x);
	2243	+#endif
	2244	+#ifdef AL_CLOCKGEN_TYPE
	2245	+ x = PyInt_FromLong((long) AL_CLOCKGEN_TYPE);
	2246	+ if (x == NULL \|\| PyDict_SetItemString(d, "CLOCKGEN_TYPE", x) < 0)
	2247	+ goto error;
	2248	+ Py_DECREF(x);
	2249	+#endif
	2250	+#ifdef AL_CONNECT
	2251	+ x = PyInt_FromLong((long) AL_CONNECT);
	2252	+ if (x == NULL \|\| PyDict_SetItemString(d, "CONNECT", x) < 0)
	2253	+ goto error;
	2254	+ Py_DECREF(x);
	2255	+#endif
	2256	+#ifdef AL_CONNECTION_TYPE
	2257	+ x = PyInt_FromLong((long) AL_CONNECTION_TYPE);
	2258	+ if (x == NULL \|\| PyDict_SetItemString(d, "CONNECTION_TYPE", x) < 0)
	2259	+ goto error;
	2260	+ Py_DECREF(x);
	2261	+#endif
	2262	+#ifdef AL_CONNECTIONS
	2263	+ x = PyInt_FromLong((long) AL_CONNECTIONS);
	2264	+ if (x == NULL \|\| PyDict_SetItemString(d, "CONNECTIONS", x) < 0)
	2265	+ goto error;
	2266	+ Py_DECREF(x);
	2267	+#endif
	2268	+#ifdef AL_CRYSTAL_MCLK_TYPE
	2269	+ x = PyInt_FromLong((long) AL_CRYSTAL_MCLK_TYPE);
	2270	+ if (x == NULL \|\| PyDict_SetItemString(d, "CRYSTAL_MCLK_TYPE", x) < 0)
	2271	+ goto error;
	2272	+ Py_DECREF(x);
	2273	+#endif
	2274	+#ifdef AL_DEFAULT_DEVICE
	2275	+ x = PyInt_FromLong((long) AL_DEFAULT_DEVICE);
	2276	+ if (x == NULL \|\| PyDict_SetItemString(d, "DEFAULT_DEVICE", x) < 0)
	2277	+ goto error;
	2278	+ Py_DECREF(x);
	2279	+#endif
	2280	+#ifdef AL_DEFAULT_INPUT
	2281	+ x = PyInt_FromLong((long) AL_DEFAULT_INPUT);
	2282	+ if (x == NULL \|\| PyDict_SetItemString(d, "DEFAULT_INPUT", x) < 0)
	2283	+ goto error;
	2284	+ Py_DECREF(x);
	2285	+#endif
	2286	+#ifdef AL_DEFAULT_OUTPUT
	2287	+ x = PyInt_FromLong((long) AL_DEFAULT_OUTPUT);
	2288	+ if (x == NULL \|\| PyDict_SetItemString(d, "DEFAULT_OUTPUT", x) < 0)
	2289	+ goto error;
	2290	+ Py_DECREF(x);
	2291	+#endif
	2292	+#ifdef AL_DEST
	2293	+ x = PyInt_FromLong((long) AL_DEST);
	2294	+ if (x == NULL \|\| PyDict_SetItemString(d, "DEST", x) < 0)
	2295	+ goto error;
	2296	+ Py_DECREF(x);
	2297	+#endif
	2298	+#ifdef AL_DEVICE_TYPE
	2299	+ x = PyInt_FromLong((long) AL_DEVICE_TYPE);
	2300	+ if (x == NULL \|\| PyDict_SetItemString(d, "DEVICE_TYPE", x) < 0)
	2301	+ goto error;
	2302	+ Py_DECREF(x);
	2303	+#endif
	2304	+#ifdef AL_DEVICES
	2305	+ x = PyInt_FromLong((long) AL_DEVICES);
	2306	+ if (x == NULL \|\| PyDict_SetItemString(d, "DEVICES", x) < 0)
	2307	+ goto error;
	2308	+ Py_DECREF(x);
	2309	+#endif
	2310	+#ifdef AL_DIGITAL_IF_TYPE
	2311	+ x = PyInt_FromLong((long) AL_DIGITAL_IF_TYPE);
	2312	+ if (x == NULL \|\| PyDict_SetItemString(d, "DIGITAL_IF_TYPE", x) < 0)
	2313	+ goto error;
	2314	+ Py_DECREF(x);
	2315	+#endif
	2316	+#ifdef AL_DIGITAL_INPUT_RATE
	2317	+ x = PyInt_FromLong((long) AL_DIGITAL_INPUT_RATE);
	2318	+ if (x == NULL \|\| PyDict_SetItemString(d, "DIGITAL_INPUT_RATE", x) < 0)
	2319	+ goto error;
	2320	+ Py_DECREF(x);
	2321	+#endif
	2322	+#ifdef AL_DISCONNECT
	2323	+ x = PyInt_FromLong((long) AL_DISCONNECT);
	2324	+ if (x == NULL \|\| PyDict_SetItemString(d, "DISCONNECT", x) < 0)
	2325	+ goto error;
	2326	+ Py_DECREF(x);
	2327	+#endif
	2328	+#ifdef AL_ENUM_ELEM
	2329	+ x = PyInt_FromLong((long) AL_ENUM_ELEM);
	2330	+ if (x == NULL \|\| PyDict_SetItemString(d, "ENUM_ELEM", x) < 0)
	2331	+ goto error;
	2332	+ Py_DECREF(x);
	2333	+#endif
	2334	+#ifdef AL_ENUM_VALUE
	2335	+ x = PyInt_FromLong((long) AL_ENUM_VALUE);
	2336	+ if (x == NULL \|\| PyDict_SetItemString(d, "ENUM_VALUE", x) < 0)
	2337	+ goto error;
	2338	+ Py_DECREF(x);
	2339	+#endif
	2340	+#ifdef AL_ERROR_INPUT_OVERFLOW
	2341	+ x = PyInt_FromLong((long) AL_ERROR_INPUT_OVERFLOW);
	2342	+ if (x == NULL \|\| PyDict_SetItemString(d, "ERROR_INPUT_OVERFLOW", x) < 0)
	2343	+ goto error;
	2344	+ Py_DECREF(x);
	2345	+#endif
	2346	+#ifdef AL_ERROR_LENGTH
	2347	+ x = PyInt_FromLong((long) AL_ERROR_LENGTH);
	2348	+ if (x == NULL \|\| PyDict_SetItemString(d, "ERROR_LENGTH", x) < 0)
	2349	+ goto error;
	2350	+ Py_DECREF(x);
	2351	+#endif
	2352	+#ifdef AL_ERROR_LOCATION_LSP
	2353	+ x = PyInt_FromLong((long) AL_ERROR_LOCATION_LSP);
	2354	+ if (x == NULL \|\| PyDict_SetItemString(d, "ERROR_LOCATION_LSP", x) < 0)
	2355	+ goto error;
	2356	+ Py_DECREF(x);
	2357	+#endif
	2358	+#ifdef AL_ERROR_LOCATION_MSP
	2359	+ x = PyInt_FromLong((long) AL_ERROR_LOCATION_MSP);
	2360	+ if (x == NULL \|\| PyDict_SetItemString(d, "ERROR_LOCATION_MSP", x) < 0)
	2361	+ goto error;
	2362	+ Py_DECREF(x);
	2363	+#endif
	2364	+#ifdef AL_ERROR_NUMBER
	2365	+ x = PyInt_FromLong((long) AL_ERROR_NUMBER);
	2366	+ if (x == NULL \|\| PyDict_SetItemString(d, "ERROR_NUMBER", x) < 0)
	2367	+ goto error;
	2368	+ Py_DECREF(x);
	2369	+#endif
	2370	+#ifdef AL_ERROR_OUTPUT_UNDERFLOW
	2371	+ x = PyInt_FromLong((long) AL_ERROR_OUTPUT_UNDERFLOW);
	2372	+ if (x == NULL \|\| PyDict_SetItemString(d, "ERROR_OUTPUT_UNDERFLOW", x) < 0)
	2373	+ goto error;
	2374	+ Py_DECREF(x);
	2375	+#endif
	2376	+#ifdef AL_ERROR_TYPE
	2377	+ x = PyInt_FromLong((long) AL_ERROR_TYPE);
	2378	+ if (x == NULL \|\| PyDict_SetItemString(d, "ERROR_TYPE", x) < 0)
	2379	+ goto error;
	2380	+ Py_DECREF(x);
	2381	+#endif
	2382	+#ifdef AL_FIXED_ELEM
	2383	+ x = PyInt_FromLong((long) AL_FIXED_ELEM);
	2384	+ if (x == NULL \|\| PyDict_SetItemString(d, "FIXED_ELEM", x) < 0)
	2385	+ goto error;
	2386	+ Py_DECREF(x);
	2387	+#endif
	2388	+#ifdef AL_FIXED_MCLK_TYPE
	2389	+ x = PyInt_FromLong((long) AL_FIXED_MCLK_TYPE);
	2390	+ if (x == NULL \|\| PyDict_SetItemString(d, "FIXED_MCLK_TYPE", x) < 0)
	2391	+ goto error;
	2392	+ Py_DECREF(x);
	2393	+#endif
	2394	+#ifdef AL_GAIN
	2395	+ x = PyInt_FromLong((long) AL_GAIN);
	2396	+ if (x == NULL \|\| PyDict_SetItemString(d, "GAIN", x) < 0)
	2397	+ goto error;
	2398	+ Py_DECREF(x);
	2399	+#endif
	2400	+#ifdef AL_GAIN_REF
	2401	+ x = PyInt_FromLong((long) AL_GAIN_REF);
	2402	+ if (x == NULL \|\| PyDict_SetItemString(d, "GAIN_REF", x) < 0)
	2403	+ goto error;
	2404	+ Py_DECREF(x);
	2405	+#endif
	2406	+#ifdef AL_HRB_TYPE
	2407	+ x = PyInt_FromLong((long) AL_HRB_TYPE);
	2408	+ if (x == NULL \|\| PyDict_SetItemString(d, "HRB_TYPE", x) < 0)
	2409	+ goto error;
	2410	+ Py_DECREF(x);
	2411	+#endif
	2412	+#ifdef AL_INPUT_COUNT
	2413	+ x = PyInt_FromLong((long) AL_INPUT_COUNT);
	2414	+ if (x == NULL \|\| PyDict_SetItemString(d, "INPUT_COUNT", x) < 0)
	2415	+ goto error;
	2416	+ Py_DECREF(x);
	2417	+#endif
	2418	+#ifdef AL_INPUT_DEVICE_TYPE
	2419	+ x = PyInt_FromLong((long) AL_INPUT_DEVICE_TYPE);
	2420	+ if (x == NULL \|\| PyDict_SetItemString(d, "INPUT_DEVICE_TYPE", x) < 0)
	2421	+ goto error;
	2422	+ Py_DECREF(x);
	2423	+#endif
	2424	+#ifdef AL_INPUT_DIGITAL
	2425	+ x = PyInt_FromLong((long) AL_INPUT_DIGITAL);
	2426	+ if (x == NULL \|\| PyDict_SetItemString(d, "INPUT_DIGITAL", x) < 0)
	2427	+ goto error;
	2428	+ Py_DECREF(x);
	2429	+#endif
	2430	+#ifdef AL_INPUT_HRB_TYPE
	2431	+ x = PyInt_FromLong((long) AL_INPUT_HRB_TYPE);
	2432	+ if (x == NULL \|\| PyDict_SetItemString(d, "INPUT_HRB_TYPE", x) < 0)
	2433	+ goto error;
	2434	+ Py_DECREF(x);
	2435	+#endif
	2436	+#ifdef AL_INPUT_LINE
	2437	+ x = PyInt_FromLong((long) AL_INPUT_LINE);
	2438	+ if (x == NULL \|\| PyDict_SetItemString(d, "INPUT_LINE", x) < 0)
	2439	+ goto error;
	2440	+ Py_DECREF(x);
	2441	+#endif
	2442	+#ifdef AL_INPUT_MIC
	2443	+ x = PyInt_FromLong((long) AL_INPUT_MIC);
	2444	+ if (x == NULL \|\| PyDict_SetItemString(d, "INPUT_MIC", x) < 0)
	2445	+ goto error;
	2446	+ Py_DECREF(x);
	2447	+#endif
	2448	+#ifdef AL_INPUT_PORT_TYPE
	2449	+ x = PyInt_FromLong((long) AL_INPUT_PORT_TYPE);
	2450	+ if (x == NULL \|\| PyDict_SetItemString(d, "INPUT_PORT_TYPE", x) < 0)
	2451	+ goto error;
	2452	+ Py_DECREF(x);
	2453	+#endif
	2454	+#ifdef AL_INPUT_RATE
	2455	+ x = PyInt_FromLong((long) AL_INPUT_RATE);
	2456	+ if (x == NULL \|\| PyDict_SetItemString(d, "INPUT_RATE", x) < 0)
	2457	+ goto error;
	2458	+ Py_DECREF(x);
	2459	+#endif
	2460	+#ifdef AL_INPUT_SOURCE
	2461	+ x = PyInt_FromLong((long) AL_INPUT_SOURCE);
	2462	+ if (x == NULL \|\| PyDict_SetItemString(d, "INPUT_SOURCE", x) < 0)
	2463	+ goto error;
	2464	+ Py_DECREF(x);
	2465	+#endif
	2466	+#ifdef AL_INT32_ELEM
	2467	+ x = PyInt_FromLong((long) AL_INT32_ELEM);
	2468	+ if (x == NULL \|\| PyDict_SetItemString(d, "INT32_ELEM", x) < 0)
	2469	+ goto error;
	2470	+ Py_DECREF(x);
	2471	+#endif
	2472	+#ifdef AL_INT64_ELEM
	2473	+ x = PyInt_FromLong((long) AL_INT64_ELEM);
	2474	+ if (x == NULL \|\| PyDict_SetItemString(d, "INT64_ELEM", x) < 0)
	2475	+ goto error;
	2476	+ Py_DECREF(x);
	2477	+#endif
	2478	+#ifdef AL_INTERFACE
	2479	+ x = PyInt_FromLong((long) AL_INTERFACE);
	2480	+ if (x == NULL \|\| PyDict_SetItemString(d, "INTERFACE", x) < 0)
	2481	+ goto error;
	2482	+ Py_DECREF(x);
	2483	+#endif
	2484	+#ifdef AL_INTERFACE_TYPE
	2485	+ x = PyInt_FromLong((long) AL_INTERFACE_TYPE);
	2486	+ if (x == NULL \|\| PyDict_SetItemString(d, "INTERFACE_TYPE", x) < 0)
	2487	+ goto error;
	2488	+ Py_DECREF(x);
	2489	+#endif
	2490	+#ifdef AL_INVALID_PARAM
	2491	+ x = PyInt_FromLong((long) AL_INVALID_PARAM);
	2492	+ if (x == NULL \|\| PyDict_SetItemString(d, "INVALID_PARAM", x) < 0)
	2493	+ goto error;
	2494	+ Py_DECREF(x);
	2495	+#endif
	2496	+#ifdef AL_INVALID_VALUE
	2497	+ x = PyInt_FromLong((long) AL_INVALID_VALUE);
	2498	+ if (x == NULL \|\| PyDict_SetItemString(d, "INVALID_VALUE", x) < 0)
	2499	+ goto error;
	2500	+ Py_DECREF(x);
	2501	+#endif
	2502	+#ifdef AL_JITTER
	2503	+ x = PyInt_FromLong((long) AL_JITTER);
	2504	+ if (x == NULL \|\| PyDict_SetItemString(d, "JITTER", x) < 0)
	2505	+ goto error;
	2506	+ Py_DECREF(x);
	2507	+#endif
	2508	+#ifdef AL_LABEL
	2509	+ x = PyInt_FromLong((long) AL_LABEL);
	2510	+ if (x == NULL \|\| PyDict_SetItemString(d, "LABEL", x) < 0)
	2511	+ goto error;
	2512	+ Py_DECREF(x);
	2513	+#endif
	2514	+#ifdef AL_LEFT_INPUT_ATTEN
	2515	+ x = PyInt_FromLong((long) AL_LEFT_INPUT_ATTEN);
	2516	+ if (x == NULL \|\| PyDict_SetItemString(d, "LEFT_INPUT_ATTEN", x) < 0)
	2517	+ goto error;
	2518	+ Py_DECREF(x);
	2519	+#endif
	2520	+#ifdef AL_LEFT_MONITOR_ATTEN
	2521	+ x = PyInt_FromLong((long) AL_LEFT_MONITOR_ATTEN);
	2522	+ if (x == NULL \|\| PyDict_SetItemString(d, "LEFT_MONITOR_ATTEN", x) < 0)
	2523	+ goto error;
	2524	+ Py_DECREF(x);
	2525	+#endif
	2526	+#ifdef AL_LEFT_SPEAKER_GAIN
	2527	+ x = PyInt_FromLong((long) AL_LEFT_SPEAKER_GAIN);
	2528	+ if (x == NULL \|\| PyDict_SetItemString(d, "LEFT_SPEAKER_GAIN", x) < 0)
	2529	+ goto error;
	2530	+ Py_DECREF(x);
	2531	+#endif
	2532	+#ifdef AL_LEFT1_INPUT_ATTEN
	2533	+ x = PyInt_FromLong((long) AL_LEFT1_INPUT_ATTEN);
	2534	+ if (x == NULL \|\| PyDict_SetItemString(d, "LEFT1_INPUT_ATTEN", x) < 0)
	2535	+ goto error;
	2536	+ Py_DECREF(x);
	2537	+#endif
	2538	+#ifdef AL_LEFT2_INPUT_ATTEN
	2539	+ x = PyInt_FromLong((long) AL_LEFT2_INPUT_ATTEN);
	2540	+ if (x == NULL \|\| PyDict_SetItemString(d, "LEFT2_INPUT_ATTEN", x) < 0)
	2541	+ goto error;
	2542	+ Py_DECREF(x);
	2543	+#endif
	2544	+#ifdef AL_LINE_IF_TYPE
	2545	+ x = PyInt_FromLong((long) AL_LINE_IF_TYPE);
	2546	+ if (x == NULL \|\| PyDict_SetItemString(d, "LINE_IF_TYPE", x) < 0)
	2547	+ goto error;
	2548	+ Py_DECREF(x);
	2549	+#endif
	2550	+#ifdef AL_LOCKED
	2551	+ x = PyInt_FromLong((long) AL_LOCKED);
	2552	+ if (x == NULL \|\| PyDict_SetItemString(d, "LOCKED", x) < 0)
	2553	+ goto error;
	2554	+ Py_DECREF(x);
	2555	+#endif
	2556	+#ifdef AL_MASTER_CLOCK
	2557	+ x = PyInt_FromLong((long) AL_MASTER_CLOCK);
	2558	+ if (x == NULL \|\| PyDict_SetItemString(d, "MASTER_CLOCK", x) < 0)
	2559	+ goto error;
	2560	+ Py_DECREF(x);
	2561	+#endif
	2562	+#ifdef AL_MATRIX_VAL
	2563	+ x = PyInt_FromLong((long) AL_MATRIX_VAL);
	2564	+ if (x == NULL \|\| PyDict_SetItemString(d, "MATRIX_VAL", x) < 0)
	2565	+ goto error;
	2566	+ Py_DECREF(x);
	2567	+#endif
	2568	+#ifdef AL_MAX_ERROR
	2569	+ x = PyInt_FromLong((long) AL_MAX_ERROR);
	2570	+ if (x == NULL \|\| PyDict_SetItemString(d, "MAX_ERROR", x) < 0)
	2571	+ goto error;
	2572	+ Py_DECREF(x);
	2573	+#endif
	2574	+#ifdef AL_MAX_EVENT_PARAM
	2575	+ x = PyInt_FromLong((long) AL_MAX_EVENT_PARAM);
	2576	+ if (x == NULL \|\| PyDict_SetItemString(d, "MAX_EVENT_PARAM", x) < 0)
	2577	+ goto error;
	2578	+ Py_DECREF(x);
	2579	+#endif
	2580	+#ifdef AL_MAX_PBUFSIZE
	2581	+ x = PyInt_FromLong((long) AL_MAX_PBUFSIZE);
	2582	+ if (x == NULL \|\| PyDict_SetItemString(d, "MAX_PBUFSIZE", x) < 0)
	2583	+ goto error;
	2584	+ Py_DECREF(x);
	2585	+#endif
	2586	+#ifdef AL_MAX_PORTS
	2587	+ x = PyInt_FromLong((long) AL_MAX_PORTS);
	2588	+ if (x == NULL \|\| PyDict_SetItemString(d, "MAX_PORTS", x) < 0)
	2589	+ goto error;
	2590	+ Py_DECREF(x);
	2591	+#endif
	2592	+#ifdef AL_MAX_RESOURCE_ID
	2593	+ x = PyInt_FromLong((long) AL_MAX_RESOURCE_ID);
	2594	+ if (x == NULL \|\| PyDict_SetItemString(d, "MAX_RESOURCE_ID", x) < 0)
	2595	+ goto error;
	2596	+ Py_DECREF(x);
	2597	+#endif
	2598	+#ifdef AL_MAX_SETSIZE
	2599	+ x = PyInt_FromLong((long) AL_MAX_SETSIZE);
	2600	+ if (x == NULL \|\| PyDict_SetItemString(d, "MAX_SETSIZE", x) < 0)
	2601	+ goto error;
	2602	+ Py_DECREF(x);
	2603	+#endif
	2604	+#ifdef AL_MAX_STRLEN
	2605	+ x = PyInt_FromLong((long) AL_MAX_STRLEN);
	2606	+ if (x == NULL \|\| PyDict_SetItemString(d, "MAX_STRLEN", x) < 0)
	2607	+ goto error;
	2608	+ Py_DECREF(x);
	2609	+#endif
	2610	+#ifdef AL_MCLK_TYPE
	2611	+ x = PyInt_FromLong((long) AL_MCLK_TYPE);
	2612	+ if (x == NULL \|\| PyDict_SetItemString(d, "MCLK_TYPE", x) < 0)
	2613	+ goto error;
	2614	+ Py_DECREF(x);
	2615	+#endif
	2616	+#ifdef AL_MIC_IF_TYPE
	2617	+ x = PyInt_FromLong((long) AL_MIC_IF_TYPE);
	2618	+ if (x == NULL \|\| PyDict_SetItemString(d, "MIC_IF_TYPE", x) < 0)
	2619	+ goto error;
	2620	+ Py_DECREF(x);
	2621	+#endif
	2622	+#ifdef AL_MONITOR_CTL
	2623	+ x = PyInt_FromLong((long) AL_MONITOR_CTL);
	2624	+ if (x == NULL \|\| PyDict_SetItemString(d, "MONITOR_CTL", x) < 0)
	2625	+ goto error;
	2626	+ Py_DECREF(x);
	2627	+#endif
	2628	+#ifdef AL_MONITOR_OFF
	2629	+ x = PyInt_FromLong((long) AL_MONITOR_OFF);
	2630	+ if (x == NULL \|\| PyDict_SetItemString(d, "MONITOR_OFF", x) < 0)
	2631	+ goto error;
	2632	+ Py_DECREF(x);
	2633	+#endif
	2634	+#ifdef AL_MONITOR_ON
	2635	+ x = PyInt_FromLong((long) AL_MONITOR_ON);
	2636	+ if (x == NULL \|\| PyDict_SetItemString(d, "MONITOR_ON", x) < 0)
	2637	+ goto error;
	2638	+ Py_DECREF(x);
	2639	+#endif
	2640	+#ifdef AL_MONO
	2641	+ x = PyInt_FromLong((long) AL_MONO);
	2642	+ if (x == NULL \|\| PyDict_SetItemString(d, "MONO", x) < 0)
	2643	+ goto error;
	2644	+ Py_DECREF(x);
	2645	+#endif
	2646	+#ifdef AL_MUTE
	2647	+ x = PyInt_FromLong((long) AL_MUTE);
	2648	+ if (x == NULL \|\| PyDict_SetItemString(d, "MUTE", x) < 0)
	2649	+ goto error;
	2650	+ Py_DECREF(x);
	2651	+#endif
	2652	+#ifdef AL_NAME
	2653	+ x = PyInt_FromLong((long) AL_NAME);
	2654	+ if (x == NULL \|\| PyDict_SetItemString(d, "NAME", x) < 0)
	2655	+ goto error;
	2656	+ Py_DECREF(x);
	2657	+#endif
	2658	+#ifdef AL_NEG_INFINITY
	2659	+ x = PyInt_FromLong((long) AL_NEG_INFINITY);
	2660	+ if (x == NULL \|\| PyDict_SetItemString(d, "NEG_INFINITY", x) < 0)
	2661	+ goto error;
	2662	+ Py_DECREF(x);
	2663	+#endif
	2664	+#ifdef AL_NEG_INFINITY_BIT
	2665	+ x = PyInt_FromLong((long) AL_NEG_INFINITY_BIT);
	2666	+ if (x == NULL \|\| PyDict_SetItemString(d, "NEG_INFINITY_BIT", x) < 0)
	2667	+ goto error;
	2668	+ Py_DECREF(x);
	2669	+#endif
	2670	+#ifdef AL_NO_CHANGE
	2671	+ x = PyInt_FromLong((long) AL_NO_CHANGE);
	2672	+ if (x == NULL \|\| PyDict_SetItemString(d, "NO_CHANGE", x) < 0)
	2673	+ goto error;
	2674	+ Py_DECREF(x);
	2675	+#endif
	2676	+#ifdef AL_NO_CHANGE_BIT
	2677	+ x = PyInt_FromLong((long) AL_NO_CHANGE_BIT);
	2678	+ if (x == NULL \|\| PyDict_SetItemString(d, "NO_CHANGE_BIT", x) < 0)
	2679	+ goto error;
	2680	+ Py_DECREF(x);
	2681	+#endif
	2682	+#ifdef AL_NO_ELEM
	2683	+ x = PyInt_FromLong((long) AL_NO_ELEM);
	2684	+ if (x == NULL \|\| PyDict_SetItemString(d, "NO_ELEM", x) < 0)
	2685	+ goto error;
	2686	+ Py_DECREF(x);
	2687	+#endif
	2688	+#ifdef AL_NO_ERRORS
	2689	+ x = PyInt_FromLong((long) AL_NO_ERRORS);
	2690	+ if (x == NULL \|\| PyDict_SetItemString(d, "NO_ERRORS", x) < 0)
	2691	+ goto error;
	2692	+ Py_DECREF(x);
	2693	+#endif
	2694	+#ifdef AL_NO_OP
	2695	+ x = PyInt_FromLong((long) AL_NO_OP);
	2696	+ if (x == NULL \|\| PyDict_SetItemString(d, "NO_OP", x) < 0)
	2697	+ goto error;
	2698	+ Py_DECREF(x);
	2699	+#endif
	2700	+#ifdef AL_NO_VAL
	2701	+ x = PyInt_FromLong((long) AL_NO_VAL);
	2702	+ if (x == NULL \|\| PyDict_SetItemString(d, "NO_VAL", x) < 0)
	2703	+ goto error;
	2704	+ Py_DECREF(x);
	2705	+#endif
	2706	+#ifdef AL_NULL_INTERFACE
	2707	+ x = PyInt_FromLong((long) AL_NULL_INTERFACE);
	2708	+ if (x == NULL \|\| PyDict_SetItemString(d, "NULL_INTERFACE", x) < 0)
	2709	+ goto error;
	2710	+ Py_DECREF(x);
	2711	+#endif
	2712	+#ifdef AL_NULL_RESOURCE
	2713	+ x = PyInt_FromLong((long) AL_NULL_RESOURCE);
	2714	+ if (x == NULL \|\| PyDict_SetItemString(d, "NULL_RESOURCE", x) < 0)
	2715	+ goto error;
	2716	+ Py_DECREF(x);
	2717	+#endif
	2718	+#ifdef AL_OPTICAL_IF_TYPE
	2719	+ x = PyInt_FromLong((long) AL_OPTICAL_IF_TYPE);
	2720	+ if (x == NULL \|\| PyDict_SetItemString(d, "OPTICAL_IF_TYPE", x) < 0)
	2721	+ goto error;
	2722	+ Py_DECREF(x);
	2723	+#endif
	2724	+#ifdef AL_OUTPUT_COUNT
	2725	+ x = PyInt_FromLong((long) AL_OUTPUT_COUNT);
	2726	+ if (x == NULL \|\| PyDict_SetItemString(d, "OUTPUT_COUNT", x) < 0)
	2727	+ goto error;
	2728	+ Py_DECREF(x);
	2729	+#endif
	2730	+#ifdef AL_OUTPUT_DEVICE_TYPE
	2731	+ x = PyInt_FromLong((long) AL_OUTPUT_DEVICE_TYPE);
	2732	+ if (x == NULL \|\| PyDict_SetItemString(d, "OUTPUT_DEVICE_TYPE", x) < 0)
	2733	+ goto error;
	2734	+ Py_DECREF(x);
	2735	+#endif
	2736	+#ifdef AL_OUTPUT_HRB_TYPE
	2737	+ x = PyInt_FromLong((long) AL_OUTPUT_HRB_TYPE);
	2738	+ if (x == NULL \|\| PyDict_SetItemString(d, "OUTPUT_HRB_TYPE", x) < 0)
	2739	+ goto error;
	2740	+ Py_DECREF(x);
	2741	+#endif
	2742	+#ifdef AL_OUTPUT_PORT_TYPE
	2743	+ x = PyInt_FromLong((long) AL_OUTPUT_PORT_TYPE);
	2744	+ if (x == NULL \|\| PyDict_SetItemString(d, "OUTPUT_PORT_TYPE", x) < 0)
	2745	+ goto error;
	2746	+ Py_DECREF(x);
	2747	+#endif
	2748	+#ifdef AL_OUTPUT_RATE
	2749	+ x = PyInt_FromLong((long) AL_OUTPUT_RATE);
	2750	+ if (x == NULL \|\| PyDict_SetItemString(d, "OUTPUT_RATE", x) < 0)
	2751	+ goto error;
	2752	+ Py_DECREF(x);
	2753	+#endif
	2754	+#ifdef AL_PARAM_BIT
	2755	+ x = PyInt_FromLong((long) AL_PARAM_BIT);
	2756	+ if (x == NULL \|\| PyDict_SetItemString(d, "PARAM_BIT", x) < 0)
	2757	+ goto error;
	2758	+ Py_DECREF(x);
	2759	+#endif
	2760	+#ifdef AL_PARAMS
	2761	+ x = PyInt_FromLong((long) AL_PARAMS);
	2762	+ if (x == NULL \|\| PyDict_SetItemString(d, "PARAMS", x) < 0)
	2763	+ goto error;
	2764	+ Py_DECREF(x);
	2765	+#endif
	2766	+#ifdef AL_PORT_COUNT
	2767	+ x = PyInt_FromLong((long) AL_PORT_COUNT);
	2768	+ if (x == NULL \|\| PyDict_SetItemString(d, "PORT_COUNT", x) < 0)
	2769	+ goto error;
	2770	+ Py_DECREF(x);
	2771	+#endif
	2772	+#ifdef AL_PORT_TYPE
	2773	+ x = PyInt_FromLong((long) AL_PORT_TYPE);
	2774	+ if (x == NULL \|\| PyDict_SetItemString(d, "PORT_TYPE", x) < 0)
	2775	+ goto error;
	2776	+ Py_DECREF(x);
	2777	+#endif
	2778	+#ifdef AL_PORTS
	2779	+ x = PyInt_FromLong((long) AL_PORTS);
	2780	+ if (x == NULL \|\| PyDict_SetItemString(d, "PORTS", x) < 0)
	2781	+ goto error;
	2782	+ Py_DECREF(x);
	2783	+#endif
	2784	+#ifdef AL_PORTSTYLE_DIRECT
	2785	+ x = PyInt_FromLong((long) AL_PORTSTYLE_DIRECT);
	2786	+ if (x == NULL \|\| PyDict_SetItemString(d, "PORTSTYLE_DIRECT", x) < 0)
	2787	+ goto error;
	2788	+ Py_DECREF(x);
	2789	+#endif
	2790	+#ifdef AL_PORTSTYLE_SERIAL
	2791	+ x = PyInt_FromLong((long) AL_PORTSTYLE_SERIAL);
	2792	+ if (x == NULL \|\| PyDict_SetItemString(d, "PORTSTYLE_SERIAL", x) < 0)
	2793	+ goto error;
	2794	+ Py_DECREF(x);
	2795	+#endif
	2796	+#ifdef AL_PRINT_ERRORS
	2797	+ x = PyInt_FromLong((long) AL_PRINT_ERRORS);
	2798	+ if (x == NULL \|\| PyDict_SetItemString(d, "PRINT_ERRORS", x) < 0)
	2799	+ goto error;
	2800	+ Py_DECREF(x);
	2801	+#endif
	2802	+#ifdef AL_PTR_ELEM
	2803	+ x = PyInt_FromLong((long) AL_PTR_ELEM);
	2804	+ if (x == NULL \|\| PyDict_SetItemString(d, "PTR_ELEM", x) < 0)
	2805	+ goto error;
	2806	+ Py_DECREF(x);
	2807	+#endif
	2808	+#ifdef AL_RANGE_VALUE
	2809	+ x = PyInt_FromLong((long) AL_RANGE_VALUE);
	2810	+ if (x == NULL \|\| PyDict_SetItemString(d, "RANGE_VALUE", x) < 0)
	2811	+ goto error;
	2812	+ Py_DECREF(x);
	2813	+#endif
	2814	+#ifdef AL_RATE
	2815	+ x = PyInt_FromLong((long) AL_RATE);
	2816	+ if (x == NULL \|\| PyDict_SetItemString(d, "RATE", x) < 0)
	2817	+ goto error;
	2818	+ Py_DECREF(x);
	2819	+#endif
	2820	+#ifdef AL_RATE_11025
	2821	+ x = PyInt_FromLong((long) AL_RATE_11025);
	2822	+ if (x == NULL \|\| PyDict_SetItemString(d, "RATE_11025", x) < 0)
	2823	+ goto error;
	2824	+ Py_DECREF(x);
	2825	+#endif
	2826	+#ifdef AL_RATE_16000
	2827	+ x = PyInt_FromLong((long) AL_RATE_16000);
	2828	+ if (x == NULL \|\| PyDict_SetItemString(d, "RATE_16000", x) < 0)
	2829	+ goto error;
	2830	+ Py_DECREF(x);
	2831	+#endif
	2832	+#ifdef AL_RATE_22050
	2833	+ x = PyInt_FromLong((long) AL_RATE_22050);
	2834	+ if (x == NULL \|\| PyDict_SetItemString(d, "RATE_22050", x) < 0)
	2835	+ goto error;
	2836	+ Py_DECREF(x);
	2837	+#endif
	2838	+#ifdef AL_RATE_32000
	2839	+ x = PyInt_FromLong((long) AL_RATE_32000);
	2840	+ if (x == NULL \|\| PyDict_SetItemString(d, "RATE_32000", x) < 0)
	2841	+ goto error;
	2842	+ Py_DECREF(x);
	2843	+#endif
	2844	+#ifdef AL_RATE_44100
	2845	+ x = PyInt_FromLong((long) AL_RATE_44100);
	2846	+ if (x == NULL \|\| PyDict_SetItemString(d, "RATE_44100", x) < 0)
	2847	+ goto error;
	2848	+ Py_DECREF(x);
	2849	+#endif
	2850	+#ifdef AL_RATE_48000
	2851	+ x = PyInt_FromLong((long) AL_RATE_48000);
	2852	+ if (x == NULL \|\| PyDict_SetItemString(d, "RATE_48000", x) < 0)
	2853	+ goto error;
	2854	+ Py_DECREF(x);
	2855	+#endif
	2856	+#ifdef AL_RATE_8000
	2857	+ x = PyInt_FromLong((long) AL_RATE_8000);
	2858	+ if (x == NULL \|\| PyDict_SetItemString(d, "RATE_8000", x) < 0)
	2859	+ goto error;
	2860	+ Py_DECREF(x);
	2861	+#endif
	2862	+#ifdef AL_RATE_AES_1
	2863	+ x = PyInt_FromLong((long) AL_RATE_AES_1);
	2864	+ if (x == NULL \|\| PyDict_SetItemString(d, "RATE_AES_1", x) < 0)
	2865	+ goto error;
	2866	+ Py_DECREF(x);
	2867	+#endif
	2868	+#ifdef AL_RATE_AES_1s
	2869	+ x = PyInt_FromLong((long) AL_RATE_AES_1s);
	2870	+ if (x == NULL \|\| PyDict_SetItemString(d, "RATE_AES_1s", x) < 0)
	2871	+ goto error;
	2872	+ Py_DECREF(x);
	2873	+#endif
	2874	+#ifdef AL_RATE_AES_2
	2875	+ x = PyInt_FromLong((long) AL_RATE_AES_2);
	2876	+ if (x == NULL \|\| PyDict_SetItemString(d, "RATE_AES_2", x) < 0)
	2877	+ goto error;
	2878	+ Py_DECREF(x);
	2879	+#endif
	2880	+#ifdef AL_RATE_AES_3
	2881	+ x = PyInt_FromLong((long) AL_RATE_AES_3);
	2882	+ if (x == NULL \|\| PyDict_SetItemString(d, "RATE_AES_3", x) < 0)
	2883	+ goto error;
	2884	+ Py_DECREF(x);
	2885	+#endif
	2886	+#ifdef AL_RATE_AES_4
	2887	+ x = PyInt_FromLong((long) AL_RATE_AES_4);
	2888	+ if (x == NULL \|\| PyDict_SetItemString(d, "RATE_AES_4", x) < 0)
	2889	+ goto error;
	2890	+ Py_DECREF(x);
	2891	+#endif
	2892	+#ifdef AL_RATE_AES_6
	2893	+ x = PyInt_FromLong((long) AL_RATE_AES_6);
	2894	+ if (x == NULL \|\| PyDict_SetItemString(d, "RATE_AES_6", x) < 0)
	2895	+ goto error;
	2896	+ Py_DECREF(x);
	2897	+#endif
	2898	+#ifdef AL_RATE_FRACTION_D
	2899	+ x = PyInt_FromLong((long) AL_RATE_FRACTION_D);
	2900	+ if (x == NULL \|\| PyDict_SetItemString(d, "RATE_FRACTION_D", x) < 0)
	2901	+ goto error;
	2902	+ Py_DECREF(x);
	2903	+#endif
	2904	+#ifdef AL_RATE_FRACTION_N
	2905	+ x = PyInt_FromLong((long) AL_RATE_FRACTION_N);
	2906	+ if (x == NULL \|\| PyDict_SetItemString(d, "RATE_FRACTION_N", x) < 0)
	2907	+ goto error;
	2908	+ Py_DECREF(x);
	2909	+#endif
	2910	+#ifdef AL_RATE_INPUTRATE
	2911	+ x = PyInt_FromLong((long) AL_RATE_INPUTRATE);
	2912	+ if (x == NULL \|\| PyDict_SetItemString(d, "RATE_INPUTRATE", x) < 0)
	2913	+ goto error;
	2914	+ Py_DECREF(x);
	2915	+#endif
	2916	+#ifdef AL_RATE_NO_DIGITAL_INPUT
	2917	+ x = PyInt_FromLong((long) AL_RATE_NO_DIGITAL_INPUT);
	2918	+ if (x == NULL \|\| PyDict_SetItemString(d, "RATE_NO_DIGITAL_INPUT", x) < 0)
	2919	+ goto error;
	2920	+ Py_DECREF(x);
	2921	+#endif
	2922	+#ifdef AL_RATE_UNACQUIRED
	2923	+ x = PyInt_FromLong((long) AL_RATE_UNACQUIRED);
	2924	+ if (x == NULL \|\| PyDict_SetItemString(d, "RATE_UNACQUIRED", x) < 0)
	2925	+ goto error;
	2926	+ Py_DECREF(x);
	2927	+#endif
	2928	+#ifdef AL_RATE_UNDEFINED
	2929	+ x = PyInt_FromLong((long) AL_RATE_UNDEFINED);
	2930	+ if (x == NULL \|\| PyDict_SetItemString(d, "RATE_UNDEFINED", x) < 0)
	2931	+ goto error;
	2932	+ Py_DECREF(x);
	2933	+#endif
	2934	+#ifdef AL_REF_0DBV
	2935	+ x = PyInt_FromLong((long) AL_REF_0DBV);
	2936	+ if (x == NULL \|\| PyDict_SetItemString(d, "REF_0DBV", x) < 0)
	2937	+ goto error;
	2938	+ Py_DECREF(x);
	2939	+#endif
	2940	+#ifdef AL_REF_NONE
	2941	+ x = PyInt_FromLong((long) AL_REF_NONE);
	2942	+ if (x == NULL \|\| PyDict_SetItemString(d, "REF_NONE", x) < 0)
	2943	+ goto error;
	2944	+ Py_DECREF(x);
	2945	+#endif
	2946	+#ifdef AL_RESERVED1_TYPE
	2947	+ x = PyInt_FromLong((long) AL_RESERVED1_TYPE);
	2948	+ if (x == NULL \|\| PyDict_SetItemString(d, "RESERVED1_TYPE", x) < 0)
	2949	+ goto error;
	2950	+ Py_DECREF(x);
	2951	+#endif
	2952	+#ifdef AL_RESERVED2_TYPE
	2953	+ x = PyInt_FromLong((long) AL_RESERVED2_TYPE);
	2954	+ if (x == NULL \|\| PyDict_SetItemString(d, "RESERVED2_TYPE", x) < 0)
	2955	+ goto error;
	2956	+ Py_DECREF(x);
	2957	+#endif
	2958	+#ifdef AL_RESERVED3_TYPE
	2959	+ x = PyInt_FromLong((long) AL_RESERVED3_TYPE);
	2960	+ if (x == NULL \|\| PyDict_SetItemString(d, "RESERVED3_TYPE", x) < 0)
	2961	+ goto error;
	2962	+ Py_DECREF(x);
	2963	+#endif
	2964	+#ifdef AL_RESERVED4_TYPE
	2965	+ x = PyInt_FromLong((long) AL_RESERVED4_TYPE);
	2966	+ if (x == NULL \|\| PyDict_SetItemString(d, "RESERVED4_TYPE", x) < 0)
	2967	+ goto error;
	2968	+ Py_DECREF(x);
	2969	+#endif
	2970	+#ifdef AL_RESOURCE
	2971	+ x = PyInt_FromLong((long) AL_RESOURCE);
	2972	+ if (x == NULL \|\| PyDict_SetItemString(d, "RESOURCE", x) < 0)
	2973	+ goto error;
	2974	+ Py_DECREF(x);
	2975	+#endif
	2976	+#ifdef AL_RESOURCE_ELEM
	2977	+ x = PyInt_FromLong((long) AL_RESOURCE_ELEM);
	2978	+ if (x == NULL \|\| PyDict_SetItemString(d, "RESOURCE_ELEM", x) < 0)
	2979	+ goto error;
	2980	+ Py_DECREF(x);
	2981	+#endif
	2982	+#ifdef AL_RESOURCE_TYPE
	2983	+ x = PyInt_FromLong((long) AL_RESOURCE_TYPE);
	2984	+ if (x == NULL \|\| PyDict_SetItemString(d, "RESOURCE_TYPE", x) < 0)
	2985	+ goto error;
	2986	+ Py_DECREF(x);
	2987	+#endif
	2988	+#ifdef AL_RIGHT_INPUT_ATTEN
	2989	+ x = PyInt_FromLong((long) AL_RIGHT_INPUT_ATTEN);
	2990	+ if (x == NULL \|\| PyDict_SetItemString(d, "RIGHT_INPUT_ATTEN", x) < 0)
	2991	+ goto error;
	2992	+ Py_DECREF(x);
	2993	+#endif
	2994	+#ifdef AL_RIGHT_MONITOR_ATTEN
	2995	+ x = PyInt_FromLong((long) AL_RIGHT_MONITOR_ATTEN);
	2996	+ if (x == NULL \|\| PyDict_SetItemString(d, "RIGHT_MONITOR_ATTEN", x) < 0)
	2997	+ goto error;
	2998	+ Py_DECREF(x);
	2999	+#endif
	3000	+#ifdef AL_RIGHT_SPEAKER_GAIN
	3001	+ x = PyInt_FromLong((long) AL_RIGHT_SPEAKER_GAIN);
	3002	+ if (x == NULL \|\| PyDict_SetItemString(d, "RIGHT_SPEAKER_GAIN", x) < 0)
	3003	+ goto error;
	3004	+ Py_DECREF(x);
	3005	+#endif
	3006	+#ifdef AL_RIGHT1_INPUT_ATTEN
	3007	+ x = PyInt_FromLong((long) AL_RIGHT1_INPUT_ATTEN);
	3008	+ if (x == NULL \|\| PyDict_SetItemString(d, "RIGHT1_INPUT_ATTEN", x) < 0)
	3009	+ goto error;
	3010	+ Py_DECREF(x);
	3011	+#endif
	3012	+#ifdef AL_RIGHT2_INPUT_ATTEN
	3013	+ x = PyInt_FromLong((long) AL_RIGHT2_INPUT_ATTEN);
	3014	+ if (x == NULL \|\| PyDict_SetItemString(d, "RIGHT2_INPUT_ATTEN", x) < 0)
	3015	+ goto error;
	3016	+ Py_DECREF(x);
	3017	+#endif
	3018	+#ifdef AL_SAMPFMT_DOUBLE
	3019	+ x = PyInt_FromLong((long) AL_SAMPFMT_DOUBLE);
	3020	+ if (x == NULL \|\| PyDict_SetItemString(d, "SAMPFMT_DOUBLE", x) < 0)
	3021	+ goto error;
	3022	+ Py_DECREF(x);
	3023	+#endif
	3024	+#ifdef AL_SAMPFMT_FLOAT
	3025	+ x = PyInt_FromLong((long) AL_SAMPFMT_FLOAT);
	3026	+ if (x == NULL \|\| PyDict_SetItemString(d, "SAMPFMT_FLOAT", x) < 0)
	3027	+ goto error;
	3028	+ Py_DECREF(x);
	3029	+#endif
	3030	+#ifdef AL_SAMPFMT_TWOSCOMP
	3031	+ x = PyInt_FromLong((long) AL_SAMPFMT_TWOSCOMP);
	3032	+ if (x == NULL \|\| PyDict_SetItemString(d, "SAMPFMT_TWOSCOMP", x) < 0)
	3033	+ goto error;
	3034	+ Py_DECREF(x);
	3035	+#endif
	3036	+#ifdef AL_SAMPLE_16
	3037	+ x = PyInt_FromLong((long) AL_SAMPLE_16);
	3038	+ if (x == NULL \|\| PyDict_SetItemString(d, "SAMPLE_16", x) < 0)
	3039	+ goto error;
	3040	+ Py_DECREF(x);
	3041	+#endif
	3042	+#ifdef AL_SAMPLE_24
	3043	+ x = PyInt_FromLong((long) AL_SAMPLE_24);
	3044	+ if (x == NULL \|\| PyDict_SetItemString(d, "SAMPLE_24", x) < 0)
	3045	+ goto error;
	3046	+ Py_DECREF(x);
	3047	+#endif
	3048	+#ifdef AL_SAMPLE_8
	3049	+ x = PyInt_FromLong((long) AL_SAMPLE_8);
	3050	+ if (x == NULL \|\| PyDict_SetItemString(d, "SAMPLE_8", x) < 0)
	3051	+ goto error;
	3052	+ Py_DECREF(x);
	3053	+#endif
	3054	+#ifdef AL_SCALAR_VAL
	3055	+ x = PyInt_FromLong((long) AL_SCALAR_VAL);
	3056	+ if (x == NULL \|\| PyDict_SetItemString(d, "SCALAR_VAL", x) < 0)
	3057	+ goto error;
	3058	+ Py_DECREF(x);
	3059	+#endif
	3060	+#ifdef AL_SET_VAL
	3061	+ x = PyInt_FromLong((long) AL_SET_VAL);
	3062	+ if (x == NULL \|\| PyDict_SetItemString(d, "SET_VAL", x) < 0)
	3063	+ goto error;
	3064	+ Py_DECREF(x);
	3065	+#endif
	3066	+#ifdef AL_SHORT_NAME
	3067	+ x = PyInt_FromLong((long) AL_SHORT_NAME);
	3068	+ if (x == NULL \|\| PyDict_SetItemString(d, "SHORT_NAME", x) < 0)
	3069	+ goto error;
	3070	+ Py_DECREF(x);
	3071	+#endif
	3072	+#ifdef AL_SMPTE272M_IF_TYPE
	3073	+ x = PyInt_FromLong((long) AL_SMPTE272M_IF_TYPE);
	3074	+ if (x == NULL \|\| PyDict_SetItemString(d, "SMPTE272M_IF_TYPE", x) < 0)
	3075	+ goto error;
	3076	+ Py_DECREF(x);
	3077	+#endif
	3078	+#ifdef AL_SOURCE
	3079	+ x = PyInt_FromLong((long) AL_SOURCE);
	3080	+ if (x == NULL \|\| PyDict_SetItemString(d, "SOURCE", x) < 0)
	3081	+ goto error;
	3082	+ Py_DECREF(x);
	3083	+#endif
	3084	+#ifdef AL_SPEAKER_IF_TYPE
	3085	+ x = PyInt_FromLong((long) AL_SPEAKER_IF_TYPE);
	3086	+ if (x == NULL \|\| PyDict_SetItemString(d, "SPEAKER_IF_TYPE", x) < 0)
	3087	+ goto error;
	3088	+ Py_DECREF(x);
	3089	+#endif
	3090	+#ifdef AL_SPEAKER_MUTE_CTL
	3091	+ x = PyInt_FromLong((long) AL_SPEAKER_MUTE_CTL);
	3092	+ if (x == NULL \|\| PyDict_SetItemString(d, "SPEAKER_MUTE_CTL", x) < 0)
	3093	+ goto error;
	3094	+ Py_DECREF(x);
	3095	+#endif
	3096	+#ifdef AL_SPEAKER_MUTE_OFF
	3097	+ x = PyInt_FromLong((long) AL_SPEAKER_MUTE_OFF);
	3098	+ if (x == NULL \|\| PyDict_SetItemString(d, "SPEAKER_MUTE_OFF", x) < 0)
	3099	+ goto error;
	3100	+ Py_DECREF(x);
	3101	+#endif
	3102	+#ifdef AL_SPEAKER_MUTE_ON
	3103	+ x = PyInt_FromLong((long) AL_SPEAKER_MUTE_ON);
	3104	+ if (x == NULL \|\| PyDict_SetItemString(d, "SPEAKER_MUTE_ON", x) < 0)
	3105	+ goto error;
	3106	+ Py_DECREF(x);
	3107	+#endif
	3108	+#ifdef AL_SPEAKER_PLUS_LINE_IF_TYPE
	3109	+ x = PyInt_FromLong((long) AL_SPEAKER_PLUS_LINE_IF_TYPE);
	3110	+ if (x == NULL \|\| PyDict_SetItemString(d, "SPEAKER_PLUS_LINE_IF_TYPE", x) < 0)
	3111	+ goto error;
	3112	+ Py_DECREF(x);
	3113	+#endif
	3114	+#ifdef AL_STEREO
	3115	+ x = PyInt_FromLong((long) AL_STEREO);
	3116	+ if (x == NULL \|\| PyDict_SetItemString(d, "STEREO", x) < 0)
	3117	+ goto error;
	3118	+ Py_DECREF(x);
	3119	+#endif
	3120	+#ifdef AL_STRING_VAL
	3121	+ x = PyInt_FromLong((long) AL_STRING_VAL);
	3122	+ if (x == NULL \|\| PyDict_SetItemString(d, "STRING_VAL", x) < 0)
	3123	+ goto error;
	3124	+ Py_DECREF(x);
	3125	+#endif
	3126	+#ifdef AL_SUBSYSTEM
	3127	+ x = PyInt_FromLong((long) AL_SUBSYSTEM);
	3128	+ if (x == NULL \|\| PyDict_SetItemString(d, "SUBSYSTEM", x) < 0)
	3129	+ goto error;
	3130	+ Py_DECREF(x);
	3131	+#endif
	3132	+#ifdef AL_SUBSYSTEM_TYPE
	3133	+ x = PyInt_FromLong((long) AL_SUBSYSTEM_TYPE);
	3134	+ if (x == NULL \|\| PyDict_SetItemString(d, "SUBSYSTEM_TYPE", x) < 0)
	3135	+ goto error;
	3136	+ Py_DECREF(x);
	3137	+#endif
	3138	+#ifdef AL_SYNC_INPUT_TO_AES
	3139	+ x = PyInt_FromLong((long) AL_SYNC_INPUT_TO_AES);
	3140	+ if (x == NULL \|\| PyDict_SetItemString(d, "SYNC_INPUT_TO_AES", x) < 0)
	3141	+ goto error;
	3142	+ Py_DECREF(x);
	3143	+#endif
	3144	+#ifdef AL_SYNC_OUTPUT_TO_AES
	3145	+ x = PyInt_FromLong((long) AL_SYNC_OUTPUT_TO_AES);
	3146	+ if (x == NULL \|\| PyDict_SetItemString(d, "SYNC_OUTPUT_TO_AES", x) < 0)
	3147	+ goto error;
	3148	+ Py_DECREF(x);
	3149	+#endif
	3150	+#ifdef AL_SYSTEM
	3151	+ x = PyInt_FromLong((long) AL_SYSTEM);
	3152	+ if (x == NULL \|\| PyDict_SetItemString(d, "SYSTEM", x) < 0)
	3153	+ goto error;
	3154	+ Py_DECREF(x);
	3155	+#endif
	3156	+#ifdef AL_SYSTEM_TYPE
	3157	+ x = PyInt_FromLong((long) AL_SYSTEM_TYPE);
	3158	+ if (x == NULL \|\| PyDict_SetItemString(d, "SYSTEM_TYPE", x) < 0)
	3159	+ goto error;
	3160	+ Py_DECREF(x);
	3161	+#endif
	3162	+#ifdef AL_TEST_IF_TYPE
	3163	+ x = PyInt_FromLong((long) AL_TEST_IF_TYPE);
	3164	+ if (x == NULL \|\| PyDict_SetItemString(d, "TEST_IF_TYPE", x) < 0)
	3165	+ goto error;
	3166	+ Py_DECREF(x);
	3167	+#endif
	3168	+#ifdef AL_TYPE
	3169	+ x = PyInt_FromLong((long) AL_TYPE);
	3170	+ if (x == NULL \|\| PyDict_SetItemString(d, "TYPE", x) < 0)
	3171	+ goto error;
	3172	+ Py_DECREF(x);
	3173	+#endif
	3174	+#ifdef AL_TYPE_BIT
	3175	+ x = PyInt_FromLong((long) AL_TYPE_BIT);
	3176	+ if (x == NULL \|\| PyDict_SetItemString(d, "TYPE_BIT", x) < 0)
	3177	+ goto error;
	3178	+ Py_DECREF(x);
	3179	+#endif
	3180	+#ifdef AL_UNUSED_COUNT
	3181	+ x = PyInt_FromLong((long) AL_UNUSED_COUNT);
	3182	+ if (x == NULL \|\| PyDict_SetItemString(d, "UNUSED_COUNT", x) < 0)
	3183	+ goto error;
	3184	+ Py_DECREF(x);
	3185	+#endif
	3186	+#ifdef AL_UNUSED_PORTS
	3187	+ x = PyInt_FromLong((long) AL_UNUSED_PORTS);
	3188	+ if (x == NULL \|\| PyDict_SetItemString(d, "UNUSED_PORTS", x) < 0)
	3189	+ goto error;
	3190	+ Py_DECREF(x);
	3191	+#endif
	3192	+#ifdef AL_VARIABLE_MCLK_TYPE
	3193	+ x = PyInt_FromLong((long) AL_VARIABLE_MCLK_TYPE);
	3194	+ if (x == NULL \|\| PyDict_SetItemString(d, "VARIABLE_MCLK_TYPE", x) < 0)
	3195	+ goto error;
	3196	+ Py_DECREF(x);
	3197	+#endif
	3198	+#ifdef AL_VECTOR_VAL
	3199	+ x = PyInt_FromLong((long) AL_VECTOR_VAL);
	3200	+ if (x == NULL \|\| PyDict_SetItemString(d, "VECTOR_VAL", x) < 0)
	3201	+ goto error;
	3202	+ Py_DECREF(x);
	3203	+#endif
	3204	+#ifdef AL_VIDEO_MCLK_TYPE
	3205	+ x = PyInt_FromLong((long) AL_VIDEO_MCLK_TYPE);
	3206	+ if (x == NULL \|\| PyDict_SetItemString(d, "VIDEO_MCLK_TYPE", x) < 0)
	3207	+ goto error;
	3208	+ Py_DECREF(x);
	3209	+#endif
	3210	+#ifdef AL_WORDSIZE
	3211	+ x = PyInt_FromLong((long) AL_WORDSIZE);
	3212	+ if (x == NULL \|\| PyDict_SetItemString(d, "WORDSIZE", x) < 0)
	3213	+ goto error;
	3214	+ Py_DECREF(x);
	3215	+#endif
	3216	+
	3217	+#ifdef AL_NO_ELEM /* IRIX 6 */
	3218	+ (void) alSetErrorHandler(ErrorHandler);
	3219	+#endif /* AL_NO_ELEM */
	3220	+#ifdef OLD_INTERFACE
	3221	+ (void) ALseterrorhandler(ErrorHandler);
	3222	+#endif /* OLD_INTERFACE */
	3223	+
	3224	+ error:
	3225	+ return;
	3226	+}

add hg and python

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code