mirror of
https://github.com/python/cpython.git
synced 2024-11-24 10:24:35 +08:00
3487 lines
83 KiB
C
3487 lines
83 KiB
C
/***********************************************************
|
|
Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
|
|
The Netherlands.
|
|
|
|
All Rights Reserved
|
|
|
|
Permission to use, copy, modify, and distribute this software and its
|
|
documentation for any purpose and without fee is hereby granted,
|
|
provided that the above copyright notice appear in all copies and that
|
|
both that copyright notice and this permission notice appear in
|
|
supporting documentation, and that the names of Stichting Mathematisch
|
|
Centrum or CWI or Corporation for National Research Initiatives or
|
|
CNRI not be used in advertising or publicity pertaining to
|
|
distribution of the software without specific, written prior
|
|
permission.
|
|
|
|
While CWI is the initial source for this software, a modified version
|
|
is made available by the Corporation for National Research Initiatives
|
|
(CNRI) at the Internet address ftp://ftp.python.org.
|
|
|
|
STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
|
|
REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
|
|
MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
|
|
CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
|
|
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
|
|
PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
|
TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
|
PERFORMANCE OF THIS SOFTWARE.
|
|
|
|
******************************************************************/
|
|
|
|
#define OLD_INTERFACE /* define for pre-Irix 6 interface */
|
|
|
|
#include "Python.h"
|
|
#include "stringobject.h"
|
|
#include <audio.h>
|
|
#include <stdarg.h>
|
|
|
|
#ifndef AL_NO_ELEM
|
|
#ifndef OLD_INTERFACE
|
|
#define OLD_INTERFACE
|
|
#endif /* OLD_INTERFACE */
|
|
#endif /* AL_NO_ELEM */
|
|
|
|
static PyObject *ErrorObject;
|
|
|
|
/* ----------------------------------------------------- */
|
|
|
|
/* Declarations for objects of type port */
|
|
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
/* XXXX Add your own stuff here */
|
|
ALport port;
|
|
} alpobject;
|
|
|
|
staticforward PyTypeObject Alptype;
|
|
|
|
|
|
|
|
/* ---------------------------------------------------------------- */
|
|
|
|
/* Declarations for objects of type config */
|
|
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
/* XXXX Add your own stuff here */
|
|
ALconfig config;
|
|
} alcobject;
|
|
|
|
staticforward PyTypeObject Alctype;
|
|
|
|
|
|
static void
|
|
ErrorHandler(long code, const char *fmt, ...)
|
|
{
|
|
va_list args;
|
|
char buf[128];
|
|
|
|
va_start(args, fmt);
|
|
vsprintf(buf, fmt, args);
|
|
va_end(args);
|
|
PyErr_SetString(ErrorObject, buf);
|
|
}
|
|
|
|
#ifdef AL_NO_ELEM /* IRIX 6 */
|
|
|
|
static PyObject *
|
|
PyLong_FromLongLong(long long v)
|
|
{
|
|
/* XXXX Somewhat complicated way to convert a long long to a PyLong */
|
|
PyObject *l = NULL, *lhi, *llo;
|
|
int is_negative = 0;
|
|
static PyObject *i32; /* 32 as a python long */
|
|
|
|
if (v < 0) {
|
|
is_negative = 1;
|
|
v = -v;
|
|
}
|
|
lhi = PyLong_FromUnsignedLong((unsigned long) ((unsigned long long) v >> 32));
|
|
llo = PyLong_FromUnsignedLong((unsigned long) (v & 0xFFFFFFFFLL));
|
|
if (i32 == NULL)
|
|
i32 = PyLong_FromLong(32L); /* don't decref */
|
|
if (PyErr_Occurred())
|
|
goto error;
|
|
if ((l = PyNumber_Lshift(lhi, i32)) == NULL)
|
|
goto error;
|
|
Py_DECREF(lhi);
|
|
lhi = l;
|
|
if ((l = PyNumber_Or(lhi, llo)) == NULL)
|
|
goto error;
|
|
Py_DECREF(lhi);
|
|
Py_DECREF(llo);
|
|
if (is_negative) {
|
|
if ((lhi = PyNumber_Negative(l)) == NULL)
|
|
goto error;
|
|
Py_DECREF(l);
|
|
l = lhi;
|
|
}
|
|
return l;
|
|
|
|
error:
|
|
Py_XDECREF(lhi);
|
|
Py_XDECREF(llo);
|
|
Py_XDECREF(l);
|
|
return NULL;
|
|
}
|
|
|
|
static long long
|
|
PyLong_AsLongLong(PyObject *v)
|
|
{
|
|
/* XXXX Somewhat complicated way to convert a PyLong to a long long */
|
|
static PyObject *i2_32; /* 2**32 as a python long */
|
|
PyObject *lhi, *llo;
|
|
long long ihi;
|
|
unsigned long long ilo;
|
|
|
|
if (!PyLong_Check(v)) {
|
|
PyErr_BadInternalCall();
|
|
return -1;
|
|
}
|
|
if (i2_32 == NULL)
|
|
i2_32 = PyLong_FromLongLong(0x100000000LL); /* don't decref */
|
|
if ((v = PyNumber_Divmod(v, i2_32)) == NULL)
|
|
return -1;
|
|
lhi = PyTuple_GetItem(v, 0);
|
|
llo = PyTuple_GetItem(v, 1);
|
|
ihi = PyLong_AsLong(lhi);
|
|
ilo = PyLong_AsUnsignedLong(llo);
|
|
Py_DECREF(v);
|
|
return ihi * 0x100000000LL + ilo;
|
|
}
|
|
|
|
static PyObject *
|
|
param2python(int resource, int param, ALvalue value, ALparamInfo *pinfo)
|
|
{
|
|
ALparamInfo info;
|
|
PyObject *v;
|
|
|
|
if (pinfo == NULL) {
|
|
pinfo = &info;
|
|
if (alGetParamInfo(resource, param, &info) < 0)
|
|
return NULL;
|
|
}
|
|
switch (pinfo->elementType) {
|
|
case AL_PTR_ELEM:
|
|
/* XXXX don't know how to handle this */
|
|
case AL_NO_ELEM:
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
case AL_INT32_ELEM:
|
|
case AL_RESOURCE_ELEM:
|
|
case AL_ENUM_ELEM:
|
|
return PyInt_FromLong((long) value.i);
|
|
case AL_INT64_ELEM:
|
|
return PyLong_FromLongLong(value.ll);
|
|
case AL_FIXED_ELEM:
|
|
return PyFloat_FromDouble(alFixedToDouble(value.ll));
|
|
case AL_CHAR_ELEM:
|
|
if (value.ptr == NULL) {
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
return PyString_FromString((char *) value.ptr);
|
|
default:
|
|
PyErr_SetString(ErrorObject, "unknown element type");
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
static int
|
|
python2elem(PyObject *item, void *ptr, int elementType)
|
|
{
|
|
switch (elementType) {
|
|
case AL_INT32_ELEM:
|
|
case AL_RESOURCE_ELEM:
|
|
case AL_ENUM_ELEM:
|
|
if (!PyInt_Check(item)) {
|
|
PyErr_BadArgument();
|
|
return -1;
|
|
}
|
|
*((int *) ptr) = PyInt_AsLong(item);
|
|
break;
|
|
case AL_INT64_ELEM:
|
|
if (PyInt_Check(item))
|
|
*((long long *) ptr) = PyInt_AsLong(item);
|
|
else if (PyLong_Check(item))
|
|
*((long long *) ptr) = PyLong_AsLongLong(item);
|
|
else {
|
|
PyErr_BadArgument();
|
|
return -1;
|
|
}
|
|
break;
|
|
case AL_FIXED_ELEM:
|
|
if (PyInt_Check(item))
|
|
*((long long *) ptr) = alDoubleToFixed((double) PyInt_AsLong(item));
|
|
else if (PyFloat_Check(item))
|
|
*((long long *) ptr) = alDoubleToFixed(PyFloat_AsDouble(item));
|
|
else {
|
|
PyErr_BadArgument();
|
|
return -1;
|
|
}
|
|
break;
|
|
default:
|
|
PyErr_SetString(ErrorObject, "unknown element type");
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
python2param(int resource, ALpv *param, PyObject *value, ALparamInfo *pinfo)
|
|
{
|
|
ALparamInfo info;
|
|
int i, stepsize;
|
|
PyObject *item;
|
|
|
|
if (pinfo == NULL) {
|
|
pinfo = &info;
|
|
if (alGetParamInfo(resource, param->param, &info) < 0)
|
|
return -1;
|
|
}
|
|
switch (pinfo->valueType) {
|
|
case AL_STRING_VAL:
|
|
if (pinfo->elementType != AL_CHAR_ELEM) {
|
|
PyErr_SetString(ErrorObject, "unknown element type");
|
|
return -1;
|
|
}
|
|
if (!PyString_Check(value)) {
|
|
PyErr_BadArgument();
|
|
return -1;
|
|
}
|
|
param->value.ptr = PyString_AS_STRING(value);
|
|
param->sizeIn = PyString_GET_SIZE(value)+1; /*account for NUL*/
|
|
break;
|
|
case AL_SET_VAL:
|
|
case AL_VECTOR_VAL:
|
|
if (!PyList_Check(value) && !PyTuple_Check(value)) {
|
|
PyErr_BadArgument();
|
|
return -1;
|
|
}
|
|
switch (pinfo->elementType) {
|
|
case AL_INT32_ELEM:
|
|
case AL_RESOURCE_ELEM:
|
|
case AL_ENUM_ELEM:
|
|
param->sizeIn = PySequence_Length(value);
|
|
param->value.ptr = PyMem_NEW(int, param->sizeIn);
|
|
stepsize = sizeof(int);
|
|
break;
|
|
case AL_INT64_ELEM:
|
|
case AL_FIXED_ELEM:
|
|
param->sizeIn = PySequence_Length(value);
|
|
param->value.ptr = PyMem_NEW(long long, param->sizeIn);
|
|
stepsize = sizeof(long long);
|
|
break;
|
|
}
|
|
for (i = 0; i < param->sizeIn; i++) {
|
|
item = PySequence_GetItem(value, i);
|
|
if (python2elem(item, (void *) ((char *) param->value.ptr + i*stepsize), pinfo->elementType) < 0) {
|
|
PyMem_DEL(param->value.ptr);
|
|
return -1;
|
|
}
|
|
}
|
|
break;
|
|
case AL_SCALAR_VAL:
|
|
switch (pinfo->elementType) {
|
|
case AL_INT32_ELEM:
|
|
case AL_RESOURCE_ELEM:
|
|
case AL_ENUM_ELEM:
|
|
return python2elem(value, (void *) ¶m->value.i,
|
|
pinfo->elementType);
|
|
break;
|
|
case AL_INT64_ELEM:
|
|
case AL_FIXED_ELEM:
|
|
return python2elem(value, (void *) ¶m->value.ll,
|
|
pinfo->elementType);
|
|
break;
|
|
default:
|
|
PyErr_SetString(ErrorObject, "unknown element type");
|
|
return -1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
python2params(int resource1, int resource2, PyObject *list, ALpv **pvsp, ALparamInfo **pinfop)
|
|
{
|
|
PyObject *item;
|
|
ALpv *pvs;
|
|
ALparamInfo *pinfo;
|
|
int npvs, i;
|
|
|
|
npvs = PyList_Size(list);
|
|
pvs = PyMem_NEW(ALpv, npvs);
|
|
pinfo = PyMem_NEW(ALparamInfo, npvs);
|
|
for (i = 0; i < npvs; i++) {
|
|
item = PyList_GetItem(list, i);
|
|
if (!PyArg_ParseTuple(item, "iO", &pvs[i].param, &item))
|
|
goto error;
|
|
if (alGetParamInfo(resource1, pvs[i].param, &pinfo[i]) < 0 &&
|
|
alGetParamInfo(resource2, pvs[i].param, &pinfo[i]) < 0)
|
|
goto error;
|
|
if (python2param(resource1, &pvs[i], item, &pinfo[i]) < 0)
|
|
goto error;
|
|
}
|
|
|
|
*pvsp = pvs;
|
|
*pinfop = pinfo;
|
|
return npvs;
|
|
|
|
error:
|
|
/* XXXX we should clean up everything */
|
|
if (pvs)
|
|
PyMem_DEL(pvs);
|
|
if (pinfo)
|
|
PyMem_DEL(pinfo);
|
|
return -1;
|
|
}
|
|
|
|
/* -------------------------------------------------------- */
|
|
|
|
|
|
static PyObject *
|
|
SetConfig(self, args, func)
|
|
alcobject *self;
|
|
PyObject *args;
|
|
int (*func)(ALconfig, int);
|
|
{
|
|
int par;
|
|
|
|
if (!PyArg_ParseTuple(args, "i", &par))
|
|
return NULL;
|
|
|
|
if ((*func)(self->config, par) == -1)
|
|
return NULL;
|
|
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static PyObject *
|
|
GetConfig(self, args, func)
|
|
alcobject *self;
|
|
PyObject *args;
|
|
int (*func)(ALconfig);
|
|
{
|
|
int par;
|
|
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
|
|
if ((par = (*func)(self->config)) == -1)
|
|
return NULL;
|
|
|
|
return PyInt_FromLong((long) par);
|
|
}
|
|
|
|
static char alc_SetWidth__doc__[] =
|
|
"alSetWidth: set the wordsize for integer audio data."
|
|
;
|
|
|
|
static PyObject *
|
|
alc_SetWidth(self, args)
|
|
alcobject *self;
|
|
PyObject *args;
|
|
{
|
|
return SetConfig(self, args, alSetWidth);
|
|
}
|
|
|
|
|
|
static char alc_GetWidth__doc__[] =
|
|
"alGetWidth: get the wordsize for integer audio data."
|
|
;
|
|
|
|
static PyObject *
|
|
alc_GetWidth(self, args)
|
|
alcobject *self;
|
|
PyObject *args;
|
|
{
|
|
return GetConfig(self, args, alGetWidth);
|
|
}
|
|
|
|
|
|
static char alc_SetSampFmt__doc__[] =
|
|
"alSetSampFmt: set the sample format setting in an audio ALconfig structure."
|
|
;
|
|
|
|
static PyObject *
|
|
alc_SetSampFmt(self, args)
|
|
alcobject *self;
|
|
PyObject *args;
|
|
{
|
|
return SetConfig(self, args, alSetSampFmt);
|
|
}
|
|
|
|
|
|
static char alc_GetSampFmt__doc__[] =
|
|
"alGetSampFmt: get the sample format setting in an audio ALconfig structure."
|
|
;
|
|
|
|
static PyObject *
|
|
alc_GetSampFmt(self, args)
|
|
alcobject *self;
|
|
PyObject *args;
|
|
{
|
|
return GetConfig(self, args, alGetSampFmt);
|
|
}
|
|
|
|
|
|
static char alc_SetChannels__doc__[] =
|
|
"alSetChannels: set the channel settings in an audio ALconfig."
|
|
;
|
|
|
|
static PyObject *
|
|
alc_SetChannels(self, args)
|
|
alcobject *self;
|
|
PyObject *args;
|
|
{
|
|
return SetConfig(self, args, alSetChannels);
|
|
}
|
|
|
|
|
|
static char alc_GetChannels__doc__[] =
|
|
"alGetChannels: get the channel settings in an audio ALconfig."
|
|
;
|
|
|
|
static PyObject *
|
|
alc_GetChannels(self, args)
|
|
alcobject *self;
|
|
PyObject *args;
|
|
{
|
|
return GetConfig(self, args, alGetChannels);
|
|
}
|
|
|
|
|
|
static char alc_SetFloatMax__doc__[] =
|
|
"alSetFloatMax: set the maximum value of floating point sample data."
|
|
;
|
|
|
|
static PyObject *
|
|
alc_SetFloatMax(self, args)
|
|
alcobject *self;
|
|
PyObject *args;
|
|
{
|
|
double maximum_value;
|
|
|
|
if (!PyArg_ParseTuple(args, "d", &maximum_value))
|
|
return NULL;
|
|
if (alSetFloatMax(self->config, maximum_value) < 0)
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
|
|
static char alc_GetFloatMax__doc__[] =
|
|
"alGetFloatMax: get the maximum value of floating point sample data."
|
|
;
|
|
|
|
static PyObject *
|
|
alc_GetFloatMax(self, args)
|
|
alcobject *self;
|
|
PyObject *args;
|
|
{
|
|
double maximum_value;
|
|
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
if ((maximum_value = alGetFloatMax(self->config)) == 0)
|
|
return NULL;
|
|
return PyFloat_FromDouble(maximum_value);
|
|
}
|
|
|
|
|
|
static char alc_SetDevice__doc__[] =
|
|
"alSetDevice: set the device setting in an audio ALconfig structure."
|
|
;
|
|
|
|
static PyObject *
|
|
alc_SetDevice(self, args)
|
|
alcobject *self;
|
|
PyObject *args;
|
|
{
|
|
return SetConfig(self, args, alSetDevice);
|
|
}
|
|
|
|
|
|
static char alc_GetDevice__doc__[] =
|
|
"alGetDevice: get the device setting in an audio ALconfig structure."
|
|
;
|
|
|
|
static PyObject *
|
|
alc_GetDevice(self, args)
|
|
alcobject *self;
|
|
PyObject *args;
|
|
{
|
|
return GetConfig(self, args, alGetDevice);
|
|
}
|
|
|
|
|
|
static char alc_SetQueueSize__doc__[] =
|
|
"alSetQueueSize: set audio port buffer size."
|
|
;
|
|
|
|
static PyObject *
|
|
alc_SetQueueSize(self, args)
|
|
alcobject *self;
|
|
PyObject *args;
|
|
{
|
|
return SetConfig(self, args, alSetQueueSize);
|
|
}
|
|
|
|
|
|
static char alc_GetQueueSize__doc__[] =
|
|
"alGetQueueSize: get audio port buffer size."
|
|
;
|
|
|
|
static PyObject *
|
|
alc_GetQueueSize(self, args)
|
|
alcobject *self;
|
|
PyObject *args;
|
|
{
|
|
return GetConfig(self, args, alGetQueueSize);
|
|
}
|
|
|
|
#endif /* AL_NO_ELEM */
|
|
|
|
static PyObject *
|
|
setconfig(self, args, func)
|
|
alcobject *self;
|
|
PyObject *args;
|
|
int (*func)(ALconfig, long);
|
|
{
|
|
long par;
|
|
|
|
if (!PyArg_ParseTuple(args, "l", &par))
|
|
return NULL;
|
|
|
|
if ((*func)(self->config, par) == -1)
|
|
return NULL;
|
|
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static PyObject *
|
|
getconfig(self, args, func)
|
|
alcobject *self;
|
|
PyObject *args;
|
|
long (*func)(ALconfig);
|
|
{
|
|
long par;
|
|
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
|
|
if ((par = (*func)(self->config)) == -1)
|
|
return NULL;
|
|
|
|
return PyInt_FromLong((long) par);
|
|
}
|
|
|
|
static PyObject *
|
|
alc_setqueuesize (self, args)
|
|
alcobject *self;
|
|
PyObject *args;
|
|
{
|
|
return setconfig(self, args, ALsetqueuesize);
|
|
}
|
|
|
|
static PyObject *
|
|
alc_getqueuesize (self, args)
|
|
alcobject *self;
|
|
PyObject *args;
|
|
{
|
|
return getconfig(self, args, ALgetqueuesize);
|
|
}
|
|
|
|
static PyObject *
|
|
alc_setwidth (self, args)
|
|
alcobject *self;
|
|
PyObject *args;
|
|
{
|
|
return setconfig(self, args, ALsetwidth);
|
|
}
|
|
|
|
static PyObject *
|
|
alc_getwidth (self, args)
|
|
alcobject *self;
|
|
PyObject *args;
|
|
{
|
|
return getconfig(self, args, ALgetwidth);
|
|
}
|
|
|
|
static PyObject *
|
|
alc_getchannels (self, args)
|
|
alcobject *self;
|
|
PyObject *args;
|
|
{
|
|
return getconfig(self, args, ALgetchannels);
|
|
}
|
|
|
|
static PyObject *
|
|
alc_setchannels (self, args)
|
|
alcobject *self;
|
|
PyObject *args;
|
|
{
|
|
return setconfig(self, args, ALsetchannels);
|
|
}
|
|
|
|
#ifdef AL_405
|
|
|
|
static PyObject *
|
|
alc_getsampfmt (self, args)
|
|
alcobject *self;
|
|
PyObject *args;
|
|
{
|
|
return getconfig(self, args, ALgetsampfmt);
|
|
}
|
|
|
|
static PyObject *
|
|
alc_setsampfmt (self, args)
|
|
alcobject *self;
|
|
PyObject *args;
|
|
{
|
|
return setconfig(self, args, ALsetsampfmt);
|
|
}
|
|
|
|
static PyObject *
|
|
alc_getfloatmax(self, args)
|
|
alcobject *self;
|
|
PyObject *args;
|
|
{
|
|
double arg;
|
|
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return 0;
|
|
if ((arg = ALgetfloatmax(self->config)) == 0)
|
|
return NULL;
|
|
return PyFloat_FromDouble(arg);
|
|
}
|
|
|
|
static PyObject *
|
|
alc_setfloatmax(self, args)
|
|
alcobject *self;
|
|
PyObject *args;
|
|
{
|
|
double arg;
|
|
|
|
if (!PyArg_ParseTuple(args, "d", &arg))
|
|
return 0;
|
|
if (ALsetfloatmax(self->config, arg) == -1)
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
#endif /* AL_405 */
|
|
|
|
static struct PyMethodDef alc_methods[] = {
|
|
#ifdef AL_NO_ELEM /* IRIX 6 */
|
|
{"SetWidth", (PyCFunction)alc_SetWidth, METH_VARARGS, alc_SetWidth__doc__},
|
|
{"GetWidth", (PyCFunction)alc_GetWidth, METH_VARARGS, alc_GetWidth__doc__},
|
|
{"SetSampFmt", (PyCFunction)alc_SetSampFmt, METH_VARARGS, alc_SetSampFmt__doc__},
|
|
{"GetSampFmt", (PyCFunction)alc_GetSampFmt, METH_VARARGS, alc_GetSampFmt__doc__},
|
|
{"SetChannels", (PyCFunction)alc_SetChannels, METH_VARARGS, alc_SetChannels__doc__},
|
|
{"GetChannels", (PyCFunction)alc_GetChannels, METH_VARARGS, alc_GetChannels__doc__},
|
|
{"SetFloatMax", (PyCFunction)alc_SetFloatMax, METH_VARARGS, alc_SetFloatMax__doc__},
|
|
{"GetFloatMax", (PyCFunction)alc_GetFloatMax, METH_VARARGS, alc_GetFloatMax__doc__},
|
|
{"SetDevice", (PyCFunction)alc_SetDevice, METH_VARARGS, alc_SetDevice__doc__},
|
|
{"GetDevice", (PyCFunction)alc_GetDevice, METH_VARARGS, alc_GetDevice__doc__},
|
|
{"SetQueueSize", (PyCFunction)alc_SetQueueSize, METH_VARARGS, alc_SetQueueSize__doc__},
|
|
{"GetQueueSize", (PyCFunction)alc_GetQueueSize, METH_VARARGS, alc_GetQueueSize__doc__},
|
|
#endif /* AL_NO_ELEM */
|
|
{"getqueuesize", (PyCFunction)alc_getqueuesize, METH_VARARGS},
|
|
{"setqueuesize", (PyCFunction)alc_setqueuesize, METH_VARARGS},
|
|
{"getwidth", (PyCFunction)alc_getwidth, METH_VARARGS},
|
|
{"setwidth", (PyCFunction)alc_setwidth, METH_VARARGS},
|
|
{"getchannels", (PyCFunction)alc_getchannels, METH_VARARGS},
|
|
{"setchannels", (PyCFunction)alc_setchannels, METH_VARARGS},
|
|
#ifdef AL_405
|
|
{"getsampfmt", (PyCFunction)alc_getsampfmt, METH_VARARGS},
|
|
{"setsampfmt", (PyCFunction)alc_setsampfmt, METH_VARARGS},
|
|
{"getfloatmax", (PyCFunction)alc_getfloatmax, METH_VARARGS},
|
|
{"setfloatmax", (PyCFunction)alc_setfloatmax, METH_VARARGS},
|
|
#endif /* AL_405 */
|
|
|
|
{NULL, NULL} /* sentinel */
|
|
};
|
|
|
|
/* ---------- */
|
|
|
|
|
|
static PyObject *
|
|
newalcobject(ALconfig config)
|
|
{
|
|
alcobject *self;
|
|
|
|
self = PyObject_NEW(alcobject, &Alctype);
|
|
if (self == NULL)
|
|
return NULL;
|
|
/* XXXX Add your own initializers here */
|
|
self->config = config;
|
|
return (PyObject *) self;
|
|
}
|
|
|
|
|
|
static void
|
|
alc_dealloc(self)
|
|
alcobject *self;
|
|
{
|
|
/* XXXX Add your own cleanup code here */
|
|
#ifdef AL_NO_ELEM /* IRIX 6 */
|
|
(void) alFreeConfig(self->config); /* ignore errors */
|
|
#else
|
|
(void) ALfreeconfig(self->config); /* ignore errors */
|
|
#endif
|
|
PyMem_DEL(self);
|
|
}
|
|
|
|
static PyObject *
|
|
alc_getattr(self, name)
|
|
alcobject *self;
|
|
char *name;
|
|
{
|
|
/* XXXX Add your own getattr code here */
|
|
return Py_FindMethod(alc_methods, (PyObject *)self, name);
|
|
}
|
|
|
|
static char Alctype__doc__[] =
|
|
""
|
|
;
|
|
|
|
static PyTypeObject Alctype = {
|
|
PyObject_HEAD_INIT(&PyType_Type)
|
|
0, /*ob_size*/
|
|
"config", /*tp_name*/
|
|
sizeof(alcobject), /*tp_basicsize*/
|
|
0, /*tp_itemsize*/
|
|
/* methods */
|
|
(destructor)alc_dealloc, /*tp_dealloc*/
|
|
(printfunc)0, /*tp_print*/
|
|
(getattrfunc)alc_getattr, /*tp_getattr*/
|
|
(setattrfunc)0, /*tp_setattr*/
|
|
(cmpfunc)0, /*tp_compare*/
|
|
(reprfunc)0, /*tp_repr*/
|
|
0, /*tp_as_number*/
|
|
0, /*tp_as_sequence*/
|
|
0, /*tp_as_mapping*/
|
|
(hashfunc)0, /*tp_hash*/
|
|
(ternaryfunc)0, /*tp_call*/
|
|
(reprfunc)0, /*tp_str*/
|
|
|
|
/* Space for future expansion */
|
|
0L,0L,0L,0L,
|
|
Alctype__doc__ /* Documentation string */
|
|
};
|
|
|
|
/* End of code for config objects */
|
|
/* ---------------------------------------------------------------- */
|
|
|
|
#ifdef AL_NO_ELEM /* IRIX 6 */
|
|
|
|
static char alp_SetConfig__doc__[] =
|
|
"alSetConfig: set the ALconfig of an audio ALport."
|
|
;
|
|
|
|
static PyObject *
|
|
alp_SetConfig(self, args)
|
|
alpobject *self;
|
|
PyObject *args;
|
|
{
|
|
alcobject *config;
|
|
if (!PyArg_ParseTuple(args, "O!", &Alctype, &config))
|
|
return NULL;
|
|
if (alSetConfig(self->port, config->config) < 0)
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
|
|
static char alp_GetConfig__doc__[] =
|
|
"alGetConfig: get the ALconfig of an audio ALport."
|
|
;
|
|
|
|
static PyObject *
|
|
alp_GetConfig(self, args)
|
|
alpobject *self;
|
|
PyObject *args;
|
|
{
|
|
ALconfig config;
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
if ((config = alGetConfig(self->port)) == NULL)
|
|
return NULL;
|
|
return newalcobject(config);
|
|
}
|
|
|
|
|
|
static char alp_GetResource__doc__[] =
|
|
"alGetResource: get the resource associated with an audio port."
|
|
;
|
|
|
|
static PyObject *
|
|
alp_GetResource(self, args)
|
|
alpobject *self;
|
|
PyObject *args;
|
|
{
|
|
int resource;
|
|
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
if ((resource = alGetResource(self->port)) == 0)
|
|
return NULL;
|
|
return PyInt_FromLong((long) resource);
|
|
}
|
|
|
|
|
|
static char alp_GetFD__doc__[] =
|
|
"alGetFD: get the file descriptor for an audio port."
|
|
;
|
|
|
|
static PyObject *
|
|
alp_GetFD(self, args)
|
|
alpobject *self;
|
|
PyObject *args;
|
|
{
|
|
int fd;
|
|
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
|
|
if ((fd = alGetFD(self->port)) < 0)
|
|
return NULL;
|
|
|
|
return PyInt_FromLong((long) fd);
|
|
}
|
|
|
|
|
|
static char alp_GetFilled__doc__[] =
|
|
"alGetFilled: return the number of filled sample frames in an audio port."
|
|
;
|
|
|
|
static PyObject *
|
|
alp_GetFilled(self, args)
|
|
alpobject *self;
|
|
PyObject *args;
|
|
{
|
|
int filled;
|
|
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
if ((filled = alGetFilled(self->port)) < 0)
|
|
return NULL;
|
|
return PyInt_FromLong((long) filled);
|
|
}
|
|
|
|
|
|
static char alp_GetFillable__doc__[] =
|
|
"alGetFillable: report the number of unfilled sample frames in an audio port."
|
|
;
|
|
|
|
static PyObject *
|
|
alp_GetFillable(self, args)
|
|
alpobject *self;
|
|
PyObject *args;
|
|
{
|
|
int fillable;
|
|
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
if ((fillable = alGetFillable(self->port)) < 0)
|
|
return NULL;
|
|
return PyInt_FromLong((long) fillable);
|
|
}
|
|
|
|
|
|
static char alp_ReadFrames__doc__[] =
|
|
"alReadFrames: read sample frames from an audio port."
|
|
;
|
|
|
|
static PyObject *
|
|
alp_ReadFrames(self, args)
|
|
alpobject *self;
|
|
PyObject *args;
|
|
{
|
|
void *samples;
|
|
int framecount;
|
|
PyObject *v;
|
|
int size;
|
|
int ch;
|
|
ALconfig c;
|
|
|
|
if (!PyArg_ParseTuple(args, "i", framecount))
|
|
return NULL;
|
|
if (framecount < 0) {
|
|
PyErr_SetString(ErrorObject, "negative framecount");
|
|
return NULL;
|
|
}
|
|
c = alGetConfig(self->port);
|
|
switch (alGetSampFmt(c)) {
|
|
case AL_SAMPFMT_TWOSCOMP:
|
|
switch (alGetWidth(c)) {
|
|
case AL_SAMPLE_8:
|
|
size = 1;
|
|
break;
|
|
case AL_SAMPLE_16:
|
|
size = 2;
|
|
break;
|
|
case AL_SAMPLE_24:
|
|
size = 4;
|
|
break;
|
|
default:
|
|
PyErr_SetString(ErrorObject, "can't determine width");
|
|
alFreeConfig(c);
|
|
return NULL;
|
|
}
|
|
break;
|
|
case AL_SAMPFMT_FLOAT:
|
|
size = 4;
|
|
break;
|
|
case AL_SAMPFMT_DOUBLE:
|
|
size = 8;
|
|
break;
|
|
default:
|
|
PyErr_SetString(ErrorObject, "can't determine format");
|
|
alFreeConfig(c);
|
|
return NULL;
|
|
}
|
|
ch = alGetChannels(c);
|
|
alFreeConfig(c);
|
|
if (ch < 0) {
|
|
PyErr_SetString(ErrorObject, "can't determine # of channels");
|
|
return NULL;
|
|
}
|
|
size *= ch;
|
|
v = PyString_FromStringAndSize((char *) NULL, size * framecount);
|
|
if (v == NULL)
|
|
return NULL;
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
alReadFrames(self->port, (void *) PyString_AS_STRING(v), framecount);
|
|
Py_END_ALLOW_THREADS
|
|
|
|
return v;
|
|
}
|
|
|
|
|
|
static char alp_DiscardFrames__doc__[] =
|
|
"alDiscardFrames: discard audio from an audio port."
|
|
;
|
|
|
|
static PyObject *
|
|
alp_DiscardFrames(self, args)
|
|
alpobject *self;
|
|
PyObject *args;
|
|
{
|
|
int framecount;
|
|
|
|
if (!PyArg_ParseTuple(args, "i", &framecount))
|
|
return NULL;
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
framecount = alDiscardFrames(self->port, framecount);
|
|
Py_END_ALLOW_THREADS
|
|
|
|
if (framecount < 0)
|
|
return NULL;
|
|
|
|
return PyInt_FromLong((long) framecount);
|
|
}
|
|
|
|
|
|
static char alp_ZeroFrames__doc__[] =
|
|
"alZeroFrames: write zero-valued sample frames to an audio port."
|
|
;
|
|
|
|
static PyObject *
|
|
alp_ZeroFrames(self, args)
|
|
alpobject *self;
|
|
PyObject *args;
|
|
{
|
|
int framecount;
|
|
|
|
if (!PyArg_ParseTuple(args, "i", &framecount))
|
|
return NULL;
|
|
|
|
if (framecount < 0) {
|
|
PyErr_SetString(ErrorObject, "negative framecount");
|
|
return NULL;
|
|
}
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
alZeroFrames(self->port, framecount);
|
|
Py_END_ALLOW_THREADS
|
|
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
|
|
static char alp_SetFillPoint__doc__[] =
|
|
"alSetFillPoint: set low- or high-water mark for an audio port."
|
|
;
|
|
|
|
static PyObject *
|
|
alp_SetFillPoint(self, args)
|
|
alpobject *self;
|
|
PyObject *args;
|
|
{
|
|
int fillpoint;
|
|
|
|
if (!PyArg_ParseTuple(args, "i", &fillpoint))
|
|
return NULL;
|
|
|
|
if (alSetFillPoint(self->port, fillpoint) < 0)
|
|
return NULL;
|
|
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
|
|
static char alp_GetFillPoint__doc__[] =
|
|
"alGetFillPoint: get low- or high-water mark for an audio port."
|
|
;
|
|
|
|
static PyObject *
|
|
alp_GetFillPoint(self, args)
|
|
alpobject *self;
|
|
PyObject *args;
|
|
{
|
|
int fillpoint;
|
|
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
|
|
if ((fillpoint = alGetFillPoint(self->port)) < 0)
|
|
return NULL;
|
|
|
|
return PyInt_FromLong((long) fillpoint);
|
|
}
|
|
|
|
|
|
static char alp_GetFrameNumber__doc__[] =
|
|
"alGetFrameNumber: get the absolute sample frame number associated with a port."
|
|
;
|
|
|
|
static PyObject *
|
|
alp_GetFrameNumber(self, args)
|
|
alpobject *self;
|
|
PyObject *args;
|
|
{
|
|
stamp_t fnum;
|
|
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
|
|
if (alGetFrameNumber(self->port, &fnum) < 0)
|
|
return NULL;
|
|
|
|
return PyLong_FromLongLong((long long) fnum);
|
|
}
|
|
|
|
|
|
static char alp_GetFrameTime__doc__[] =
|
|
"alGetFrameTime: get the time at which a sample frame came in or will go out."
|
|
;
|
|
|
|
static PyObject *
|
|
alp_GetFrameTime(self, args)
|
|
alpobject *self;
|
|
PyObject *args;
|
|
{
|
|
stamp_t fnum, time;
|
|
PyObject *ret, *v0, *v1;
|
|
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
if (alGetFrameTime(self->port, &fnum, &time) < 0)
|
|
return NULL;
|
|
v0 = PyLong_FromLongLong((long long) fnum);
|
|
v1 = PyLong_FromLongLong((long long) time);
|
|
if (PyErr_Occurred()) {
|
|
Py_XDECREF(v0);
|
|
Py_XDECREF(v1);
|
|
return NULL;
|
|
}
|
|
ret = Py_BuildValue("(OO)", v0, v1);
|
|
Py_DECREF(v0);
|
|
Py_DECREF(v1);
|
|
return ret;
|
|
}
|
|
|
|
|
|
static char alp_WriteFrames__doc__[] =
|
|
"alWriteFrames: write sample frames to an audio port."
|
|
;
|
|
|
|
static PyObject *
|
|
alp_WriteFrames(self, args)
|
|
alpobject *self;
|
|
PyObject *args;
|
|
{
|
|
char *samples;
|
|
int length;
|
|
int size, ch;
|
|
ALconfig c;
|
|
|
|
if (!PyArg_ParseTuple(args, "s#", &samples, &length))
|
|
return NULL;
|
|
c = alGetConfig(self->port);
|
|
switch (alGetSampFmt(c)) {
|
|
case AL_SAMPFMT_TWOSCOMP:
|
|
switch (alGetWidth(c)) {
|
|
case AL_SAMPLE_8:
|
|
size = 1;
|
|
break;
|
|
case AL_SAMPLE_16:
|
|
size = 2;
|
|
break;
|
|
case AL_SAMPLE_24:
|
|
size = 4;
|
|
break;
|
|
default:
|
|
PyErr_SetString(ErrorObject, "can't determine width");
|
|
alFreeConfig(c);
|
|
return NULL;
|
|
}
|
|
break;
|
|
case AL_SAMPFMT_FLOAT:
|
|
size = 4;
|
|
break;
|
|
case AL_SAMPFMT_DOUBLE:
|
|
size = 8;
|
|
break;
|
|
default:
|
|
PyErr_SetString(ErrorObject, "can't determine format");
|
|
alFreeConfig(c);
|
|
return NULL;
|
|
}
|
|
ch = alGetChannels(c);
|
|
alFreeConfig(c);
|
|
if (ch < 0) {
|
|
PyErr_SetString(ErrorObject, "can't determine # of channels");
|
|
return NULL;
|
|
}
|
|
size *= ch;
|
|
if (length % size != 0) {
|
|
PyErr_SetString(ErrorObject,
|
|
"buffer length not whole number of frames");
|
|
return NULL;
|
|
}
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
alWriteFrames(self->port, (void *) samples, length / size);
|
|
Py_END_ALLOW_THREADS
|
|
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
|
|
static char alp_ClosePort__doc__[] =
|
|
"alClosePort: close an audio port."
|
|
;
|
|
|
|
static PyObject *
|
|
alp_ClosePort(self, args)
|
|
alpobject *self;
|
|
PyObject *args;
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
if (alClosePort(self->port) < 0)
|
|
return NULL;
|
|
self->port = NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
#endif /* AL_NO_ELEM */
|
|
|
|
#ifdef OLD_INTERFACE
|
|
static PyObject *
|
|
alp_closeport(self, args)
|
|
alpobject *self;
|
|
PyObject *args;
|
|
{
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
if (ALcloseport(self->port) < 0)
|
|
return NULL;
|
|
self->port = NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static PyObject *
|
|
alp_getfd (self, args)
|
|
alpobject *self;
|
|
PyObject *args;
|
|
{
|
|
int fd;
|
|
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
if ((fd = ALgetfd(self-> port)) == -1)
|
|
return NULL;
|
|
return PyInt_FromLong(fd);
|
|
}
|
|
|
|
static PyObject *
|
|
alp_getfilled(self, args)
|
|
alpobject *self;
|
|
PyObject *args;
|
|
{
|
|
long count;
|
|
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
if ((count = ALgetfilled(self-> port)) == -1)
|
|
return NULL;
|
|
return PyInt_FromLong(count);
|
|
}
|
|
|
|
static PyObject *
|
|
alp_getfillable(self, args)
|
|
alpobject *self;
|
|
PyObject *args;
|
|
{
|
|
long count;
|
|
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
if ((count = ALgetfillable(self-> port)) == -1)
|
|
return NULL;
|
|
return PyInt_FromLong (count);
|
|
}
|
|
|
|
static PyObject *
|
|
alp_readsamps(self, args)
|
|
alpobject *self;
|
|
PyObject *args;
|
|
{
|
|
long count;
|
|
PyObject *v;
|
|
ALconfig c;
|
|
int width;
|
|
int ret;
|
|
|
|
if (!PyArg_ParseTuple(args, "l", &count))
|
|
return NULL;
|
|
|
|
if (count <= 0) {
|
|
PyErr_SetString(ErrorObject, "al.readsamps : arg <= 0");
|
|
return NULL;
|
|
}
|
|
|
|
c = ALgetconfig(self->port);
|
|
#ifdef AL_405
|
|
width = ALgetsampfmt(c);
|
|
if (width == AL_SAMPFMT_FLOAT)
|
|
width = sizeof(float);
|
|
else if (width == AL_SAMPFMT_DOUBLE)
|
|
width = sizeof(double);
|
|
else
|
|
width = ALgetwidth(c);
|
|
#else
|
|
width = ALgetwidth(c);
|
|
#endif /* AL_405 */
|
|
ALfreeconfig(c);
|
|
v = PyString_FromStringAndSize((char *)NULL, width * count);
|
|
if (v == NULL)
|
|
return NULL;
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
ret = ALreadsamps(self->port, (void *) PyString_AsString(v), count);
|
|
Py_END_ALLOW_THREADS
|
|
if (ret == -1) {
|
|
Py_DECREF(v);
|
|
return NULL;
|
|
}
|
|
|
|
return (v);
|
|
}
|
|
|
|
static PyObject *
|
|
alp_writesamps(self, args)
|
|
alpobject *self;
|
|
PyObject *args;
|
|
{
|
|
char *buf;
|
|
int size, width;
|
|
ALconfig c;
|
|
int ret;
|
|
|
|
if (!PyArg_ParseTuple(args, "s#", &buf, &size))
|
|
return NULL;
|
|
|
|
c = ALgetconfig(self->port);
|
|
#ifdef AL_405
|
|
width = ALgetsampfmt(c);
|
|
if (width == AL_SAMPFMT_FLOAT)
|
|
width = sizeof(float);
|
|
else if (width == AL_SAMPFMT_DOUBLE)
|
|
width = sizeof(double);
|
|
else
|
|
width = ALgetwidth(c);
|
|
#else
|
|
width = ALgetwidth(c);
|
|
#endif /* AL_405 */
|
|
ALfreeconfig(c);
|
|
Py_BEGIN_ALLOW_THREADS
|
|
ret = ALwritesamps (self->port, (void *) buf, (long) size / width);
|
|
Py_END_ALLOW_THREADS
|
|
if (ret == -1)
|
|
return NULL;
|
|
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static PyObject *
|
|
alp_getfillpoint(self, args)
|
|
alpobject *self;
|
|
PyObject *args;
|
|
{
|
|
long count;
|
|
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
if ((count = ALgetfillpoint(self->port)) == -1)
|
|
return NULL;
|
|
return PyInt_FromLong(count);
|
|
}
|
|
|
|
static PyObject *
|
|
alp_setfillpoint (self, args)
|
|
alpobject *self;
|
|
PyObject *args;
|
|
{
|
|
long count;
|
|
|
|
if (!PyArg_ParseTuple(args, "l", &count))
|
|
return NULL;
|
|
if (ALsetfillpoint(self->port, count) == -1)
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static PyObject *
|
|
alp_setconfig(self, args)
|
|
alpobject *self;
|
|
PyObject *args;
|
|
{
|
|
alcobject *config;
|
|
|
|
if (!PyArg_ParseTuple(args, "O!", &Alctype, &config))
|
|
return NULL;
|
|
if (ALsetconfig(self->port, config->config) == -1)
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static PyObject *
|
|
alp_getconfig(self, args)
|
|
alpobject *self;
|
|
PyObject *args;
|
|
{
|
|
ALconfig config;
|
|
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
config = ALgetconfig(self->port);
|
|
if (config == NULL)
|
|
return NULL;
|
|
return newalcobject(config);
|
|
}
|
|
|
|
#ifdef AL_405
|
|
static PyObject *
|
|
alp_getstatus(self, args)
|
|
alpobject *self;
|
|
PyObject *args;
|
|
{
|
|
PyObject *list, *v;
|
|
long *PVbuffer;
|
|
long length;
|
|
int i;
|
|
|
|
if (!PyArg_Parse(args, "O!", &PyList_Type, &list))
|
|
return NULL;
|
|
length = PyList_Size(list);
|
|
PVbuffer = PyMem_NEW(long, length);
|
|
if (PVbuffer == NULL)
|
|
return PyErr_NoMemory();
|
|
for (i = 0; i < length; i++) {
|
|
v = PyList_GetItem(list, i);
|
|
if (!PyInt_Check(v)) {
|
|
PyMem_DEL(PVbuffer);
|
|
PyErr_BadArgument();
|
|
return NULL;
|
|
}
|
|
PVbuffer[i] = PyInt_AsLong(v);
|
|
}
|
|
|
|
if (ALgetstatus(self->port, PVbuffer, length) == -1)
|
|
return NULL;
|
|
|
|
for (i = 0; i < length; i++)
|
|
PyList_SetItem(list, i, PyInt_FromLong(PVbuffer[i]));
|
|
|
|
PyMem_DEL(PVbuffer);
|
|
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
#endif /* AL_405 */
|
|
|
|
#endif /* OLD_INTERFACE */
|
|
|
|
static struct PyMethodDef alp_methods[] = {
|
|
#ifdef AL_NO_ELEM /* IRIX 6 */
|
|
{"SetConfig", (PyCFunction)alp_SetConfig, METH_VARARGS, alp_SetConfig__doc__},
|
|
{"GetConfig", (PyCFunction)alp_GetConfig, METH_VARARGS, alp_GetConfig__doc__},
|
|
{"GetResource", (PyCFunction)alp_GetResource, METH_VARARGS, alp_GetResource__doc__},
|
|
{"GetFD", (PyCFunction)alp_GetFD, METH_VARARGS, alp_GetFD__doc__},
|
|
{"GetFilled", (PyCFunction)alp_GetFilled, METH_VARARGS, alp_GetFilled__doc__},
|
|
{"GetFillable", (PyCFunction)alp_GetFillable, METH_VARARGS, alp_GetFillable__doc__},
|
|
{"ReadFrames", (PyCFunction)alp_ReadFrames, METH_VARARGS, alp_ReadFrames__doc__},
|
|
{"DiscardFrames", (PyCFunction)alp_DiscardFrames, METH_VARARGS, alp_DiscardFrames__doc__},
|
|
{"ZeroFrames", (PyCFunction)alp_ZeroFrames, METH_VARARGS, alp_ZeroFrames__doc__},
|
|
{"SetFillPoint", (PyCFunction)alp_SetFillPoint, METH_VARARGS, alp_SetFillPoint__doc__},
|
|
{"GetFillPoint", (PyCFunction)alp_GetFillPoint, METH_VARARGS, alp_GetFillPoint__doc__},
|
|
{"GetFrameNumber", (PyCFunction)alp_GetFrameNumber, METH_VARARGS, alp_GetFrameNumber__doc__},
|
|
{"GetFrameTime", (PyCFunction)alp_GetFrameTime, METH_VARARGS, alp_GetFrameTime__doc__},
|
|
{"WriteFrames", (PyCFunction)alp_WriteFrames, METH_VARARGS, alp_WriteFrames__doc__},
|
|
{"ClosePort", (PyCFunction)alp_ClosePort, METH_VARARGS, alp_ClosePort__doc__},
|
|
#endif /* AL_NO_ELEM */
|
|
#ifdef OLD_INTERFACE
|
|
{"closeport", (PyCFunction)alp_closeport, METH_VARARGS},
|
|
{"getfd", (PyCFunction)alp_getfd, METH_VARARGS},
|
|
{"fileno", (PyCFunction)alp_getfd, METH_VARARGS},
|
|
{"getfilled", (PyCFunction)alp_getfilled, METH_VARARGS},
|
|
{"getfillable", (PyCFunction)alp_getfillable, METH_VARARGS},
|
|
{"readsamps", (PyCFunction)alp_readsamps, METH_VARARGS},
|
|
{"writesamps", (PyCFunction)alp_writesamps, METH_VARARGS},
|
|
{"setfillpoint", (PyCFunction)alp_setfillpoint, METH_VARARGS},
|
|
{"getfillpoint", (PyCFunction)alp_getfillpoint, METH_VARARGS},
|
|
{"setconfig", (PyCFunction)alp_setconfig, METH_VARARGS},
|
|
{"getconfig", (PyCFunction)alp_getconfig, METH_VARARGS},
|
|
#ifdef AL_405
|
|
{"getstatus", (PyCFunction)alp_getstatus, METH_VARARGS},
|
|
#endif /* AL_405 */
|
|
#endif /* OLD_INTERFACE */
|
|
|
|
{NULL, NULL} /* sentinel */
|
|
};
|
|
|
|
/* ---------- */
|
|
|
|
|
|
static PyObject *
|
|
newalpobject(ALport port)
|
|
{
|
|
alpobject *self;
|
|
|
|
self = PyObject_NEW(alpobject, &Alptype);
|
|
if (self == NULL)
|
|
return NULL;
|
|
/* XXXX Add your own initializers here */
|
|
self->port = port;
|
|
return (PyObject *) self;
|
|
}
|
|
|
|
|
|
static void
|
|
alp_dealloc(self)
|
|
alpobject *self;
|
|
{
|
|
/* XXXX Add your own cleanup code here */
|
|
if (self->port) {
|
|
#ifdef AL_NO_ELEM /* IRIX 6 */
|
|
alClosePort(self->port);
|
|
#else
|
|
ALcloseport(self->port);
|
|
#endif
|
|
}
|
|
PyMem_DEL(self);
|
|
}
|
|
|
|
static PyObject *
|
|
alp_getattr(self, name)
|
|
alpobject *self;
|
|
char *name;
|
|
{
|
|
/* XXXX Add your own getattr code here */
|
|
if (self->port == NULL) {
|
|
PyErr_SetString(ErrorObject, "port already closed");
|
|
return NULL;
|
|
}
|
|
return Py_FindMethod(alp_methods, (PyObject *)self, name);
|
|
}
|
|
|
|
static char Alptype__doc__[] =
|
|
""
|
|
;
|
|
|
|
static PyTypeObject Alptype = {
|
|
PyObject_HEAD_INIT(&PyType_Type)
|
|
0, /*ob_size*/
|
|
"port", /*tp_name*/
|
|
sizeof(alpobject), /*tp_basicsize*/
|
|
0, /*tp_itemsize*/
|
|
/* methods */
|
|
(destructor)alp_dealloc, /*tp_dealloc*/
|
|
(printfunc)0, /*tp_print*/
|
|
(getattrfunc)alp_getattr, /*tp_getattr*/
|
|
(setattrfunc)0, /*tp_setattr*/
|
|
(cmpfunc)0, /*tp_compare*/
|
|
(reprfunc)0, /*tp_repr*/
|
|
0, /*tp_as_number*/
|
|
0, /*tp_as_sequence*/
|
|
0, /*tp_as_mapping*/
|
|
(hashfunc)0, /*tp_hash*/
|
|
(ternaryfunc)0, /*tp_call*/
|
|
(reprfunc)0, /*tp_str*/
|
|
|
|
/* Space for future expansion */
|
|
0L,0L,0L,0L,
|
|
Alptype__doc__ /* Documentation string */
|
|
};
|
|
|
|
/* End of code for port objects */
|
|
/* -------------------------------------------------------- */
|
|
|
|
|
|
#ifdef AL_NO_ELEM /* IRIX 6 */
|
|
|
|
static char al_NewConfig__doc__[] =
|
|
"alNewConfig: create and initialize an audio ALconfig structure."
|
|
;
|
|
|
|
static PyObject *
|
|
al_NewConfig(self, args)
|
|
PyObject *self; /* Not used */
|
|
PyObject *args;
|
|
{
|
|
ALconfig config;
|
|
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
if ((config = alNewConfig()) == NULL)
|
|
return NULL;
|
|
return newalcobject(config);
|
|
}
|
|
|
|
static char al_OpenPort__doc__[] =
|
|
"alOpenPort: open an audio port."
|
|
;
|
|
|
|
static PyObject *
|
|
al_OpenPort(self, args)
|
|
PyObject *self; /* Not used */
|
|
PyObject *args;
|
|
{
|
|
ALport port;
|
|
char *name, *dir;
|
|
alcobject *config = NULL;
|
|
|
|
if (!PyArg_ParseTuple(args, "ss|O!", &name, &dir, &Alctype, &config))
|
|
return NULL;
|
|
if ((port = alOpenPort(name, dir, config ? config->config : NULL)) == NULL)
|
|
return NULL;
|
|
return newalpobject(port);
|
|
}
|
|
|
|
static char al_Connect__doc__[] =
|
|
"alConnect: connect two audio I/O resources."
|
|
;
|
|
|
|
static PyObject *
|
|
al_Connect(self, args)
|
|
PyObject *self; /* Not used */
|
|
PyObject *args;
|
|
{
|
|
int source, dest, nprops = 0, id, i;
|
|
ALpv *props = NULL;
|
|
ALparamInfo *propinfo = NULL;
|
|
PyObject *propobj = NULL;
|
|
|
|
if (!PyArg_ParseTuple(args, "ii|O!", &source, &dest, &propobj))
|
|
return NULL;
|
|
if (propobj != NULL) {
|
|
nprops = python2params(source, dest, propobj, &props, &propinfo);
|
|
if (nprops < 0)
|
|
return NULL;
|
|
}
|
|
|
|
id = alConnect(source, dest, props, nprops);
|
|
|
|
if (props) {
|
|
for (i = 0; i < nprops; i++) {
|
|
switch (propinfo[i].valueType) {
|
|
case AL_SET_VAL:
|
|
case AL_VECTOR_VAL:
|
|
PyMem_DEL(props[i].value.ptr);
|
|
break;
|
|
}
|
|
}
|
|
PyMem_DEL(props);
|
|
PyMem_DEL(propinfo);
|
|
}
|
|
|
|
if (id < 0)
|
|
return NULL;
|
|
return PyInt_FromLong((long) id);
|
|
}
|
|
|
|
static char al_Disconnect__doc__[] =
|
|
"alDisconnect: delete a connection between two audio I/O resources."
|
|
;
|
|
|
|
static PyObject *
|
|
al_Disconnect(self, args)
|
|
PyObject *self; /* Not used */
|
|
PyObject *args;
|
|
{
|
|
int res;
|
|
|
|
if (!PyArg_ParseTuple(args, "i", &res))
|
|
return NULL;
|
|
if (alDisconnect(res) < 0)
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static char al_GetParams__doc__[] =
|
|
"alGetParams: get the values of audio resource parameters."
|
|
;
|
|
|
|
static PyObject *
|
|
al_GetParams(self, args)
|
|
PyObject *self; /* Not used */
|
|
PyObject *args;
|
|
{
|
|
int resource;
|
|
PyObject *pvslist, *item = NULL, *v = NULL;
|
|
ALpv *pvs;
|
|
int i, j, npvs;
|
|
ALparamInfo *pinfo;
|
|
|
|
if (!PyArg_ParseTuple(args, "iO!", &resource, &PyList_Type, &pvslist))
|
|
return NULL;
|
|
npvs = PyList_Size(pvslist);
|
|
pvs = PyMem_NEW(ALpv, npvs);
|
|
pinfo = PyMem_NEW(ALparamInfo, npvs);
|
|
for (i = 0; i < npvs; i++) {
|
|
item = PyList_GetItem(pvslist, i);
|
|
if (!PyInt_Check(item)) {
|
|
item = NULL;
|
|
PyErr_SetString(ErrorObject, "list of integers expected");
|
|
goto error;
|
|
}
|
|
pvs[i].param = (int) PyInt_AsLong(item);
|
|
item = NULL; /* not needed anymore */
|
|
if (alGetParamInfo(resource, pvs[i].param, &pinfo[i]) < 0)
|
|
goto error;
|
|
switch (pinfo[i].valueType) {
|
|
case AL_NO_VAL:
|
|
break;
|
|
case AL_MATRIX_VAL:
|
|
pinfo[i].maxElems *= pinfo[i].maxElems2;
|
|
/* fall through */
|
|
case AL_STRING_VAL:
|
|
case AL_SET_VAL:
|
|
case AL_VECTOR_VAL:
|
|
switch (pinfo[i].elementType) {
|
|
case AL_INT32_ELEM:
|
|
case AL_RESOURCE_ELEM:
|
|
case AL_ENUM_ELEM:
|
|
pvs[i].value.ptr = PyMem_NEW(int, pinfo[i].maxElems);
|
|
pvs[i].sizeIn = pinfo[i].maxElems;
|
|
break;
|
|
case AL_INT64_ELEM:
|
|
case AL_FIXED_ELEM:
|
|
pvs[i].value.ptr = PyMem_NEW(long long, pinfo[i].maxElems);
|
|
pvs[i].sizeIn = pinfo[i].maxElems;
|
|
break;
|
|
case AL_CHAR_ELEM:
|
|
pvs[i].value.ptr = PyMem_NEW(char, 32);
|
|
pvs[i].sizeIn = 32;
|
|
break;
|
|
case AL_NO_ELEM:
|
|
case AL_PTR_ELEM:
|
|
default:
|
|
PyErr_SetString(ErrorObject, "internal error");
|
|
goto error;
|
|
}
|
|
break;
|
|
case AL_SCALAR_VAL:
|
|
break;
|
|
default:
|
|
PyErr_SetString(ErrorObject, "internal error");
|
|
goto error;
|
|
}
|
|
if (pinfo[i].valueType == AL_MATRIX_VAL) {
|
|
pinfo[i].maxElems /= pinfo[i].maxElems2;
|
|
pvs[i].sizeIn /= pinfo[i].maxElems2;
|
|
pvs[i].size2In = pinfo[i].maxElems2;
|
|
}
|
|
}
|
|
if (alGetParams(resource, pvs, npvs) < 0)
|
|
goto error;
|
|
v = PyList_New(npvs);
|
|
for (i = 0; i < npvs; i++) {
|
|
if (pvs[i].sizeOut < 0) {
|
|
char buf[32];
|
|
sprintf(buf, "problem with param %d", i);
|
|
PyErr_SetString(ErrorObject, buf);
|
|
goto error;
|
|
}
|
|
switch (pinfo[i].valueType) {
|
|
case AL_NO_VAL:
|
|
item = Py_None;
|
|
Py_INCREF(item);
|
|
break;
|
|
case AL_STRING_VAL:
|
|
item = PyString_FromString(pvs[i].value.ptr);
|
|
PyMem_DEL(pvs[i].value.ptr);
|
|
break;
|
|
case AL_MATRIX_VAL:
|
|
/* XXXX this is not right */
|
|
pvs[i].sizeOut *= pvs[i].size2Out;
|
|
/* fall through */
|
|
case AL_SET_VAL:
|
|
case AL_VECTOR_VAL:
|
|
item = PyList_New(pvs[i].sizeOut);
|
|
for (j = 0; j < pvs[i].sizeOut; j++) {
|
|
switch (pinfo[i].elementType) {
|
|
case AL_INT32_ELEM:
|
|
case AL_RESOURCE_ELEM:
|
|
case AL_ENUM_ELEM:
|
|
PyList_SetItem(item, j, PyInt_FromLong((long) ((int *) pvs[i].value.ptr)[j]));
|
|
break;
|
|
case AL_INT64_ELEM:
|
|
PyList_SetItem(item, j, PyLong_FromLongLong(((long long *) pvs[i].value.ptr)[j]));
|
|
break;
|
|
case AL_FIXED_ELEM:
|
|
PyList_SetItem(item, j, PyFloat_FromDouble(alFixedToDouble(((long long *) pvs[i].value.ptr)[j])));
|
|
break;
|
|
default:
|
|
PyErr_SetString(ErrorObject, "internal error");
|
|
goto error;
|
|
}
|
|
}
|
|
PyMem_DEL(pvs[i].value.ptr);
|
|
break;
|
|
case AL_SCALAR_VAL:
|
|
item = param2python(resource, pvs[i].param, pvs[i].value, &pinfo[i]);
|
|
break;
|
|
}
|
|
if (PyErr_Occurred() ||
|
|
PyList_SetItem(v, i, Py_BuildValue("(iO)", pvs[i].param,
|
|
item)) < 0 ||
|
|
PyErr_Occurred())
|
|
goto error;
|
|
Py_DECREF(item);
|
|
}
|
|
PyMem_DEL(pvs);
|
|
PyMem_DEL(pinfo);
|
|
return v;
|
|
|
|
error:
|
|
Py_XDECREF(v);
|
|
Py_XDECREF(item);
|
|
if (pvs)
|
|
PyMem_DEL(pvs);
|
|
if (pinfo)
|
|
PyMem_DEL(pinfo);
|
|
return NULL;
|
|
}
|
|
|
|
static char al_SetParams__doc__[] =
|
|
"alSetParams: set the values of audio resource parameters."
|
|
;
|
|
|
|
static PyObject *
|
|
al_SetParams(self, args)
|
|
PyObject *self; /* Not used */
|
|
PyObject *args;
|
|
{
|
|
int resource;
|
|
PyObject *pvslist, *item;
|
|
ALpv *pvs;
|
|
ALparamInfo *pinfo;
|
|
int npvs, i;
|
|
|
|
if (!PyArg_ParseTuple(args, "iO!", &resource, &PyList_Type, &pvslist))
|
|
return NULL;
|
|
npvs = python2params(resource, -1, pvslist, &pvs, &pinfo);
|
|
if (npvs < 0)
|
|
return NULL;
|
|
|
|
if (alSetParams(resource, pvs, npvs) < 0)
|
|
goto error;
|
|
|
|
/* cleanup */
|
|
for (i = 0; i < npvs; i++) {
|
|
switch (pinfo[i].valueType) {
|
|
case AL_SET_VAL:
|
|
case AL_VECTOR_VAL:
|
|
PyMem_DEL(pvs[i].value.ptr);
|
|
break;
|
|
}
|
|
}
|
|
PyMem_DEL(pvs);
|
|
PyMem_DEL(pinfo);
|
|
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
|
|
error:
|
|
/* XXXX we should clean up everything */
|
|
if (pvs)
|
|
PyMem_DEL(pvs);
|
|
if (pinfo)
|
|
PyMem_DEL(pinfo);
|
|
return NULL;
|
|
}
|
|
|
|
static char al_QueryValues__doc__[] =
|
|
"alQueryValues: get the set of possible values for a parameter."
|
|
;
|
|
|
|
static PyObject *
|
|
al_QueryValues(self, args)
|
|
PyObject *self; /* Not used */
|
|
PyObject *args;
|
|
{
|
|
int resource, param;
|
|
ALvalue *return_set = NULL;
|
|
int setsize = 32, qualsize = 0, nvals, i;
|
|
ALpv *quals = NULL;
|
|
ALparamInfo pinfo;
|
|
ALparamInfo *qualinfo = NULL;
|
|
PyObject *qualobj = NULL;
|
|
PyObject *res = NULL, *item;
|
|
|
|
if (!PyArg_ParseTuple(args, "ii|O!", &resource, ¶m,
|
|
&PyList_Type, &qualobj))
|
|
return NULL;
|
|
if (qualobj != NULL) {
|
|
qualsize = python2params(resource, param, qualobj, &quals, &qualinfo);
|
|
if (qualsize < 0)
|
|
return NULL;
|
|
}
|
|
setsize = 32;
|
|
return_set = PyMem_NEW(ALvalue, setsize);
|
|
if (return_set == NULL) {
|
|
PyErr_NoMemory();
|
|
goto cleanup;
|
|
}
|
|
|
|
retry:
|
|
nvals = alQueryValues(resource, param, return_set, setsize, quals, qualsize);
|
|
if (nvals < 0)
|
|
goto cleanup;
|
|
if (nvals > setsize) {
|
|
setsize = nvals;
|
|
PyMem_RESIZE(return_set, ALvalue, setsize);
|
|
if (return_set == NULL) {
|
|
PyErr_NoMemory();
|
|
goto cleanup;
|
|
}
|
|
goto retry;
|
|
}
|
|
|
|
if (alGetParamInfo(resource, param, &pinfo) < 0)
|
|
goto cleanup;
|
|
|
|
res = PyList_New(nvals);
|
|
if (res == NULL)
|
|
goto cleanup;
|
|
for (i = 0; i < nvals; i++) {
|
|
item = param2python(resource, param, return_set[i], &pinfo);
|
|
if (item == NULL ||
|
|
PyList_SetItem(res, i, item) < 0) {
|
|
Py_DECREF(res);
|
|
res = NULL;
|
|
goto cleanup;
|
|
}
|
|
}
|
|
|
|
cleanup:
|
|
if (return_set)
|
|
PyMem_DEL(return_set);
|
|
if (quals) {
|
|
for (i = 0; i < qualsize; i++) {
|
|
switch (qualinfo[i].valueType) {
|
|
case AL_SET_VAL:
|
|
case AL_VECTOR_VAL:
|
|
PyMem_DEL(quals[i].value.ptr);
|
|
break;
|
|
}
|
|
}
|
|
PyMem_DEL(quals);
|
|
PyMem_DEL(qualinfo);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
static char al_GetParamInfo__doc__[] =
|
|
"alGetParamInfo: get information about a parameter on a particular audio resource."
|
|
;
|
|
|
|
static PyObject *
|
|
al_GetParamInfo(self, args)
|
|
PyObject *self; /* Not used */
|
|
PyObject *args;
|
|
{
|
|
int res, param;
|
|
ALparamInfo pinfo;
|
|
PyObject *v, *item;;
|
|
|
|
if (!PyArg_ParseTuple(args, "ii", &res, ¶m))
|
|
return NULL;
|
|
if (alGetParamInfo(res, param, &pinfo) < 0)
|
|
return NULL;
|
|
v = PyDict_New();
|
|
|
|
item = PyInt_FromLong((long) pinfo.resource);
|
|
PyDict_SetItemString(v, "resource", item);
|
|
Py_DECREF(item);
|
|
|
|
item = PyInt_FromLong((long) pinfo.param);
|
|
PyDict_SetItemString(v, "param", item);
|
|
Py_DECREF(item);
|
|
|
|
item = PyInt_FromLong((long) pinfo.valueType);
|
|
PyDict_SetItemString(v, "valueType", item);
|
|
Py_DECREF(item);
|
|
|
|
if (pinfo.valueType != AL_NO_VAL && pinfo.valueType != AL_SCALAR_VAL) {
|
|
/* multiple values */
|
|
item = PyInt_FromLong((long) pinfo.maxElems);
|
|
PyDict_SetItemString(v, "maxElems", item);
|
|
Py_DECREF(item);
|
|
|
|
if (pinfo.valueType == AL_MATRIX_VAL) {
|
|
/* 2 dimensional */
|
|
item = PyInt_FromLong((long) pinfo.maxElems2);
|
|
PyDict_SetItemString(v, "maxElems2", item);
|
|
Py_DECREF(item);
|
|
}
|
|
}
|
|
|
|
item = PyInt_FromLong((long) pinfo.elementType);
|
|
PyDict_SetItemString(v, "elementType", item);
|
|
Py_DECREF(item);
|
|
|
|
item = PyString_FromString(pinfo.name);
|
|
PyDict_SetItemString(v, "name", item);
|
|
Py_DECREF(item);
|
|
|
|
item = param2python(res, param, pinfo.initial, &pinfo);
|
|
PyDict_SetItemString(v, "initial", item);
|
|
Py_DECREF(item);
|
|
|
|
if (pinfo.elementType != AL_ENUM_ELEM &&
|
|
pinfo.elementType != AL_RESOURCE_ELEM &&
|
|
pinfo.elementType != AL_CHAR_ELEM) {
|
|
/* range param */
|
|
item = param2python(res, param, pinfo.min, &pinfo);
|
|
PyDict_SetItemString(v, "min", item);
|
|
Py_DECREF(item);
|
|
|
|
item = param2python(res, param, pinfo.max, &pinfo);
|
|
PyDict_SetItemString(v, "max", item);
|
|
Py_DECREF(item);
|
|
|
|
item = param2python(res, param, pinfo.minDelta, &pinfo);
|
|
PyDict_SetItemString(v, "minDelta", item);
|
|
Py_DECREF(item);
|
|
|
|
item = param2python(res, param, pinfo.maxDelta, &pinfo);
|
|
PyDict_SetItemString(v, "maxDelta", item);
|
|
Py_DECREF(item);
|
|
|
|
item = PyInt_FromLong((long) pinfo.specialVals);
|
|
PyDict_SetItemString(v, "specialVals", item);
|
|
Py_DECREF(item);
|
|
}
|
|
|
|
return v;
|
|
}
|
|
|
|
static char al_GetResourceByName__doc__[] =
|
|
"alGetResourceByName: find an audio resource by name."
|
|
;
|
|
|
|
static PyObject *
|
|
al_GetResourceByName(self, args)
|
|
PyObject *self; /* Not used */
|
|
PyObject *args;
|
|
{
|
|
int res, start_res, type;
|
|
char *name;
|
|
|
|
if (!PyArg_ParseTuple(args, "isi", &start_res, &name, &type))
|
|
return NULL;
|
|
if ((res = alGetResourceByName(start_res, name, type)) == 0)
|
|
return NULL;
|
|
return PyInt_FromLong((long) res);
|
|
}
|
|
|
|
static char al_IsSubtype__doc__[] =
|
|
"alIsSubtype: indicate if one resource type is a subtype of another."
|
|
;
|
|
|
|
static PyObject *
|
|
al_IsSubtype(self, args)
|
|
PyObject *self; /* Not used */
|
|
PyObject *args;
|
|
{
|
|
int type, subtype;
|
|
|
|
if (!PyArg_ParseTuple(args, "ii", &type, &subtype))
|
|
return NULL;
|
|
return PyInt_FromLong((long) alIsSubtype(type, subtype));
|
|
}
|
|
|
|
static char al_SetErrorHandler__doc__[] =
|
|
""
|
|
;
|
|
|
|
static PyObject *
|
|
al_SetErrorHandler(self, args)
|
|
PyObject *self; /* Not used */
|
|
PyObject *args;
|
|
{
|
|
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
#endif /* AL_NO_ELEM */
|
|
|
|
#ifdef OLD_INTERFACE
|
|
|
|
static PyObject *
|
|
al_openport(self, args)
|
|
PyObject *self, *args;
|
|
{
|
|
char *name, *dir;
|
|
ALport port;
|
|
alcobject *config = NULL;
|
|
|
|
if (!PyArg_ParseTuple(args, "ss|O!", &name, &dir, &Alctype, &config))
|
|
return NULL;
|
|
if ((port = ALopenport(name, dir, config ? config->config : NULL)) == NULL)
|
|
return NULL;
|
|
return newalpobject(port);
|
|
}
|
|
|
|
static PyObject *
|
|
al_newconfig(self, args)
|
|
PyObject *self, *args;
|
|
{
|
|
ALconfig config;
|
|
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
return NULL;
|
|
if ((config = ALnewconfig ()) == NULL)
|
|
return NULL;
|
|
return newalcobject(config);
|
|
}
|
|
|
|
static PyObject *
|
|
al_queryparams(self, args)
|
|
PyObject *self, *args;
|
|
{
|
|
long device;
|
|
long length;
|
|
long *PVbuffer;
|
|
long PVdummy[2];
|
|
PyObject *v = NULL;
|
|
int i;
|
|
|
|
if (!PyArg_ParseTuple(args, "l", &device))
|
|
return NULL;
|
|
if ((length = ALqueryparams(device, PVdummy, 2L)) == -1)
|
|
return NULL;
|
|
if ((PVbuffer = PyMem_NEW(long, length)) == NULL)
|
|
return PyErr_NoMemory();
|
|
if (ALqueryparams(device, PVbuffer, length) >= 0 &&
|
|
(v = PyList_New((int)length)) != NULL) {
|
|
for (i = 0; i < length; i++)
|
|
PyList_SetItem(v, i, PyInt_FromLong(PVbuffer[i]));
|
|
}
|
|
PyMem_DEL(PVbuffer);
|
|
return v;
|
|
}
|
|
|
|
static PyObject *
|
|
doParams(args, func, modified)
|
|
PyObject *args;
|
|
int (*func)(long, long *, long);
|
|
int modified;
|
|
{
|
|
long device;
|
|
PyObject *list, *v;
|
|
long *PVbuffer;
|
|
long length;
|
|
int i;
|
|
|
|
if (!PyArg_ParseTuple(args, "lO!", &device, &PyList_Type, &list))
|
|
return NULL;
|
|
length = PyList_Size(list);
|
|
PVbuffer = PyMem_NEW(long, length);
|
|
if (PVbuffer == NULL)
|
|
return PyErr_NoMemory();
|
|
for (i = 0; i < length; i++) {
|
|
v = PyList_GetItem(list, i);
|
|
if (!PyInt_Check(v)) {
|
|
PyMem_DEL(PVbuffer);
|
|
PyErr_BadArgument();
|
|
return NULL;
|
|
}
|
|
PVbuffer[i] = PyInt_AsLong(v);
|
|
}
|
|
|
|
if ((*func)(device, PVbuffer, length) == -1) {
|
|
PyMem_DEL(PVbuffer);
|
|
return NULL;
|
|
}
|
|
|
|
if (modified) {
|
|
for (i = 0; i < length; i++)
|
|
PyList_SetItem(list, i, PyInt_FromLong(PVbuffer[i]));
|
|
}
|
|
|
|
PyMem_DEL(PVbuffer);
|
|
|
|
Py_INCREF(Py_None);
|
|
return Py_None;
|
|
}
|
|
|
|
static PyObject *
|
|
al_getparams(self, args)
|
|
PyObject *self, *args;
|
|
{
|
|
return doParams(args, ALgetparams, 1);
|
|
}
|
|
|
|
static PyObject *
|
|
al_setparams(self, args)
|
|
PyObject *self, *args;
|
|
{
|
|
return doParams(args, ALsetparams, 0);
|
|
}
|
|
|
|
static PyObject *
|
|
al_getname(self, args)
|
|
PyObject *self, *args;
|
|
{
|
|
long device, descriptor;
|
|
char *name;
|
|
|
|
if (!PyArg_ParseTuple(args, "ll", &device, &descriptor))
|
|
return NULL;
|
|
if ((name = ALgetname(device, descriptor)) == NULL)
|
|
return NULL;
|
|
return PyString_FromString(name);
|
|
}
|
|
|
|
static PyObject *
|
|
al_getdefault(self, args)
|
|
PyObject *self, *args;
|
|
{
|
|
long device, descriptor, value;
|
|
|
|
if (!PyArg_ParseTuple(args, "ll", &device, &descriptor))
|
|
return NULL;
|
|
if ((value = ALgetdefault(device, descriptor)) == -1)
|
|
return NULL;
|
|
return PyLong_FromLong(value);
|
|
}
|
|
|
|
static PyObject *
|
|
al_getminmax(self, args)
|
|
PyObject *self, *args;
|
|
{
|
|
long device, descriptor, min, max;
|
|
|
|
if (!PyArg_ParseTuple(args, "ll", &device, &descriptor))
|
|
return NULL;
|
|
min = -1;
|
|
max = -1;
|
|
if (ALgetminmax(device, descriptor, &min, &max) == -1)
|
|
return NULL;
|
|
return Py_BuildValue("ll", min, max);
|
|
}
|
|
|
|
#endif /* OLD_INTERFACE */
|
|
|
|
/* List of methods defined in the module */
|
|
|
|
static struct PyMethodDef al_methods[] = {
|
|
#ifdef AL_NO_ELEM /* IRIX 6 */
|
|
{"NewConfig", (PyCFunction)al_NewConfig, METH_VARARGS, al_NewConfig__doc__},
|
|
{"OpenPort", (PyCFunction)al_OpenPort, METH_VARARGS, al_OpenPort__doc__},
|
|
{"Connect", (PyCFunction)al_Connect, METH_VARARGS, al_Connect__doc__},
|
|
{"Disconnect", (PyCFunction)al_Disconnect, METH_VARARGS, al_Disconnect__doc__},
|
|
{"GetParams", (PyCFunction)al_GetParams, METH_VARARGS, al_GetParams__doc__},
|
|
{"SetParams", (PyCFunction)al_SetParams, METH_VARARGS, al_SetParams__doc__},
|
|
{"QueryValues", (PyCFunction)al_QueryValues, METH_VARARGS, al_QueryValues__doc__},
|
|
{"GetParamInfo", (PyCFunction)al_GetParamInfo, METH_VARARGS, al_GetParamInfo__doc__},
|
|
{"GetResourceByName", (PyCFunction)al_GetResourceByName, METH_VARARGS, al_GetResourceByName__doc__},
|
|
{"IsSubtype", (PyCFunction)al_IsSubtype, METH_VARARGS, al_IsSubtype__doc__},
|
|
#if 0
|
|
/* this one not supported */
|
|
{"SetErrorHandler", (PyCFunction)al_SetErrorHandler, METH_VARARGS, al_SetErrorHandler__doc__},
|
|
#endif
|
|
#endif /* AL_NO_ELEM */
|
|
#ifdef OLD_INTERFACE
|
|
{"openport", (PyCFunction)al_openport, METH_VARARGS},
|
|
{"newconfig", (PyCFunction)al_newconfig, METH_VARARGS},
|
|
{"queryparams", (PyCFunction)al_queryparams, METH_VARARGS},
|
|
{"getparams", (PyCFunction)al_getparams, METH_VARARGS},
|
|
{"setparams", (PyCFunction)al_setparams, METH_VARARGS},
|
|
{"getname", (PyCFunction)al_getname, METH_VARARGS},
|
|
{"getdefault", (PyCFunction)al_getdefault, METH_VARARGS},
|
|
{"getminmax", (PyCFunction)al_getminmax, METH_VARARGS},
|
|
#endif /* OLD_INTERFACE */
|
|
|
|
{NULL, (PyCFunction)NULL, 0, NULL} /* sentinel */
|
|
};
|
|
|
|
|
|
/* Initialization function for the module (*must* be called inital) */
|
|
|
|
static char al_module_documentation[] =
|
|
""
|
|
;
|
|
|
|
void
|
|
inital()
|
|
{
|
|
PyObject *m, *d, *x;
|
|
|
|
/* Create the module and add the functions */
|
|
m = Py_InitModule4("al", al_methods,
|
|
al_module_documentation,
|
|
(PyObject*)NULL,PYTHON_API_VERSION);
|
|
|
|
/* Add some symbolic constants to the module */
|
|
d = PyModule_GetDict(m);
|
|
ErrorObject = PyString_FromString("al.error");
|
|
PyDict_SetItemString(d, "error", ErrorObject);
|
|
|
|
/* XXXX Add constants here */
|
|
#ifdef AL_4CHANNEL
|
|
x = PyInt_FromLong((long) AL_4CHANNEL);
|
|
if (x == NULL || PyDict_SetItemString(d, "FOURCHANNEL", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_ADAT_IF_TYPE
|
|
x = PyInt_FromLong((long) AL_ADAT_IF_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "ADAT_IF_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_ADAT_MCLK_TYPE
|
|
x = PyInt_FromLong((long) AL_ADAT_MCLK_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "ADAT_MCLK_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_AES_IF_TYPE
|
|
x = PyInt_FromLong((long) AL_AES_IF_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "AES_IF_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_AES_MCLK_TYPE
|
|
x = PyInt_FromLong((long) AL_AES_MCLK_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "AES_MCLK_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_ANALOG_IF_TYPE
|
|
x = PyInt_FromLong((long) AL_ANALOG_IF_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "ANALOG_IF_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_ASSOCIATE
|
|
x = PyInt_FromLong((long) AL_ASSOCIATE);
|
|
if (x == NULL || PyDict_SetItemString(d, "ASSOCIATE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_BAD_BUFFER_NULL
|
|
x = PyInt_FromLong((long) AL_BAD_BUFFER_NULL);
|
|
if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_NULL", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_BAD_BUFFERLENGTH
|
|
x = PyInt_FromLong((long) AL_BAD_BUFFERLENGTH);
|
|
if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERLENGTH", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_BAD_BUFFERLENGTH_NEG
|
|
x = PyInt_FromLong((long) AL_BAD_BUFFERLENGTH_NEG);
|
|
if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERLENGTH_NEG", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_BAD_BUFFERLENGTH_ODD
|
|
x = PyInt_FromLong((long) AL_BAD_BUFFERLENGTH_ODD);
|
|
if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERLENGTH_ODD", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_BAD_CHANNELS
|
|
x = PyInt_FromLong((long) AL_BAD_CHANNELS);
|
|
if (x == NULL || PyDict_SetItemString(d, "BAD_CHANNELS", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_BAD_CONFIG
|
|
x = PyInt_FromLong((long) AL_BAD_CONFIG);
|
|
if (x == NULL || PyDict_SetItemString(d, "BAD_CONFIG", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_BAD_COUNT_NEG
|
|
x = PyInt_FromLong((long) AL_BAD_COUNT_NEG);
|
|
if (x == NULL || PyDict_SetItemString(d, "BAD_COUNT_NEG", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_BAD_DEVICE
|
|
x = PyInt_FromLong((long) AL_BAD_DEVICE);
|
|
if (x == NULL || PyDict_SetItemString(d, "BAD_DEVICE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_BAD_DEVICE_ACCESS
|
|
x = PyInt_FromLong((long) AL_BAD_DEVICE_ACCESS);
|
|
if (x == NULL || PyDict_SetItemString(d, "BAD_DEVICE_ACCESS", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_BAD_DIRECTION
|
|
x = PyInt_FromLong((long) AL_BAD_DIRECTION);
|
|
if (x == NULL || PyDict_SetItemString(d, "BAD_DIRECTION", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_BAD_FILLPOINT
|
|
x = PyInt_FromLong((long) AL_BAD_FILLPOINT);
|
|
if (x == NULL || PyDict_SetItemString(d, "BAD_FILLPOINT", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_BAD_FLOATMAX
|
|
x = PyInt_FromLong((long) AL_BAD_FLOATMAX);
|
|
if (x == NULL || PyDict_SetItemString(d, "BAD_FLOATMAX", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_BAD_ILLEGAL_STATE
|
|
x = PyInt_FromLong((long) AL_BAD_ILLEGAL_STATE);
|
|
if (x == NULL || PyDict_SetItemString(d, "BAD_ILLEGAL_STATE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_BAD_NO_PORTS
|
|
x = PyInt_FromLong((long) AL_BAD_NO_PORTS);
|
|
if (x == NULL || PyDict_SetItemString(d, "BAD_NO_PORTS", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_BAD_NOT_FOUND
|
|
x = PyInt_FromLong((long) AL_BAD_NOT_FOUND);
|
|
if (x == NULL || PyDict_SetItemString(d, "BAD_NOT_FOUND", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_BAD_NOT_IMPLEMENTED
|
|
x = PyInt_FromLong((long) AL_BAD_NOT_IMPLEMENTED);
|
|
if (x == NULL || PyDict_SetItemString(d, "BAD_NOT_IMPLEMENTED", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_BAD_OUT_OF_MEM
|
|
x = PyInt_FromLong((long) AL_BAD_OUT_OF_MEM);
|
|
if (x == NULL || PyDict_SetItemString(d, "BAD_OUT_OF_MEM", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_BAD_PARAM
|
|
x = PyInt_FromLong((long) AL_BAD_PARAM);
|
|
if (x == NULL || PyDict_SetItemString(d, "BAD_PARAM", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_BAD_PERMISSIONS
|
|
x = PyInt_FromLong((long) AL_BAD_PERMISSIONS);
|
|
if (x == NULL || PyDict_SetItemString(d, "BAD_PERMISSIONS", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_BAD_PORT
|
|
x = PyInt_FromLong((long) AL_BAD_PORT);
|
|
if (x == NULL || PyDict_SetItemString(d, "BAD_PORT", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_BAD_PORTSTYLE
|
|
x = PyInt_FromLong((long) AL_BAD_PORTSTYLE);
|
|
if (x == NULL || PyDict_SetItemString(d, "BAD_PORTSTYLE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_BAD_PVBUFFER
|
|
x = PyInt_FromLong((long) AL_BAD_PVBUFFER);
|
|
if (x == NULL || PyDict_SetItemString(d, "BAD_PVBUFFER", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_BAD_QSIZE
|
|
x = PyInt_FromLong((long) AL_BAD_QSIZE);
|
|
if (x == NULL || PyDict_SetItemString(d, "BAD_QSIZE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_BAD_RATE
|
|
x = PyInt_FromLong((long) AL_BAD_RATE);
|
|
if (x == NULL || PyDict_SetItemString(d, "BAD_RATE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_BAD_RESOURCE
|
|
x = PyInt_FromLong((long) AL_BAD_RESOURCE);
|
|
if (x == NULL || PyDict_SetItemString(d, "BAD_RESOURCE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_BAD_SAMPFMT
|
|
x = PyInt_FromLong((long) AL_BAD_SAMPFMT);
|
|
if (x == NULL || PyDict_SetItemString(d, "BAD_SAMPFMT", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_BAD_TRANSFER_SIZE
|
|
x = PyInt_FromLong((long) AL_BAD_TRANSFER_SIZE);
|
|
if (x == NULL || PyDict_SetItemString(d, "BAD_TRANSFER_SIZE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_BAD_WIDTH
|
|
x = PyInt_FromLong((long) AL_BAD_WIDTH);
|
|
if (x == NULL || PyDict_SetItemString(d, "BAD_WIDTH", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_CHANNEL_MODE
|
|
x = PyInt_FromLong((long) AL_CHANNEL_MODE);
|
|
if (x == NULL || PyDict_SetItemString(d, "CHANNEL_MODE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_CHANNELS
|
|
x = PyInt_FromLong((long) AL_CHANNELS);
|
|
if (x == NULL || PyDict_SetItemString(d, "CHANNELS", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_CHAR_ELEM
|
|
x = PyInt_FromLong((long) AL_CHAR_ELEM);
|
|
if (x == NULL || PyDict_SetItemString(d, "CHAR_ELEM", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_CLOCK_GEN
|
|
x = PyInt_FromLong((long) AL_CLOCK_GEN);
|
|
if (x == NULL || PyDict_SetItemString(d, "CLOCK_GEN", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_CLOCKGEN_TYPE
|
|
x = PyInt_FromLong((long) AL_CLOCKGEN_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "CLOCKGEN_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_CONNECT
|
|
x = PyInt_FromLong((long) AL_CONNECT);
|
|
if (x == NULL || PyDict_SetItemString(d, "CONNECT", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_CONNECTION_TYPE
|
|
x = PyInt_FromLong((long) AL_CONNECTION_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "CONNECTION_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_CONNECTIONS
|
|
x = PyInt_FromLong((long) AL_CONNECTIONS);
|
|
if (x == NULL || PyDict_SetItemString(d, "CONNECTIONS", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_CRYSTAL_MCLK_TYPE
|
|
x = PyInt_FromLong((long) AL_CRYSTAL_MCLK_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "CRYSTAL_MCLK_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_DEFAULT_DEVICE
|
|
x = PyInt_FromLong((long) AL_DEFAULT_DEVICE);
|
|
if (x == NULL || PyDict_SetItemString(d, "DEFAULT_DEVICE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_DEFAULT_INPUT
|
|
x = PyInt_FromLong((long) AL_DEFAULT_INPUT);
|
|
if (x == NULL || PyDict_SetItemString(d, "DEFAULT_INPUT", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_DEFAULT_OUTPUT
|
|
x = PyInt_FromLong((long) AL_DEFAULT_OUTPUT);
|
|
if (x == NULL || PyDict_SetItemString(d, "DEFAULT_OUTPUT", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_DEST
|
|
x = PyInt_FromLong((long) AL_DEST);
|
|
if (x == NULL || PyDict_SetItemString(d, "DEST", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_DEVICE_TYPE
|
|
x = PyInt_FromLong((long) AL_DEVICE_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "DEVICE_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_DEVICES
|
|
x = PyInt_FromLong((long) AL_DEVICES);
|
|
if (x == NULL || PyDict_SetItemString(d, "DEVICES", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_DIGITAL_IF_TYPE
|
|
x = PyInt_FromLong((long) AL_DIGITAL_IF_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "DIGITAL_IF_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_DIGITAL_INPUT_RATE
|
|
x = PyInt_FromLong((long) AL_DIGITAL_INPUT_RATE);
|
|
if (x == NULL || PyDict_SetItemString(d, "DIGITAL_INPUT_RATE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_DISCONNECT
|
|
x = PyInt_FromLong((long) AL_DISCONNECT);
|
|
if (x == NULL || PyDict_SetItemString(d, "DISCONNECT", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_ENUM_ELEM
|
|
x = PyInt_FromLong((long) AL_ENUM_ELEM);
|
|
if (x == NULL || PyDict_SetItemString(d, "ENUM_ELEM", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_ENUM_VALUE
|
|
x = PyInt_FromLong((long) AL_ENUM_VALUE);
|
|
if (x == NULL || PyDict_SetItemString(d, "ENUM_VALUE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_ERROR_INPUT_OVERFLOW
|
|
x = PyInt_FromLong((long) AL_ERROR_INPUT_OVERFLOW);
|
|
if (x == NULL || PyDict_SetItemString(d, "ERROR_INPUT_OVERFLOW", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_ERROR_LENGTH
|
|
x = PyInt_FromLong((long) AL_ERROR_LENGTH);
|
|
if (x == NULL || PyDict_SetItemString(d, "ERROR_LENGTH", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_ERROR_LOCATION_LSP
|
|
x = PyInt_FromLong((long) AL_ERROR_LOCATION_LSP);
|
|
if (x == NULL || PyDict_SetItemString(d, "ERROR_LOCATION_LSP", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_ERROR_LOCATION_MSP
|
|
x = PyInt_FromLong((long) AL_ERROR_LOCATION_MSP);
|
|
if (x == NULL || PyDict_SetItemString(d, "ERROR_LOCATION_MSP", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_ERROR_NUMBER
|
|
x = PyInt_FromLong((long) AL_ERROR_NUMBER);
|
|
if (x == NULL || PyDict_SetItemString(d, "ERROR_NUMBER", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_ERROR_OUTPUT_UNDERFLOW
|
|
x = PyInt_FromLong((long) AL_ERROR_OUTPUT_UNDERFLOW);
|
|
if (x == NULL || PyDict_SetItemString(d, "ERROR_OUTPUT_UNDERFLOW", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_ERROR_TYPE
|
|
x = PyInt_FromLong((long) AL_ERROR_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "ERROR_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_FIXED_ELEM
|
|
x = PyInt_FromLong((long) AL_FIXED_ELEM);
|
|
if (x == NULL || PyDict_SetItemString(d, "FIXED_ELEM", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_FIXED_MCLK_TYPE
|
|
x = PyInt_FromLong((long) AL_FIXED_MCLK_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "FIXED_MCLK_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_GAIN
|
|
x = PyInt_FromLong((long) AL_GAIN);
|
|
if (x == NULL || PyDict_SetItemString(d, "GAIN", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_GAIN_REF
|
|
x = PyInt_FromLong((long) AL_GAIN_REF);
|
|
if (x == NULL || PyDict_SetItemString(d, "GAIN_REF", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_HRB_TYPE
|
|
x = PyInt_FromLong((long) AL_HRB_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "HRB_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_INPUT_COUNT
|
|
x = PyInt_FromLong((long) AL_INPUT_COUNT);
|
|
if (x == NULL || PyDict_SetItemString(d, "INPUT_COUNT", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_INPUT_DEVICE_TYPE
|
|
x = PyInt_FromLong((long) AL_INPUT_DEVICE_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "INPUT_DEVICE_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_INPUT_DIGITAL
|
|
x = PyInt_FromLong((long) AL_INPUT_DIGITAL);
|
|
if (x == NULL || PyDict_SetItemString(d, "INPUT_DIGITAL", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_INPUT_HRB_TYPE
|
|
x = PyInt_FromLong((long) AL_INPUT_HRB_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "INPUT_HRB_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_INPUT_LINE
|
|
x = PyInt_FromLong((long) AL_INPUT_LINE);
|
|
if (x == NULL || PyDict_SetItemString(d, "INPUT_LINE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_INPUT_MIC
|
|
x = PyInt_FromLong((long) AL_INPUT_MIC);
|
|
if (x == NULL || PyDict_SetItemString(d, "INPUT_MIC", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_INPUT_PORT_TYPE
|
|
x = PyInt_FromLong((long) AL_INPUT_PORT_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "INPUT_PORT_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_INPUT_RATE
|
|
x = PyInt_FromLong((long) AL_INPUT_RATE);
|
|
if (x == NULL || PyDict_SetItemString(d, "INPUT_RATE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_INPUT_SOURCE
|
|
x = PyInt_FromLong((long) AL_INPUT_SOURCE);
|
|
if (x == NULL || PyDict_SetItemString(d, "INPUT_SOURCE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_INT32_ELEM
|
|
x = PyInt_FromLong((long) AL_INT32_ELEM);
|
|
if (x == NULL || PyDict_SetItemString(d, "INT32_ELEM", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_INT64_ELEM
|
|
x = PyInt_FromLong((long) AL_INT64_ELEM);
|
|
if (x == NULL || PyDict_SetItemString(d, "INT64_ELEM", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_INTERFACE
|
|
x = PyInt_FromLong((long) AL_INTERFACE);
|
|
if (x == NULL || PyDict_SetItemString(d, "INTERFACE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_INTERFACE_TYPE
|
|
x = PyInt_FromLong((long) AL_INTERFACE_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "INTERFACE_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_INVALID_PARAM
|
|
x = PyInt_FromLong((long) AL_INVALID_PARAM);
|
|
if (x == NULL || PyDict_SetItemString(d, "INVALID_PARAM", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_INVALID_VALUE
|
|
x = PyInt_FromLong((long) AL_INVALID_VALUE);
|
|
if (x == NULL || PyDict_SetItemString(d, "INVALID_VALUE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_JITTER
|
|
x = PyInt_FromLong((long) AL_JITTER);
|
|
if (x == NULL || PyDict_SetItemString(d, "JITTER", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_LABEL
|
|
x = PyInt_FromLong((long) AL_LABEL);
|
|
if (x == NULL || PyDict_SetItemString(d, "LABEL", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_LEFT_INPUT_ATTEN
|
|
x = PyInt_FromLong((long) AL_LEFT_INPUT_ATTEN);
|
|
if (x == NULL || PyDict_SetItemString(d, "LEFT_INPUT_ATTEN", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_LEFT_MONITOR_ATTEN
|
|
x = PyInt_FromLong((long) AL_LEFT_MONITOR_ATTEN);
|
|
if (x == NULL || PyDict_SetItemString(d, "LEFT_MONITOR_ATTEN", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_LEFT_SPEAKER_GAIN
|
|
x = PyInt_FromLong((long) AL_LEFT_SPEAKER_GAIN);
|
|
if (x == NULL || PyDict_SetItemString(d, "LEFT_SPEAKER_GAIN", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_LEFT1_INPUT_ATTEN
|
|
x = PyInt_FromLong((long) AL_LEFT1_INPUT_ATTEN);
|
|
if (x == NULL || PyDict_SetItemString(d, "LEFT1_INPUT_ATTEN", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_LEFT2_INPUT_ATTEN
|
|
x = PyInt_FromLong((long) AL_LEFT2_INPUT_ATTEN);
|
|
if (x == NULL || PyDict_SetItemString(d, "LEFT2_INPUT_ATTEN", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_LINE_IF_TYPE
|
|
x = PyInt_FromLong((long) AL_LINE_IF_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "LINE_IF_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_MASTER_CLOCK
|
|
x = PyInt_FromLong((long) AL_MASTER_CLOCK);
|
|
if (x == NULL || PyDict_SetItemString(d, "MASTER_CLOCK", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_MATRIX_VAL
|
|
x = PyInt_FromLong((long) AL_MATRIX_VAL);
|
|
if (x == NULL || PyDict_SetItemString(d, "MATRIX_VAL", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_MAX_ERROR
|
|
x = PyInt_FromLong((long) AL_MAX_ERROR);
|
|
if (x == NULL || PyDict_SetItemString(d, "MAX_ERROR", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_MAX_EVENT_PARAM
|
|
x = PyInt_FromLong((long) AL_MAX_EVENT_PARAM);
|
|
if (x == NULL || PyDict_SetItemString(d, "MAX_EVENT_PARAM", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_MAX_PBUFSIZE
|
|
x = PyInt_FromLong((long) AL_MAX_PBUFSIZE);
|
|
if (x == NULL || PyDict_SetItemString(d, "MAX_PBUFSIZE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_MAX_PORTS
|
|
x = PyInt_FromLong((long) AL_MAX_PORTS);
|
|
if (x == NULL || PyDict_SetItemString(d, "MAX_PORTS", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_MAX_RESOURCE_ID
|
|
x = PyInt_FromLong((long) AL_MAX_RESOURCE_ID);
|
|
if (x == NULL || PyDict_SetItemString(d, "MAX_RESOURCE_ID", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_MAX_SETSIZE
|
|
x = PyInt_FromLong((long) AL_MAX_SETSIZE);
|
|
if (x == NULL || PyDict_SetItemString(d, "MAX_SETSIZE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_MAX_STRLEN
|
|
x = PyInt_FromLong((long) AL_MAX_STRLEN);
|
|
if (x == NULL || PyDict_SetItemString(d, "MAX_STRLEN", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_MCLK_TYPE
|
|
x = PyInt_FromLong((long) AL_MCLK_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "MCLK_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_MIC_IF_TYPE
|
|
x = PyInt_FromLong((long) AL_MIC_IF_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "MIC_IF_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_MONITOR_CTL
|
|
x = PyInt_FromLong((long) AL_MONITOR_CTL);
|
|
if (x == NULL || PyDict_SetItemString(d, "MONITOR_CTL", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_MONITOR_OFF
|
|
x = PyInt_FromLong((long) AL_MONITOR_OFF);
|
|
if (x == NULL || PyDict_SetItemString(d, "MONITOR_OFF", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_MONITOR_ON
|
|
x = PyInt_FromLong((long) AL_MONITOR_ON);
|
|
if (x == NULL || PyDict_SetItemString(d, "MONITOR_ON", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_MONO
|
|
x = PyInt_FromLong((long) AL_MONO);
|
|
if (x == NULL || PyDict_SetItemString(d, "MONO", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_MUTE
|
|
x = PyInt_FromLong((long) AL_MUTE);
|
|
if (x == NULL || PyDict_SetItemString(d, "MUTE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_NAME
|
|
x = PyInt_FromLong((long) AL_NAME);
|
|
if (x == NULL || PyDict_SetItemString(d, "NAME", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_NEG_INFINITY
|
|
x = PyInt_FromLong((long) AL_NEG_INFINITY);
|
|
if (x == NULL || PyDict_SetItemString(d, "NEG_INFINITY", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_NEG_INFINITY_BIT
|
|
x = PyInt_FromLong((long) AL_NEG_INFINITY_BIT);
|
|
if (x == NULL || PyDict_SetItemString(d, "NEG_INFINITY_BIT", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_NO_CHANGE
|
|
x = PyInt_FromLong((long) AL_NO_CHANGE);
|
|
if (x == NULL || PyDict_SetItemString(d, "NO_CHANGE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_NO_CHANGE_BIT
|
|
x = PyInt_FromLong((long) AL_NO_CHANGE_BIT);
|
|
if (x == NULL || PyDict_SetItemString(d, "NO_CHANGE_BIT", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_NO_ELEM
|
|
x = PyInt_FromLong((long) AL_NO_ELEM);
|
|
if (x == NULL || PyDict_SetItemString(d, "NO_ELEM", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_NO_ERRORS
|
|
x = PyInt_FromLong((long) AL_NO_ERRORS);
|
|
if (x == NULL || PyDict_SetItemString(d, "NO_ERRORS", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_NO_OP
|
|
x = PyInt_FromLong((long) AL_NO_OP);
|
|
if (x == NULL || PyDict_SetItemString(d, "NO_OP", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_NO_VAL
|
|
x = PyInt_FromLong((long) AL_NO_VAL);
|
|
if (x == NULL || PyDict_SetItemString(d, "NO_VAL", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_NULL_RESOURCE
|
|
x = PyInt_FromLong((long) AL_NULL_RESOURCE);
|
|
if (x == NULL || PyDict_SetItemString(d, "NULL_RESOURCE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_OUTPUT_COUNT
|
|
x = PyInt_FromLong((long) AL_OUTPUT_COUNT);
|
|
if (x == NULL || PyDict_SetItemString(d, "OUTPUT_COUNT", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_OUTPUT_DEVICE_TYPE
|
|
x = PyInt_FromLong((long) AL_OUTPUT_DEVICE_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "OUTPUT_DEVICE_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_OUTPUT_HRB_TYPE
|
|
x = PyInt_FromLong((long) AL_OUTPUT_HRB_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "OUTPUT_HRB_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_OUTPUT_PORT_TYPE
|
|
x = PyInt_FromLong((long) AL_OUTPUT_PORT_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "OUTPUT_PORT_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_OUTPUT_RATE
|
|
x = PyInt_FromLong((long) AL_OUTPUT_RATE);
|
|
if (x == NULL || PyDict_SetItemString(d, "OUTPUT_RATE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_PARAM_BIT
|
|
x = PyInt_FromLong((long) AL_PARAM_BIT);
|
|
if (x == NULL || PyDict_SetItemString(d, "PARAM_BIT", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_PARAMS
|
|
x = PyInt_FromLong((long) AL_PARAMS);
|
|
if (x == NULL || PyDict_SetItemString(d, "PARAMS", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_PORT_COUNT
|
|
x = PyInt_FromLong((long) AL_PORT_COUNT);
|
|
if (x == NULL || PyDict_SetItemString(d, "PORT_COUNT", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_PORT_TYPE
|
|
x = PyInt_FromLong((long) AL_PORT_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "PORT_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_PORTS
|
|
x = PyInt_FromLong((long) AL_PORTS);
|
|
if (x == NULL || PyDict_SetItemString(d, "PORTS", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_PORTSTYLE_DIRECT
|
|
x = PyInt_FromLong((long) AL_PORTSTYLE_DIRECT);
|
|
if (x == NULL || PyDict_SetItemString(d, "PORTSTYLE_DIRECT", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_PORTSTYLE_SERIAL
|
|
x = PyInt_FromLong((long) AL_PORTSTYLE_SERIAL);
|
|
if (x == NULL || PyDict_SetItemString(d, "PORTSTYLE_SERIAL", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_PRINT_ERRORS
|
|
x = PyInt_FromLong((long) AL_PRINT_ERRORS);
|
|
if (x == NULL || PyDict_SetItemString(d, "PRINT_ERRORS", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_PTR_ELEM
|
|
x = PyInt_FromLong((long) AL_PTR_ELEM);
|
|
if (x == NULL || PyDict_SetItemString(d, "PTR_ELEM", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RANGE_VALUE
|
|
x = PyInt_FromLong((long) AL_RANGE_VALUE);
|
|
if (x == NULL || PyDict_SetItemString(d, "RANGE_VALUE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RATE
|
|
x = PyInt_FromLong((long) AL_RATE);
|
|
if (x == NULL || PyDict_SetItemString(d, "RATE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RATE_11025
|
|
x = PyInt_FromLong((long) AL_RATE_11025);
|
|
if (x == NULL || PyDict_SetItemString(d, "RATE_11025", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RATE_16000
|
|
x = PyInt_FromLong((long) AL_RATE_16000);
|
|
if (x == NULL || PyDict_SetItemString(d, "RATE_16000", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RATE_22050
|
|
x = PyInt_FromLong((long) AL_RATE_22050);
|
|
if (x == NULL || PyDict_SetItemString(d, "RATE_22050", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RATE_32000
|
|
x = PyInt_FromLong((long) AL_RATE_32000);
|
|
if (x == NULL || PyDict_SetItemString(d, "RATE_32000", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RATE_44100
|
|
x = PyInt_FromLong((long) AL_RATE_44100);
|
|
if (x == NULL || PyDict_SetItemString(d, "RATE_44100", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RATE_48000
|
|
x = PyInt_FromLong((long) AL_RATE_48000);
|
|
if (x == NULL || PyDict_SetItemString(d, "RATE_48000", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RATE_8000
|
|
x = PyInt_FromLong((long) AL_RATE_8000);
|
|
if (x == NULL || PyDict_SetItemString(d, "RATE_8000", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RATE_AES_1
|
|
x = PyInt_FromLong((long) AL_RATE_AES_1);
|
|
if (x == NULL || PyDict_SetItemString(d, "RATE_AES_1", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RATE_AES_1s
|
|
x = PyInt_FromLong((long) AL_RATE_AES_1s);
|
|
if (x == NULL || PyDict_SetItemString(d, "RATE_AES_1s", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RATE_AES_2
|
|
x = PyInt_FromLong((long) AL_RATE_AES_2);
|
|
if (x == NULL || PyDict_SetItemString(d, "RATE_AES_2", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RATE_AES_3
|
|
x = PyInt_FromLong((long) AL_RATE_AES_3);
|
|
if (x == NULL || PyDict_SetItemString(d, "RATE_AES_3", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RATE_AES_4
|
|
x = PyInt_FromLong((long) AL_RATE_AES_4);
|
|
if (x == NULL || PyDict_SetItemString(d, "RATE_AES_4", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RATE_AES_6
|
|
x = PyInt_FromLong((long) AL_RATE_AES_6);
|
|
if (x == NULL || PyDict_SetItemString(d, "RATE_AES_6", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RATE_FRACTION_D
|
|
x = PyInt_FromLong((long) AL_RATE_FRACTION_D);
|
|
if (x == NULL || PyDict_SetItemString(d, "RATE_FRACTION_D", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RATE_FRACTION_N
|
|
x = PyInt_FromLong((long) AL_RATE_FRACTION_N);
|
|
if (x == NULL || PyDict_SetItemString(d, "RATE_FRACTION_N", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RATE_INPUTRATE
|
|
x = PyInt_FromLong((long) AL_RATE_INPUTRATE);
|
|
if (x == NULL || PyDict_SetItemString(d, "RATE_INPUTRATE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RATE_NO_DIGITAL_INPUT
|
|
x = PyInt_FromLong((long) AL_RATE_NO_DIGITAL_INPUT);
|
|
if (x == NULL || PyDict_SetItemString(d, "RATE_NO_DIGITAL_INPUT", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RATE_UNACQUIRED
|
|
x = PyInt_FromLong((long) AL_RATE_UNACQUIRED);
|
|
if (x == NULL || PyDict_SetItemString(d, "RATE_UNACQUIRED", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RATE_UNDEFINED
|
|
x = PyInt_FromLong((long) AL_RATE_UNDEFINED);
|
|
if (x == NULL || PyDict_SetItemString(d, "RATE_UNDEFINED", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_REF_0DBV
|
|
x = PyInt_FromLong((long) AL_REF_0DBV);
|
|
if (x == NULL || PyDict_SetItemString(d, "REF_0DBV", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_REF_NONE
|
|
x = PyInt_FromLong((long) AL_REF_NONE);
|
|
if (x == NULL || PyDict_SetItemString(d, "REF_NONE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RESERVED1_TYPE
|
|
x = PyInt_FromLong((long) AL_RESERVED1_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "RESERVED1_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RESERVED2_TYPE
|
|
x = PyInt_FromLong((long) AL_RESERVED2_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "RESERVED2_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RESERVED3_TYPE
|
|
x = PyInt_FromLong((long) AL_RESERVED3_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "RESERVED3_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RESERVED4_TYPE
|
|
x = PyInt_FromLong((long) AL_RESERVED4_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "RESERVED4_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RESOURCE
|
|
x = PyInt_FromLong((long) AL_RESOURCE);
|
|
if (x == NULL || PyDict_SetItemString(d, "RESOURCE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RESOURCE_ELEM
|
|
x = PyInt_FromLong((long) AL_RESOURCE_ELEM);
|
|
if (x == NULL || PyDict_SetItemString(d, "RESOURCE_ELEM", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RESOURCE_TYPE
|
|
x = PyInt_FromLong((long) AL_RESOURCE_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "RESOURCE_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RIGHT_INPUT_ATTEN
|
|
x = PyInt_FromLong((long) AL_RIGHT_INPUT_ATTEN);
|
|
if (x == NULL || PyDict_SetItemString(d, "RIGHT_INPUT_ATTEN", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RIGHT_MONITOR_ATTEN
|
|
x = PyInt_FromLong((long) AL_RIGHT_MONITOR_ATTEN);
|
|
if (x == NULL || PyDict_SetItemString(d, "RIGHT_MONITOR_ATTEN", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RIGHT_SPEAKER_GAIN
|
|
x = PyInt_FromLong((long) AL_RIGHT_SPEAKER_GAIN);
|
|
if (x == NULL || PyDict_SetItemString(d, "RIGHT_SPEAKER_GAIN", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RIGHT1_INPUT_ATTEN
|
|
x = PyInt_FromLong((long) AL_RIGHT1_INPUT_ATTEN);
|
|
if (x == NULL || PyDict_SetItemString(d, "RIGHT1_INPUT_ATTEN", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_RIGHT2_INPUT_ATTEN
|
|
x = PyInt_FromLong((long) AL_RIGHT2_INPUT_ATTEN);
|
|
if (x == NULL || PyDict_SetItemString(d, "RIGHT2_INPUT_ATTEN", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_SAMPFMT_DOUBLE
|
|
x = PyInt_FromLong((long) AL_SAMPFMT_DOUBLE);
|
|
if (x == NULL || PyDict_SetItemString(d, "SAMPFMT_DOUBLE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_SAMPFMT_FLOAT
|
|
x = PyInt_FromLong((long) AL_SAMPFMT_FLOAT);
|
|
if (x == NULL || PyDict_SetItemString(d, "SAMPFMT_FLOAT", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_SAMPFMT_TWOSCOMP
|
|
x = PyInt_FromLong((long) AL_SAMPFMT_TWOSCOMP);
|
|
if (x == NULL || PyDict_SetItemString(d, "SAMPFMT_TWOSCOMP", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_SAMPLE_16
|
|
x = PyInt_FromLong((long) AL_SAMPLE_16);
|
|
if (x == NULL || PyDict_SetItemString(d, "SAMPLE_16", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_SAMPLE_24
|
|
x = PyInt_FromLong((long) AL_SAMPLE_24);
|
|
if (x == NULL || PyDict_SetItemString(d, "SAMPLE_24", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_SAMPLE_8
|
|
x = PyInt_FromLong((long) AL_SAMPLE_8);
|
|
if (x == NULL || PyDict_SetItemString(d, "SAMPLE_8", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_SCALAR_VAL
|
|
x = PyInt_FromLong((long) AL_SCALAR_VAL);
|
|
if (x == NULL || PyDict_SetItemString(d, "SCALAR_VAL", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_SET_VAL
|
|
x = PyInt_FromLong((long) AL_SET_VAL);
|
|
if (x == NULL || PyDict_SetItemString(d, "SET_VAL", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_SHORT_NAME
|
|
x = PyInt_FromLong((long) AL_SHORT_NAME);
|
|
if (x == NULL || PyDict_SetItemString(d, "SHORT_NAME", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_SOURCE
|
|
x = PyInt_FromLong((long) AL_SOURCE);
|
|
if (x == NULL || PyDict_SetItemString(d, "SOURCE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_SPEAKER_IF_TYPE
|
|
x = PyInt_FromLong((long) AL_SPEAKER_IF_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "SPEAKER_IF_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_SPEAKER_MUTE_CTL
|
|
x = PyInt_FromLong((long) AL_SPEAKER_MUTE_CTL);
|
|
if (x == NULL || PyDict_SetItemString(d, "SPEAKER_MUTE_CTL", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_SPEAKER_MUTE_OFF
|
|
x = PyInt_FromLong((long) AL_SPEAKER_MUTE_OFF);
|
|
if (x == NULL || PyDict_SetItemString(d, "SPEAKER_MUTE_OFF", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_SPEAKER_MUTE_ON
|
|
x = PyInt_FromLong((long) AL_SPEAKER_MUTE_ON);
|
|
if (x == NULL || PyDict_SetItemString(d, "SPEAKER_MUTE_ON", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_SPEAKER_PLUS_LINE_IF_TYPE
|
|
x = PyInt_FromLong((long) AL_SPEAKER_PLUS_LINE_IF_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "SPEAKER_PLUS_LINE_IF_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_STEREO
|
|
x = PyInt_FromLong((long) AL_STEREO);
|
|
if (x == NULL || PyDict_SetItemString(d, "STEREO", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_STRING_VAL
|
|
x = PyInt_FromLong((long) AL_STRING_VAL);
|
|
if (x == NULL || PyDict_SetItemString(d, "STRING_VAL", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_SUBSYSTEM
|
|
x = PyInt_FromLong((long) AL_SUBSYSTEM);
|
|
if (x == NULL || PyDict_SetItemString(d, "SUBSYSTEM", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_SUBSYSTEM_TYPE
|
|
x = PyInt_FromLong((long) AL_SUBSYSTEM_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "SUBSYSTEM_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_SYNC_INPUT_TO_AES
|
|
x = PyInt_FromLong((long) AL_SYNC_INPUT_TO_AES);
|
|
if (x == NULL || PyDict_SetItemString(d, "SYNC_INPUT_TO_AES", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_SYNC_OUTPUT_TO_AES
|
|
x = PyInt_FromLong((long) AL_SYNC_OUTPUT_TO_AES);
|
|
if (x == NULL || PyDict_SetItemString(d, "SYNC_OUTPUT_TO_AES", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_SYSTEM
|
|
x = PyInt_FromLong((long) AL_SYSTEM);
|
|
if (x == NULL || PyDict_SetItemString(d, "SYSTEM", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_SYSTEM_TYPE
|
|
x = PyInt_FromLong((long) AL_SYSTEM_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "SYSTEM_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_TEST_IF_TYPE
|
|
x = PyInt_FromLong((long) AL_TEST_IF_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "TEST_IF_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_TYPE
|
|
x = PyInt_FromLong((long) AL_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_TYPE_BIT
|
|
x = PyInt_FromLong((long) AL_TYPE_BIT);
|
|
if (x == NULL || PyDict_SetItemString(d, "TYPE_BIT", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_UNUSED_COUNT
|
|
x = PyInt_FromLong((long) AL_UNUSED_COUNT);
|
|
if (x == NULL || PyDict_SetItemString(d, "UNUSED_COUNT", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_UNUSED_PORTS
|
|
x = PyInt_FromLong((long) AL_UNUSED_PORTS);
|
|
if (x == NULL || PyDict_SetItemString(d, "UNUSED_PORTS", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_VARIABLE_MCLK_TYPE
|
|
x = PyInt_FromLong((long) AL_VARIABLE_MCLK_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "VARIABLE_MCLK_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_VECTOR_VAL
|
|
x = PyInt_FromLong((long) AL_VECTOR_VAL);
|
|
if (x == NULL || PyDict_SetItemString(d, "VECTOR_VAL", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_VIDEO_MCLK_TYPE
|
|
x = PyInt_FromLong((long) AL_VIDEO_MCLK_TYPE);
|
|
if (x == NULL || PyDict_SetItemString(d, "VIDEO_MCLK_TYPE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
#ifdef AL_WORDSIZE
|
|
x = PyInt_FromLong((long) AL_WORDSIZE);
|
|
if (x == NULL || PyDict_SetItemString(d, "WORDSIZE", x) < 0)
|
|
goto error;
|
|
Py_DECREF(x);
|
|
#endif
|
|
|
|
#ifdef AL_NO_ELEM /* IRIX 6 */
|
|
(void) alSetErrorHandler(ErrorHandler);
|
|
#endif /* AL_NO_ELEM */
|
|
#ifdef OLD_INTERFACE
|
|
(void) ALseterrorhandler(ErrorHandler);
|
|
#endif /* OLD_INTERFACE */
|
|
|
|
/* Check for errors */
|
|
if (PyErr_Occurred()) {
|
|
error:
|
|
Py_FatalError("can't initialize module al");
|
|
}
|
|
}
|