1 

     2 #define OLD_INTERFACE		/* define for pre-Irix 6 interface */

     3 

     4 #include "Python.h"

     5 #include "stringobject.h"

     6 #include <audio.h>

     7 #include <stdarg.h>

     8 

     9 #ifndef AL_NO_ELEM

    10 #ifndef OLD_INTERFACE

    11 #define OLD_INTERFACE

    12 #endif /* OLD_INTERFACE */

    13 #endif /* AL_NO_ELEM */

    14 

    15 static PyObject *ErrorObject;

    16 

    17 /* ----------------------------------------------------- */

    18 

    19 /* Declarations for objects of type port */

    20 

    21 typedef struct {

    22 	PyObject_HEAD

    23 	/* XXXX Add your own stuff here */

    24 	ALport port;

    25 } alpobject;

    26 

    27 static PyTypeObject Alptype;

    28 

    29 

    30 

    31 /* ---------------------------------------------------------------- */

    32 

    33 /* Declarations for objects of type config */

    34 

    35 typedef struct {

    36 	PyObject_HEAD

    37 	/* XXXX Add your own stuff here */

    38 	ALconfig config;

    39 } alcobject;

    40 

    41 static PyTypeObject Alctype;

    42 

    43 

    44 static void

    45 ErrorHandler(long code, const char *fmt, ...)

    46 {

    47 	va_list args;

    48 	char buf[128];

    49 

    50 	va_start(args, fmt);

    51 	vsprintf(buf, fmt, args);

    52 	va_end(args);

    53 	PyErr_SetString(ErrorObject, buf);

    54 }

    55 

    56 #ifdef AL_NO_ELEM		/* IRIX 6 */

    57 

    58 static PyObject *

    59 param2python(int resource, int param, ALvalue value, ALparamInfo *pinfo)

    60 {

    61 	ALparamInfo info;

    62 

    63 	if (pinfo == NULL) {

    64 		pinfo = &info;

    65 		if (alGetParamInfo(resource, param, &info) < 0)

    66 			return NULL;

    67 	}

    68 	switch (pinfo->elementType) {

    69 	case AL_PTR_ELEM:

    70 		/* XXXX don't know how to handle this */

    71 	case AL_NO_ELEM:

    72 		Py_INCREF(Py_None);

    73 		return Py_None;

    74 	case AL_INT32_ELEM:

    75 	case AL_RESOURCE_ELEM:

    76 	case AL_ENUM_ELEM:

    77 		return PyInt_FromLong((long) value.i);

    78 	case AL_INT64_ELEM:

    79 		return PyLong_FromLongLong(value.ll);

    80 	case AL_FIXED_ELEM:

    81 		return PyFloat_FromDouble(alFixedToDouble(value.ll));

    82 	case AL_CHAR_ELEM:

    83 		if (value.ptr == NULL) {

    84 			Py_INCREF(Py_None);

    85 			return Py_None;

    86 		}

    87 		return PyString_FromString((char *) value.ptr);

    88 	default:

    89 		PyErr_SetString(ErrorObject, "unknown element type");

    90 		return NULL;

    91 	}

    92 }

    93 

    94 static int

    95 python2elem(PyObject *item, void *ptr, int elementType)

    96 {

    97 	switch (elementType) {

    98 	case AL_INT32_ELEM:

    99 	case AL_RESOURCE_ELEM:

   100 	case AL_ENUM_ELEM:

   101 		if (!PyInt_Check(item)) {

   102 			PyErr_BadArgument();

   103 			return -1;

   104 		}

   105 		*((int *) ptr) = PyInt_AsLong(item);

   106 		break;

   107 	case AL_INT64_ELEM:

   108 		if (PyInt_Check(item))

   109 			*((long long *) ptr) = PyInt_AsLong(item);

   110 		else if (PyLong_Check(item))

   111 			*((long long *) ptr) = PyLong_AsLongLong(item);

   112 		else {

   113 			PyErr_BadArgument();

   114 			return -1;

   115 		}

   116 		break;

   117 	case AL_FIXED_ELEM:

   118 		if (PyInt_Check(item))

   119 			*((long long *) ptr) = alDoubleToFixed((double) PyInt_AsLong(item));

   120 		else if (PyFloat_Check(item))

   121 			*((long long *) ptr) = alDoubleToFixed(PyFloat_AsDouble(item));

   122 		else {

   123 			PyErr_BadArgument();

   124 			return -1;

   125 		}

   126 		break;

   127 	default:

   128 		PyErr_SetString(ErrorObject, "unknown element type");

   129 		return -1;

   130 	}

   131 	return 0;

   132 }

   133 

   134 static int

   135 python2param(int resource, ALpv *param, PyObject *value, ALparamInfo *pinfo)

   136 {

   137 	ALparamInfo info;

   138 	int i, stepsize;

   139 	PyObject *item;

   140 

   141 	if (pinfo == NULL) {

   142 		pinfo = &info;

   143 		if (alGetParamInfo(resource, param->param, &info) < 0)

   144 			return -1;

   145 	}

   146 	switch (pinfo->valueType) {

   147 	case AL_STRING_VAL:

   148 		if (pinfo->elementType != AL_CHAR_ELEM) {

   149 			PyErr_SetString(ErrorObject, "unknown element type");

   150 			return -1;

   151 		}

   152 		if (!PyString_Check(value)) {

   153 			PyErr_BadArgument();

   154 			return -1;

   155 		}

   156 		param->value.ptr = PyString_AS_STRING(value);

   157 		param->sizeIn = PyString_GET_SIZE(value)+1; /*account for NUL*/

   158 		break;

   159 	case AL_SET_VAL:

   160 	case AL_VECTOR_VAL:

   161 		if (!PyList_Check(value) && !PyTuple_Check(value)) {

   162 			PyErr_BadArgument();

   163 			return -1;

   164 		}

   165 		switch (pinfo->elementType) {

   166 		case AL_INT32_ELEM:

   167 		case AL_RESOURCE_ELEM:

   168 		case AL_ENUM_ELEM:

   169 			param->sizeIn = PySequence_Size(value);

   170 			param->value.ptr = PyMem_NEW(int, param->sizeIn);

   171 			stepsize = sizeof(int);

   172 			break;

   173 		case AL_INT64_ELEM:

   174 		case AL_FIXED_ELEM:

   175 			param->sizeIn = PySequence_Size(value);

   176 			param->value.ptr = PyMem_NEW(long long, param->sizeIn);

   177 			stepsize = sizeof(long long);

   178 			break;

   179 		}

   180 		for (i = 0; i < param->sizeIn; i++) {

   181 			item = PySequence_GetItem(value, i);

   182 			if (python2elem(item, (void *) ((char *) param->value.ptr + i*stepsize), pinfo->elementType) < 0) {

   183 				PyMem_DEL(param->value.ptr);

   184 				return -1;

   185 			}

   186 		}

   187 		break;

   188 	case AL_SCALAR_VAL:

   189 		switch (pinfo->elementType) {

   190 		case AL_INT32_ELEM:

   191 		case AL_RESOURCE_ELEM:

   192 		case AL_ENUM_ELEM:

   193 			return python2elem(value, (void *) &param->value.i,

   194 					   pinfo->elementType);

   195 		case AL_INT64_ELEM:

   196 		case AL_FIXED_ELEM:

   197 			return python2elem(value, (void *) &param->value.ll,

   198 					   pinfo->elementType);

   199 		default:

   200 			PyErr_SetString(ErrorObject, "unknown element type");

   201 			return -1;

   202 		}

   203 	}

   204 	return 0;

   205 }

   206 

   207 static int

   208 python2params(int resource1, int resource2, PyObject *list, ALpv **pvsp, ALparamInfo **pinfop)

   209 {

   210 	PyObject *item;

   211 	ALpv *pvs;

   212 	ALparamInfo *pinfo;

   213 	int npvs, i;

   214 

   215 	npvs = PyList_Size(list);

   216 	pvs = PyMem_NEW(ALpv, npvs);

   217 	pinfo = PyMem_NEW(ALparamInfo, npvs);

   218 	for (i = 0; i < npvs; i++) {

   219 		item = PyList_GetItem(list, i);

   220 		if (!PyArg_ParseTuple(item, "iO", &pvs[i].param, &item))

   221 			goto error;

   222 		if (alGetParamInfo(resource1, pvs[i].param, &pinfo[i]) < 0 &&

   223 		    alGetParamInfo(resource2, pvs[i].param, &pinfo[i]) < 0)

   224 			goto error;

   225 		if (python2param(resource1, &pvs[i], item, &pinfo[i]) < 0)

   226 			goto error;

   227 	}

   228 

   229 	*pvsp = pvs;

   230 	*pinfop = pinfo;

   231 	return npvs;

   232 

   233   error:

   234 	/* XXXX we should clean up everything */

   235 	if (pvs)

   236 		PyMem_DEL(pvs);

   237 	if (pinfo)

   238 		PyMem_DEL(pinfo);

   239 	return -1;

   240 }

   241 

   242 /* -------------------------------------------------------- */

   243 

   244 

   245 static PyObject *

   246 SetConfig(alcobject *self, PyObject *args, int (*func)(ALconfig, int))

   247 {

   248 	int par;

   249 

   250 	if (!PyArg_ParseTuple(args, "i:SetConfig", &par))

   251 		return NULL;

   252 

   253 	if ((*func)(self->config, par) == -1)

   254 		return NULL;

   255 

   256 	Py_INCREF(Py_None);

   257 	return Py_None;

   258 }

   259 

   260 static PyObject *

   261 GetConfig(alcobject *self, PyObject *args, int (*func)(ALconfig))

   262 {	

   263 	int par;

   264 

   265 	if (!PyArg_ParseTuple(args, ":GetConfig"))

   266 		return NULL;

   267 	

   268 	if ((par = (*func)(self->config)) == -1)

   269 		return NULL;

   270 

   271 	return PyInt_FromLong((long) par);

   272 }

   273 

   274 PyDoc_STRVAR(alc_SetWidth__doc__,

   275 "alSetWidth: set the wordsize for integer audio data.");

   276 

   277 static PyObject *

   278 alc_SetWidth(alcobject *self, PyObject *args)

   279 {

   280 	return SetConfig(self, args, alSetWidth);

   281 }

   282 

   283 

   284 PyDoc_STRVAR(alc_GetWidth__doc__,

   285 "alGetWidth: get the wordsize for integer audio data.");

   286 

   287 static PyObject *

   288 alc_GetWidth(alcobject *self, PyObject *args)

   289 {

   290 	return GetConfig(self, args, alGetWidth);

   291 }

   292 

   293 

   294 PyDoc_STRVAR(alc_SetSampFmt__doc__,

   295 "alSetSampFmt: set the sample format setting in an audio ALconfig "

   296 "structure.");

   297 

   298 static PyObject *

   299 alc_SetSampFmt(alcobject *self, PyObject *args)

   300 {

   301 	return SetConfig(self, args, alSetSampFmt);

   302 }

   303 

   304 

   305 PyDoc_STRVAR(alc_GetSampFmt__doc__,

   306 "alGetSampFmt: get the sample format setting in an audio ALconfig "

   307 "structure.");

   308 

   309 static PyObject *

   310 alc_GetSampFmt(alcobject *self, PyObject *args)

   311 {

   312 	return GetConfig(self, args, alGetSampFmt);

   313 }

   314 

   315 

   316 PyDoc_STRVAR(alc_SetChannels__doc__,

   317 "alSetChannels: set the channel settings in an audio ALconfig.");

   318 

   319 static PyObject *

   320 alc_SetChannels(alcobject *self, PyObject *args)

   321 {

   322 	return SetConfig(self, args, alSetChannels);

   323 }

   324 

   325 

   326 PyDoc_STRVAR(alc_GetChannels__doc__,

   327 "alGetChannels: get the channel settings in an audio ALconfig.");

   328 

   329 static PyObject *

   330 alc_GetChannels(alcobject *self, PyObject *args)

   331 {

   332 	return GetConfig(self, args, alGetChannels);

   333 }

   334 

   335 

   336 PyDoc_STRVAR(alc_SetFloatMax__doc__,

   337 "alSetFloatMax: set the maximum value of floating point sample data.");

   338 

   339 static PyObject *

   340 alc_SetFloatMax(alcobject *self, PyObject *args)

   341 {

   342 	double maximum_value;

   343 

   344 	if (!PyArg_ParseTuple(args, "d:SetFloatMax", &maximum_value))

   345 		return NULL;

   346 	if (alSetFloatMax(self->config, maximum_value) < 0)

   347 		return NULL;

   348 	Py_INCREF(Py_None);

   349 	return Py_None;

   350 }

   351 

   352 

   353 PyDoc_STRVAR(alc_GetFloatMax__doc__,

   354 "alGetFloatMax: get the maximum value of floating point sample data.");

   355 

   356 static PyObject *

   357 alc_GetFloatMax(alcobject *self, PyObject *args)

   358 {

   359 	double maximum_value;

   360 

   361 	if (!PyArg_ParseTuple(args, ":GetFloatMax"))

   362 		return NULL;

   363 	if ((maximum_value = alGetFloatMax(self->config)) == 0)

   364 		return NULL;

   365 	return PyFloat_FromDouble(maximum_value);

   366 }

   367 

   368 

   369 PyDoc_STRVAR(alc_SetDevice__doc__,

   370 "alSetDevice: set the device setting in an audio ALconfig structure.");

   371 

   372 static PyObject *

   373 alc_SetDevice(alcobject *self, PyObject *args)

   374 {

   375 	return SetConfig(self, args, alSetDevice);

   376 }

   377 

   378 

   379 PyDoc_STRVAR(alc_GetDevice__doc__,

   380 "alGetDevice: get the device setting in an audio ALconfig structure.");

   381 

   382 static PyObject *

   383 alc_GetDevice(alcobject *self, PyObject *args)

   384 {

   385 	return GetConfig(self, args, alGetDevice);

   386 }

   387 

   388 

   389 PyDoc_STRVAR(alc_SetQueueSize__doc__,

   390 "alSetQueueSize: set audio port buffer size.");

   391 

   392 static PyObject *

   393 alc_SetQueueSize(alcobject *self, PyObject *args)

   394 {

   395 	return SetConfig(self, args, alSetQueueSize);

   396 }

   397 

   398 

   399 PyDoc_STRVAR(alc_GetQueueSize__doc__,

   400 "alGetQueueSize: get audio port buffer size.");

   401 

   402 static PyObject *

   403 alc_GetQueueSize(alcobject *self, PyObject *args)

   404 {

   405 	return GetConfig(self, args, alGetQueueSize);

   406 }

   407 

   408 #endif /* AL_NO_ELEM */

   409 

   410 static PyObject *

   411 setconfig(alcobject *self, PyObject *args, int (*func)(ALconfig, long))

   412 {

   413 	long par;

   414 

   415 	if (!PyArg_ParseTuple(args, "l:SetConfig", &par))

   416 		return NULL;

   417 

   418 	if ((*func)(self->config, par) == -1)

   419 		return NULL;

   420 

   421 	Py_INCREF(Py_None);

   422 	return Py_None;

   423 }

   424 

   425 static PyObject *

   426 getconfig(alcobject *self, PyObject *args, long (*func)(ALconfig))

   427 {	

   428 	long par;

   429 

   430 	if (!PyArg_ParseTuple(args, ":GetConfig"))

   431 		return NULL;

   432 	

   433 	if ((par = (*func)(self->config)) == -1)

   434 		return NULL;

   435 

   436 	return PyInt_FromLong((long) par);

   437 }

   438 

   439 static PyObject *

   440 alc_setqueuesize (alcobject *self, PyObject *args)

   441 {

   442 	return setconfig(self, args, ALsetqueuesize);

   443 }

   444 

   445 static PyObject *

   446 alc_getqueuesize (alcobject *self, PyObject *args)

   447 {

   448 	return getconfig(self, args, ALgetqueuesize);

   449 }

   450 

   451 static PyObject *

   452 alc_setwidth (alcobject *self, PyObject *args)

   453 {

   454 	return setconfig(self, args, ALsetwidth);

   455 }

   456 

   457 static PyObject *

   458 alc_getwidth (alcobject *self, PyObject *args)

   459 {

   460 	return getconfig(self, args, ALgetwidth);	

   461 }

   462 

   463 static PyObject *

   464 alc_getchannels (alcobject *self, PyObject *args)

   465 {

   466 	return getconfig(self, args, ALgetchannels);	

   467 }

   468 

   469 static PyObject *

   470 alc_setchannels (alcobject *self, PyObject *args)

   471 {

   472 	return setconfig(self, args, ALsetchannels);

   473 }

   474 

   475 #ifdef AL_405

   476 

   477 static PyObject *

   478 alc_getsampfmt (alcobject *self, PyObject *args)

   479 {

   480 	return getconfig(self, args, ALgetsampfmt);	

   481 }

   482 

   483 static PyObject *

   484 alc_setsampfmt (alcobject *self, PyObject *args)

   485 {

   486 	return setconfig(self, args, ALsetsampfmt);

   487 }

   488 

   489 static PyObject *

   490 alc_getfloatmax(alcobject *self, PyObject *args)

   491 {

   492 	double arg;

   493 

   494 	if (!PyArg_ParseTuple(args, ":GetFloatMax"))

   495 		return 0;

   496 	if ((arg = ALgetfloatmax(self->config)) == 0)

   497 		return NULL;

   498 	return PyFloat_FromDouble(arg);

   499 }

   500 

   501 static PyObject *

   502 alc_setfloatmax(alcobject *self, PyObject *args)

   503 {

   504 	double arg;

   505 

   506 	if (!PyArg_ParseTuple(args, "d:SetFloatMax", &arg))

   507 		return 0;

   508 	if (ALsetfloatmax(self->config, arg) == -1)

   509 		return NULL;

   510 	Py_INCREF(Py_None);

   511 	return Py_None;

   512 }

   513 #endif /* AL_405 */

   514 	

   515 static struct PyMethodDef alc_methods[] = {

   516 #ifdef AL_NO_ELEM		/* IRIX 6 */

   517 	{"SetWidth",	(PyCFunction)alc_SetWidth,	METH_VARARGS,	alc_SetWidth__doc__},

   518 	{"GetWidth",	(PyCFunction)alc_GetWidth,	METH_VARARGS,	alc_GetWidth__doc__},

   519 	{"SetSampFmt",	(PyCFunction)alc_SetSampFmt,	METH_VARARGS,	alc_SetSampFmt__doc__},

   520 	{"GetSampFmt",	(PyCFunction)alc_GetSampFmt,	METH_VARARGS,	alc_GetSampFmt__doc__},

   521 	{"SetChannels",	(PyCFunction)alc_SetChannels,	METH_VARARGS,	alc_SetChannels__doc__},

   522 	{"GetChannels",	(PyCFunction)alc_GetChannels,	METH_VARARGS,	alc_GetChannels__doc__},

   523 	{"SetFloatMax",	(PyCFunction)alc_SetFloatMax,	METH_VARARGS,	alc_SetFloatMax__doc__},

   524 	{"GetFloatMax",	(PyCFunction)alc_GetFloatMax,	METH_VARARGS,	alc_GetFloatMax__doc__},

   525 	{"SetDevice",	(PyCFunction)alc_SetDevice,	METH_VARARGS,	alc_SetDevice__doc__},

   526 	{"GetDevice",	(PyCFunction)alc_GetDevice,	METH_VARARGS,	alc_GetDevice__doc__},

   527 	{"SetQueueSize",	(PyCFunction)alc_SetQueueSize,	METH_VARARGS,	alc_SetQueueSize__doc__},

   528 	{"GetQueueSize",	(PyCFunction)alc_GetQueueSize,	METH_VARARGS,	alc_GetQueueSize__doc__},

   529 #endif /* AL_NO_ELEM */

   530 	{"getqueuesize",	(PyCFunction)alc_getqueuesize,	METH_VARARGS},

   531 	{"setqueuesize",	(PyCFunction)alc_setqueuesize,	METH_VARARGS},

   532 	{"getwidth",		(PyCFunction)alc_getwidth,	METH_VARARGS},

   533 	{"setwidth",		(PyCFunction)alc_setwidth,	METH_VARARGS},

   534 	{"getchannels",		(PyCFunction)alc_getchannels,	METH_VARARGS},

   535 	{"setchannels",		(PyCFunction)alc_setchannels,	METH_VARARGS},

   536 #ifdef AL_405

   537 	{"getsampfmt",		(PyCFunction)alc_getsampfmt,	METH_VARARGS},

   538 	{"setsampfmt",		(PyCFunction)alc_setsampfmt,	METH_VARARGS},

   539 	{"getfloatmax",		(PyCFunction)alc_getfloatmax,	METH_VARARGS},

   540 	{"setfloatmax",		(PyCFunction)alc_setfloatmax,	METH_VARARGS},

   541 #endif /* AL_405 */

   542 

   543 	{NULL,		NULL}		/* sentinel */

   544 };

   545 

   546 /* ---------- */

   547 

   548 

   549 static PyObject *

   550 newalcobject(ALconfig config)

   551 {

   552 	alcobject *self;

   553 	

   554 	self = PyObject_New(alcobject, &Alctype);

   555 	if (self == NULL)

   556 		return NULL;

   557 	/* XXXX Add your own initializers here */

   558 	self->config = config;

   559 	return (PyObject *) self;

   560 }

   561 

   562 

   563 static void

   564 alc_dealloc(alcobject *self)

   565 {

   566 	/* XXXX Add your own cleanup code here */

   567 #ifdef AL_NO_ELEM		/* IRIX 6 */

   568 	(void) alFreeConfig(self->config);	/* ignore errors */

   569 #else

   570 	(void) ALfreeconfig(self->config);	/* ignore errors */

   571 #endif

   572 	PyObject_Del(self);

   573 }

   574 

   575 static PyObject *

   576 alc_getattr(alcobject *self, char *name)

   577 {

   578 	/* XXXX Add your own getattr code here */

   579 	return Py_FindMethod(alc_methods, (PyObject *)self, name);

   580 }

   581 

   582 PyDoc_STRVAR(Alctype__doc__, "");

   583 

   584 static PyTypeObject Alctype = {

   585 	PyObject_HEAD_INIT(&PyType_Type)

   586 	0,				/*ob_size*/

   587 	"al.config",			/*tp_name*/

   588 	sizeof(alcobject),		/*tp_basicsize*/

   589 	0,				/*tp_itemsize*/

   590 	/* methods */

   591 	(destructor)alc_dealloc,	/*tp_dealloc*/

   592 	(printfunc)0,		/*tp_print*/

   593 	(getattrfunc)alc_getattr,	/*tp_getattr*/

   594 	(setattrfunc)0,	/*tp_setattr*/

   595 	(cmpfunc)0,		/*tp_compare*/

   596 	(reprfunc)0,		/*tp_repr*/

   597 	0,			/*tp_as_number*/

   598 	0,		/*tp_as_sequence*/

   599 	0,		/*tp_as_mapping*/

   600 	(hashfunc)0,		/*tp_hash*/

   601 	(ternaryfunc)0,		/*tp_call*/

   602 	(reprfunc)0,		/*tp_str*/

   603 

   604 	/* Space for future expansion */

   605 	0L,0L,0L,0L,

   606 	Alctype__doc__ /* Documentation string */

   607 };

   608 

   609 /* End of code for config objects */

   610 /* ---------------------------------------------------------------- */

   611 

   612 #ifdef AL_NO_ELEM		/* IRIX 6 */

   613 

   614 PyDoc_STRVAR(alp_SetConfig__doc__,

   615 "alSetConfig: set the ALconfig of an audio ALport.");

   616 

   617 static PyObject *

   618 alp_SetConfig(alpobject *self, PyObject *args)

   619 {

   620 	alcobject *config;

   621 	if (!PyArg_ParseTuple(args, "O!:SetConfig", &Alctype, &config))

   622 		return NULL;

   623 	if (alSetConfig(self->port, config->config) < 0)

   624 		return NULL;

   625 	Py_INCREF(Py_None);

   626 	return Py_None;

   627 }

   628 

   629 

   630 PyDoc_STRVAR(alp_GetConfig__doc__,

   631 "alGetConfig: get the ALconfig of an audio ALport.");

   632 

   633 static PyObject *

   634 alp_GetConfig(alpobject *self, PyObject *args)

   635 {

   636 	ALconfig config;

   637 	if (!PyArg_ParseTuple(args, ":GetConfig"))

   638 		return NULL;

   639 	if ((config = alGetConfig(self->port)) == NULL)

   640 		return NULL;

   641 	return newalcobject(config);

   642 }

   643 

   644 

   645 PyDoc_STRVAR(alp_GetResource__doc__,

   646 "alGetResource: get the resource associated with an audio port.");

   647 

   648 static PyObject *

   649 alp_GetResource(alpobject *self, PyObject *args)

   650 {

   651 	int resource;

   652 

   653 	if (!PyArg_ParseTuple(args, ":GetResource"))

   654 		return NULL;

   655 	if ((resource = alGetResource(self->port)) == 0)

   656 		return NULL;

   657 	return PyInt_FromLong((long) resource);

   658 }

   659 

   660 

   661 PyDoc_STRVAR(alp_GetFD__doc__,

   662 "alGetFD: get the file descriptor for an audio port.");

   663 

   664 static PyObject *

   665 alp_GetFD(alpobject *self, PyObject *args)

   666 {

   667 	int fd;

   668 

   669 	if (!PyArg_ParseTuple(args, ":GetFD"))

   670 		return NULL;

   671 

   672 	if ((fd = alGetFD(self->port)) < 0)

   673 		return NULL;

   674 

   675 	return PyInt_FromLong((long) fd);

   676 }

   677 

   678 

   679 PyDoc_STRVAR(alp_GetFilled__doc__,

   680 "alGetFilled: return the number of filled sample frames in "

   681 "an audio port.");

   682 

   683 static PyObject *

   684 alp_GetFilled(alpobject *self, PyObject *args)

   685 {

   686 	int filled;

   687 

   688 	if (!PyArg_ParseTuple(args, ":GetFilled"))

   689 		return NULL;

   690 	if ((filled = alGetFilled(self->port)) < 0)

   691 		return NULL;

   692 	return PyInt_FromLong((long) filled);

   693 }

   694 

   695 

   696 PyDoc_STRVAR(alp_GetFillable__doc__,

   697 "alGetFillable: report the number of unfilled sample frames "

   698 "in an audio port.");

   699 

   700 static PyObject *

   701 alp_GetFillable(alpobject *self, PyObject *args)

   702 {

   703 	int fillable;

   704 

   705 	if (!PyArg_ParseTuple(args, ":GetFillable"))

   706 		return NULL;

   707 	if ((fillable = alGetFillable(self->port)) < 0)

   708 		return NULL;

   709 	return PyInt_FromLong((long) fillable);

   710 }

   711 

   712 

   713 PyDoc_STRVAR(alp_ReadFrames__doc__,

   714 "alReadFrames: read sample frames from an audio port.");

   715 

   716 static PyObject *

   717 alp_ReadFrames(alpobject *self, PyObject *args)

   718 {

   719 	int framecount;

   720 	PyObject *v;

   721 	int size;

   722 	int ch;

   723 	ALconfig c;

   724 

   725 	if (!PyArg_ParseTuple(args, "i:ReadFrames", &framecount))

   726 		return NULL;

   727 	if (framecount < 0) {

   728 		PyErr_SetString(ErrorObject, "negative framecount");

   729 		return NULL;

   730 	}

   731 	c = alGetConfig(self->port);

   732 	switch (alGetSampFmt(c)) {

   733 	case AL_SAMPFMT_TWOSCOMP:

   734 		switch (alGetWidth(c)) {

   735 		case AL_SAMPLE_8:

   736 			size = 1;

   737 			break;

   738 		case AL_SAMPLE_16:

   739 			size = 2;

   740 			break;

   741 		case AL_SAMPLE_24:

   742 			size = 4;

   743 			break;

   744 		default:

   745 			PyErr_SetString(ErrorObject, "can't determine width");

   746 			alFreeConfig(c);

   747 			return NULL;

   748 		}

   749 		break;

   750 	case AL_SAMPFMT_FLOAT:

   751 		size = 4;

   752 		break;

   753 	case AL_SAMPFMT_DOUBLE:

   754 		size = 8;

   755 		break;

   756 	default:

   757 		PyErr_SetString(ErrorObject, "can't determine format");

   758 		alFreeConfig(c);

   759 		return NULL;

   760 	}

   761 	ch = alGetChannels(c);

   762 	alFreeConfig(c);

   763 	if (ch < 0) {

   764 		PyErr_SetString(ErrorObject, "can't determine # of channels");

   765 		return NULL;

   766 	}

   767 	size *= ch;

   768 	v = PyString_FromStringAndSize((char *) NULL, size * framecount);

   769 	if (v == NULL)

   770 		return NULL;

   771 

   772 	Py_BEGIN_ALLOW_THREADS

   773 	alReadFrames(self->port, (void *) PyString_AS_STRING(v), framecount);

   774 	Py_END_ALLOW_THREADS

   775 

   776 	return v;

   777 }

   778 

   779 

   780 PyDoc_STRVAR(alp_DiscardFrames__doc__,

   781 "alDiscardFrames: discard audio from an audio port.");

   782 

   783 static PyObject *

   784 alp_DiscardFrames(alpobject *self, PyObject *args)

   785 {

   786 	int framecount;

   787 

   788 	if (!PyArg_ParseTuple(args, "i:DiscardFrames", &framecount))

   789 		return NULL;

   790 

   791 	Py_BEGIN_ALLOW_THREADS

   792 	framecount = alDiscardFrames(self->port, framecount);

   793 	Py_END_ALLOW_THREADS

   794 

   795 	if (framecount < 0)

   796 		return NULL;

   797 

   798 	return PyInt_FromLong((long) framecount);

   799 }

   800 

   801 

   802 PyDoc_STRVAR(alp_ZeroFrames__doc__,

   803 "alZeroFrames: write zero-valued sample frames to an audio port.");

   804 

   805 static PyObject *

   806 alp_ZeroFrames(alpobject *self, PyObject *args)

   807 {

   808 	int framecount;

   809 

   810 	if (!PyArg_ParseTuple(args, "i:ZeroFrames", &framecount))

   811 		return NULL;

   812 

   813 	if (framecount < 0) {

   814 		PyErr_SetString(ErrorObject, "negative framecount");

   815 		return NULL;

   816 	}

   817 

   818 	Py_BEGIN_ALLOW_THREADS

   819 	alZeroFrames(self->port, framecount);

   820 	Py_END_ALLOW_THREADS

   821 

   822 	Py_INCREF(Py_None);

   823 	return Py_None;

   824 }

   825 

   826 

   827 PyDoc_STRVAR(alp_SetFillPoint__doc__,

   828 "alSetFillPoint: set low- or high-water mark for an audio port.");

   829 

   830 static PyObject *

   831 alp_SetFillPoint(alpobject *self, PyObject *args)

   832 {

   833 	int fillpoint;

   834 

   835 	if (!PyArg_ParseTuple(args, "i:SetFillPoint", &fillpoint))

   836 		return NULL;

   837 

   838 	if (alSetFillPoint(self->port, fillpoint) < 0)

   839 		return NULL;

   840 

   841 	Py_INCREF(Py_None);

   842 	return Py_None;

   843 }

   844 

   845 

   846 PyDoc_STRVAR(alp_GetFillPoint__doc__,

   847 "alGetFillPoint: get low- or high-water mark for an audio port.");

   848 

   849 static PyObject *

   850 alp_GetFillPoint(alpobject *self, PyObject *args)

   851 {

   852 	int fillpoint;

   853 

   854 	if (!PyArg_ParseTuple(args, ":GetFillPoint"))

   855 		return NULL;

   856 

   857 	if ((fillpoint = alGetFillPoint(self->port)) < 0)

   858 		return NULL;

   859 

   860 	return PyInt_FromLong((long) fillpoint);

   861 }

   862 

   863 

   864 PyDoc_STRVAR(alp_GetFrameNumber__doc__,

   865 "alGetFrameNumber: get the absolute sample frame number "

   866 "associated with a port.");

   867 

   868 static PyObject *

   869 alp_GetFrameNumber(alpobject *self, PyObject *args)

   870 {

   871 	stamp_t fnum;

   872 

   873 	if (!PyArg_ParseTuple(args, ":GetFrameNumber"))

   874 		return NULL;

   875 

   876 	if (alGetFrameNumber(self->port, &fnum) < 0)

   877 		return NULL;

   878 

   879 	return PyLong_FromLongLong((long long) fnum);

   880 }

   881 

   882 

   883 PyDoc_STRVAR(alp_GetFrameTime__doc__,

   884 "alGetFrameTime: get the time at which a sample frame came "

   885 "in or will go out.");

   886 

   887 static PyObject *

   888 alp_GetFrameTime(alpobject *self, PyObject *args)

   889 {

   890 	stamp_t fnum, time;

   891 	PyObject *ret, *v0, *v1;

   892 

   893 	if (!PyArg_ParseTuple(args, ":GetFrameTime"))

   894 		return NULL;

   895 	if (alGetFrameTime(self->port, &fnum, &time) < 0)

   896 		return NULL;

   897 	v0 = PyLong_FromLongLong((long long) fnum);

   898 	v1 = PyLong_FromLongLong((long long) time);

   899 	if (PyErr_Occurred()) {

   900 		Py_XDECREF(v0);

   901 		Py_XDECREF(v1);

   902 		return NULL;

   903 	}

   904 	ret = PyTuple_Pack(2, v0, v1);

   905 	Py_DECREF(v0);

   906 	Py_DECREF(v1);

   907 	return ret;

   908 }

   909 

   910 

   911 PyDoc_STRVAR(alp_WriteFrames__doc__,

   912 "alWriteFrames: write sample frames to an audio port.");

   913 

   914 static PyObject *

   915 alp_WriteFrames(alpobject *self, PyObject *args)

   916 {

   917 	char *samples;

   918 	int length;

   919 	int size, ch;

   920 	ALconfig c;

   921 

   922 	if (!PyArg_ParseTuple(args, "s#:WriteFrames", &samples, &length))

   923 		return NULL;

   924 	c = alGetConfig(self->port);

   925 	switch (alGetSampFmt(c)) {

   926 	case AL_SAMPFMT_TWOSCOMP:

   927 		switch (alGetWidth(c)) {

   928 		case AL_SAMPLE_8:

   929 			size = 1;

   930 			break;

   931 		case AL_SAMPLE_16:

   932 			size = 2;

   933 			break;

   934 		case AL_SAMPLE_24:

   935 			size = 4;

   936 			break;

   937 		default:

   938 			PyErr_SetString(ErrorObject, "can't determine width");

   939 			alFreeConfig(c);

   940 			return NULL;

   941 		}

   942 		break;

   943 	case AL_SAMPFMT_FLOAT:

   944 		size = 4;

   945 		break;

   946 	case AL_SAMPFMT_DOUBLE:

   947 		size = 8;

   948 		break;

   949 	default:

   950 		PyErr_SetString(ErrorObject, "can't determine format");

   951 		alFreeConfig(c);

   952 		return NULL;

   953 	}

   954 	ch = alGetChannels(c);

   955 	alFreeConfig(c);

   956 	if (ch < 0) {

   957 		PyErr_SetString(ErrorObject, "can't determine # of channels");

   958 		return NULL;

   959 	}

   960 	size *= ch;

   961 	if (length % size != 0) {

   962 		PyErr_SetString(ErrorObject,

   963 				"buffer length not whole number of frames");

   964 		return NULL;

   965 	}

   966 

   967 	Py_BEGIN_ALLOW_THREADS

   968 	alWriteFrames(self->port, (void *) samples, length / size);

   969 	Py_END_ALLOW_THREADS

   970 

   971 	Py_INCREF(Py_None);

   972 	return Py_None;

   973 }

   974 

   975 

   976 PyDoc_STRVAR(alp_ClosePort__doc__, "alClosePort: close an audio port.");

   977 

   978 static PyObject *

   979 alp_ClosePort(alpobject *self, PyObject *args)

   980 {

   981 	if (!PyArg_ParseTuple(args, ":ClosePort"))

   982 		return NULL;

   983 	if (alClosePort(self->port) < 0)

   984 		return NULL;

   985 	self->port = NULL;

   986 	Py_INCREF(Py_None);

   987 	return Py_None;

   988 }

   989 

   990 #endif /* AL_NO_ELEM */

   991 

   992 #ifdef OLD_INTERFACE

   993 static PyObject *

   994 alp_closeport(alpobject *self, PyObject *args)

   995 {

   996 	if (!PyArg_ParseTuple(args, ":ClosePort"))

   997 		return NULL;

   998 	if (ALcloseport(self->port) < 0)

   999 		return NULL;

  1000 	self->port = NULL;

  1001 	Py_INCREF(Py_None);

  1002 	return Py_None;

  1003 }

  1004 

  1005 static PyObject *

  1006 alp_getfd(alpobject *self, PyObject *args)

  1007 {

  1008 	int fd;

  1009 

  1010 	if (!PyArg_ParseTuple(args, ":GetFD"))

  1011 		return NULL;

  1012 	if ((fd = ALgetfd(self-> port)) == -1)

  1013 		return NULL;

  1014 	return PyInt_FromLong(fd);

  1015 }

  1016 

  1017 static PyObject *

  1018 alp_getfilled(alpobject *self, PyObject *args)

  1019 {

  1020 	long count;

  1021 

  1022 	if (!PyArg_ParseTuple(args, ":GetFilled"))

  1023 		return NULL;

  1024 	if ((count = ALgetfilled(self-> port)) == -1)

  1025 		return NULL;

  1026 	return PyInt_FromLong(count);

  1027 }

  1028 

  1029 static PyObject *

  1030 alp_getfillable(alpobject *self, PyObject *args)

  1031 {

  1032 	long count;

  1033 

  1034 	if (!PyArg_ParseTuple(args, ":GetFillable"))

  1035 		return NULL;

  1036 	if ((count = ALgetfillable(self-> port)) == -1)

  1037 		return NULL;

  1038 	return PyInt_FromLong (count);

  1039 }

  1040 

  1041 static PyObject *

  1042 alp_readsamps(alpobject *self, PyObject *args)

  1043 {

  1044 	long count;

  1045 	PyObject *v;

  1046 	ALconfig c;

  1047 	int width;

  1048 	int ret;

  1049 

  1050 	if (!PyArg_ParseTuple(args, "l:readsamps", &count))

  1051 		return NULL;

  1052 

  1053 	if (count <= 0) {

  1054 		PyErr_SetString(ErrorObject, "al.readsamps : arg <= 0");

  1055 		return NULL;

  1056 	}

  1057 

  1058 	c = ALgetconfig(self->port);

  1059 #ifdef AL_405

  1060 	width = ALgetsampfmt(c);

  1061 	if (width == AL_SAMPFMT_FLOAT)

  1062 		width = sizeof(float);

  1063 	else if (width == AL_SAMPFMT_DOUBLE)

  1064 		width = sizeof(double);

  1065 	else

  1066 		width = ALgetwidth(c);

  1067 #else

  1068 	width = ALgetwidth(c);

  1069 #endif /* AL_405 */

  1070 	ALfreeconfig(c);

  1071 	v = PyString_FromStringAndSize((char *)NULL, width * count);

  1072 	if (v == NULL)

  1073 		return NULL;

  1074 

  1075 	Py_BEGIN_ALLOW_THREADS

  1076 	ret = ALreadsamps(self->port, (void *) PyString_AsString(v), count);

  1077 	Py_END_ALLOW_THREADS

  1078 	if (ret == -1) {

  1079 		Py_DECREF(v);

  1080 		return NULL;

  1081 	}

  1082 

  1083 	return (v);

  1084 }

  1085 

  1086 static PyObject *

  1087 alp_writesamps(alpobject *self, PyObject *args)

  1088 {

  1089 	char *buf;

  1090 	int size, width;

  1091 	ALconfig c;

  1092 	int ret;

  1093 

  1094 	if (!PyArg_ParseTuple(args, "s#:writesamps", &buf, &size))

  1095 		return NULL;

  1096 

  1097 	c = ALgetconfig(self->port);

  1098 #ifdef AL_405

  1099 	width = ALgetsampfmt(c);

  1100 	if (width == AL_SAMPFMT_FLOAT)

  1101 		width = sizeof(float);

  1102 	else if (width == AL_SAMPFMT_DOUBLE)

  1103 		width = sizeof(double);

  1104 	else

  1105 		width = ALgetwidth(c);

  1106 #else

  1107 	width = ALgetwidth(c);

  1108 #endif /* AL_405 */

  1109 	ALfreeconfig(c);

  1110 	Py_BEGIN_ALLOW_THREADS

  1111 	ret = ALwritesamps (self->port, (void *) buf, (long) size / width);

  1112 	Py_END_ALLOW_THREADS

  1113 	if (ret == -1)

  1114 		return NULL;

  1115 

  1116 	Py_INCREF(Py_None);

  1117 	return Py_None;

  1118 }

  1119 

  1120 static PyObject *

  1121 alp_getfillpoint(alpobject *self, PyObject *args)

  1122 {

  1123 	long count;

  1124 

  1125 	if (!PyArg_ParseTuple(args, ":GetFillPoint"))

  1126 		return NULL;

  1127 	if ((count = ALgetfillpoint(self->port)) == -1)

  1128 		return NULL;

  1129 	return PyInt_FromLong(count);

  1130 }

  1131 

  1132 static PyObject *

  1133 alp_setfillpoint(alpobject *self, PyObject *args)

  1134 {

  1135 	long count;