Modules/almodule.c

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