source: python/vendor/Python-2.7.6/Modules/almodule.c

Last change on this file was 388, checked in by dmik, 11 years ago

python: Update vendor to 2.7.6.
  • Property svn:eol-style set to native
File size: 90.0 KB
Line 
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
15static PyObject *ErrorObject;
16
17/* ----------------------------------------------------- */
18
19/* Declarations for objects of type port */
20
21typedef struct {
22 PyObject_HEAD
23 /* XXXX Add your own stuff here */
24 ALport port;
25} alpobject;
26
27static PyTypeObject Alptype;
28
29
30
31/* ---------------------------------------------------------------- */
32
33/* Declarations for objects of type config */
34
35typedef struct {
36 PyObject_HEAD
37 /* XXXX Add your own stuff here */
38 ALconfig config;
39} alcobject;
40
41static PyTypeObject Alctype;
42
43
44static void
45ErrorHandler(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
58static PyObject *
59param2python(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
94static int
95python2elem(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
134static int
135python2param(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
207static int
208python2params(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
245static PyObject *
246SetConfig(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
260static PyObject *
261GetConfig(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
274PyDoc_STRVAR(alc_SetWidth__doc__,
275"alSetWidth: set the wordsize for integer audio data.");
276
277static PyObject *
278alc_SetWidth(alcobject *self, PyObject *args)
279{
280 return SetConfig(self, args, alSetWidth);
281}
282
283
284PyDoc_STRVAR(alc_GetWidth__doc__,
285"alGetWidth: get the wordsize for integer audio data.");
286
287static PyObject *
288alc_GetWidth(alcobject *self, PyObject *args)
289{
290 return GetConfig(self, args, alGetWidth);
291}
292
293
294PyDoc_STRVAR(alc_SetSampFmt__doc__,
295"alSetSampFmt: set the sample format setting in an audio ALconfig "
296"structure.");
297
298static PyObject *
299alc_SetSampFmt(alcobject *self, PyObject *args)
300{
301 return SetConfig(self, args, alSetSampFmt);
302}
303
304
305PyDoc_STRVAR(alc_GetSampFmt__doc__,
306"alGetSampFmt: get the sample format setting in an audio ALconfig "
307"structure.");
308
309static PyObject *
310alc_GetSampFmt(alcobject *self, PyObject *args)
311{
312 return GetConfig(self, args, alGetSampFmt);
313}
314
315
316PyDoc_STRVAR(alc_SetChannels__doc__,
317"alSetChannels: set the channel settings in an audio ALconfig.");
318
319static PyObject *
320alc_SetChannels(alcobject *self, PyObject *args)
321{
322 return SetConfig(self, args, alSetChannels);
323}
324
325
326PyDoc_STRVAR(alc_GetChannels__doc__,
327"alGetChannels: get the channel settings in an audio ALconfig.");
328
329static PyObject *
330alc_GetChannels(alcobject *self, PyObject *args)
331{
332 return GetConfig(self, args, alGetChannels);
333}
334
335
336PyDoc_STRVAR(alc_SetFloatMax__doc__,
337"alSetFloatMax: set the maximum value of floating point sample data.");
338
339static PyObject *
340alc_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
353PyDoc_STRVAR(alc_GetFloatMax__doc__,
354"alGetFloatMax: get the maximum value of floating point sample data.");
355
356static PyObject *
357alc_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
369PyDoc_STRVAR(alc_SetDevice__doc__,
370"alSetDevice: set the device setting in an audio ALconfig structure.");
371
372static PyObject *
373alc_SetDevice(alcobject *self, PyObject *args)
374{
375 return SetConfig(self, args, alSetDevice);
376}
377
378
379PyDoc_STRVAR(alc_GetDevice__doc__,
380"alGetDevice: get the device setting in an audio ALconfig structure.");
381
382static PyObject *
383alc_GetDevice(alcobject *self, PyObject *args)
384{
385 return GetConfig(self, args, alGetDevice);
386}
387
388
389PyDoc_STRVAR(alc_SetQueueSize__doc__,
390"alSetQueueSize: set audio port buffer size.");
391
392static PyObject *
393alc_SetQueueSize(alcobject *self, PyObject *args)
394{
395 return SetConfig(self, args, alSetQueueSize);
396}
397
398
399PyDoc_STRVAR(alc_GetQueueSize__doc__,
400"alGetQueueSize: get audio port buffer size.");
401
402static PyObject *
403alc_GetQueueSize(alcobject *self, PyObject *args)
404{
405 return GetConfig(self, args, alGetQueueSize);
406}
407
408#endif /* AL_NO_ELEM */
409
410static PyObject *
411setconfig(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
425static PyObject *
426getconfig(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
439static PyObject *
440alc_setqueuesize (alcobject *self, PyObject *args)
441{
442 return setconfig(self, args, ALsetqueuesize);
443}
444
445static PyObject *
446alc_getqueuesize (alcobject *self, PyObject *args)
447{
448 return getconfig(self, args, ALgetqueuesize);
449}
450
451static PyObject *
452alc_setwidth (alcobject *self, PyObject *args)
453{
454 return setconfig(self, args, ALsetwidth);
455}
456
457static PyObject *
458alc_getwidth (alcobject *self, PyObject *args)
459{
460 return getconfig(self, args, ALgetwidth);
461}
462
463static PyObject *
464alc_getchannels (alcobject *self, PyObject *args)
465{
466 return getconfig(self, args, ALgetchannels);
467}
468
469static PyObject *
470alc_setchannels (alcobject *self, PyObject *args)
471{
472 return setconfig(self, args, ALsetchannels);
473}
474
475#ifdef AL_405
476
477static PyObject *
478alc_getsampfmt (alcobject *self, PyObject *args)
479{
480 return getconfig(self, args, ALgetsampfmt);
481}
482
483static PyObject *
484alc_setsampfmt (alcobject *self, PyObject *args)
485{
486 return setconfig(self, args, ALsetsampfmt);
487}
488
489static PyObject *
490alc_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
501static PyObject *
502alc_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
515static 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
549static PyObject *
550newalcobject(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
563static void
564alc_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
575static PyObject *
576alc_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
582PyDoc_STRVAR(Alctype__doc__, "");
583
584static 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
614PyDoc_STRVAR(alp_SetConfig__doc__,
615"alSetConfig: set the ALconfig of an audio ALport.");
616
617static PyObject *
618alp_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
630PyDoc_STRVAR(alp_GetConfig__doc__,
631"alGetConfig: get the ALconfig of an audio ALport.");
632
633static PyObject *
634alp_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
645PyDoc_STRVAR(alp_GetResource__doc__,
646"alGetResource: get the resource associated with an audio port.");
647
648static PyObject *
649alp_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
661PyDoc_STRVAR(alp_GetFD__doc__,
662"alGetFD: get the file descriptor for an audio port.");
663
664static PyObject *
665alp_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
679PyDoc_STRVAR(alp_GetFilled__doc__,
680"alGetFilled: return the number of filled sample frames in "
681"an audio port.");
682
683static PyObject *
684alp_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
696PyDoc_STRVAR(alp_GetFillable__doc__,
697"alGetFillable: report the number of unfilled sample frames "
698"in an audio port.");
699
700static PyObject *
701alp_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
713PyDoc_STRVAR(alp_ReadFrames__doc__,
714"alReadFrames: read sample frames from an audio port.");
715
716static PyObject *
717alp_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
780PyDoc_STRVAR(alp_DiscardFrames__doc__,
781"alDiscardFrames: discard audio from an audio port.");
782
783static PyObject *
784alp_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
802PyDoc_STRVAR(alp_ZeroFrames__doc__,
803"alZeroFrames: write zero-valued sample frames to an audio port.");
804
805static PyObject *
806alp_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
827PyDoc_STRVAR(alp_SetFillPoint__doc__,
828"alSetFillPoint: set low- or high-water mark for an audio port.");
829
830static PyObject *
831alp_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
846PyDoc_STRVAR(alp_GetFillPoint__doc__,
847"alGetFillPoint: get low- or high-water mark for an audio port.");
848
849static PyObject *
850alp_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
864PyDoc_STRVAR(alp_GetFrameNumber__doc__,
865"alGetFrameNumber: get the absolute sample frame number "
866"associated with a port.");
867
868static PyObject *
869alp_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
883PyDoc_STRVAR(alp_GetFrameTime__doc__,
884"alGetFrameTime: get the time at which a sample frame came "
885"in or will go out.");
886
887static PyObject *
888alp_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
911PyDoc_STRVAR(alp_WriteFrames__doc__,
912"alWriteFrames: write sample frames to an audio port.");
913
914static PyObject *
915alp_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
976PyDoc_STRVAR(alp_ClosePort__doc__, "alClosePort: close an audio port.");
977
978static PyObject *
979alp_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
993static PyObject *
994alp_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
1005static PyObject *
1006alp_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
1017static PyObject *
1018alp_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
1029static PyObject *
1030alp_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
1041static PyObject *
1042alp_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
1086static PyObject *
1087alp_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
1120static PyObject *
1121alp_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
1132static PyObject *
1133alp_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
1145static PyObject *
1146alp_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
1158static PyObject *
1159alp_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
1172static PyObject *
1173alp_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
1211static 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
1252static PyObject *
1253newalpobject(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
1266static void
1267alp_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
1280static PyObject *
1281alp_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
1291PyDoc_STRVAR(Alptype__doc__, "");
1292
1293static 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
1324PyDoc_STRVAR(al_NewConfig__doc__,
1325"alNewConfig: create and initialize an audio ALconfig structure.");
1326
1327static PyObject *
1328al_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
1339PyDoc_STRVAR(al_OpenPort__doc__,
1340"alOpenPort: open an audio port.");
1341
1342static PyObject *
1343al_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
1356PyDoc_STRVAR(al_Connect__doc__,
1357"alConnect: connect two audio I/O resources.");
1358
1359static PyObject *
1360al_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
1395PyDoc_STRVAR(al_Disconnect__doc__,
1396"alDisconnect: delete a connection between two audio I/O resources.");
1397
1398static PyObject *
1399al_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
1411PyDoc_STRVAR(al_GetParams__doc__,
1412"alGetParams: get the values of audio resource parameters.");
1413
1414static PyObject *
1415al_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
1556PyDoc_STRVAR(al_SetParams__doc__,
1557"alSetParams: set the values of audio resource parameters.");
1558
1559static PyObject *
1560al_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
1601PyDoc_STRVAR(al_QueryValues__doc__,
1602"alQueryValues: get the set of possible values for a parameter.");
1603
1604static PyObject *
1605al_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 ALvalue *old_return_set = return_set;
1637 setsize = nvals;
1638 PyMem_RESIZE(return_set, ALvalue, setsize);
1639 if (return_set == NULL) {
1640 return_set = old_return_set;
1641 PyErr_NoMemory();
1642 goto cleanup;
1643 }
1644 goto retry;
1645 }
1646
1647 if (alGetParamInfo(resource, param, &pinfo) < 0)
1648 goto cleanup;
1649
1650 res = PyList_New(nvals);
1651 if (res == NULL)
1652 goto cleanup;
1653 for (i = 0; i < nvals; i++) {
1654 item = param2python(resource, param, return_set[i], &pinfo);
1655 if (item == NULL ||
1656 PyList_SetItem(res, i, item) < 0) {
1657 Py_DECREF(res);
1658 res = NULL;
1659 goto cleanup;
1660 }
1661 }
1662
1663 cleanup:
1664 if (return_set)
1665 PyMem_DEL(return_set);
1666 if (quals) {
1667 for (i = 0; i < qualsize; i++) {
1668 switch (qualinfo[i].valueType) {
1669 case AL_SET_VAL:
1670 case AL_VECTOR_VAL:
1671 PyMem_DEL(quals[i].value.ptr);
1672 break;
1673 }
1674 }
1675 PyMem_DEL(quals);
1676 PyMem_DEL(qualinfo);
1677 }
1678
1679 return res;
1680}
1681
1682PyDoc_STRVAR(al_GetParamInfo__doc__,
1683"alGetParamInfo: get information about a parameter on "
1684"a particular audio resource.");
1685
1686static PyObject *
1687al_GetParamInfo(PyObject *self, PyObject *args)
1688{
1689 int res, param;
1690 ALparamInfo pinfo;
1691 PyObject *v, *item;
1692
1693 if (!PyArg_ParseTuple(args, "ii:GetParamInfo", &res, &param))
1694 return NULL;
1695 if (alGetParamInfo(res, param, &pinfo) < 0)
1696 return NULL;
1697 v = PyDict_New();
1698 if (!v) return NULL;
1699
1700 item = PyInt_FromLong((long) pinfo.resource);
1701 PyDict_SetItemString(v, "resource", item);
1702 Py_DECREF(item);
1703
1704 item = PyInt_FromLong((long) pinfo.param);
1705 PyDict_SetItemString(v, "param", item);
1706 Py_DECREF(item);
1707
1708 item = PyInt_FromLong((long) pinfo.valueType);
1709 PyDict_SetItemString(v, "valueType", item);
1710 Py_DECREF(item);
1711
1712 if (pinfo.valueType != AL_NO_VAL && pinfo.valueType != AL_SCALAR_VAL) {
1713 /* multiple values */
1714 item = PyInt_FromLong((long) pinfo.maxElems);
1715 PyDict_SetItemString(v, "maxElems", item);
1716 Py_DECREF(item);
1717
1718 if (pinfo.valueType == AL_MATRIX_VAL) {
1719 /* 2 dimensional */
1720 item = PyInt_FromLong((long) pinfo.maxElems2);
1721 PyDict_SetItemString(v, "maxElems2", item);
1722 Py_DECREF(item);
1723 }
1724 }
1725
1726 item = PyInt_FromLong((long) pinfo.elementType);
1727 PyDict_SetItemString(v, "elementType", item);
1728 Py_DECREF(item);
1729
1730 item = PyString_FromString(pinfo.name);
1731 PyDict_SetItemString(v, "name", item);
1732 Py_DECREF(item);
1733
1734 item = param2python(res, param, pinfo.initial, &pinfo);
1735 PyDict_SetItemString(v, "initial", item);
1736 Py_DECREF(item);
1737
1738 if (pinfo.elementType != AL_ENUM_ELEM &&
1739 pinfo.elementType != AL_RESOURCE_ELEM &&
1740 pinfo.elementType != AL_CHAR_ELEM) {
1741 /* range param */
1742 item = param2python(res, param, pinfo.min, &pinfo);
1743 PyDict_SetItemString(v, "min", item);
1744 Py_DECREF(item);
1745
1746 item = param2python(res, param, pinfo.max, &pinfo);
1747 PyDict_SetItemString(v, "max", item);
1748 Py_DECREF(item);
1749
1750 item = param2python(res, param, pinfo.minDelta, &pinfo);
1751 PyDict_SetItemString(v, "minDelta", item);
1752 Py_DECREF(item);
1753
1754 item = param2python(res, param, pinfo.maxDelta, &pinfo);
1755 PyDict_SetItemString(v, "maxDelta", item);
1756 Py_DECREF(item);
1757
1758 item = PyInt_FromLong((long) pinfo.specialVals);
1759 PyDict_SetItemString(v, "specialVals", item);
1760 Py_DECREF(item);
1761 }
1762
1763 return v;
1764}
1765
1766PyDoc_STRVAR(al_GetResourceByName__doc__,
1767"alGetResourceByName: find an audio resource by name.");
1768
1769static PyObject *
1770al_GetResourceByName(PyObject *self, PyObject *args)
1771{
1772 int res, start_res, type;
1773 char *name;
1774
1775 if (!PyArg_ParseTuple(args, "isi:GetResourceByName", &start_res, &name, &type))
1776 return NULL;
1777 if ((res = alGetResourceByName(start_res, name, type)) == 0)
1778 return NULL;
1779 return PyInt_FromLong((long) res);
1780}
1781
1782PyDoc_STRVAR(al_IsSubtype__doc__,
1783"alIsSubtype: indicate if one resource type is a subtype of another.");
1784
1785static PyObject *
1786al_IsSubtype(PyObject *self, PyObject *args)
1787{
1788 int type, subtype;
1789
1790 if (!PyArg_ParseTuple(args, "ii:IsSubtype", &type, &subtype))
1791 return NULL;
1792 return PyInt_FromLong((long) alIsSubtype(type, subtype));
1793}
1794
1795PyDoc_STRVAR(al_SetErrorHandler__doc__, "");
1796
1797static PyObject *
1798al_SetErrorHandler(PyObject *self, PyObject *args)
1799{
1800
1801 if (!PyArg_ParseTuple(args, ":SetErrorHandler"))
1802 return NULL;
1803 Py_INCREF(Py_None);
1804 return Py_None;
1805}
1806
1807#endif /* AL_NO_ELEM */
1808
1809#ifdef OLD_INTERFACE
1810
1811static PyObject *
1812al_openport(PyObject *self, PyObject *args)
1813{
1814 char *name, *dir;
1815 ALport port;
1816 alcobject *config = NULL;
1817
1818 if (!PyArg_ParseTuple(args, "ss|O!:OpenPort", &name, &dir, &Alctype, &config))
1819 return NULL;
1820 if ((port = ALopenport(name, dir, config ? config->config : NULL)) == NULL)
1821 return NULL;
1822 return newalpobject(port);
1823}
1824
1825static PyObject *
1826al_newconfig(PyObject *self, PyObject *args)
1827{
1828 ALconfig config;
1829
1830 if (!PyArg_ParseTuple(args, ":NewConfig"))
1831 return NULL;
1832 if ((config = ALnewconfig ()) == NULL)
1833 return NULL;
1834 return newalcobject(config);
1835}
1836
1837static PyObject *
1838al_queryparams(PyObject *self, PyObject *args)
1839{
1840 long device;
1841 long length;
1842 long *PVbuffer;
1843 long PVdummy[2];
1844 PyObject *v = NULL;
1845 int i;
1846
1847 if (!PyArg_ParseTuple(args, "l:queryparams", &device))
1848 return NULL;
1849 if ((length = ALqueryparams(device, PVdummy, 2L)) == -1)
1850 return NULL;
1851 if ((PVbuffer = PyMem_NEW(long, length)) == NULL)
1852 return PyErr_NoMemory();
1853 if (ALqueryparams(device, PVbuffer, length) >= 0 &&
1854 (v = PyList_New((int)length)) != NULL) {
1855 for (i = 0; i < length; i++)
1856 PyList_SetItem(v, i, PyInt_FromLong(PVbuffer[i]));
1857 }
1858 PyMem_DEL(PVbuffer);
1859 return v;
1860}
1861
1862static PyObject *
1863doParams(PyObject *args, int (*func)(long, long *, long), int modified)
1864{
1865 long device;
1866 PyObject *list, *v;
1867 long *PVbuffer;
1868 long length;
1869 int i;
1870
1871 if (!PyArg_ParseTuple(args, "lO!", &device, &PyList_Type, &list))
1872 return NULL;
1873 length = PyList_Size(list);
1874 PVbuffer = PyMem_NEW(long, length);
1875 if (PVbuffer == NULL)
1876 return PyErr_NoMemory();
1877 for (i = 0; i < length; i++) {
1878 v = PyList_GetItem(list, i);
1879 if (!PyInt_Check(v)) {
1880 PyMem_DEL(PVbuffer);
1881 PyErr_BadArgument();
1882 return NULL;
1883 }
1884 PVbuffer[i] = PyInt_AsLong(v);
1885 }
1886
1887 if ((*func)(device, PVbuffer, length) == -1) {
1888 PyMem_DEL(PVbuffer);
1889 return NULL;
1890 }
1891
1892 if (modified) {
1893 for (i = 0; i < length; i++)
1894 PyList_SetItem(list, i, PyInt_FromLong(PVbuffer[i]));
1895 }
1896
1897 PyMem_DEL(PVbuffer);
1898
1899 Py_INCREF(Py_None);
1900 return Py_None;
1901}
1902
1903static PyObject *
1904al_getparams(PyObject *self, PyObject *args)
1905{
1906 return doParams(args, ALgetparams, 1);
1907}
1908
1909static PyObject *
1910al_setparams(PyObject *self, PyObject *args)
1911{
1912 return doParams(args, ALsetparams, 0);
1913}
1914
1915static PyObject *
1916al_getname(PyObject *self, PyObject *args)
1917{
1918 long device, descriptor;
1919 char *name;
1920
1921 if (!PyArg_ParseTuple(args, "ll:getname", &device, &descriptor))
1922 return NULL;
1923 if ((name = ALgetname(device, descriptor)) == NULL)
1924 return NULL;
1925 return PyString_FromString(name);
1926}
1927
1928static PyObject *
1929al_getdefault(PyObject *self, PyObject *args)
1930{
1931 long device, descriptor, value;
1932
1933 if (!PyArg_ParseTuple(args, "ll:getdefault", &device, &descriptor))
1934 return NULL;
1935 if ((value = ALgetdefault(device, descriptor)) == -1)
1936 return NULL;
1937 return PyLong_FromLong(value);
1938}
1939
1940static PyObject *
1941al_getminmax(PyObject *self, PyObject *args)
1942{
1943 long device, descriptor, min, max;
1944
1945 if (!PyArg_ParseTuple(args, "ll:getminmax", &device, &descriptor))
1946 return NULL;
1947 min = -1;
1948 max = -1;
1949 if (ALgetminmax(device, descriptor, &min, &max) == -1)
1950 return NULL;
1951 return Py_BuildValue("ll", min, max);
1952}
1953
1954#endif /* OLD_INTERFACE */
1955
1956/* List of methods defined in the module */
1957
1958static struct PyMethodDef al_methods[] = {
1959#ifdef AL_NO_ELEM /* IRIX 6 */
1960 {"NewConfig", (PyCFunction)al_NewConfig, METH_VARARGS, al_NewConfig__doc__},
1961 {"OpenPort", (PyCFunction)al_OpenPort, METH_VARARGS, al_OpenPort__doc__},
1962 {"Connect", (PyCFunction)al_Connect, METH_VARARGS, al_Connect__doc__},
1963 {"Disconnect", (PyCFunction)al_Disconnect, METH_VARARGS, al_Disconnect__doc__},
1964 {"GetParams", (PyCFunction)al_GetParams, METH_VARARGS, al_GetParams__doc__},
1965 {"SetParams", (PyCFunction)al_SetParams, METH_VARARGS, al_SetParams__doc__},
1966 {"QueryValues", (PyCFunction)al_QueryValues, METH_VARARGS, al_QueryValues__doc__},
1967 {"GetParamInfo", (PyCFunction)al_GetParamInfo, METH_VARARGS, al_GetParamInfo__doc__},
1968 {"GetResourceByName", (PyCFunction)al_GetResourceByName, METH_VARARGS, al_GetResourceByName__doc__},
1969 {"IsSubtype", (PyCFunction)al_IsSubtype, METH_VARARGS, al_IsSubtype__doc__},
1970#if 0
1971 /* this one not supported */
1972 {"SetErrorHandler", (PyCFunction)al_SetErrorHandler, METH_VARARGS, al_SetErrorHandler__doc__},
1973#endif
1974#endif /* AL_NO_ELEM */
1975#ifdef OLD_INTERFACE
1976 {"openport", (PyCFunction)al_openport, METH_VARARGS},
1977 {"newconfig", (PyCFunction)al_newconfig, METH_VARARGS},
1978 {"queryparams", (PyCFunction)al_queryparams, METH_VARARGS},
1979 {"getparams", (PyCFunction)al_getparams, METH_VARARGS},
1980 {"setparams", (PyCFunction)al_setparams, METH_VARARGS},
1981 {"getname", (PyCFunction)al_getname, METH_VARARGS},
1982 {"getdefault", (PyCFunction)al_getdefault, METH_VARARGS},
1983 {"getminmax", (PyCFunction)al_getminmax, METH_VARARGS},
1984#endif /* OLD_INTERFACE */
1985
1986 {NULL, (PyCFunction)NULL, 0, NULL} /* sentinel */
1987};
1988
1989
1990/* Initialization function for the module (*must* be called inital) */
1991
1992PyDoc_STRVAR(al_module_documentation, "");
1993
1994void
1995inital(void)
1996{
1997 PyObject *m, *d, *x;
1998
1999 if (PyErr_WarnPy3k("the al module has been removed in "
2000 "Python 3.0", 2) < 0)
2001 return;
2002
2003 /* Create the module and add the functions */
2004 m = Py_InitModule4("al", al_methods,
2005 al_module_documentation,
2006 (PyObject*)NULL,PYTHON_API_VERSION);
2007 if (m == NULL)
2008 return;
2009
2010 /* Add some symbolic constants to the module */
2011 d = PyModule_GetDict(m);
2012 ErrorObject = PyErr_NewException("al.error", NULL, NULL);
2013 PyDict_SetItemString(d, "error", ErrorObject);
2014
2015 /* XXXX Add constants here */
2016#ifdef AL_4CHANNEL
2017 x = PyInt_FromLong((long) AL_4CHANNEL);
2018 if (x == NULL || PyDict_SetItemString(d, "FOURCHANNEL", x) < 0)
2019 goto error;
2020 Py_DECREF(x);
2021#endif
2022#ifdef AL_ADAT_IF_TYPE
2023 x = PyInt_FromLong((long) AL_ADAT_IF_TYPE);
2024 if (x == NULL || PyDict_SetItemString(d, "ADAT_IF_TYPE", x) < 0)
2025 goto error;
2026 Py_DECREF(x);
2027#endif
2028#ifdef AL_ADAT_MCLK_TYPE
2029 x = PyInt_FromLong((long) AL_ADAT_MCLK_TYPE);
2030 if (x == NULL || PyDict_SetItemString(d, "ADAT_MCLK_TYPE", x) < 0)
2031 goto error;
2032 Py_DECREF(x);
2033#endif
2034#ifdef AL_AES_IF_TYPE
2035 x = PyInt_FromLong((long) AL_AES_IF_TYPE);
2036 if (x == NULL || PyDict_SetItemString(d, "AES_IF_TYPE", x) < 0)
2037 goto error;
2038 Py_DECREF(x);
2039#endif
2040#ifdef AL_AES_MCLK_TYPE
2041 x = PyInt_FromLong((long) AL_AES_MCLK_TYPE);
2042 if (x == NULL || PyDict_SetItemString(d, "AES_MCLK_TYPE", x) < 0)
2043 goto error;
2044 Py_DECREF(x);
2045#endif
2046#ifdef AL_ANALOG_IF_TYPE
2047 x = PyInt_FromLong((long) AL_ANALOG_IF_TYPE);
2048 if (x == NULL || PyDict_SetItemString(d, "ANALOG_IF_TYPE", x) < 0)
2049 goto error;
2050 Py_DECREF(x);
2051#endif
2052#ifdef AL_ASSOCIATE
2053 x = PyInt_FromLong((long) AL_ASSOCIATE);
2054 if (x == NULL || PyDict_SetItemString(d, "ASSOCIATE", x) < 0)
2055 goto error;
2056 Py_DECREF(x);
2057#endif
2058#ifdef AL_BAD_BUFFER_NULL
2059 x = PyInt_FromLong((long) AL_BAD_BUFFER_NULL);
2060 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_NULL", x) < 0)
2061 goto error;
2062 Py_DECREF(x);
2063#endif
2064#ifdef AL_BAD_BUFFERLENGTH
2065 x = PyInt_FromLong((long) AL_BAD_BUFFERLENGTH);
2066 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERLENGTH", x) < 0)
2067 goto error;
2068 Py_DECREF(x);
2069#endif
2070#ifdef AL_BAD_BUFFERLENGTH_NEG
2071 x = PyInt_FromLong((long) AL_BAD_BUFFERLENGTH_NEG);
2072 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERLENGTH_NEG", x) < 0)
2073 goto error;
2074 Py_DECREF(x);
2075#endif
2076#ifdef AL_BAD_BUFFERLENGTH_ODD
2077 x = PyInt_FromLong((long) AL_BAD_BUFFERLENGTH_ODD);
2078 if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERLENGTH_ODD", x) < 0)
2079 goto error;
2080 Py_DECREF(x);
2081#endif
2082#ifdef AL_BAD_CHANNELS
2083 x = PyInt_FromLong((long) AL_BAD_CHANNELS);
2084 if (x == NULL || PyDict_SetItemString(d, "BAD_CHANNELS", x) < 0)
2085 goto error;
2086 Py_DECREF(x);
2087#endif
2088#ifdef AL_BAD_CONFIG
2089 x = PyInt_FromLong((long) AL_BAD_CONFIG);
2090 if (x == NULL || PyDict_SetItemString(d, "BAD_CONFIG", x) < 0)
2091 goto error;
2092 Py_DECREF(x);
2093#endif
2094#ifdef AL_BAD_COUNT_NEG
2095 x = PyInt_FromLong((long) AL_BAD_COUNT_NEG);
2096 if (x == NULL || PyDict_SetItemString(d, "BAD_COUNT_NEG", x) < 0)
2097 goto error;
2098 Py_DECREF(x);
2099#endif
2100#ifdef AL_BAD_DEVICE
2101 x = PyInt_FromLong((long) AL_BAD_DEVICE);
2102 if (x == NULL || PyDict_SetItemString(d, "BAD_DEVICE", x) < 0)
2103 goto error;
2104 Py_DECREF(x);
2105#endif
2106#ifdef AL_BAD_DEVICE_ACCESS
2107 x = PyInt_FromLong((long) AL_BAD_DEVICE_ACCESS);
2108 if (x == NULL || PyDict_SetItemString(d, "BAD_DEVICE_ACCESS", x) < 0)
2109 goto error;
2110 Py_DECREF(x);
2111#endif
2112#ifdef AL_BAD_DIRECTION
2113 x = PyInt_FromLong((long) AL_BAD_DIRECTION);
2114 if (x == NULL || PyDict_SetItemString(d, "BAD_DIRECTION", x) < 0)
2115 goto error;
2116 Py_DECREF(x);
2117#endif
2118#ifdef AL_BAD_FILLPOINT
2119 x = PyInt_FromLong((long) AL_BAD_FILLPOINT);
2120 if (x == NULL || PyDict_SetItemString(d, "BAD_FILLPOINT", x) < 0)
2121 goto error;
2122 Py_DECREF(x);
2123#endif
2124#ifdef AL_BAD_FLOATMAX
2125 x = PyInt_FromLong((long) AL_BAD_FLOATMAX);
2126 if (x == NULL || PyDict_SetItemString(d, "BAD_FLOATMAX", x) < 0)
2127 goto error;
2128 Py_DECREF(x);
2129#endif
2130#ifdef AL_BAD_ILLEGAL_STATE
2131 x = PyInt_FromLong((long) AL_BAD_ILLEGAL_STATE);
2132 if (x == NULL || PyDict_SetItemString(d, "BAD_ILLEGAL_STATE", x) < 0)
2133 goto error;
2134 Py_DECREF(x);
2135#endif
2136#ifdef AL_BAD_NO_PORTS
2137 x = PyInt_FromLong((long) AL_BAD_NO_PORTS);
2138 if (x == NULL || PyDict_SetItemString(d, "BAD_NO_PORTS", x) < 0)
2139 goto error;
2140 Py_DECREF(x);
2141#endif
2142#ifdef AL_BAD_NOT_FOUND
2143 x = PyInt_FromLong((long) AL_BAD_NOT_FOUND);
2144 if (x == NULL || PyDict_SetItemString(d, "BAD_NOT_FOUND", x) < 0)
2145 goto error;
2146 Py_DECREF(x);
2147#endif
2148#ifdef AL_BAD_NOT_IMPLEMENTED
2149 x = PyInt_FromLong((long) AL_BAD_NOT_IMPLEMENTED);
2150 if (x == NULL || PyDict_SetItemString(d, "BAD_NOT_IMPLEMENTED", x) < 0)
2151 goto error;
2152 Py_DECREF(x);
2153#endif
2154#ifdef AL_BAD_OUT_OF_MEM
2155 x = PyInt_FromLong((long) AL_BAD_OUT_OF_MEM);
2156 if (x == NULL || PyDict_SetItemString(d, "BAD_OUT_OF_MEM", x) < 0)
2157 goto error;
2158 Py_DECREF(x);
2159#endif
2160#ifdef AL_BAD_PARAM
2161 x = PyInt_FromLong((long) AL_BAD_PARAM);
2162 if (x == NULL || PyDict_SetItemString(d, "BAD_PARAM", x) < 0)
2163 goto error;
2164 Py_DECREF(x);
2165#endif
2166#ifdef AL_BAD_PERMISSIONS
2167 x = PyInt_FromLong((long) AL_BAD_PERMISSIONS);
2168 if (x == NULL || PyDict_SetItemString(d, "BAD_PERMISSIONS", x) < 0)
2169 goto error;
2170 Py_DECREF(x);
2171#endif
2172#ifdef AL_BAD_PORT
2173 x = PyInt_FromLong((long) AL_BAD_PORT);
2174 if (x == NULL || PyDict_SetItemString(d, "BAD_PORT", x) < 0)
2175 goto error;
2176 Py_DECREF(x);
2177#endif
2178#ifdef AL_BAD_PORTSTYLE
2179 x = PyInt_FromLong((long) AL_BAD_PORTSTYLE);
2180 if (x == NULL || PyDict_SetItemString(d, "BAD_PORTSTYLE", x) < 0)
2181 goto error;
2182 Py_DECREF(x);
2183#endif
2184#ifdef AL_BAD_PVBUFFER
2185 x = PyInt_FromLong((long) AL_BAD_PVBUFFER);
2186 if (x == NULL || PyDict_SetItemString(d, "BAD_PVBUFFER", x) < 0)
2187 goto error;
2188 Py_DECREF(x);
2189#endif
2190#ifdef AL_BAD_QSIZE
2191 x = PyInt_FromLong((long) AL_BAD_QSIZE);
2192 if (x == NULL || PyDict_SetItemString(d, "BAD_QSIZE", x) < 0)
2193 goto error;
2194 Py_DECREF(x);
2195#endif
2196#ifdef AL_BAD_RATE
2197 x = PyInt_FromLong((long) AL_BAD_RATE);
2198 if (x == NULL || PyDict_SetItemString(d, "BAD_RATE", x) < 0)
2199 goto error;
2200 Py_DECREF(x);
2201#endif
2202#ifdef AL_BAD_RESOURCE
2203 x = PyInt_FromLong((long) AL_BAD_RESOURCE);
2204 if (x == NULL || PyDict_SetItemString(d, "BAD_RESOURCE", x) < 0)
2205 goto error;
2206 Py_DECREF(x);
2207#endif
2208#ifdef AL_BAD_SAMPFMT
2209 x = PyInt_FromLong((long) AL_BAD_SAMPFMT);
2210 if (x == NULL || PyDict_SetItemString(d, "BAD_SAMPFMT", x) < 0)
2211 goto error;
2212 Py_DECREF(x);
2213#endif
2214#ifdef AL_BAD_TRANSFER_SIZE
2215 x = PyInt_FromLong((long) AL_BAD_TRANSFER_SIZE);
2216 if (x == NULL || PyDict_SetItemString(d, "BAD_TRANSFER_SIZE", x) < 0)
2217 goto error;
2218 Py_DECREF(x);
2219#endif
2220#ifdef AL_BAD_WIDTH
2221 x = PyInt_FromLong((long) AL_BAD_WIDTH);
2222 if (x == NULL || PyDict_SetItemString(d, "BAD_WIDTH", x) < 0)
2223 goto error;
2224 Py_DECREF(x);
2225#endif
2226#ifdef AL_CHANNEL_MODE
2227 x = PyInt_FromLong((long) AL_CHANNEL_MODE);
2228 if (x == NULL || PyDict_SetItemString(d, "CHANNEL_MODE", x) < 0)
2229 goto error;
2230 Py_DECREF(x);
2231#endif
2232#ifdef AL_CHANNELS
2233 x = PyInt_FromLong((long) AL_CHANNELS);
2234 if (x == NULL || PyDict_SetItemString(d, "CHANNELS", x) < 0)
2235 goto error;
2236 Py_DECREF(x);
2237#endif
2238#ifdef AL_CHAR_ELEM
2239 x = PyInt_FromLong((long) AL_CHAR_ELEM);
2240 if (x == NULL || PyDict_SetItemString(d, "CHAR_ELEM", x) < 0)
2241 goto error;
2242 Py_DECREF(x);
2243#endif
2244#ifdef AL_CLOCK_GEN
2245 x = PyInt_FromLong((long) AL_CLOCK_GEN);
2246 if (x == NULL || PyDict_SetItemString(d, "CLOCK_GEN", x) < 0)
2247 goto error;
2248 Py_DECREF(x);
2249#endif
2250#ifdef AL_CLOCKGEN_TYPE
2251 x = PyInt_FromLong((long) AL_CLOCKGEN_TYPE);
2252 if (x == NULL || PyDict_SetItemString(d, "CLOCKGEN_TYPE", x) < 0)
2253 goto error;
2254 Py_DECREF(x);
2255#endif
2256#ifdef AL_CONNECT
2257 x = PyInt_FromLong((long) AL_CONNECT);
2258 if (x == NULL || PyDict_SetItemString(d, "CONNECT", x) < 0)
2259 goto error;
2260 Py_DECREF(x);
2261#endif
2262#ifdef AL_CONNECTION_TYPE
2263 x = PyInt_FromLong((long) AL_CONNECTION_TYPE);
2264 if (x == NULL || PyDict_SetItemString(d, "CONNECTION_TYPE", x) < 0)
2265 goto error;
2266 Py_DECREF(x);
2267#endif
2268#ifdef AL_CONNECTIONS
2269 x = PyInt_FromLong((long) AL_CONNECTIONS);
2270 if (x == NULL || PyDict_SetItemString(d, "CONNECTIONS", x) < 0)
2271 goto error;
2272 Py_DECREF(x);
2273#endif
2274#ifdef AL_CRYSTAL_MCLK_TYPE
2275 x = PyInt_FromLong((long) AL_CRYSTAL_MCLK_TYPE);
2276 if (x == NULL || PyDict_SetItemString(d, "CRYSTAL_MCLK_TYPE", x) < 0)
2277 goto error;
2278 Py_DECREF(x);
2279#endif
2280#ifdef AL_DEFAULT_DEVICE
2281 x = PyInt_FromLong((long) AL_DEFAULT_DEVICE);
2282 if (x == NULL || PyDict_SetItemString(d, "DEFAULT_DEVICE", x) < 0)
2283 goto error;
2284 Py_DECREF(x);
2285#endif
2286#ifdef AL_DEFAULT_INPUT
2287 x = PyInt_FromLong((long) AL_DEFAULT_INPUT);
2288 if (x == NULL || PyDict_SetItemString(d, "DEFAULT_INPUT", x) < 0)
2289 goto error;
2290 Py_DECREF(x);
2291#endif
2292#ifdef AL_DEFAULT_OUTPUT
2293 x = PyInt_FromLong((long) AL_DEFAULT_OUTPUT);
2294 if (x == NULL || PyDict_SetItemString(d, "DEFAULT_OUTPUT", x) < 0)
2295 goto error;
2296 Py_DECREF(x);
2297#endif
2298#ifdef AL_DEST
2299 x = PyInt_FromLong((long) AL_DEST);
2300 if (x == NULL || PyDict_SetItemString(d, "DEST", x) < 0)
2301 goto error;
2302 Py_DECREF(x);
2303#endif
2304#ifdef AL_DEVICE_TYPE
2305 x = PyInt_FromLong((long) AL_DEVICE_TYPE);
2306 if (x == NULL || PyDict_SetItemString(d, "DEVICE_TYPE", x) < 0)
2307 goto error;
2308 Py_DECREF(x);
2309#endif
2310#ifdef AL_DEVICES
2311 x = PyInt_FromLong((long) AL_DEVICES);
2312 if (x == NULL || PyDict_SetItemString(d, "DEVICES", x) < 0)
2313 goto error;
2314 Py_DECREF(x);
2315#endif
2316#ifdef AL_DIGITAL_IF_TYPE
2317 x = PyInt_FromLong((long) AL_DIGITAL_IF_TYPE);
2318 if (x == NULL || PyDict_SetItemString(d, "DIGITAL_IF_TYPE", x) < 0)
2319 goto error;
2320 Py_DECREF(x);
2321#endif
2322#ifdef AL_DIGITAL_INPUT_RATE
2323 x = PyInt_FromLong((long) AL_DIGITAL_INPUT_RATE);
2324 if (x == NULL || PyDict_SetItemString(d, "DIGITAL_INPUT_RATE", x) < 0)
2325 goto error;
2326 Py_DECREF(x);
2327#endif
2328#ifdef AL_DISCONNECT
2329 x = PyInt_FromLong((long) AL_DISCONNECT);
2330 if (x == NULL || PyDict_SetItemString(d, "DISCONNECT", x) < 0)
2331 goto error;
2332 Py_DECREF(x);
2333#endif
2334#ifdef AL_ENUM_ELEM
2335 x = PyInt_FromLong((long) AL_ENUM_ELEM);
2336 if (x == NULL || PyDict_SetItemString(d, "ENUM_ELEM", x) < 0)
2337 goto error;
2338 Py_DECREF(x);
2339#endif
2340#ifdef AL_ENUM_VALUE
2341 x = PyInt_FromLong((long) AL_ENUM_VALUE);
2342 if (x == NULL || PyDict_SetItemString(d, "ENUM_VALUE", x) < 0)
2343 goto error;
2344 Py_DECREF(x);
2345#endif
2346#ifdef AL_ERROR_INPUT_OVERFLOW
2347 x = PyInt_FromLong((long) AL_ERROR_INPUT_OVERFLOW);
2348 if (x == NULL || PyDict_SetItemString(d, "ERROR_INPUT_OVERFLOW", x) < 0)
2349 goto error;
2350 Py_DECREF(x);
2351#endif
2352#ifdef AL_ERROR_LENGTH
2353 x = PyInt_FromLong((long) AL_ERROR_LENGTH);
2354 if (x == NULL || PyDict_SetItemString(d, "ERROR_LENGTH", x) < 0)
2355 goto error;
2356 Py_DECREF(x);
2357#endif
2358#ifdef AL_ERROR_LOCATION_LSP
2359 x = PyInt_FromLong((long) AL_ERROR_LOCATION_LSP);
2360 if (x == NULL || PyDict_SetItemString(d, "ERROR_LOCATION_LSP", x) < 0)
2361 goto error;
2362 Py_DECREF(x);
2363#endif
2364#ifdef AL_ERROR_LOCATION_MSP
2365 x = PyInt_FromLong((long) AL_ERROR_LOCATION_MSP);
2366 if (x == NULL || PyDict_SetItemString(d, "ERROR_LOCATION_MSP", x) < 0)
2367 goto error;
2368 Py_DECREF(x);
2369#endif
2370#ifdef AL_ERROR_NUMBER
2371 x = PyInt_FromLong((long) AL_ERROR_NUMBER);
2372 if (x == NULL || PyDict_SetItemString(d, "ERROR_NUMBER", x) < 0)
2373 goto error;
2374 Py_DECREF(x);
2375#endif
2376#ifdef AL_ERROR_OUTPUT_UNDERFLOW
2377 x = PyInt_FromLong((long) AL_ERROR_OUTPUT_UNDERFLOW);
2378 if (x == NULL || PyDict_SetItemString(d, "ERROR_OUTPUT_UNDERFLOW", x) < 0)
2379 goto error;
2380 Py_DECREF(x);
2381#endif
2382#ifdef AL_ERROR_TYPE
2383 x = PyInt_FromLong((long) AL_ERROR_TYPE);
2384 if (x == NULL || PyDict_SetItemString(d, "ERROR_TYPE", x) < 0)
2385 goto error;
2386 Py_DECREF(x);
2387#endif
2388#ifdef AL_FIXED_ELEM
2389 x = PyInt_FromLong((long) AL_FIXED_ELEM);
2390 if (x == NULL || PyDict_SetItemString(d, "FIXED_ELEM", x) < 0)
2391 goto error;
2392 Py_DECREF(x);
2393#endif
2394#ifdef AL_FIXED_MCLK_TYPE
2395 x = PyInt_FromLong((long) AL_FIXED_MCLK_TYPE);
2396 if (x == NULL || PyDict_SetItemString(d, "FIXED_MCLK_TYPE", x) < 0)
2397 goto error;
2398 Py_DECREF(x);
2399#endif
2400#ifdef AL_GAIN
2401 x = PyInt_FromLong((long) AL_GAIN);
2402 if (x == NULL || PyDict_SetItemString(d, "GAIN", x) < 0)
2403 goto error;
2404 Py_DECREF(x);
2405#endif
2406#ifdef AL_GAIN_REF
2407 x = PyInt_FromLong((long) AL_GAIN_REF);
2408 if (x == NULL || PyDict_SetItemString(d, "GAIN_REF", x) < 0)
2409 goto error;
2410 Py_DECREF(x);
2411#endif
2412#ifdef AL_HRB_TYPE
2413 x = PyInt_FromLong((long) AL_HRB_TYPE);
2414 if (x == NULL || PyDict_SetItemString(d, "HRB_TYPE", x) < 0)
2415 goto error;
2416 Py_DECREF(x);
2417#endif
2418#ifdef AL_INPUT_COUNT
2419 x = PyInt_FromLong((long) AL_INPUT_COUNT);
2420 if (x == NULL || PyDict_SetItemString(d, "INPUT_COUNT", x) < 0)
2421 goto error;
2422 Py_DECREF(x);
2423#endif
2424#ifdef AL_INPUT_DEVICE_TYPE
2425 x = PyInt_FromLong((long) AL_INPUT_DEVICE_TYPE);
2426 if (x == NULL || PyDict_SetItemString(d, "INPUT_DEVICE_TYPE", x) < 0)
2427 goto error;
2428 Py_DECREF(x);
2429#endif
2430#ifdef AL_INPUT_DIGITAL
2431 x = PyInt_FromLong((long) AL_INPUT_DIGITAL);
2432 if (x == NULL || PyDict_SetItemString(d, "INPUT_DIGITAL", x) < 0)
2433 goto error;
2434 Py_DECREF(x);
2435#endif
2436#ifdef AL_INPUT_HRB_TYPE
2437 x = PyInt_FromLong((long) AL_INPUT_HRB_TYPE);
2438 if (x == NULL || PyDict_SetItemString(d, "INPUT_HRB_TYPE", x) < 0)
2439 goto error;
2440 Py_DECREF(x);
2441#endif
2442#ifdef AL_INPUT_LINE
2443 x = PyInt_FromLong((long) AL_INPUT_LINE);
2444 if (x == NULL || PyDict_SetItemString(d, "INPUT_LINE", x) < 0)
2445 goto error;
2446 Py_DECREF(x);
2447#endif
2448#ifdef AL_INPUT_MIC
2449 x = PyInt_FromLong((long) AL_INPUT_MIC);
2450 if (x == NULL || PyDict_SetItemString(d, "INPUT_MIC", x) < 0)
2451 goto error;
2452 Py_DECREF(x);
2453#endif
2454#ifdef AL_INPUT_PORT_TYPE
2455 x = PyInt_FromLong((long) AL_INPUT_PORT_TYPE);
2456 if (x == NULL || PyDict_SetItemString(d, "INPUT_PORT_TYPE", x) < 0)
2457 goto error;
2458 Py_DECREF(x);
2459#endif
2460#ifdef AL_INPUT_RATE
2461 x = PyInt_FromLong((long) AL_INPUT_RATE);
2462 if (x == NULL || PyDict_SetItemString(d, "INPUT_RATE", x) < 0)
2463 goto error;
2464 Py_DECREF(x);
2465#endif
2466#ifdef AL_INPUT_SOURCE
2467 x = PyInt_FromLong((long) AL_INPUT_SOURCE);
2468 if (x == NULL || PyDict_SetItemString(d, "INPUT_SOURCE", x) < 0)
2469 goto error;
2470 Py_DECREF(x);
2471#endif
2472#ifdef AL_INT32_ELEM
2473 x = PyInt_FromLong((long) AL_INT32_ELEM);
2474 if (x == NULL || PyDict_SetItemString(d, "INT32_ELEM", x) < 0)
2475 goto error;
2476 Py_DECREF(x);
2477#endif
2478#ifdef AL_INT64_ELEM
2479 x = PyInt_FromLong((long) AL_INT64_ELEM);
2480 if (x == NULL || PyDict_SetItemString(d, "INT64_ELEM", x) < 0)
2481 goto error;
2482 Py_DECREF(x);
2483#endif
2484#ifdef AL_INTERFACE
2485 x = PyInt_FromLong((long) AL_INTERFACE);
2486 if (x == NULL || PyDict_SetItemString(d, "INTERFACE", x) < 0)
2487 goto error;
2488 Py_DECREF(x);
2489#endif
2490#ifdef AL_INTERFACE_TYPE
2491 x = PyInt_FromLong((long) AL_INTERFACE_TYPE);
2492 if (x == NULL || PyDict_SetItemString(d, "INTERFACE_TYPE", x) < 0)
2493 goto error;
2494 Py_DECREF(x);
2495#endif
2496#ifdef AL_INVALID_PARAM
2497 x = PyInt_FromLong((long) AL_INVALID_PARAM);
2498 if (x == NULL || PyDict_SetItemString(d, "INVALID_PARAM", x) < 0)
2499 goto error;
2500 Py_DECREF(x);
2501#endif
2502#ifdef AL_INVALID_VALUE
2503 x = PyInt_FromLong((long) AL_INVALID_VALUE);
2504 if (x == NULL || PyDict_SetItemString(d, "INVALID_VALUE", x) < 0)
2505 goto error;
2506 Py_DECREF(x);
2507#endif
2508#ifdef AL_JITTER
2509 x = PyInt_FromLong((long) AL_JITTER);
2510 if (x == NULL || PyDict_SetItemString(d, "JITTER", x) < 0)
2511 goto error;
2512 Py_DECREF(x);
2513#endif
2514#ifdef AL_LABEL
2515 x = PyInt_FromLong((long) AL_LABEL);
2516 if (x == NULL || PyDict_SetItemString(d, "LABEL", x) < 0)
2517 goto error;
2518 Py_DECREF(x);
2519#endif
2520#ifdef AL_LEFT_INPUT_ATTEN
2521 x = PyInt_FromLong((long) AL_LEFT_INPUT_ATTEN);
2522 if (x == NULL || PyDict_SetItemString(d, "LEFT_INPUT_ATTEN", x) < 0)
2523 goto error;
2524 Py_DECREF(x);
2525#endif
2526#ifdef AL_LEFT_MONITOR_ATTEN
2527 x = PyInt_FromLong((long) AL_LEFT_MONITOR_ATTEN);
2528 if (x == NULL || PyDict_SetItemString(d, "LEFT_MONITOR_ATTEN", x) < 0)
2529 goto error;
2530 Py_DECREF(x);
2531#endif
2532#ifdef AL_LEFT_SPEAKER_GAIN
2533 x = PyInt_FromLong((long) AL_LEFT_SPEAKER_GAIN);
2534 if (x == NULL || PyDict_SetItemString(d, "LEFT_SPEAKER_GAIN", x) < 0)
2535 goto error;
2536 Py_DECREF(x);
2537#endif
2538#ifdef AL_LEFT1_INPUT_ATTEN
2539 x = PyInt_FromLong((long) AL_LEFT1_INPUT_ATTEN);
2540 if (x == NULL || PyDict_SetItemString(d, "LEFT1_INPUT_ATTEN", x) < 0)
2541 goto error;
2542 Py_DECREF(x);
2543#endif
2544#ifdef AL_LEFT2_INPUT_ATTEN
2545 x = PyInt_FromLong((long) AL_LEFT2_INPUT_ATTEN);
2546 if (x == NULL || PyDict_SetItemString(d, "LEFT2_INPUT_ATTEN", x) < 0)
2547 goto error;
2548 Py_DECREF(x);
2549#endif
2550#ifdef AL_LINE_IF_TYPE
2551 x = PyInt_FromLong((long) AL_LINE_IF_TYPE);
2552 if (x == NULL || PyDict_SetItemString(d, "LINE_IF_TYPE", x) < 0)
2553 goto error;
2554 Py_DECREF(x);
2555#endif
2556#ifdef AL_LOCKED
2557 x = PyInt_FromLong((long) AL_LOCKED);
2558 if (x == NULL || PyDict_SetItemString(d, "LOCKED", x) < 0)
2559 goto error;
2560 Py_DECREF(x);
2561#endif
2562#ifdef AL_MASTER_CLOCK
2563 x = PyInt_FromLong((long) AL_MASTER_CLOCK);
2564 if (x == NULL || PyDict_SetItemString(d, "MASTER_CLOCK", x) < 0)
2565 goto error;
2566 Py_DECREF(x);
2567#endif
2568#ifdef AL_MATRIX_VAL
2569 x = PyInt_FromLong((long) AL_MATRIX_VAL);
2570 if (x == NULL || PyDict_SetItemString(d, "MATRIX_VAL", x) < 0)
2571 goto error;
2572 Py_DECREF(x);
2573#endif
2574#ifdef AL_MAX_ERROR
2575 x = PyInt_FromLong((long) AL_MAX_ERROR);
2576 if (x == NULL || PyDict_SetItemString(d, "MAX_ERROR", x) < 0)
2577 goto error;
2578 Py_DECREF(x);
2579#endif
2580#ifdef AL_MAX_EVENT_PARAM
2581 x = PyInt_FromLong((long) AL_MAX_EVENT_PARAM);
2582 if (x == NULL || PyDict_SetItemString(d, "MAX_EVENT_PARAM", x) < 0)
2583 goto error;
2584 Py_DECREF(x);
2585#endif
2586#ifdef AL_MAX_PBUFSIZE
2587 x = PyInt_FromLong((long) AL_MAX_PBUFSIZE);
2588 if (x == NULL || PyDict_SetItemString(d, "MAX_PBUFSIZE", x) < 0)
2589 goto error;
2590 Py_DECREF(x);
2591#endif
2592#ifdef AL_MAX_PORTS
2593 x = PyInt_FromLong((long) AL_MAX_PORTS);
2594 if (x == NULL || PyDict_SetItemString(d, "MAX_PORTS", x) < 0)
2595 goto error;
2596 Py_DECREF(x);
2597#endif
2598#ifdef AL_MAX_RESOURCE_ID
2599 x = PyInt_FromLong((long) AL_MAX_RESOURCE_ID);
2600 if (x == NULL || PyDict_SetItemString(d, "MAX_RESOURCE_ID", x) < 0)
2601 goto error;
2602 Py_DECREF(x);
2603#endif
2604#ifdef AL_MAX_SETSIZE
2605 x = PyInt_FromLong((long) AL_MAX_SETSIZE);
2606 if (x == NULL || PyDict_SetItemString(d, "MAX_SETSIZE", x) < 0)
2607 goto error;
2608 Py_DECREF(x);
2609#endif
2610#ifdef AL_MAX_STRLEN
2611 x = PyInt_FromLong((long) AL_MAX_STRLEN);
2612 if (x == NULL || PyDict_SetItemString(d, "MAX_STRLEN", x) < 0)
2613 goto error;
2614 Py_DECREF(x);
2615#endif
2616#ifdef AL_MCLK_TYPE
2617 x = PyInt_FromLong((long) AL_MCLK_TYPE);
2618 if (x == NULL || PyDict_SetItemString(d, "MCLK_TYPE", x) < 0)
2619 goto error;
2620 Py_DECREF(x);
2621#endif
2622#ifdef AL_MIC_IF_TYPE
2623 x = PyInt_FromLong((long) AL_MIC_IF_TYPE);
2624 if (x == NULL || PyDict_SetItemString(d, "MIC_IF_TYPE", x) < 0)
2625 goto error;
2626 Py_DECREF(x);
2627#endif
2628#ifdef AL_MONITOR_CTL
2629 x = PyInt_FromLong((long) AL_MONITOR_CTL);
2630 if (x == NULL || PyDict_SetItemString(d, "MONITOR_CTL", x) < 0)
2631 goto error;
2632 Py_DECREF(x);
2633#endif
2634#ifdef AL_MONITOR_OFF
2635 x = PyInt_FromLong((long) AL_MONITOR_OFF);
2636 if (x == NULL || PyDict_SetItemString(d, "MONITOR_OFF", x) < 0)
2637 goto error;
2638 Py_DECREF(x);
2639#endif
2640#ifdef AL_MONITOR_ON
2641 x = PyInt_FromLong((long) AL_MONITOR_ON);
2642 if (x == NULL || PyDict_SetItemString(d, "MONITOR_ON", x) < 0)
2643 goto error;
2644 Py_DECREF(x);
2645#endif
2646#ifdef AL_MONO
2647 x = PyInt_FromLong((long) AL_MONO);
2648 if (x == NULL || PyDict_SetItemString(d, "MONO", x) < 0)
2649 goto error;
2650 Py_DECREF(x);
2651#endif
2652#ifdef AL_MUTE
2653 x = PyInt_FromLong((long) AL_MUTE);
2654 if (x == NULL || PyDict_SetItemString(d, "MUTE", x) < 0)
2655 goto error;
2656 Py_DECREF(x);
2657#endif
2658#ifdef AL_NAME
2659 x = PyInt_FromLong((long) AL_NAME);
2660 if (x == NULL || PyDict_SetItemString(d, "NAME", x) < 0)
2661 goto error;
2662 Py_DECREF(x);
2663#endif
2664#ifdef AL_NEG_INFINITY
2665 x = PyInt_FromLong((long) AL_NEG_INFINITY);
2666 if (x == NULL || PyDict_SetItemString(d, "NEG_INFINITY", x) < 0)
2667 goto error;
2668 Py_DECREF(x);
2669#endif
2670#ifdef AL_NEG_INFINITY_BIT
2671 x = PyInt_FromLong((long) AL_NEG_INFINITY_BIT);
2672 if (x == NULL || PyDict_SetItemString(d, "NEG_INFINITY_BIT", x) < 0)
2673 goto error;
2674 Py_DECREF(x);
2675#endif
2676#ifdef AL_NO_CHANGE
2677 x = PyInt_FromLong((long) AL_NO_CHANGE);
2678 if (x == NULL || PyDict_SetItemString(d, "NO_CHANGE", x) < 0)
2679 goto error;
2680 Py_DECREF(x);
2681#endif
2682#ifdef AL_NO_CHANGE_BIT
2683 x = PyInt_FromLong((long) AL_NO_CHANGE_BIT);
2684 if (x == NULL || PyDict_SetItemString(d, "NO_CHANGE_BIT", x) < 0)
2685 goto error;
2686 Py_DECREF(x);
2687#endif
2688#ifdef AL_NO_ELEM
2689 x = PyInt_FromLong((long) AL_NO_ELEM);
2690 if (x == NULL || PyDict_SetItemString(d, "NO_ELEM", x) < 0)
2691 goto error;
2692 Py_DECREF(x);
2693#endif
2694#ifdef AL_NO_ERRORS
2695 x = PyInt_FromLong((long) AL_NO_ERRORS);
2696 if (x == NULL || PyDict_SetItemString(d, "NO_ERRORS", x) < 0)
2697 goto error;
2698 Py_DECREF(x);
2699#endif
2700#ifdef AL_NO_OP
2701 x = PyInt_FromLong((long) AL_NO_OP);
2702 if (x == NULL || PyDict_SetItemString(d, "NO_OP", x) < 0)
2703 goto error;
2704 Py_DECREF(x);
2705#endif
2706#ifdef AL_NO_VAL
2707 x = PyInt_FromLong((long) AL_NO_VAL);
2708 if (x == NULL || PyDict_SetItemString(d, "NO_VAL", x) < 0)
2709 goto error;
2710 Py_DECREF(x);
2711#endif
2712#ifdef AL_NULL_INTERFACE
2713 x = PyInt_FromLong((long) AL_NULL_INTERFACE);
2714 if (x == NULL || PyDict_SetItemString(d, "NULL_INTERFACE", x) < 0)
2715 goto error;
2716 Py_DECREF(x);
2717#endif
2718#ifdef AL_NULL_RESOURCE
2719 x = PyInt_FromLong((long) AL_NULL_RESOURCE);
2720 if (x == NULL || PyDict_SetItemString(d, "NULL_RESOURCE", x) < 0)
2721 goto error;
2722 Py_DECREF(x);
2723#endif
2724#ifdef AL_OPTICAL_IF_TYPE
2725 x = PyInt_FromLong((long) AL_OPTICAL_IF_TYPE);
2726 if (x == NULL || PyDict_SetItemString(d, "OPTICAL_IF_TYPE", x) < 0)
2727 goto error;
2728 Py_DECREF(x);
2729#endif
2730#ifdef AL_OUTPUT_COUNT
2731 x = PyInt_FromLong((long) AL_OUTPUT_COUNT);
2732 if (x == NULL || PyDict_SetItemString(d, "OUTPUT_COUNT", x) < 0)
2733 goto error;
2734 Py_DECREF(x);
2735#endif
2736#ifdef AL_OUTPUT_DEVICE_TYPE
2737 x = PyInt_FromLong((long) AL_OUTPUT_DEVICE_TYPE);
2738 if (x == NULL || PyDict_SetItemString(d, "OUTPUT_DEVICE_TYPE", x) < 0)
2739 goto error;
2740 Py_DECREF(x);
2741#endif
2742#ifdef AL_OUTPUT_HRB_TYPE
2743 x = PyInt_FromLong((long) AL_OUTPUT_HRB_TYPE);
2744 if (x == NULL || PyDict_SetItemString(d, "OUTPUT_HRB_TYPE", x) < 0)
2745 goto error;
2746 Py_DECREF(x);
2747#endif
2748#ifdef AL_OUTPUT_PORT_TYPE
2749 x = PyInt_FromLong((long) AL_OUTPUT_PORT_TYPE);
2750 if (x == NULL || PyDict_SetItemString(d, "OUTPUT_PORT_TYPE", x) < 0)
2751 goto error;
2752 Py_DECREF(x);
2753#endif
2754#ifdef AL_OUTPUT_RATE
2755 x = PyInt_FromLong((long) AL_OUTPUT_RATE);
2756 if (x == NULL || PyDict_SetItemString(d, "OUTPUT_RATE", x) < 0)
2757 goto error;
2758 Py_DECREF(x);
2759#endif
2760#ifdef AL_PARAM_BIT
2761 x = PyInt_FromLong((long) AL_PARAM_BIT);
2762 if (x == NULL || PyDict_SetItemString(d, "PARAM_BIT", x) < 0)
2763 goto error;
2764 Py_DECREF(x);
2765#endif
2766#ifdef AL_PARAMS
2767 x = PyInt_FromLong((long) AL_PARAMS);
2768 if (x == NULL || PyDict_SetItemString(d, "PARAMS", x) < 0)
2769 goto error;
2770 Py_DECREF(x);
2771#endif
2772#ifdef AL_PORT_COUNT
2773 x = PyInt_FromLong((long) AL_PORT_COUNT);
2774 if (x == NULL || PyDict_SetItemString(d, "PORT_COUNT", x) < 0)
2775 goto error;
2776 Py_DECREF(x);
2777#endif
2778#ifdef AL_PORT_TYPE
2779 x = PyInt_FromLong((long) AL_PORT_TYPE);
2780 if (x == NULL || PyDict_SetItemString(d, "PORT_TYPE", x) < 0)
2781 goto error;
2782 Py_DECREF(x);
2783#endif
2784#ifdef AL_PORTS
2785 x = PyInt_FromLong((long) AL_PORTS);
2786 if (x == NULL || PyDict_SetItemString(d, "PORTS", x) < 0)
2787 goto error;
2788 Py_DECREF(x);
2789#endif
2790#ifdef AL_PORTSTYLE_DIRECT
2791 x = PyInt_FromLong((long) AL_PORTSTYLE_DIRECT);
2792 if (x == NULL || PyDict_SetItemString(d, "PORTSTYLE_DIRECT", x) < 0)
2793 goto error;
2794 Py_DECREF(x);
2795#endif
2796#ifdef AL_PORTSTYLE_SERIAL
2797 x = PyInt_FromLong((long) AL_PORTSTYLE_SERIAL);
2798 if (x == NULL || PyDict_SetItemString(d, "PORTSTYLE_SERIAL", x) < 0)
2799 goto error;
2800 Py_DECREF(x);
2801#endif
2802#ifdef AL_PRINT_ERRORS
2803 x = PyInt_FromLong((long) AL_PRINT_ERRORS);
2804 if (x == NULL || PyDict_SetItemString(d, "PRINT_ERRORS", x) < 0)
2805 goto error;
2806 Py_DECREF(x);
2807#endif
2808#ifdef AL_PTR_ELEM
2809 x = PyInt_FromLong((long) AL_PTR_ELEM);
2810 if (x == NULL || PyDict_SetItemString(d, "PTR_ELEM", x) < 0)
2811 goto error;
2812 Py_DECREF(x);
2813#endif
2814#ifdef AL_RANGE_VALUE
2815 x = PyInt_FromLong((long) AL_RANGE_VALUE);
2816 if (x == NULL || PyDict_SetItemString(d, "RANGE_VALUE", x) < 0)
2817 goto error;
2818 Py_DECREF(x);
2819#endif
2820#ifdef AL_RATE
2821 x = PyInt_FromLong((long) AL_RATE);
2822 if (x == NULL || PyDict_SetItemString(d, "RATE", x) < 0)
2823 goto error;
2824 Py_DECREF(x);
2825#endif
2826#ifdef AL_RATE_11025
2827 x = PyInt_FromLong((long) AL_RATE_11025);
2828 if (x == NULL || PyDict_SetItemString(d, "RATE_11025", x) < 0)
2829 goto error;
2830 Py_DECREF(x);
2831#endif
2832#ifdef AL_RATE_16000
2833 x = PyInt_FromLong((long) AL_RATE_16000);
2834 if (x == NULL || PyDict_SetItemString(d, "RATE_16000", x) < 0)
2835 goto error;
2836 Py_DECREF(x);
2837#endif
2838#ifdef AL_RATE_22050
2839 x = PyInt_FromLong((long) AL_RATE_22050);
2840 if (x == NULL || PyDict_SetItemString(d, "RATE_22050", x) < 0)
2841 goto error;
2842 Py_DECREF(x);
2843#endif
2844#ifdef AL_RATE_32000
2845 x = PyInt_FromLong((long) AL_RATE_32000);
2846 if (x == NULL || PyDict_SetItemString(d, "RATE_32000", x) < 0)
2847 goto error;
2848 Py_DECREF(x);
2849#endif
2850#ifdef AL_RATE_44100
2851 x = PyInt_FromLong((long) AL_RATE_44100);
2852 if (x == NULL || PyDict_SetItemString(d, "RATE_44100", x) < 0)
2853 goto error;
2854 Py_DECREF(x);
2855#endif
2856#ifdef AL_RATE_48000
2857 x = PyInt_FromLong((long) AL_RATE_48000);
2858 if (x == NULL || PyDict_SetItemString(d, "RATE_48000", x) < 0)
2859 goto error;
2860 Py_DECREF(x);
2861#endif
2862#ifdef AL_RATE_8000
2863 x = PyInt_FromLong((long) AL_RATE_8000);
2864 if (x == NULL || PyDict_SetItemString(d, "RATE_8000", x) < 0)
2865 goto error;
2866 Py_DECREF(x);
2867#endif
2868#ifdef AL_RATE_AES_1
2869 x = PyInt_FromLong((long) AL_RATE_AES_1);
2870 if (x == NULL || PyDict_SetItemString(d, "RATE_AES_1", x) < 0)
2871 goto error;
2872 Py_DECREF(x);
2873#endif
2874#ifdef AL_RATE_AES_1s
2875 x = PyInt_FromLong((long) AL_RATE_AES_1s);
2876 if (x == NULL || PyDict_SetItemString(d, "RATE_AES_1s", x) < 0)
2877 goto error;
2878 Py_DECREF(x);
2879#endif
2880#ifdef AL_RATE_AES_2
2881 x = PyInt_FromLong((long) AL_RATE_AES_2);
2882 if (x == NULL || PyDict_SetItemString(d, "RATE_AES_2", x) < 0)
2883 goto error;
2884 Py_DECREF(x);
2885#endif
2886#ifdef AL_RATE_AES_3
2887 x = PyInt_FromLong((long) AL_RATE_AES_3);
2888 if (x == NULL || PyDict_SetItemString(d, "RATE_AES_3", x) < 0)
2889 goto error;
2890 Py_DECREF(x);
2891#endif
2892#ifdef AL_RATE_AES_4
2893 x = PyInt_FromLong((long) AL_RATE_AES_4);
2894 if (x == NULL || PyDict_SetItemString(d, "RATE_AES_4", x) < 0)
2895 goto error;
2896 Py_DECREF(x);
2897#endif
2898#ifdef AL_RATE_AES_6
2899 x = PyInt_FromLong((long) AL_RATE_AES_6);
2900 if (x == NULL || PyDict_SetItemString(d, "RATE_AES_6", x) < 0)
2901 goto error;
2902 Py_DECREF(x);
2903#endif
2904#ifdef AL_RATE_FRACTION_D
2905 x = PyInt_FromLong((long) AL_RATE_FRACTION_D);
2906 if (x == NULL || PyDict_SetItemString(d, "RATE_FRACTION_D", x) < 0)
2907 goto error;
2908 Py_DECREF(x);
2909#endif
2910#ifdef AL_RATE_FRACTION_N
2911 x = PyInt_FromLong((long) AL_RATE_FRACTION_N);
2912 if (x == NULL || PyDict_SetItemString(d, "RATE_FRACTION_N", x) < 0)
2913 goto error;
2914 Py_DECREF(x);
2915#endif
2916#ifdef AL_RATE_INPUTRATE
2917 x = PyInt_FromLong((long) AL_RATE_INPUTRATE);
2918 if (x == NULL || PyDict_SetItemString(d, "RATE_INPUTRATE", x) < 0)
2919 goto error;
2920 Py_DECREF(x);
2921#endif
2922#ifdef AL_RATE_NO_DIGITAL_INPUT
2923 x = PyInt_FromLong((long) AL_RATE_NO_DIGITAL_INPUT);
2924 if (x == NULL || PyDict_SetItemString(d, "RATE_NO_DIGITAL_INPUT", x) < 0)
2925 goto error;
2926 Py_DECREF(x);
2927#endif
2928#ifdef AL_RATE_UNACQUIRED
2929 x = PyInt_FromLong((long) AL_RATE_UNACQUIRED);
2930 if (x == NULL || PyDict_SetItemString(d, "RATE_UNACQUIRED", x) < 0)
2931 goto error;
2932 Py_DECREF(x);
2933#endif
2934#ifdef AL_RATE_UNDEFINED
2935 x = PyInt_FromLong((long) AL_RATE_UNDEFINED);
2936 if (x == NULL || PyDict_SetItemString(d, "RATE_UNDEFINED", x) < 0)
2937 goto error;
2938 Py_DECREF(x);
2939#endif
2940#ifdef AL_REF_0DBV
2941 x = PyInt_FromLong((long) AL_REF_0DBV);
2942 if (x == NULL || PyDict_SetItemString(d, "REF_0DBV", x) < 0)
2943 goto error;
2944 Py_DECREF(x);
2945#endif
2946#ifdef AL_REF_NONE
2947 x = PyInt_FromLong((long) AL_REF_NONE);
2948 if (x == NULL || PyDict_SetItemString(d, "REF_NONE", x) < 0)
2949 goto error;
2950 Py_DECREF(x);
2951#endif
2952#ifdef AL_RESERVED1_TYPE
2953 x = PyInt_FromLong((long) AL_RESERVED1_TYPE);
2954 if (x == NULL || PyDict_SetItemString(d, "RESERVED1_TYPE", x) < 0)
2955 goto error;
2956 Py_DECREF(x);
2957#endif
2958#ifdef AL_RESERVED2_TYPE
2959 x = PyInt_FromLong((long) AL_RESERVED2_TYPE);
2960 if (x == NULL || PyDict_SetItemString(d, "RESERVED2_TYPE", x) < 0)
2961 goto error;
2962 Py_DECREF(x);
2963#endif
2964#ifdef AL_RESERVED3_TYPE
2965 x = PyInt_FromLong((long) AL_RESERVED3_TYPE);
2966 if (x == NULL || PyDict_SetItemString(d, "RESERVED3_TYPE", x) < 0)
2967 goto error;
2968 Py_DECREF(x);
2969#endif
2970#ifdef AL_RESERVED4_TYPE
2971 x = PyInt_FromLong((long) AL_RESERVED4_TYPE);
2972 if (x == NULL || PyDict_SetItemString(d, "RESERVED4_TYPE", x) < 0)
2973 goto error;
2974 Py_DECREF(x);
2975#endif
2976#ifdef AL_RESOURCE
2977 x = PyInt_FromLong((long) AL_RESOURCE);
2978 if (x == NULL || PyDict_SetItemString(d, "RESOURCE", x) < 0)
2979 goto error;
2980 Py_DECREF(x);
2981#endif
2982#ifdef AL_RESOURCE_ELEM
2983 x = PyInt_FromLong((long) AL_RESOURCE_ELEM);
2984 if (x == NULL || PyDict_SetItemString(d, "RESOURCE_ELEM", x) < 0)
2985 goto error;
2986 Py_DECREF(x);
2987#endif
2988#ifdef AL_RESOURCE_TYPE
2989 x = PyInt_FromLong((long) AL_RESOURCE_TYPE);
2990 if (x == NULL || PyDict_SetItemString(d, "RESOURCE_TYPE", x) < 0)
2991 goto error;
2992 Py_DECREF(x);
2993#endif
2994#ifdef AL_RIGHT_INPUT_ATTEN
2995 x = PyInt_FromLong((long) AL_RIGHT_INPUT_ATTEN);
2996 if (x == NULL || PyDict_SetItemString(d, "RIGHT_INPUT_ATTEN", x) < 0)
2997 goto error;
2998 Py_DECREF(x);
2999#endif
3000#ifdef AL_RIGHT_MONITOR_ATTEN
3001 x = PyInt_FromLong((long) AL_RIGHT_MONITOR_ATTEN);
3002 if (x == NULL || PyDict_SetItemString(d, "RIGHT_MONITOR_ATTEN", x) < 0)
3003 goto error;
3004 Py_DECREF(x);
3005#endif
3006#ifdef AL_RIGHT_SPEAKER_GAIN
3007 x = PyInt_FromLong((long) AL_RIGHT_SPEAKER_GAIN);
3008 if (x == NULL || PyDict_SetItemString(d, "RIGHT_SPEAKER_GAIN", x) < 0)
3009 goto error;
3010 Py_DECREF(x);
3011#endif
3012#ifdef AL_RIGHT1_INPUT_ATTEN
3013 x = PyInt_FromLong((long) AL_RIGHT1_INPUT_ATTEN);
3014 if (x == NULL || PyDict_SetItemString(d, "RIGHT1_INPUT_ATTEN", x) < 0)
3015 goto error;
3016 Py_DECREF(x);
3017#endif
3018#ifdef AL_RIGHT2_INPUT_ATTEN
3019 x = PyInt_FromLong((long) AL_RIGHT2_INPUT_ATTEN);
3020 if (x == NULL || PyDict_SetItemString(d, "RIGHT2_INPUT_ATTEN", x) < 0)
3021 goto error;
3022 Py_DECREF(x);
3023#endif
3024#ifdef AL_SAMPFMT_DOUBLE
3025 x = PyInt_FromLong((long) AL_SAMPFMT_DOUBLE);
3026 if (x == NULL || PyDict_SetItemString(d, "SAMPFMT_DOUBLE", x) < 0)
3027 goto error;
3028 Py_DECREF(x);
3029#endif
3030#ifdef AL_SAMPFMT_FLOAT
3031 x = PyInt_FromLong((long) AL_SAMPFMT_FLOAT);
3032 if (x == NULL || PyDict_SetItemString(d, "SAMPFMT_FLOAT", x) < 0)
3033 goto error;
3034 Py_DECREF(x);
3035#endif
3036#ifdef AL_SAMPFMT_TWOSCOMP
3037 x = PyInt_FromLong((long) AL_SAMPFMT_TWOSCOMP);
3038 if (x == NULL || PyDict_SetItemString(d, "SAMPFMT_TWOSCOMP", x) < 0)
3039 goto error;
3040 Py_DECREF(x);
3041#endif
3042#ifdef AL_SAMPLE_16
3043 x = PyInt_FromLong((long) AL_SAMPLE_16);
3044 if (x == NULL || PyDict_SetItemString(d, "SAMPLE_16", x) < 0)
3045 goto error;
3046 Py_DECREF(x);
3047#endif
3048#ifdef AL_SAMPLE_24
3049 x = PyInt_FromLong((long) AL_SAMPLE_24);
3050 if (x == NULL || PyDict_SetItemString(d, "SAMPLE_24", x) < 0)
3051 goto error;
3052 Py_DECREF(x);
3053#endif
3054#ifdef AL_SAMPLE_8
3055 x = PyInt_FromLong((long) AL_SAMPLE_8);
3056 if (x == NULL || PyDict_SetItemString(d, "SAMPLE_8", x) < 0)
3057 goto error;
3058 Py_DECREF(x);
3059#endif
3060#ifdef AL_SCALAR_VAL
3061 x = PyInt_FromLong((long) AL_SCALAR_VAL);
3062 if (x == NULL || PyDict_SetItemString(d, "SCALAR_VAL", x) < 0)
3063 goto error;
3064 Py_DECREF(x);
3065#endif
3066#ifdef AL_SET_VAL
3067 x = PyInt_FromLong((long) AL_SET_VAL);
3068 if (x == NULL || PyDict_SetItemString(d, "SET_VAL", x) < 0)
3069 goto error;
3070 Py_DECREF(x);
3071#endif
3072#ifdef AL_SHORT_NAME
3073 x = PyInt_FromLong((long) AL_SHORT_NAME);
3074 if (x == NULL || PyDict_SetItemString(d, "SHORT_NAME", x) < 0)
3075 goto error;
3076 Py_DECREF(x);
3077#endif
3078#ifdef AL_SMPTE272M_IF_TYPE
3079 x = PyInt_FromLong((long) AL_SMPTE272M_IF_TYPE);
3080 if (x == NULL || PyDict_SetItemString(d, "SMPTE272M_IF_TYPE", x) < 0)
3081 goto error;
3082 Py_DECREF(x);
3083#endif
3084#ifdef AL_SOURCE
3085 x = PyInt_FromLong((long) AL_SOURCE);
3086 if (x == NULL || PyDict_SetItemString(d, "SOURCE", x) < 0)
3087 goto error;
3088 Py_DECREF(x);
3089#endif
3090#ifdef AL_SPEAKER_IF_TYPE
3091 x = PyInt_FromLong((long) AL_SPEAKER_IF_TYPE);
3092 if (x == NULL || PyDict_SetItemString(d, "SPEAKER_IF_TYPE", x) < 0)
3093 goto error;
3094 Py_DECREF(x);
3095#endif
3096#ifdef AL_SPEAKER_MUTE_CTL
3097 x = PyInt_FromLong((long) AL_SPEAKER_MUTE_CTL);
3098 if (x == NULL || PyDict_SetItemString(d, "SPEAKER_MUTE_CTL", x) < 0)
3099 goto error;
3100 Py_DECREF(x);
3101#endif
3102#ifdef AL_SPEAKER_MUTE_OFF
3103 x = PyInt_FromLong((long) AL_SPEAKER_MUTE_OFF);
3104 if (x == NULL || PyDict_SetItemString(d, "SPEAKER_MUTE_OFF", x) < 0)
3105 goto error;
3106 Py_DECREF(x);
3107#endif
3108#ifdef AL_SPEAKER_MUTE_ON
3109 x = PyInt_FromLong((long) AL_SPEAKER_MUTE_ON);
3110 if (x == NULL || PyDict_SetItemString(d, "SPEAKER_MUTE_ON", x) < 0)
3111 goto error;
3112 Py_DECREF(x);
3113#endif
3114#ifdef AL_SPEAKER_PLUS_LINE_IF_TYPE
3115 x = PyInt_FromLong((long) AL_SPEAKER_PLUS_LINE_IF_TYPE);
3116 if (x == NULL || PyDict_SetItemString(d, "SPEAKER_PLUS_LINE_IF_TYPE", x) < 0)
3117 goto error;
3118 Py_DECREF(x);
3119#endif
3120#ifdef AL_STEREO
3121 x = PyInt_FromLong((long) AL_STEREO);
3122 if (x == NULL || PyDict_SetItemString(d, "STEREO", x) < 0)
3123 goto error;
3124 Py_DECREF(x);
3125#endif
3126#ifdef AL_STRING_VAL
3127 x = PyInt_FromLong((long) AL_STRING_VAL);
3128 if (x == NULL || PyDict_SetItemString(d, "STRING_VAL", x) < 0)
3129 goto error;
3130 Py_DECREF(x);
3131#endif
3132#ifdef AL_SUBSYSTEM
3133 x = PyInt_FromLong((long) AL_SUBSYSTEM);
3134 if (x == NULL || PyDict_SetItemString(d, "SUBSYSTEM", x) < 0)
3135 goto error;
3136 Py_DECREF(x);
3137#endif
3138#ifdef AL_SUBSYSTEM_TYPE
3139 x = PyInt_FromLong((long) AL_SUBSYSTEM_TYPE);
3140 if (x == NULL || PyDict_SetItemString(d, "SUBSYSTEM_TYPE", x) < 0)
3141 goto error;
3142 Py_DECREF(x);
3143#endif
3144#ifdef AL_SYNC_INPUT_TO_AES
3145 x = PyInt_FromLong((long) AL_SYNC_INPUT_TO_AES);
3146 if (x == NULL || PyDict_SetItemString(d, "SYNC_INPUT_TO_AES", x) < 0)
3147 goto error;
3148 Py_DECREF(x);
3149#endif
3150#ifdef AL_SYNC_OUTPUT_TO_AES
3151 x = PyInt_FromLong((long) AL_SYNC_OUTPUT_TO_AES);
3152 if (x == NULL || PyDict_SetItemString(d, "SYNC_OUTPUT_TO_AES", x) < 0)
3153 goto error;
3154 Py_DECREF(x);
3155#endif
3156#ifdef AL_SYSTEM
3157 x = PyInt_FromLong((long) AL_SYSTEM);
3158 if (x == NULL || PyDict_SetItemString(d, "SYSTEM", x) < 0)
3159 goto error;
3160 Py_DECREF(x);
3161#endif
3162#ifdef AL_SYSTEM_TYPE
3163 x = PyInt_FromLong((long) AL_SYSTEM_TYPE);
3164 if (x == NULL || PyDict_SetItemString(d, "SYSTEM_TYPE", x) < 0)
3165 goto error;
3166 Py_DECREF(x);
3167#endif
3168#ifdef AL_TEST_IF_TYPE
3169 x = PyInt_FromLong((long) AL_TEST_IF_TYPE);
3170 if (x == NULL || PyDict_SetItemString(d, "TEST_IF_TYPE", x) < 0)
3171 goto error;
3172 Py_DECREF(x);
3173#endif
3174#ifdef AL_TYPE
3175 x = PyInt_FromLong((long) AL_TYPE);
3176 if (x == NULL || PyDict_SetItemString(d, "TYPE", x) < 0)
3177 goto error;
3178 Py_DECREF(x);
3179#endif
3180#ifdef AL_TYPE_BIT
3181 x = PyInt_FromLong((long) AL_TYPE_BIT);
3182 if (x == NULL || PyDict_SetItemString(d, "TYPE_BIT", x) < 0)
3183 goto error;
3184 Py_DECREF(x);
3185#endif
3186#ifdef AL_UNUSED_COUNT
3187 x = PyInt_FromLong((long) AL_UNUSED_COUNT);
3188 if (x == NULL || PyDict_SetItemString(d, "UNUSED_COUNT", x) < 0)
3189 goto error;
3190 Py_DECREF(x);
3191#endif
3192#ifdef AL_UNUSED_PORTS
3193 x = PyInt_FromLong((long) AL_UNUSED_PORTS);
3194 if (x == NULL || PyDict_SetItemString(d, "UNUSED_PORTS", x) < 0)
3195 goto error;
3196 Py_DECREF(x);
3197#endif
3198#ifdef AL_VARIABLE_MCLK_TYPE
3199 x = PyInt_FromLong((long) AL_VARIABLE_MCLK_TYPE);
3200 if (x == NULL || PyDict_SetItemString(d, "VARIABLE_MCLK_TYPE", x) < 0)
3201 goto error;
3202 Py_DECREF(x);
3203#endif
3204#ifdef AL_VECTOR_VAL
3205 x = PyInt_FromLong((long) AL_VECTOR_VAL);
3206 if (x == NULL || PyDict_SetItemString(d, "VECTOR_VAL", x) < 0)
3207 goto error;
3208 Py_DECREF(x);
3209#endif
3210#ifdef AL_VIDEO_MCLK_TYPE
3211 x = PyInt_FromLong((long) AL_VIDEO_MCLK_TYPE);
3212 if (x == NULL || PyDict_SetItemString(d, "VIDEO_MCLK_TYPE", x) < 0)
3213 goto error;
3214 Py_DECREF(x);
3215#endif
3216#ifdef AL_WORDSIZE
3217 x = PyInt_FromLong((long) AL_WORDSIZE);
3218 if (x == NULL || PyDict_SetItemString(d, "WORDSIZE", x) < 0)
3219 goto error;
3220 Py_DECREF(x);
3221#endif
3222
3223#ifdef AL_NO_ELEM /* IRIX 6 */
3224 (void) alSetErrorHandler(ErrorHandler);
3225#endif /* AL_NO_ELEM */
3226#ifdef OLD_INTERFACE
3227 (void) ALseterrorhandler(ErrorHandler);
3228#endif /* OLD_INTERFACE */
3229
3230 error:
3231 return;
3232}
Note: See TracBrowser for help on using the repository browser.