1 

     2 /* Sad objects */

     3 

     4 #include "Python.h"

     5 #include "structmember.h"

     6 

     7 #ifdef HAVE_SYS_AUDIOIO_H

     8 #define SOLARIS

     9 #endif

    10 

    11 #ifdef HAVE_FCNTL_H

    12 #include <fcntl.h>

    13 #endif

    14 

    15 #include <stropts.h>

    16 #include <sys/ioctl.h>

    17 #ifdef SOLARIS

    18 #include <sys/audioio.h>

    19 #else

    20 #include <sun/audioio.h>

    21 #endif

    22 

    23 /* #define offsetof(str,mem) ((int)(((str *)0)->mem)) */

    24 

    25 typedef struct {

    26 	PyObject_HEAD

    27 	int	x_fd;		/* The open file */

    28 	int	x_icount;	/* # samples read */

    29 	int	x_ocount;	/* # samples written */

    30 	int	x_isctl;	/* True if control device */

    31 	

    32 } sadobject;

    33 

    34 typedef struct {

    35 	PyObject_HEAD

    36 	audio_info_t ai;

    37 } sadstatusobject;

    38 

    39 static PyTypeObject Sadtype;

    40 static PyTypeObject Sadstatustype;

    41 static sadstatusobject *sads_alloc(void);	/* Forward */

    42 

    43 static PyObject *SunAudioError;

    44 

    45 #define is_sadobject(v)		(Py_TYPE(v) == &Sadtype)

    46 #define is_sadstatusobject(v)	(Py_TYPE(v) == &Sadstatustype)

    47 

    48 

    49 static sadobject *

    50 newsadobject(PyObject *args)

    51 {

    52 	sadobject *xp;

    53 	int fd;

    54 	char *mode;

    55 	int imode;

    56 	char* basedev;

    57 	char* ctldev;

    58 	char* opendev;

    59 

    60 	/* Check arg for r/w/rw */

    61 	if (!PyArg_ParseTuple(args, "s", &mode))

    62 		return NULL;

    63 	if (strcmp(mode, "r") == 0)

    64 		imode = 0;

    65 	else if (strcmp(mode, "w") == 0)

    66 		imode = 1;

    67 	else if (strcmp(mode, "rw") == 0)

    68 		imode = 2;

    69 	else if (strcmp(mode, "control") == 0)

    70 		imode = -1;

    71 	else {

    72 		PyErr_SetString(SunAudioError,

    73 			  "Mode should be one of 'r', 'w', 'rw' or 'control'");

    74 		return NULL;

    75 	}

    76 	

    77 	/* Open the correct device.  The base device name comes from the

    78 	 * AUDIODEV environment variable first, then /dev/audio.  The

    79 	 * control device tacks "ctl" onto the base device name.

    80 	 */

    81 	basedev = getenv("AUDIODEV");

    82 	if (!basedev)

    83 		basedev = "/dev/audio";

    84 	ctldev = PyMem_NEW(char, strlen(basedev) + 4);

    85 	if (!ctldev) {

    86 		PyErr_NoMemory();

    87 		return NULL;

    88 	}

    89 	strcpy(ctldev, basedev);

    90 	strcat(ctldev, "ctl");

    91 

    92 	if (imode < 0) {

    93 		opendev = ctldev;

    94 		fd = open(ctldev, 2);

    95 	}

    96 	else {

    97 		opendev = basedev;

    98 		fd = open(basedev, imode);

    99 	}

   100 	if (fd < 0) {

   101 		PyErr_SetFromErrnoWithFilename(SunAudioError, opendev);

   102 		PyMem_DEL(ctldev);

   103 		return NULL;

   104 	}

   105 	PyMem_DEL(ctldev);

   106 

   107 	/* Create and initialize the object */

   108 	xp = PyObject_New(sadobject, &Sadtype);

   109 	if (xp == NULL) {

   110 		close(fd);

   111 		return NULL;

   112 	}

   113 	xp->x_fd = fd;

   114 	xp->x_icount = xp->x_ocount = 0;

   115 	xp->x_isctl = (imode < 0);

   116 	

   117 	return xp;

   118 }

   119 

   120 /* Sad methods */

   121 

   122 static void

   123 sad_dealloc(sadobject *xp)

   124 {

   125         close(xp->x_fd);

   126 	PyObject_Del(xp);

   127 }

   128 

   129 static PyObject *

   130 sad_read(sadobject *self, PyObject *args)

   131 {

   132         int size, count;

   133 	char *cp;

   134 	PyObject *rv;

   135 	

   136         if (!PyArg_ParseTuple(args, "i:read", &size))

   137 		return NULL;

   138 	rv = PyString_FromStringAndSize(NULL, size);

   139 	if (rv == NULL)

   140 		return NULL;

   141 

   142 	if (!(cp = PyString_AsString(rv)))

   143 		goto finally;

   144 

   145 	count = read(self->x_fd, cp, size);

   146 	if (count < 0) {

   147 		PyErr_SetFromErrno(SunAudioError);

   148 		goto finally;

   149 	}

   150 #if 0

   151 	/* TBD: why print this message if you can handle the condition?

   152 	 * assume it's debugging info which we can just as well get rid

   153 	 * of.  in any case this message should *not* be using printf!

   154 	 */

   155 	if (count != size)

   156 		printf("sunaudio: funny read rv %d wtd %d\n", count, size);

   157 #endif

   158 	self->x_icount += count;

   159 	return rv;

   160 

   161   finally:

   162 	Py_DECREF(rv);

   163 	return NULL;

   164 }

   165 

   166 static PyObject *

   167 sad_write(sadobject *self, PyObject *args)

   168 {

   169         char *cp;

   170 	int count, size;

   171 	

   172         if (!PyArg_ParseTuple(args, "s#:write", &cp, &size))

   173 		return NULL;

   174 

   175 	count = write(self->x_fd, cp, size);

   176 	if (count < 0) {

   177 		PyErr_SetFromErrno(SunAudioError);

   178 		return NULL;

   179 	}

   180 #if 0

   181 	if (count != size)

   182 		printf("sunaudio: funny write rv %d wanted %d\n", count, size);

   183 #endif

   184 	self->x_ocount += count;

   185 	

   186 	Py_INCREF(Py_None);

   187 	return Py_None;

   188 }

   189 

   190 static PyObject *

   191 sad_getinfo(sadobject *self)

   192 {

   193 	sadstatusobject *rv;

   194 

   195 	if (!(rv = sads_alloc()))

   196 		return NULL;

   197 

   198 	if (ioctl(self->x_fd, AUDIO_GETINFO, &rv->ai) < 0) {

   199 		PyErr_SetFromErrno(SunAudioError);

   200 		Py_DECREF(rv);

   201 		return NULL;

   202 	}

   203 	return (PyObject *)rv;

   204 }

   205 

   206 static PyObject *

   207 sad_setinfo(sadobject *self, sadstatusobject *arg)

   208 {

   209 	if (!is_sadstatusobject(arg)) {

   210 		PyErr_SetString(PyExc_TypeError,

   211 				"Must be sun audio status object");

   212 		return NULL;

   213 	}

   214 	if (ioctl(self->x_fd, AUDIO_SETINFO, &arg->ai) < 0) {

   215 		PyErr_SetFromErrno(SunAudioError);

   216 		return NULL;

   217 	}

   218 	Py_INCREF(Py_None);

   219 	return Py_None;

   220 }

   221 

   222 static PyObject *

   223 sad_ibufcount(sadobject *self)

   224 {

   225 	audio_info_t ai;

   226     

   227 	if (ioctl(self->x_fd, AUDIO_GETINFO, &ai) < 0) {

   228 		PyErr_SetFromErrno(SunAudioError);

   229 		return NULL;

   230 	}

   231 	return PyInt_FromLong(ai.record.samples - self->x_icount);

   232 }

   233 

   234 static PyObject *

   235 sad_obufcount(sadobject *self)

   236 {

   237 	audio_info_t ai;

   238     

   239 	if (ioctl(self->x_fd, AUDIO_GETINFO, &ai) < 0) {

   240 		PyErr_SetFromErrno(SunAudioError);

   241 		return NULL;

   242 	}

   243 	/* x_ocount is in bytes, whereas play.samples is in frames */

   244 	/* we want frames */

   245 	return PyInt_FromLong(self->x_ocount / (ai.play.channels *

   246 						ai.play.precision / 8) -

   247 			      ai.play.samples);

   248 }

   249 

   250 static PyObject *

   251 sad_drain(sadobject *self)

   252 {

   253 	if (ioctl(self->x_fd, AUDIO_DRAIN, 0) < 0) {

   254 		PyErr_SetFromErrno(SunAudioError);

   255 		return NULL;

   256 	}

   257 	Py_INCREF(Py_None);

   258 	return Py_None;

   259 }

   260 

   261 #ifdef SOLARIS

   262 static PyObject *

   263 sad_getdev(sadobject *self)

   264 {

   265 	struct audio_device ad;

   266 

   267 	if (ioctl(self->x_fd, AUDIO_GETDEV, &ad) < 0) {

   268 		PyErr_SetFromErrno(SunAudioError);

   269 		return NULL;

   270 	}

   271 	return Py_BuildValue("(sss)", ad.name, ad.version, ad.config);

   272 }

   273 #endif

   274 

   275 static PyObject *

   276 sad_flush(sadobject *self)

   277 {

   278 	if (ioctl(self->x_fd, I_FLUSH, FLUSHW) < 0) {

   279 		PyErr_SetFromErrno(SunAudioError);

   280 		return NULL;

   281 	}

   282 	Py_INCREF(Py_None);

   283 	return Py_None;

   284 }

   285 

   286 static PyObject *

   287 sad_close(sadobject *self)

   288 {

   289     

   290 	if (self->x_fd >= 0) {

   291 		close(self->x_fd);

   292 		self->x_fd = -1;

   293 	}

   294 	Py_INCREF(Py_None);

   295 	return Py_None;

   296 }

   297 

   298 static PyObject *

   299 sad_fileno(sadobject *self)

   300 {

   301 	return PyInt_FromLong(self->x_fd);

   302 }

   303 

   304 

   305 static PyMethodDef sad_methods[] = {

   306         { "read",	(PyCFunction)sad_read, METH_VARARGS },

   307         { "write",	(PyCFunction)sad_write, METH_VARARGS },

   308         { "ibufcount",	(PyCFunction)sad_ibufcount, METH_NOARGS },

   309         { "obufcount",	(PyCFunction)sad_obufcount, METH_NOARGS },

   310 #define CTL_METHODS 4

   311         { "getinfo",	(PyCFunction)sad_getinfo, METH_NOARGS },

   312         { "setinfo",	(PyCFunction)sad_setinfo, METH_O},

   313         { "drain",	(PyCFunction)sad_drain, METH_NOARGS },

   314         { "flush",	(PyCFunction)sad_flush, METH_NOARGS },

   315 #ifdef SOLARIS

   316 	{ "getdev",	(PyCFunction)sad_getdev, METH_NOARGS },

   317 #endif

   318         { "close",	(PyCFunction)sad_close, METH_NOARGS },

   319 	{ "fileno",     (PyCFunction)sad_fileno, METH_NOARGS },

   320 	{NULL,		NULL}		/* sentinel */

   321 };

   322 

   323 static PyObject *

   324 sad_getattr(sadobject *xp, char *name)

   325 {

   326 	if (xp->x_isctl)

   327 		return Py_FindMethod(sad_methods+CTL_METHODS,

   328 				     (PyObject *)xp, name);

   329 	else

   330 		return Py_FindMethod(sad_methods, (PyObject *)xp, name);

   331 }

   332 

   333 /* ----------------------------------------------------------------- */

   334 

   335 static sadstatusobject *

   336 sads_alloc(void) {

   337 	return PyObject_New(sadstatusobject, &Sadstatustype);

   338 }

   339 

   340 static void

   341 sads_dealloc(sadstatusobject *xp)

   342 {

   343 	PyMem_DEL(xp);

   344 }

   345 

   346 #define OFF(x) offsetof(audio_info_t,x)

   347 static struct memberlist sads_ml[] = {

   348 	{ "i_sample_rate",	T_UINT,		OFF(record.sample_rate) },

   349 	{ "i_channels",		T_UINT,		OFF(record.channels) },

   350 	{ "i_precision",	T_UINT,		OFF(record.precision) },

   351 	{ "i_encoding",		T_UINT,		OFF(record.encoding) },

   352 	{ "i_gain",		T_UINT,		OFF(record.gain) },

   353 	{ "i_port",		T_UINT,		OFF(record.port) },

   354 	{ "i_samples",		T_UINT,		OFF(record.samples) },

   355 	{ "i_eof",		T_UINT,		OFF(record.eof) },

   356 	{ "i_pause",		T_UBYTE,	OFF(record.pause) },

   357 	{ "i_error",		T_UBYTE,	OFF(record.error) },

   358 	{ "i_waiting",		T_UBYTE,	OFF(record.waiting) },

   359 	{ "i_open",		T_UBYTE,	OFF(record.open) ,	 RO},

   360 	{ "i_active",		T_UBYTE,	OFF(record.active) ,	 RO},

   361 #ifdef SOLARIS

   362 	{ "i_buffer_size",	T_UINT,		OFF(record.buffer_size) },

   363 	{ "i_balance",		T_UBYTE,	OFF(record.balance) },

   364 	{ "i_avail_ports",	T_UINT,		OFF(record.avail_ports) },

   365 #endif

   366 

   367 	{ "o_sample_rate",	T_UINT,		OFF(play.sample_rate) },

   368 	{ "o_channels",		T_UINT,		OFF(play.channels) },

   369 	{ "o_precision",	T_UINT,		OFF(play.precision) },

   370 	{ "o_encoding",		T_UINT,		OFF(play.encoding) },

   371 	{ "o_gain",		T_UINT,		OFF(play.gain) },

   372 	{ "o_port",		T_UINT,		OFF(play.port) },

   373 	{ "o_samples",		T_UINT,		OFF(play.samples) },

   374 	{ "o_eof",		T_UINT,		OFF(play.eof) },

   375 	{ "o_pause",		T_UBYTE,	OFF(play.pause) },

   376 	{ "o_error",		T_UBYTE,	OFF(play.error) },

   377 	{ "o_waiting",		T_UBYTE,	OFF(play.waiting) },

   378 	{ "o_open",		T_UBYTE,	OFF(play.open) ,	 RO},

   379 	{ "o_active",		T_UBYTE,	OFF(play.active) ,	 RO},

   380 #ifdef SOLARIS

   381 	{ "o_buffer_size",	T_UINT,		OFF(play.buffer_size) },

   382 	{ "o_balance",		T_UBYTE,	OFF(play.balance) },

   383 	{ "o_avail_ports",	T_UINT,		OFF(play.avail_ports) },

   384 #endif

   385 

   386 	{ "monitor_gain",	T_UINT,		OFF(monitor_gain) },

   387         { NULL,                 0,              0},

   388 };

   389 

   390 static PyObject *

   391 sads_getattr(sadstatusobject *xp, char *name)

   392 {

   393 	return PyMember_Get((char *)&xp->ai, sads_ml, name);

   394 }

   395 

   396 static int

   397 sads_setattr(sadstatusobject *xp, char *name, PyObject *v)

   398 {

   399 

   400 	if (v == NULL) {

   401 		PyErr_SetString(PyExc_TypeError,

   402 				"can't delete sun audio status attributes");

   403 		return -1;

   404 	}

   405 	return PyMember_Set((char *)&xp->ai, sads_ml, name, v);

   406 }

   407 

   408 /* ------------------------------------------------------------------- */

   409 

   410 

   411 static PyTypeObject Sadtype = {

   412 	PyVarObject_HEAD_INIT(&PyType_Type, 0)

   413 	"sunaudiodev.sun_audio_device",	/*tp_name*/

   414 	sizeof(sadobject),		/*tp_size*/

   415 	0,				/*tp_itemsize*/

   416 	/* methods */

   417 	(destructor)sad_dealloc,	/*tp_dealloc*/

   418 	0,				/*tp_print*/

   419 	(getattrfunc)sad_getattr,	/*tp_getattr*/

   420 	0,				/*tp_setattr*/

   421 	0,				/*tp_compare*/

   422 	0,				/*tp_repr*/

   423 };

   424 

   425 static PyTypeObject Sadstatustype = {

   426 	PyVarObject_HEAD_INIT(&PyType_Type, 0)

   427 	"sunaudiodev.sun_audio_device_status", /*tp_name*/

   428 	sizeof(sadstatusobject),	/*tp_size*/

   429 	0,				/*tp_itemsize*/

   430 	/* methods */

   431 	(destructor)sads_dealloc,	/*tp_dealloc*/

   432 	0,				/*tp_print*/

   433 	(getattrfunc)sads_getattr,	/*tp_getattr*/

   434 	(setattrfunc)sads_setattr,	/*tp_setattr*/

   435 	0,				/*tp_compare*/

   436 	0,				/*tp_repr*/

   437 };

   438 /* ------------------------------------------------------------------- */

   439 

   440 static PyObject *

   441 sadopen(PyObject *self, PyObject *args)

   442 {

   443 	return (PyObject *)newsadobject(args);

   444 }

   445     

   446 static PyMethodDef sunaudiodev_methods[] = {

   447     { "open", sadopen, METH_VARARGS },

   448     { 0, 0 },

   449 };

   450 

   451 void

   452 initsunaudiodev(void)

   453 {

   454 	PyObject *m, *d;

   455 	

   456 	if (PyErr_WarnPy3k("the sunaudiodev module has been removed in "

   457 	                   "Python 3.0", 2) < 0)

   458 	    return;

   459 

   460 	m = Py_InitModule("sunaudiodev", sunaudiodev_methods);

   461 	if (m == NULL)

   462 		return;

   463 	d = PyModule_GetDict(m);

   464 	SunAudioError = PyErr_NewException("sunaudiodev.error", NULL, NULL);

   465 	if (SunAudioError)

   466 		PyDict_SetItemString(d, "error", SunAudioError);

   467 }