?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
More configure fixes: avoid sh 'integer argument expected' error when 'long long...
[python.git] / Modules / almodule.c
blob93f26bd48e64fee903eda9a49714eb55d6e32aba
1
2 #define OLD_INTERFACE /* define for pre-Irix 6 interface */
3
4 #include "Python.h"
5 #include "stringobject.h"
6 #include <audio.h>
7 #include <stdarg.h>
8
9 #ifndef AL_NO_ELEM
10 #ifndef OLD_INTERFACE
11 #define OLD_INTERFACE
12 #endif /* OLD_INTERFACE */
13 #endif /* AL_NO_ELEM */
14
15 static PyObject *ErrorObject;
16
17 /* ----------------------------------------------------- */
18
19 /* Declarations for objects of type port */
20
21 typedef struct {
22 PyObject_HEAD
23 /* XXXX Add your own stuff here */
24 ALport port;
25 } alpobject;
26
27 static PyTypeObject Alptype;
28
29
30
31 /* ---------------------------------------------------------------- */
32
33 /* Declarations for objects of type config */
34
35 typedef struct {
36 PyObject_HEAD
37 /* XXXX Add your own stuff here */
38 ALconfig config;
39 } alcobject;
40
41 static PyTypeObject Alctype;
42
43
44 static void
45 ErrorHandler(long code, const char *fmt, ...)
46 {
47 va_list args;
48 char buf[128];
49
50 va_start(args, fmt);
51 vsprintf(buf, fmt, args);
52 va_end(args);
53 PyErr_SetString(ErrorObject, buf);
54 }
55
56 #ifdef AL_NO_ELEM /* IRIX 6 */
57
58 static PyObject *
59 param2python(int resource, int param, ALvalue value, ALparamInfo *pinfo)
60 {
61 ALparamInfo info;
62
63 if (pinfo == NULL) {
64 pinfo = &info;
65 if (alGetParamInfo(resource, param, &info) < 0)
66 return NULL;
67 }
68 switch (pinfo->elementType) {
69 case AL_PTR_ELEM:
70 /* XXXX don't know how to handle this */
71 case AL_NO_ELEM:
72 Py_INCREF(Py_None);
73 return Py_None;
74 case AL_INT32_ELEM:
75 case AL_RESOURCE_ELEM:
76 case AL_ENUM_ELEM:
77 return PyInt_FromLong((long) value.i);
78 case AL_INT64_ELEM:
79 return PyLong_FromLongLong(value.ll);
80 case AL_FIXED_ELEM:
81 return PyFloat_FromDouble(alFixedToDouble(value.ll));
82 case AL_CHAR_ELEM:
83 if (value.ptr == NULL) {
84 Py_INCREF(Py_None);
85 return Py_None;
86 }
87 return PyString_FromString((char *) value.ptr);
88 default:
89 PyErr_SetString(ErrorObject, "unknown element type");
90 return NULL;
91 }
92 }
93
94 static int
95 python2elem(PyObject *item, void *ptr, int elementType)
96 {
97 switch (elementType) {
98 case AL_INT32_ELEM:
99 case AL_RESOURCE_ELEM:
100 case AL_ENUM_ELEM:
101 if (!PyInt_Check(item)) {
102 PyErr_BadArgument();
103 return -1;
104 }
105 *((int *) ptr) = PyInt_AsLong(item);
106 break;
107 case AL_INT64_ELEM:
108 if (PyInt_Check(item))
109 *((long long *) ptr) = PyInt_AsLong(item);
110 else if (PyLong_Check(item))
111 *((long long *) ptr) = PyLong_AsLongLong(item);
112 else {
113 PyErr_BadArgument();
114 return -1;
115 }
116 break;
117 case AL_FIXED_ELEM:
118 if (PyInt_Check(item))
119 *((long long *) ptr) = alDoubleToFixed((double) PyInt_AsLong(item));
120 else if (PyFloat_Check(item))
121 *((long long *) ptr) = alDoubleToFixed(PyFloat_AsDouble(item));
122 else {
123 PyErr_BadArgument();
124 return -1;
125 }
126 break;
127 default:
128 PyErr_SetString(ErrorObject, "unknown element type");
129 return -1;
130 }
131 return 0;
132 }
133
134 static int
135 python2param(int resource, ALpv *param, PyObject *value, ALparamInfo *pinfo)
136 {
137 ALparamInfo info;
138 int i, stepsize;
139 PyObject *item;
140
141 if (pinfo == NULL) {
142 pinfo = &info;
143 if (alGetParamInfo(resource, param->param, &info) < 0)
144 return -1;
145 }
146 switch (pinfo->valueType) {
147 case AL_STRING_VAL:
148 if (pinfo->elementType != AL_CHAR_ELEM) {
149 PyErr_SetString(ErrorObject, "unknown element type");
150 return -1;
151 }
152 if (!PyString_Check(value)) {
153 PyErr_BadArgument();
154 return -1;
155 }
156 param->value.ptr = PyString_AS_STRING(value);
157 param->sizeIn = PyString_GET_SIZE(value)+1; /*account for NUL*/
158 break;
159 case AL_SET_VAL:
160 case AL_VECTOR_VAL:
161 if (!PyList_Check(value) && !PyTuple_Check(value)) {
162 PyErr_BadArgument();
163 return -1;
164 }
165 switch (pinfo->elementType) {
166 case AL_INT32_ELEM:
167 case AL_RESOURCE_ELEM:
168 case AL_ENUM_ELEM:
169 param->sizeIn = PySequence_Size(value);
170 param->value.ptr = PyMem_NEW(int, param->sizeIn);
171 stepsize = sizeof(int);
172 break;
173 case AL_INT64_ELEM:
174 case AL_FIXED_ELEM:
175 param->sizeIn = PySequence_Size(value);
176 param->value.ptr = PyMem_NEW(long long, param->sizeIn);
177 stepsize = sizeof(long long);
178 break;
179 }
180 for (i = 0; i < param->sizeIn; i++) {
181 item = PySequence_GetItem(value, i);
182 if (python2elem(item, (void *) ((char *) param->value.ptr + i*stepsize), pinfo->elementType) < 0) {
183 PyMem_DEL(param->value.ptr);
184 return -1;
185 }
186 }
187 break;
188 case AL_SCALAR_VAL:
189 switch (pinfo->elementType) {
190 case AL_INT32_ELEM:
191 case AL_RESOURCE_ELEM:
192 case AL_ENUM_ELEM:
193 return python2elem(value, (void *) &param->value.i,
194 pinfo->elementType);
195 case AL_INT64_ELEM:
196 case AL_FIXED_ELEM:
197 return python2elem(value, (void *) &param->value.ll,
198 pinfo->elementType);
199 default:
200 PyErr_SetString(ErrorObject, "unknown element type");
201 return -1;
202 }
203 }
204 return 0;
205 }
206
207 static int
208 python2params(int resource1, int resource2, PyObject *list, ALpv **pvsp, ALparamInfo **pinfop)
209 {
210 PyObject *item;
211 ALpv *pvs;
212 ALparamInfo *pinfo;
213 int npvs, i;
214
215 npvs = PyList_Size(list);
216 pvs = PyMem_NEW(ALpv, npvs);
217 pinfo = PyMem_NEW(ALparamInfo, npvs);
218 for (i = 0; i < npvs; i++) {
219 item = PyList_GetItem(list, i);
220 if (!PyArg_ParseTuple(item, "iO", &pvs[i].param, &item))
221 goto error;
222 if (alGetParamInfo(resource1, pvs[i].param, &pinfo[i]) < 0 &&
223 alGetParamInfo(resource2, pvs[i].param, &pinfo[i]) < 0)
224 goto error;
225 if (python2param(resource1, &pvs[i], item, &pinfo[i]) < 0)
226 goto error;
227 }
228
229 *pvsp = pvs;
230 *pinfop = pinfo;
231 return npvs;
232
233 error:
234 /* XXXX we should clean up everything */
235 if (pvs)
236 PyMem_DEL(pvs);
237 if (pinfo)
238 PyMem_DEL(pinfo);
239 return -1;
240 }
241
242 /* -------------------------------------------------------- */
243
244
245 static PyObject *
246 SetConfig(alcobject *self, PyObject *args, int (*func)(ALconfig, int))
247 {
248 int par;
249
250 if (!PyArg_ParseTuple(args, "i:SetConfig", &par))
251 return NULL;
252
253 if ((*func)(self->config, par) == -1)
254 return NULL;
255
256 Py_INCREF(Py_None);
257 return Py_None;
258 }
259
260 static PyObject *
261 GetConfig(alcobject *self, PyObject *args, int (*func)(ALconfig))
262 {
263 int par;
264
265 if (!PyArg_ParseTuple(args, ":GetConfig"))
266 return NULL;
267
268 if ((par = (*func)(self->config)) == -1)
269 return NULL;
270
271 return PyInt_FromLong((long) par);
272 }
273
274 PyDoc_STRVAR(alc_SetWidth__doc__,
275 "alSetWidth: set the wordsize for integer audio data.");
276
277 static PyObject *
278 alc_SetWidth(alcobject *self, PyObject *args)
279 {
280 return SetConfig(self, args, alSetWidth);
281 }
282
283
284 PyDoc_STRVAR(alc_GetWidth__doc__,
285 "alGetWidth: get the wordsize for integer audio data.");
286
287 static PyObject *
288 alc_GetWidth(alcobject *self, PyObject *args)
289 {
290 return GetConfig(self, args, alGetWidth);
291 }
292
293
294 PyDoc_STRVAR(alc_SetSampFmt__doc__,
295 "alSetSampFmt: set the sample format setting in an audio ALconfig "
296 "structure.");
297
298 static PyObject *
299 alc_SetSampFmt(alcobject *self, PyObject *args)
300 {
301 return SetConfig(self, args, alSetSampFmt);
302 }
303
304
305 PyDoc_STRVAR(alc_GetSampFmt__doc__,
306 "alGetSampFmt: get the sample format setting in an audio ALconfig "
307 "structure.");
308
309 static PyObject *
310 alc_GetSampFmt(alcobject *self, PyObject *args)
311 {
312 return GetConfig(self, args, alGetSampFmt);
313 }
314
315
316 PyDoc_STRVAR(alc_SetChannels__doc__,
317 "alSetChannels: set the channel settings in an audio ALconfig.");
318
319 static PyObject *
320 alc_SetChannels(alcobject *self, PyObject *args)
321 {
322 return SetConfig(self, args, alSetChannels);
323 }
324
325
326 PyDoc_STRVAR(alc_GetChannels__doc__,
327 "alGetChannels: get the channel settings in an audio ALconfig.");
328
329 static PyObject *
330 alc_GetChannels(alcobject *self, PyObject *args)
331 {
332 return GetConfig(self, args, alGetChannels);
333 }
334
335
336 PyDoc_STRVAR(alc_SetFloatMax__doc__,
337 "alSetFloatMax: set the maximum value of floating point sample data.");
338
339 static PyObject *
340 alc_SetFloatMax(alcobject *self, PyObject *args)
341 {
342 double maximum_value;
343
344 if (!PyArg_ParseTuple(args, "d:SetFloatMax", &maximum_value))
345 return NULL;
346 if (alSetFloatMax(self->config, maximum_value) < 0)
347 return NULL;
348 Py_INCREF(Py_None);
349 return Py_None;
350 }
351
352
353 PyDoc_STRVAR(alc_GetFloatMax__doc__,
354 "alGetFloatMax: get the maximum value of floating point sample data.");
355
356 static PyObject *
357 alc_GetFloatMax(alcobject *self, PyObject *args)
358 {
359 double maximum_value;
360
361 if (!PyArg_ParseTuple(args, ":GetFloatMax"))
362 return NULL;
363 if ((maximum_value = alGetFloatMax(self->config)) == 0)
364 return NULL;
365 return PyFloat_FromDouble(maximum_value);
366 }
367
368
369 PyDoc_STRVAR(alc_SetDevice__doc__,
370 "alSetDevice: set the device setting in an audio ALconfig structure.");
371
372 static PyObject *
373 alc_SetDevice(alcobject *self, PyObject *args)
374 {
375 return SetConfig(self, args, alSetDevice);
376 }
377
378
379 PyDoc_STRVAR(alc_GetDevice__doc__,
380 "alGetDevice: get the device setting in an audio ALconfig structure.");
381
382 static PyObject *
383 alc_GetDevice(alcobject *self, PyObject *args)
384 {
385 return GetConfig(self, args, alGetDevice);
386 }
387
388
389 PyDoc_STRVAR(alc_SetQueueSize__doc__,
390 "alSetQueueSize: set audio port buffer size.");
391
392 static PyObject *
393 alc_SetQueueSize(alcobject *self, PyObject *args)
394 {
395 return SetConfig(self, args, alSetQueueSize);
396 }
397
398
399 PyDoc_STRVAR(alc_GetQueueSize__doc__,
400 "alGetQueueSize: get audio port buffer size.");
401
402 static PyObject *
403 alc_GetQueueSize(alcobject *self, PyObject *args)
404 {
405 return GetConfig(self, args, alGetQueueSize);
406 }
407
408 #endif /* AL_NO_ELEM */
409
410 static PyObject *
411 setconfig(alcobject *self, PyObject *args, int (*func)(ALconfig, long))
412 {
413 long par;
414
415 if (!PyArg_ParseTuple(args, "l:SetConfig", &par))
416 return NULL;
417
418 if ((*func)(self->config, par) == -1)
419 return NULL;
420
421 Py_INCREF(Py_None);
422 return Py_None;
423 }
424
425 static PyObject *
426 getconfig(alcobject *self, PyObject *args, long (*func)(ALconfig))
427 {
428 long par;
429
430 if (!PyArg_ParseTuple(args, ":GetConfig"))
431 return NULL;
432
433 if ((par = (*func)(self->config)) == -1)
434 return NULL;
435
436 return PyInt_FromLong((long) par);
437 }
438
439 static PyObject *
440 alc_setqueuesize (alcobject *self, PyObject *args)
441 {
442 return setconfig(self, args, ALsetqueuesize);
443 }
444
445 static PyObject *
446 alc_getqueuesize (alcobject *self, PyObject *args)
447 {
448 return getconfig(self, args, ALgetqueuesize);
449 }
450
451 static PyObject *
452 alc_setwidth (alcobject *self, PyObject *args)
453 {
454 return setconfig(self, args, ALsetwidth);
455 }
456
457 static PyObject *
458 alc_getwidth (alcobject *self, PyObject *args)
459 {
460 return getconfig(self, args, ALgetwidth);
461 }
462
463 static PyObject *
464 alc_getchannels (alcobject *self, PyObject *args)
465 {
466 return getconfig(self, args, ALgetchannels);
467 }
468
469 static PyObject *
470 alc_setchannels (alcobject *self, PyObject *args)
471 {
472 return setconfig(self, args, ALsetchannels);
473 }
474
475 #ifdef AL_405
476
477 static PyObject *
478 alc_getsampfmt (alcobject *self, PyObject *args)
479 {
480 return getconfig(self, args, ALgetsampfmt);
481 }
482
483 static PyObject *
484 alc_setsampfmt (alcobject *self, PyObject *args)
485 {
486 return setconfig(self, args, ALsetsampfmt);
487 }
488
489 static PyObject *
490 alc_getfloatmax(alcobject *self, PyObject *args)
491 {
492 double arg;
493
494 if (!PyArg_ParseTuple(args, ":GetFloatMax"))
495 return 0;
496 if ((arg = ALgetfloatmax(self->config)) == 0)
497 return NULL;
498 return PyFloat_FromDouble(arg);
499 }
500
501 static PyObject *
502 alc_setfloatmax(alcobject *self, PyObject *args)
503 {
504 double arg;
505
506 if (!PyArg_ParseTuple(args, "d:SetFloatMax", &arg))
507 return 0;
508 if (ALsetfloatmax(self->config, arg) == -1)
509 return NULL;
510 Py_INCREF(Py_None);
511 return Py_None;
512 }
513 #endif /* AL_405 */
514
515 static struct PyMethodDef alc_methods[] = {
516 #ifdef AL_NO_ELEM /* IRIX 6 */
517 {"SetWidth", (PyCFunction)alc_SetWidth, METH_VARARGS, alc_SetWidth__doc__},
518 {"GetWidth", (PyCFunction)alc_GetWidth, METH_VARARGS, alc_GetWidth__doc__},
519 {"SetSampFmt", (PyCFunction)alc_SetSampFmt, METH_VARARGS, alc_SetSampFmt__doc__},
520 {"GetSampFmt", (PyCFunction)alc_GetSampFmt, METH_VARARGS, alc_GetSampFmt__doc__},
521 {"SetChannels", (PyCFunction)alc_SetChannels, METH_VARARGS, alc_SetChannels__doc__},
522 {"GetChannels", (PyCFunction)alc_GetChannels, METH_VARARGS, alc_GetChannels__doc__},
523 {"SetFloatMax", (PyCFunction)alc_SetFloatMax, METH_VARARGS, alc_SetFloatMax__doc__},
524 {"GetFloatMax", (PyCFunction)alc_GetFloatMax, METH_VARARGS, alc_GetFloatMax__doc__},
525 {"SetDevice", (PyCFunction)alc_SetDevice, METH_VARARGS, alc_SetDevice__doc__},
526 {"GetDevice", (PyCFunction)alc_GetDevice, METH_VARARGS, alc_GetDevice__doc__},
527 {"SetQueueSize", (PyCFunction)alc_SetQueueSize, METH_VARARGS, alc_SetQueueSize__doc__},
528 {"GetQueueSize", (PyCFunction)alc_GetQueueSize, METH_VARARGS, alc_GetQueueSize__doc__},
529 #endif /* AL_NO_ELEM */
530 {"getqueuesize", (PyCFunction)alc_getqueuesize, METH_VARARGS},
531 {"setqueuesize", (PyCFunction)alc_setqueuesize, METH_VARARGS},
532 {"getwidth", (PyCFunction)alc_getwidth, METH_VARARGS},
533 {"setwidth", (PyCFunction)alc_setwidth, METH_VARARGS},
534 {"getchannels", (PyCFunction)alc_getchannels, METH_VARARGS},
535 {"setchannels", (PyCFunction)alc_setchannels, METH_VARARGS},
536 #ifdef AL_405
537 {"getsampfmt", (PyCFunction)alc_getsampfmt, METH_VARARGS},
538 {"setsampfmt", (PyCFunction)alc_setsampfmt, METH_VARARGS},
539 {"getfloatmax", (PyCFunction)alc_getfloatmax, METH_VARARGS},
540 {"setfloatmax", (PyCFunction)alc_setfloatmax, METH_VARARGS},
541 #endif /* AL_405 */
542
543 {NULL, NULL} /* sentinel */
544 };
545
546 /* ---------- */
547
548
549 static PyObject *
550 newalcobject(ALconfig config)
551 {
552 alcobject *self;
553
554 self = PyObject_New(alcobject, &Alctype);
555 if (self == NULL)
556 return NULL;
557 /* XXXX Add your own initializers here */
558 self->config = config;
559 return (PyObject *) self;
560 }
561
562
563 static void
564 alc_dealloc(alcobject *self)
565 {
566 /* XXXX Add your own cleanup code here */
567 #ifdef AL_NO_ELEM /* IRIX 6 */
568 (void) alFreeConfig(self->config); /* ignore errors */
569 #else
570 (void) ALfreeconfig(self->config); /* ignore errors */
571 #endif
572 PyObject_Del(self);
573 }
574
575 static PyObject *
576 alc_getattr(alcobject *self, char *name)
577 {
578 /* XXXX Add your own getattr code here */
579 return Py_FindMethod(alc_methods, (PyObject *)self, name);
580 }
581
582 PyDoc_STRVAR(Alctype__doc__, "");
583
584 static PyTypeObject Alctype = {
585 PyObject_HEAD_INIT(&PyType_Type)
586 0, /*ob_size*/
587 "al.config", /*tp_name*/
588 sizeof(alcobject), /*tp_basicsize*/
589 0, /*tp_itemsize*/
590 /* methods */
591 (destructor)alc_dealloc, /*tp_dealloc*/
592 (printfunc)0, /*tp_print*/
593 (getattrfunc)alc_getattr, /*tp_getattr*/
594 (setattrfunc)0, /*tp_setattr*/
595 (cmpfunc)0, /*tp_compare*/
596 (reprfunc)0, /*tp_repr*/
597 0, /*tp_as_number*/
598 0, /*tp_as_sequence*/
599 0, /*tp_as_mapping*/
600 (hashfunc)0, /*tp_hash*/
601 (ternaryfunc)0, /*tp_call*/
602 (reprfunc)0, /*tp_str*/
603
604 /* Space for future expansion */
605 0L,0L,0L,0L,
606 Alctype__doc__ /* Documentation string */
607 };
608
609 /* End of code for config objects */
610 /* ---------------------------------------------------------------- */
611
612 #ifdef AL_NO_ELEM /* IRIX 6 */
613
614 PyDoc_STRVAR(alp_SetConfig__doc__,
615 "alSetConfig: set the ALconfig of an audio ALport.");
616
617 static PyObject *
618 alp_SetConfig(alpobject *self, PyObject *args)
619 {
620 alcobject *config;
621 if (!PyArg_ParseTuple(args, "O!:SetConfig", &Alctype, &config))
622 return NULL;
623 if (alSetConfig(self->port, config->config) < 0)
624 return NULL;
625 Py_INCREF(Py_None);
626 return Py_None;
627 }
628
629
630 PyDoc_STRVAR(alp_GetConfig__doc__,
631 "alGetConfig: get the ALconfig of an audio ALport.");
632
633 static PyObject *
634 alp_GetConfig(alpobject *self, PyObject *args)
635 {
636 ALconfig config;
637 if (!PyArg_ParseTuple(args, ":GetConfig"))
638 return NULL;
639 if ((config = alGetConfig(self->port)) == NULL)
640 return NULL;
641 return newalcobject(config);
642 }
643
644
645 PyDoc_STRVAR(alp_GetResource__doc__,
646 "alGetResource: get the resource associated with an audio port.");
647
648 static PyObject *
649 alp_GetResource(alpobject *self, PyObject *args)
650 {
651 int resource;
652
653 if (!PyArg_ParseTuple(args, ":GetResource"))
654 return NULL;
655 if ((resource = alGetResource(self->port)) == 0)
656 return NULL;
657 return PyInt_FromLong((long) resource);
658 }
659
660
661 PyDoc_STRVAR(alp_GetFD__doc__,
662 "alGetFD: get the file descriptor for an audio port.");
663
664 static PyObject *
665 alp_GetFD(alpobject *self, PyObject *args)
666 {
667 int fd;
668
669 if (!PyArg_ParseTuple(args, ":GetFD"))
670 return NULL;
671
672 if ((fd = alGetFD(self->port)) < 0)
673 return NULL;
674
675 return PyInt_FromLong((long) fd);
676 }
677
678
679 PyDoc_STRVAR(alp_GetFilled__doc__,
680 "alGetFilled: return the number of filled sample frames in "
681 "an audio port.");
682
683 static PyObject *
684 alp_GetFilled(alpobject *self, PyObject *args)
685 {
686 int filled;
687
688 if (!PyArg_ParseTuple(args, ":GetFilled"))
689 return NULL;
690 if ((filled = alGetFilled(self->port)) < 0)
691 return NULL;
692 return PyInt_FromLong((long) filled);
693 }
694
695
696 PyDoc_STRVAR(alp_GetFillable__doc__,
697 "alGetFillable: report the number of unfilled sample frames "
698 "in an audio port.");
699
700 static PyObject *
701 alp_GetFillable(alpobject *self, PyObject *args)
702 {
703 int fillable;
704
705 if (!PyArg_ParseTuple(args, ":GetFillable"))
706 return NULL;
707 if ((fillable = alGetFillable(self->port)) < 0)
708 return NULL;
709 return PyInt_FromLong((long) fillable);
710 }
711
712
713 PyDoc_STRVAR(alp_ReadFrames__doc__,
714 "alReadFrames: read sample frames from an audio port.");
715
716 static PyObject *
717 alp_ReadFrames(alpobject *self, PyObject *args)
718 {
719 int framecount;
720 PyObject *v;
721 int size;
722 int ch;
723 ALconfig c;
724
725 if (!PyArg_ParseTuple(args, "i:ReadFrames", &framecount))
726 return NULL;
727 if (framecount < 0) {
728 PyErr_SetString(ErrorObject, "negative framecount");
729 return NULL;
730 }
731 c = alGetConfig(self->port);
732 switch (alGetSampFmt(c)) {
733 case AL_SAMPFMT_TWOSCOMP:
734 switch (alGetWidth(c)) {
735 case AL_SAMPLE_8:
736 size = 1;
737 break;
738 case AL_SAMPLE_16:
739 size = 2;
740 break;
741 case AL_SAMPLE_24:
742 size = 4;
743 break;
744 default:
745 PyErr_SetString(ErrorObject, "can't determine width");
746 alFreeConfig(c);
747 return NULL;
748 }
749 break;
750 case AL_SAMPFMT_FLOAT:
751 size = 4;
752 break;
753 case AL_SAMPFMT_DOUBLE:
754 size = 8;
755 break;
756 default:
757 PyErr_SetString(ErrorObject, "can't determine format");
758 alFreeConfig(c);
759 return NULL;
760 }
761 ch = alGetChannels(c);
762 alFreeConfig(c);
763 if (ch < 0) {
764 PyErr_SetString(ErrorObject, "can't determine # of channels");
765 return NULL;
766 }
767 size *= ch;
768 v = PyString_FromStringAndSize((char *) NULL, size * framecount);
769 if (v == NULL)
770 return NULL;
771
772 Py_BEGIN_ALLOW_THREADS
773 alReadFrames(self->port, (void *) PyString_AS_STRING(v), framecount);
774 Py_END_ALLOW_THREADS
775
776 return v;
777 }
778
779
780 PyDoc_STRVAR(alp_DiscardFrames__doc__,
781 "alDiscardFrames: discard audio from an audio port.");
782
783 static PyObject *
784 alp_DiscardFrames(alpobject *self, PyObject *args)
785 {
786 int framecount;
787
788 if (!PyArg_ParseTuple(args, "i:DiscardFrames", &framecount))
789 return NULL;
790
791 Py_BEGIN_ALLOW_THREADS
792 framecount = alDiscardFrames(self->port, framecount);
793 Py_END_ALLOW_THREADS
794
795 if (framecount < 0)
796 return NULL;
797
798 return PyInt_FromLong((long) framecount);
799 }
800
801
802 PyDoc_STRVAR(alp_ZeroFrames__doc__,
803 "alZeroFrames: write zero-valued sample frames to an audio port.");
804
805 static PyObject *
806 alp_ZeroFrames(alpobject *self, PyObject *args)
807 {
808 int framecount;
809
810 if (!PyArg_ParseTuple(args, "i:ZeroFrames", &framecount))
811 return NULL;
812
813 if (framecount < 0) {
814 PyErr_SetString(ErrorObject, "negative framecount");
815 return NULL;
816 }
817
818 Py_BEGIN_ALLOW_THREADS
819 alZeroFrames(self->port, framecount);
820 Py_END_ALLOW_THREADS
821
822 Py_INCREF(Py_None);
823 return Py_None;
824 }
825
826
827 PyDoc_STRVAR(alp_SetFillPoint__doc__,
828 "alSetFillPoint: set low- or high-water mark for an audio port.");
829
830 static PyObject *
831 alp_SetFillPoint(alpobject *self, PyObject *args)
832 {
833 int fillpoint;
834
835 if (!PyArg_ParseTuple(args, "i:SetFillPoint", &fillpoint))
836 return NULL;
837
838 if (alSetFillPoint(self->port, fillpoint) < 0)
839 return NULL;
840
841 Py_INCREF(Py_None);
842 return Py_None;
843 }
844
845
846 PyDoc_STRVAR(alp_GetFillPoint__doc__,
847 "alGetFillPoint: get low- or high-water mark for an audio port.");
848
849 static PyObject *
850 alp_GetFillPoint(alpobject *self, PyObject *args)
851 {
852 int fillpoint;
853
854 if (!PyArg_ParseTuple(args, ":GetFillPoint"))
855 return NULL;
856
857 if ((fillpoint = alGetFillPoint(self->port)) < 0)
858 return NULL;
859
860 return PyInt_FromLong((long) fillpoint);
861 }
862
863
864 PyDoc_STRVAR(alp_GetFrameNumber__doc__,
865 "alGetFrameNumber: get the absolute sample frame number "
866 "associated with a port.");
867
868 static PyObject *
869 alp_GetFrameNumber(alpobject *self, PyObject *args)
870 {
871 stamp_t fnum;
872
873 if (!PyArg_ParseTuple(args, ":GetFrameNumber"))
874 return NULL;
875
876 if (alGetFrameNumber(self->port, &fnum) < 0)
877 return NULL;
878
879 return PyLong_FromLongLong((long long) fnum);
880 }
881
882
883 PyDoc_STRVAR(alp_GetFrameTime__doc__,
884 "alGetFrameTime: get the time at which a sample frame came "
885 "in or will go out.");
886
887 static PyObject *
888 alp_GetFrameTime(alpobject *self, PyObject *args)
889 {
890 stamp_t fnum, time;
891 PyObject *ret, *v0, *v1;
892
893 if (!PyArg_ParseTuple(args, ":GetFrameTime"))
894 return NULL;
895 if (alGetFrameTime(self->port, &fnum, &time) < 0)
896 return NULL;
897 v0 = PyLong_FromLongLong((long long) fnum);
898 v1 = PyLong_FromLongLong((long long) time);
899 if (PyErr_Occurred()) {
900 Py_XDECREF(v0);
901 Py_XDECREF(v1);
902 return NULL;
903 }
904 ret = PyTuple_Pack(2, v0, v1);
905 Py_DECREF(v0);
906 Py_DECREF(v1);
907 return ret;
908 }
909
910
911 PyDoc_STRVAR(alp_WriteFrames__doc__,
912 "alWriteFrames: write sample frames to an audio port.");
913
914 static PyObject *
915 alp_WriteFrames(alpobject *self, PyObject *args)
916 {
917 char *samples;
918 int length;
919 int size, ch;
920 ALconfig c;
921
922 if (!PyArg_ParseTuple(args, "s#:WriteFrames", &samples, &length))
923 return NULL;
924 c = alGetConfig(self->port);
925 switch (alGetSampFmt(c)) {
926 case AL_SAMPFMT_TWOSCOMP:
927 switch (alGetWidth(c)) {
928 case AL_SAMPLE_8:
929 size = 1;
930 break;
931 case AL_SAMPLE_16:
932 size = 2;
933 break;
934 case AL_SAMPLE_24:
935 size = 4;
936 break;
937 default:
938 PyErr_SetString(ErrorObject, "can't determine width");
939 alFreeConfig(c);
940 return NULL;
941 }
942 break;
943 case AL_SAMPFMT_FLOAT:
944 size = 4;
945 break;
946 case AL_SAMPFMT_DOUBLE:
947 size = 8;
948 break;
949 default:
950 PyErr_SetString(ErrorObject, "can't determine format");
951 alFreeConfig(c);
952 return NULL;
953 }
954 ch = alGetChannels(c);
955 alFreeConfig(c);
956 if (ch < 0) {
957 PyErr_SetString(ErrorObject, "can't determine # of channels");
958 return NULL;
959 }
960 size *= ch;
961 if (length % size != 0) {
962 PyErr_SetString(ErrorObject,
963 "buffer length not whole number of frames");
964 return NULL;
965 }
966
967 Py_BEGIN_ALLOW_THREADS
968 alWriteFrames(self->port, (void *) samples, length / size);
969 Py_END_ALLOW_THREADS
970
971 Py_INCREF(Py_None);
972 return Py_None;
973 }
974
975
976 PyDoc_STRVAR(alp_ClosePort__doc__, "alClosePort: close an audio port.");
977
978 static PyObject *
979 alp_ClosePort(alpobject *self, PyObject *args)
980 {
981 if (!PyArg_ParseTuple(args, ":ClosePort"))
982 return NULL;
983 if (alClosePort(self->port) < 0)
984 return NULL;
985 self->port = NULL;
986 Py_INCREF(Py_None);
987 return Py_None;
988 }
989
990 #endif /* AL_NO_ELEM */
991
992 #ifdef OLD_INTERFACE
993 static PyObject *
994 alp_closeport(alpobject *self, PyObject *args)
995 {
996 if (!PyArg_ParseTuple(args, ":ClosePort"))
997 return NULL;
998 if (ALcloseport(self->port) < 0)
999 return NULL;
1000 self->port = NULL;
1001 Py_INCREF(Py_None);
1002 return Py_None;
1003 }
1004
1005 static PyObject *
1006 alp_getfd(alpobject *self, PyObject *args)
1007 {
1008 int fd;
1009
1010 if (!PyArg_ParseTuple(args, ":GetFD"))
1011 return NULL;
1012 if ((fd = ALgetfd(self-> port)) == -1)
1013 return NULL;
1014 return PyInt_FromLong(fd);
1015 }
1016
1017 static PyObject *
1018 alp_getfilled(alpobject *self, PyObject *args)
1019 {
1020 long count;
1021
1022 if (!PyArg_ParseTuple(args, ":GetFilled"))
1023 return NULL;
1024 if ((count = ALgetfilled(self-> port)) == -1)
1025 return NULL;
1026 return PyInt_FromLong(count);
1027 }
1028
1029 static PyObject *
1030 alp_getfillable(alpobject *self, PyObject *args)
1031 {
1032 long count;
1033
1034 if (!PyArg_ParseTuple(args, ":GetFillable"))
1035 return NULL;
1036 if ((count = ALgetfillable(self-> port)) == -1)
1037 return NULL;
1038 return PyInt_FromLong (count);
1039 }
1040
1041 static PyObject *
1042 alp_readsamps(alpobject *self, PyObject *args)
1043 {
1044 long count;
1045 PyObject *v;
1046 ALconfig c;
1047 int width;
1048 int ret;
1049
1050 if (!PyArg_ParseTuple(args, "l:readsamps", &count))
1051 return NULL;
1052
1053 if (count <= 0) {
1054 PyErr_SetString(ErrorObject, "al.readsamps : arg <= 0");
1055 return NULL;
1056 }
1057
1058 c = ALgetconfig(self->port);
1059 #ifdef AL_405
1060 width = ALgetsampfmt(c);
1061 if (width == AL_SAMPFMT_FLOAT)
1062 width = sizeof(float);
1063 else if (width == AL_SAMPFMT_DOUBLE)
1064 width = sizeof(double);
1065 else
1066 width = ALgetwidth(c);
1067 #else
1068 width = ALgetwidth(c);
1069 #endif /* AL_405 */
1070 ALfreeconfig(c);
1071 v = PyString_FromStringAndSize((char *)NULL, width * count);
1072 if (v == NULL)
1073 return NULL;
1074
1075 Py_BEGIN_ALLOW_THREADS
1076 ret = ALreadsamps(self->port, (void *) PyString_AsString(v), count);
1077 Py_END_ALLOW_THREADS
1078 if (ret == -1) {
1079 Py_DECREF(v);
1080 return NULL;
1081 }
1082
1083 return (v);
1084 }
1085
1086 static PyObject *
1087 alp_writesamps(alpobject *self, PyObject *args)
1088 {
1089 char *buf;
1090 int size, width;
1091 ALconfig c;
1092 int ret;
1093
1094 if (!PyArg_ParseTuple(args, "s#:writesamps", &buf, &size))
1095 return NULL;
1096
1097 c = ALgetconfig(self->port);
1098 #ifdef AL_405
1099 width = ALgetsampfmt(c);
1100 if (width == AL_SAMPFMT_FLOAT)
1101 width = sizeof(float);
1102 else if (width == AL_SAMPFMT_DOUBLE)
1103 width = sizeof(double);
1104 else
1105 width = ALgetwidth(c);
1106 #else
1107 width = ALgetwidth(c);
1108 #endif /* AL_405 */
1109 ALfreeconfig(c);
1110 Py_BEGIN_ALLOW_THREADS
1111 ret = ALwritesamps (self->port, (void *) buf, (long) size / width);
1112 Py_END_ALLOW_THREADS
1113 if (ret == -1)
1114 return NULL;
1115
1116 Py_INCREF(Py_None);
1117 return Py_None;
1118 }
1119
1120 static PyObject *
1121 alp_getfillpoint(alpobject *self, PyObject *args)
1122 {
1123 long count;
1124
1125 if (!PyArg_ParseTuple(args, ":GetFillPoint"))
1126 return NULL;
1127 if ((count = ALgetfillpoint(self->port)) == -1)
1128 return NULL;
1129 return PyInt_FromLong(count);
1130 }
1131
1132 static PyObject *
1133 alp_setfillpoint(alpobject *self, PyObject *args)
1134 {
1135 long count;
1136
1137 if (!PyArg_ParseTuple(args, "l:SetFillPoint", &count))
1138 return NULL;
1139 if (ALsetfillpoint(self->port, count) == -1)
1140 return NULL;
1141 Py_INCREF(Py_None);
1142 return Py_None;
1143 }
1144
1145 static PyObject *
1146 alp_setconfig(alpobject *self, PyObject *args)
1147 {
1148 alcobject *config;
1149
1150 if (!PyArg_ParseTuple(args, "O!:SetConfig", &Alctype, &config))
1151 return NULL;
1152 if (ALsetconfig(self->port, config->config) == -1)
1153 return NULL;
1154 Py_INCREF(Py_None);
1155 return Py_None;
1156 }
1157
1158 static PyObject *
1159 alp_getconfig(alpobject *self, PyObject *args)
1160 {
1161 ALconfig config;
1162
1163 if (!PyArg_ParseTuple(args, ":GetConfig"))
1164 return NULL;
1165 config = ALgetconfig(self->port);
1166 if (config == NULL)
1167 return NULL;
1168 return newalcobject(config);
1169 }
1170
1171 #ifdef AL_405
1172 static PyObject *
1173 alp_getstatus(alpobject *self, PyObject *args)
1174 {
1175 PyObject *list, *v;
1176 long *PVbuffer;
1177 long length;
1178 int i;
1179
1180 if (!PyArg_ParseTuple(args, "O!", &PyList_Type, &list))
1181 return NULL;
1182 length = PyList_Size(list);
1183 PVbuffer = PyMem_NEW(long, length);
1184 if (PVbuffer == NULL)
1185 return PyErr_NoMemory();
1186 for (i = 0; i < length; i++) {
1187 v = PyList_GetItem(list, i);
1188 if (!PyInt_Check(v)) {
1189 PyMem_DEL(PVbuffer);
1190 PyErr_BadArgument();
1191 return NULL;
1192 }
1193 PVbuffer[i] = PyInt_AsLong(v);
1194 }
1195
1196 if (ALgetstatus(self->port, PVbuffer, length) == -1)
1197 return NULL;
1198
1199 for (i = 0; i < length; i++)
1200 PyList_SetItem(list, i, PyInt_FromLong(PVbuffer[i]));
1201
1202 PyMem_DEL(PVbuffer);
1203
1204 Py_INCREF(Py_None);
1205 return Py_None;
1206 }
1207 #endif /* AL_405 */
1208
1209 #endif /* OLD_INTERFACE */
1210
1211 static struct PyMethodDef alp_methods[] = {
1212 #ifdef AL_NO_ELEM /* IRIX 6 */
1213 {"SetConfig", (PyCFunction)alp_SetConfig, METH_VARARGS, alp_SetConfig__doc__},
1214 {"GetConfig", (PyCFunction)alp_GetConfig, METH_VARARGS, alp_GetConfig__doc__},
1215 {"GetResource", (PyCFunction)alp_GetResource, METH_VARARGS, alp_GetResource__doc__},
1216 {"GetFD", (PyCFunction)alp_GetFD, METH_VARARGS, alp_GetFD__doc__},
1217 {"GetFilled", (PyCFunction)alp_GetFilled, METH_VARARGS, alp_GetFilled__doc__},
1218 {"GetFillable", (PyCFunction)alp_GetFillable, METH_VARARGS, alp_GetFillable__doc__},
1219 {"ReadFrames", (PyCFunction)alp_ReadFrames, METH_VARARGS, alp_ReadFrames__doc__},
1220 {"DiscardFrames", (PyCFunction)alp_DiscardFrames, METH_VARARGS, alp_DiscardFrames__doc__},
1221 {"ZeroFrames", (PyCFunction)alp_ZeroFrames, METH_VARARGS, alp_ZeroFrames__doc__},
1222 {"SetFillPoint", (PyCFunction)alp_SetFillPoint, METH_VARARGS, alp_SetFillPoint__doc__},
1223 {"GetFillPoint", (PyCFunction)alp_GetFillPoint, METH_VARARGS, alp_GetFillPoint__doc__},
1224 {"GetFrameNumber", (PyCFunction)alp_GetFrameNumber, METH_VARARGS, alp_GetFrameNumber__doc__},
1225 {"GetFrameTime", (PyCFunction)alp_GetFrameTime, METH_VARARGS, alp_GetFrameTime__doc__},
1226 {"WriteFrames", (PyCFunction)alp_WriteFrames, METH_VARARGS, alp_WriteFrames__doc__},
1227 {"ClosePort", (PyCFunction)alp_ClosePort, METH_VARARGS, alp_ClosePort__doc__},
1228 #endif /* AL_NO_ELEM */
1229 #ifdef OLD_INTERFACE
1230 {"closeport", (PyCFunction)alp_closeport, METH_VARARGS},
1231 {"getfd", (PyCFunction)alp_getfd, METH_VARARGS},
1232 {"fileno", (PyCFunction)alp_getfd, METH_VARARGS},
1233 {"getfilled", (PyCFunction)alp_getfilled, METH_VARARGS},
1234 {"getfillable", (PyCFunction)alp_getfillable, METH_VARARGS},
1235 {"readsamps", (PyCFunction)alp_readsamps, METH_VARARGS},
1236 {"writesamps", (PyCFunction)alp_writesamps, METH_VARARGS},
1237 {"setfillpoint", (PyCFunction)alp_setfillpoint, METH_VARARGS},
1238 {"getfillpoint", (PyCFunction)alp_getfillpoint, METH_VARARGS},
1239 {"setconfig", (PyCFunction)alp_setconfig, METH_VARARGS},
1240 {"getconfig", (PyCFunction)alp_getconfig, METH_VARARGS},
1241 #ifdef AL_405
1242 {"getstatus", (PyCFunction)alp_getstatus, METH_VARARGS},
1243 #endif /* AL_405 */
1244 #endif /* OLD_INTERFACE */
1245
1246 {NULL, NULL} /* sentinel */
1247 };
1248
1249 /* ---------- */
1250
1251
1252 static PyObject *
1253 newalpobject(ALport port)
1254 {
1255 alpobject *self;
1256
1257 self = PyObject_New(alpobject, &Alptype);
1258 if (self == NULL)
1259 return NULL;
1260 /* XXXX Add your own initializers here */
1261 self->port = port;
1262 return (PyObject *) self;
1263 }
1264
1265
1266 static void
1267 alp_dealloc(alpobject *self)
1268 {
1269 /* XXXX Add your own cleanup code here */
1270 if (self->port) {
1271 #ifdef AL_NO_ELEM /* IRIX 6 */
1272 alClosePort(self->port);
1273 #else
1274 ALcloseport(self->port);
1275 #endif
1276 }
1277 PyObject_Del(self);
1278 }
1279
1280 static PyObject *
1281 alp_getattr(alpobject *self, char *name)
1282 {
1283 /* XXXX Add your own getattr code here */
1284 if (self->port == NULL) {
1285 PyErr_SetString(ErrorObject, "port already closed");
1286 return NULL;
1287 }
1288 return Py_FindMethod(alp_methods, (PyObject *)self, name);
1289 }
1290
1291 PyDoc_STRVAR(Alptype__doc__, "");
1292
1293 static PyTypeObject Alptype = {
1294 PyObject_HEAD_INIT(&PyType_Type)
1295 0, /*ob_size*/
1296 "al.port", /*tp_name*/
1297 sizeof(alpobject), /*tp_basicsize*/
1298 0, /*tp_itemsize*/
1299 /* methods */
1300 (destructor)alp_dealloc, /*tp_dealloc*/
1301 (printfunc)0, /*tp_print*/
1302 (getattrfunc)alp_getattr, /*tp_getattr*/
1303 (setattrfunc)0, /*tp_setattr*/
1304 (cmpfunc)0, /*tp_compare*/
1305 (reprfunc)0, /*tp_repr*/
1306 0, /*tp_as_number*/
1307 0, /*tp_as_sequence*/
1308 0, /*tp_as_mapping*/
1309 (hashfunc)0, /*tp_hash*/
1310 (ternaryfunc)0, /*tp_call*/
1311 (reprfunc)0, /*tp_str*/
1312
1313 /* Space for future expansion */
1314 0L,0L,0L,0L,
1315 Alptype__doc__ /* Documentation string */
1316 };
1317
1318 /* End of code for port objects */
1319 /* -------------------------------------------------------- */
1320
1321
1322 #ifdef AL_NO_ELEM /* IRIX 6 */
1323
1324 PyDoc_STRVAR(al_NewConfig__doc__,
1325 "alNewConfig: create and initialize an audio ALconfig structure.");
1326
1327 static PyObject *
1328 al_NewConfig(PyObject *self, PyObject *args)
1329 {
1330 ALconfig config;
1331
1332 if (!PyArg_ParseTuple(args, ":NewConfig"))
1333 return NULL;
1334 if ((config = alNewConfig()) == NULL)
1335 return NULL;
1336 return newalcobject(config);
1337 }
1338
1339 PyDoc_STRVAR(al_OpenPort__doc__,
1340 "alOpenPort: open an audio port.");
1341
1342 static PyObject *
1343 al_OpenPort(PyObject *self, PyObject *args)
1344 {
1345 ALport port;
1346 char *name, *dir;
1347 alcobject *config = NULL;
1348
1349 if (!PyArg_ParseTuple(args, "ss|O!:OpenPort", &name, &dir, &Alctype, &config))
1350 return NULL;
1351 if ((port = alOpenPort(name, dir, config ? config->config : NULL)) == NULL)
1352 return NULL;
1353 return newalpobject(port);
1354 }
1355
1356 PyDoc_STRVAR(al_Connect__doc__,
1357 "alConnect: connect two audio I/O resources.");
1358
1359 static PyObject *
1360 al_Connect(PyObject *self, PyObject *args)
1361 {
1362 int source, dest, nprops = 0, id, i;
1363 ALpv *props = NULL;
1364 ALparamInfo *propinfo = NULL;
1365 PyObject *propobj = NULL;
1366
1367 if (!PyArg_ParseTuple(args, "ii|O!:Connect", &source, &dest, &PyList_Type, &propobj))
1368 return NULL;
1369 if (propobj != NULL) {
1370 nprops = python2params(source, dest, propobj, &props, &propinfo);
1371 if (nprops < 0)
1372 return NULL;
1373 }
1374
1375 id = alConnect(source, dest, props, nprops);
1376
1377 if (props) {
1378 for (i = 0; i < nprops; i++) {
1379 switch (propinfo[i].valueType) {
1380 case AL_SET_VAL:
1381 case AL_VECTOR_VAL:
1382 PyMem_DEL(props[i].value.ptr);
1383 break;
1384 }
1385 }
1386 PyMem_DEL(props);
1387 PyMem_DEL(propinfo);
1388 }
1389
1390 if (id < 0)
1391 return NULL;
1392 return PyInt_FromLong((long) id);
1393 }
1394
1395 PyDoc_STRVAR(al_Disconnect__doc__,
1396 "alDisconnect: delete a connection between two audio I/O resources.");
1397
1398 static PyObject *
1399 al_Disconnect(PyObject *self, PyObject *args)
1400 {
1401 int res;
1402
1403 if (!PyArg_ParseTuple(args, "i:Disconnect", &res))
1404 return NULL;
1405 if (alDisconnect(res) < 0)
1406 return NULL;
1407 Py_INCREF(Py_None);
1408 return Py_None;
1409 }
1410
1411 PyDoc_STRVAR(al_GetParams__doc__,
1412 "alGetParams: get the values of audio resource parameters.");
1413
1414 static PyObject *
1415 al_GetParams(PyObject *self, PyObject *args)
1416 {
1417 int resource;
1418 PyObject *pvslist, *item = NULL, *v = NULL;
1419 ALpv *pvs;
1420 int i, j, npvs;
1421 ALparamInfo *pinfo;
1422
1423 if (!PyArg_ParseTuple(args, "iO!:GetParams", &resource, &PyList_Type, &pvslist))
1424 return NULL;
1425 npvs = PyList_Size(pvslist);
1426 pvs = PyMem_NEW(ALpv, npvs);
1427 pinfo = PyMem_NEW(ALparamInfo, npvs);
1428 for (i = 0; i < npvs; i++) {
1429 item = PyList_GetItem(pvslist, i);
1430 if (!PyInt_Check(item)) {
1431 item = NULL;
1432 PyErr_SetString(ErrorObject, "list of integers expected");
1433 goto error;
1434 }
1435 pvs[i].param = (int) PyInt_AsLong(item);
1436 item = NULL; /* not needed anymore */
1437 if (alGetParamInfo(resource, pvs[i].param, &pinfo[i]) < 0)
1438 goto error;
1439 switch (pinfo[i].valueType) {
1440 case AL_NO_VAL:
1441 break;
1442 case AL_MATRIX_VAL:
1443 pinfo[i].maxElems *= pinfo[i].maxElems2;
1444 /* fall through */
1445 case AL_STRING_VAL:
1446 case AL_SET_VAL:
1447 case AL_VECTOR_VAL:
1448 switch (pinfo[i].elementType) {
1449 case AL_INT32_ELEM:
1450 case AL_RESOURCE_ELEM:
1451 case AL_ENUM_ELEM:
1452 pvs[i].value.ptr = PyMem_NEW(int, pinfo[i].maxElems);
1453 pvs[i].sizeIn = pinfo[i].maxElems;
1454 break;
1455 case AL_INT64_ELEM:
1456 case AL_FIXED_ELEM:
1457 pvs[i].value.ptr = PyMem_NEW(long long, pinfo[i].maxElems);
1458 pvs[i].sizeIn = pinfo[i].maxElems;
1459 break;
1460 case AL_CHAR_ELEM:
1461 pvs[i].value.ptr = PyMem_NEW(char, 32);
1462 pvs[i].sizeIn = 32;
1463 break;
1464 case AL_NO_ELEM:
1465 case AL_PTR_ELEM:
1466 default:
1467 PyErr_SetString(ErrorObject, "internal error");
1468 goto error;
1469 }
1470 break;
1471 case AL_SCALAR_VAL:
1472 break;
1473 default:
1474 PyErr_SetString(ErrorObject, "internal error");
1475 goto error;
1476 }
1477 if (pinfo[i].valueType == AL_MATRIX_VAL) {
1478 pinfo[i].maxElems /= pinfo[i].maxElems2;
1479 pvs[i].sizeIn /= pinfo[i].maxElems2;
1480 pvs[i].size2In = pinfo[i].maxElems2;
1481 }
1482 }
1483 if (alGetParams(resource, pvs, npvs) < 0)
1484 goto error;
1485 if (!(v = PyList_New(npvs)))
1486 goto error;
1487 for (i = 0; i < npvs; i++) {
1488 if (pvs[i].sizeOut < 0) {
1489 char buf[32];
1490 PyOS_snprintf(buf, sizeof(buf),
1491 "problem with param %d", i);
1492 PyErr_SetString(ErrorObject, buf);
1493 goto error;
1494 }
1495 switch (pinfo[i].valueType) {
1496 case AL_NO_VAL:
1497 item = Py_None;
1498 Py_INCREF(item);
1499 break;
1500 case AL_STRING_VAL:
1501 item = PyString_FromString(pvs[i].value.ptr);
1502 PyMem_DEL(pvs[i].value.ptr);
1503 break;
1504 case AL_MATRIX_VAL:
1505 /* XXXX this is not right */
1506 pvs[i].sizeOut *= pvs[i].size2Out;
1507 /* fall through */
1508 case AL_SET_VAL:
1509 case AL_VECTOR_VAL:
1510 item = PyList_New(pvs[i].sizeOut);
1511 for (j = 0; j < pvs[i].sizeOut; j++) {
1512 switch (pinfo[i].elementType) {
1513 case AL_INT32_ELEM:
1514 case AL_RESOURCE_ELEM:
1515 case AL_ENUM_ELEM:
1516 PyList_SetItem(item, j, PyInt_FromLong((long) ((int *) pvs[i].value.ptr)[j]));
1517 break;
1518 case AL_INT64_ELEM:
1519 PyList_SetItem(item, j, PyLong_FromLongLong(((long long *) pvs[i].value.ptr)[j]));
1520 break;
1521 case AL_FIXED_ELEM:
1522 PyList_SetItem(item, j, PyFloat_FromDouble(alFixedToDouble(((long long *) pvs[i].value.ptr)[j])));
1523 break;
1524 default:
1525 PyErr_SetString(ErrorObject, "internal error");
1526 goto error;
1527 }
1528 }
1529 PyMem_DEL(pvs[i].value.ptr);
1530 break;
1531 case AL_SCALAR_VAL:
1532 item = param2python(resource, pvs[i].param, pvs[i].value, &pinfo[i]);
1533 break;
1534 }
1535 if (PyErr_Occurred() ||
1536 PyList_SetItem(v, i, Py_BuildValue("(iO)", pvs[i].param,
1537 item)) < 0 ||
1538 PyErr_Occurred())
1539 goto error;
1540 Py_DECREF(item);
1541 }
1542 PyMem_DEL(pvs);
1543 PyMem_DEL(pinfo);
1544 return v;
1545
1546 error:
1547 Py_XDECREF(v);
1548 Py_XDECREF(item);
1549 if (pvs)
1550 PyMem_DEL(pvs);
1551 if (pinfo)
1552 PyMem_DEL(pinfo);
1553 return NULL;
1554 }
1555
1556 PyDoc_STRVAR(al_SetParams__doc__,
1557 "alSetParams: set the values of audio resource parameters.");
1558
1559 static PyObject *
1560 al_SetParams(PyObject *self, PyObject *args)
1561 {
1562 int resource;
1563 PyObject *pvslist;
1564 ALpv *pvs;
1565 ALparamInfo *pinfo;
1566 int npvs, i;
1567
1568 if (!PyArg_ParseTuple(args, "iO!:SetParams", &resource, &PyList_Type, &pvslist))
1569 return NULL;
1570 npvs = python2params(resource, -1, pvslist, &pvs, &pinfo);
1571 if (npvs < 0)
1572 return NULL;
1573
1574 if (alSetParams(resource, pvs, npvs) < 0)
1575 goto error;
1576
1577 /* cleanup */
1578 for (i = 0; i < npvs; i++) {
1579 switch (pinfo[i].valueType) {
1580 case AL_SET_VAL:
1581 case AL_VECTOR_VAL:
1582 PyMem_DEL(pvs[i].value.ptr);
1583 break;
1584 }
1585 }
1586 PyMem_DEL(pvs);
1587 PyMem_DEL(pinfo);
1588
1589 Py_INCREF(Py_None);
1590 return Py_None;
1591
1592 error:
1593 /* XXXX we should clean up everything */
1594 if (pvs)
1595 PyMem_DEL(pvs);
1596 if (pinfo)
1597 PyMem_DEL(pinfo);
1598 return NULL;
1599 }
1600
1601 PyDoc_STRVAR(al_QueryValues__doc__,
1602 "alQueryValues: get the set of possible values for a parameter.");
1603
1604 static PyObject *
1605 al_QueryValues(PyObject *self, PyObject *args)
1606 {
1607 int resource, param;
1608 ALvalue *return_set = NULL;
1609 int setsize = 32, qualsize = 0, nvals, i;
1610 ALpv *quals = NULL;
1611 ALparamInfo pinfo;
1612 ALparamInfo *qualinfo = NULL;
1613 PyObject *qualobj = NULL;
1614 PyObject *res = NULL, *item;
1615
1616 if (!PyArg_ParseTuple(args, "ii|O!:QueryValues", &resource, &param,
1617 &PyList_Type, &qualobj))
1618 return NULL;
1619 if (qualobj != NULL) {
1620 qualsize = python2params(resource, param, qualobj, &quals, &qualinfo);
1621 if (qualsize < 0)
1622 return NULL;
1623 }
1624 setsize = 32;
1625 return_set = PyMem_NEW(ALvalue, setsize);
1626 if (return_set == NULL) {
1627 PyErr_NoMemory();
1628 goto cleanup;
1629 }
1630
1631 retry:
1632 nvals = alQueryValues(resource, param, return_set, setsize, quals, qualsize);
1633 if (nvals < 0)
1634 goto cleanup;
1635 if (nvals > setsize) {
1636 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
1682 PyDoc_STRVAR(al_GetParamInfo__doc__,
1683 "alGetParamInfo: get information about a parameter on "
1684 "a particular audio resource.");
1685
1686 static PyObject *
1687 al_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
1766 PyDoc_STRVAR(al_GetResourceByName__doc__,
1767 "alGetResourceByName: find an audio resource by name.");
1768
1769 static PyObject *
1770 al_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
1782 PyDoc_STRVAR(al_IsSubtype__doc__,
1783 "alIsSubtype: indicate if one resource type is a subtype of another.");
1784
1785 static PyObject *
1786 al_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
1795 PyDoc_STRVAR(al_SetErrorHandler__doc__, "");
1796
1797 static PyObject *
1798 al_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
1811 static PyObject *
1812 al_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
1825 static PyObject *
1826 al_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
1837 static PyObject *
1838 al_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
1862 static PyObject *
1863 doParams(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
1903 static PyObject *
1904 al_getparams(PyObject *self, PyObject *args)
1905 {
1906 return doParams(args, ALgetparams, 1);
1907 }
1908
1909 static PyObject *
1910 al_setparams(PyObject *self, PyObject *args)
1911 {
1912 return doParams(args, ALsetparams, 0);
1913 }
1914
1915 static PyObject *
1916 al_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
1928 static PyObject *
1929 al_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
1940 static PyObject *
1941 al_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
1958 static 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
1992 PyDoc_STRVAR(al_module_documentation, "");
1993
1994 void
1995 inital(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 }
python git mirror