home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 15 / AACD15.ISO / AACD / Programming / Python2 / Python20_source / Modules / sunaudiodev.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-10-25  |  10.7 KB  |  486 lines
  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_UNISTD_H
  12. #include <unistd.h>
  13. #endif
  14.  
  15. #ifdef HAVE_FCNTL_H
  16. #include <fcntl.h>
  17. #endif
  18.  
  19. #include <stropts.h>
  20. #include <sys/ioctl.h>
  21. #ifdef SOLARIS
  22. #include <sys/audioio.h>
  23. #else
  24. #include <sun/audioio.h>
  25. #endif
  26.  
  27. /* #define offsetof(str,mem) ((int)(((str *)0)->mem)) */
  28.  
  29. typedef struct {
  30.     PyObject_HEAD
  31.     int    x_fd;        /* The open file */
  32.     int    x_icount;    /* # samples read */
  33.     int    x_ocount;    /* # samples written */
  34.     int    x_isctl;    /* True if control device */
  35.     
  36. } sadobject;
  37.  
  38. typedef struct {
  39.     PyObject_HEAD
  40.     audio_info_t ai;
  41. } sadstatusobject;
  42.  
  43. staticforward PyTypeObject Sadtype;
  44. staticforward PyTypeObject Sadstatustype;
  45. static sadstatusobject *sads_alloc(void);    /* Forward */
  46.  
  47. static PyObject *SunAudioError;
  48.  
  49. #define is_sadobject(v)        ((v)->ob_type == &Sadtype)
  50. #define is_sadstatusobject(v)    ((v)->ob_type == &Sadstatustype)
  51.  
  52.  
  53. static sadobject *
  54. newsadobject(PyObject *args)
  55. {
  56.     sadobject *xp;
  57.     int fd;
  58.     char *mode;
  59.     int imode;
  60.     char* basedev;
  61.     char* ctldev;
  62.     char* opendev;
  63.  
  64.     /* Check arg for r/w/rw */
  65.     if (!PyArg_Parse(args, "s", &mode))
  66.         return NULL;
  67.     if (strcmp(mode, "r") == 0)
  68.         imode = 0;
  69.     else if (strcmp(mode, "w") == 0)
  70.         imode = 1;
  71.     else if (strcmp(mode, "rw") == 0)
  72.         imode = 2;
  73.     else if (strcmp(mode, "control") == 0)
  74.         imode = -1;
  75.     else {
  76.         PyErr_SetString(SunAudioError,
  77.               "Mode should be one of 'r', 'w', 'rw' or 'control'");
  78.         return NULL;
  79.     }
  80.     
  81.     /* Open the correct device.  The base device name comes from the
  82.      * AUDIODEV environment variable first, then /dev/audio.  The
  83.      * control device tacks "ctl" onto the base device name.
  84.      */
  85.     basedev = getenv("AUDIODEV");
  86.     if (!basedev)
  87.         basedev = "/dev/audio";
  88.     ctldev = PyMem_NEW(char, strlen(basedev) + 4);
  89.     if (!ctldev) {
  90.         PyErr_NoMemory();
  91.         return NULL;
  92.     }
  93.     strcpy(ctldev, basedev);
  94.     strcat(ctldev, "ctl");
  95.  
  96.     if (imode < 0) {
  97.         opendev = ctldev;
  98.         fd = open(ctldev, 2);
  99.     }
  100.     else {
  101.         opendev = basedev;
  102.         fd = open(basedev, imode);
  103.     }
  104.     if (fd < 0) {
  105.         PyErr_SetFromErrnoWithFilename(SunAudioError, opendev);
  106.         return NULL;
  107.     }
  108.     PyMem_DEL(ctldev);
  109.  
  110.     /* Create and initialize the object */
  111.     xp = PyObject_New(sadobject, &Sadtype);
  112.     if (xp == NULL) {
  113.         close(fd);
  114.         return NULL;
  115.     }
  116.     xp->x_fd = fd;
  117.     xp->x_icount = xp->x_ocount = 0;
  118.     xp->x_isctl = (imode < 0);
  119.     
  120.     return xp;
  121. }
  122.  
  123. /* Sad methods */
  124.  
  125. static void
  126. sad_dealloc(sadobject *xp)
  127. {
  128.         close(xp->x_fd);
  129.     PyObject_Del(xp);
  130. }
  131.  
  132. static PyObject *
  133. sad_read(sadobject *self, PyObject *args)
  134. {
  135.         int size, count;
  136.     char *cp;
  137.     PyObject *rv;
  138.     
  139.         if (!PyArg_Parse(args, "i", &size))
  140.         return NULL;
  141.     rv = PyString_FromStringAndSize(NULL, size);
  142.     if (rv == NULL)
  143.         return NULL;
  144.  
  145.     if (!(cp = PyString_AsString(rv)))
  146.         goto finally;
  147.  
  148.     count = read(self->x_fd, cp, size);
  149.     if (count < 0) {
  150.         PyErr_SetFromErrno(SunAudioError);
  151.         goto finally;
  152.     }
  153. #if 0
  154.     /* TBD: why print this message if you can handle the condition?
  155.      * assume it's debugging info which we can just as well get rid
  156.      * of.  in any case this message should *not* be using printf!
  157.      */
  158.     if (count != size)
  159.         printf("sunaudio: funny read rv %d wtd %d\n", count, size);
  160. #endif
  161.     self->x_icount += count;
  162.     return rv;
  163.  
  164.   finally:
  165.     Py_DECREF(rv);
  166.     return NULL;
  167. }
  168.  
  169. static PyObject *
  170. sad_write(sadobject *self, PyObject *args)
  171. {
  172.         char *cp;
  173.     int count, size;
  174.     
  175.         if (!PyArg_Parse(args, "s#", &cp, &size))
  176.         return NULL;
  177.  
  178.     count = write(self->x_fd, cp, size);
  179.     if (count < 0) {
  180.         PyErr_SetFromErrno(SunAudioError);
  181.         return NULL;
  182.     }
  183. #if 0
  184.     if (count != size)
  185.         printf("sunaudio: funny write rv %d wanted %d\n", count, size);
  186. #endif
  187.     self->x_ocount += count;
  188.     
  189.     Py_INCREF(Py_None);
  190.     return Py_None;
  191. }
  192.  
  193. static PyObject *
  194. sad_getinfo(sadobject *self, PyObject *args)
  195. {
  196.     sadstatusobject *rv;
  197.  
  198.     if (!PyArg_Parse(args, ""))
  199.         return NULL;
  200.     if (!(rv = sads_alloc()))
  201.         return NULL;
  202.  
  203.     if (ioctl(self->x_fd, AUDIO_GETINFO, &rv->ai) < 0) {
  204.         PyErr_SetFromErrno(SunAudioError);
  205.         Py_DECREF(rv);
  206.         return NULL;
  207.     }
  208.     return (PyObject *)rv;
  209. }
  210.  
  211. static PyObject *
  212. sad_setinfo(sadobject *self, sadstatusobject *arg)
  213. {
  214.     if (!is_sadstatusobject(arg)) {
  215.         PyErr_SetString(PyExc_TypeError,
  216.                 "Must be sun audio status object");
  217.         return NULL;
  218.     }
  219.     if (ioctl(self->x_fd, AUDIO_SETINFO, &arg->ai) < 0) {
  220.         PyErr_SetFromErrno(SunAudioError);
  221.         return NULL;
  222.     }
  223.     Py_INCREF(Py_None);
  224.     return Py_None;
  225. }
  226.  
  227. static PyObject *
  228. sad_ibufcount(sadobject *self, PyObject *args)
  229. {
  230.     audio_info_t ai;
  231.     
  232.     if (!PyArg_Parse(args, ""))
  233.         return NULL;
  234.     if (ioctl(self->x_fd, AUDIO_GETINFO, &ai) < 0) {
  235.         PyErr_SetFromErrno(SunAudioError);
  236.         return NULL;
  237.     }
  238.     return PyInt_FromLong(ai.record.samples - self->x_icount);
  239. }
  240.  
  241. static PyObject *
  242. sad_obufcount(sadobject *self, PyObject *args)
  243. {
  244.     audio_info_t ai;
  245.     
  246.     if (!PyArg_Parse(args, ""))
  247.         return NULL;
  248.     if (ioctl(self->x_fd, AUDIO_GETINFO, &ai) < 0) {
  249.         PyErr_SetFromErrno(SunAudioError);
  250.         return NULL;
  251.     }
  252.     /* x_ocount is in bytes, whereas play.samples is in frames */
  253.     /* we want frames */
  254.     return PyInt_FromLong(self->x_ocount / (ai.play.channels *
  255.                         ai.play.precision / 8) -
  256.                   ai.play.samples);
  257. }
  258.  
  259. static PyObject *
  260. sad_drain(sadobject *self, PyObject *args)
  261. {
  262.     
  263.     if (!PyArg_Parse(args, ""))
  264.         return NULL;
  265.     if (ioctl(self->x_fd, AUDIO_DRAIN, 0) < 0) {
  266.         PyErr_SetFromErrno(SunAudioError);
  267.         return NULL;
  268.     }
  269.     Py_INCREF(Py_None);
  270.     return Py_None;
  271. }
  272.  
  273. #ifdef SOLARIS
  274. static PyObject *
  275. sad_getdev(sadobject *self, PyObject *args)
  276. {
  277.     struct audio_device ad;
  278.  
  279.     if (!PyArg_Parse(args, ""))
  280.         return NULL;
  281.     if (ioctl(self->x_fd, AUDIO_GETDEV, &ad) < 0) {
  282.         PyErr_SetFromErrno(SunAudioError);
  283.         return NULL;
  284.     }
  285.     return Py_BuildValue("(sss)", ad.name, ad.version, ad.config);
  286. }
  287. #endif
  288.  
  289. static PyObject *
  290. sad_flush(sadobject *self, PyObject *args)
  291. {
  292.     
  293.     if (!PyArg_Parse(args, ""))
  294.         return NULL;
  295.     if (ioctl(self->x_fd, I_FLUSH, FLUSHW) < 0) {
  296.         PyErr_SetFromErrno(SunAudioError);
  297.         return NULL;
  298.     }
  299.     Py_INCREF(Py_None);
  300.     return Py_None;
  301. }
  302.  
  303. static PyObject *
  304. sad_close(sadobject *self, PyObject *args)
  305. {
  306.     
  307.     if (!PyArg_Parse(args, ""))
  308.         return NULL;
  309.     if (self->x_fd >= 0) {
  310.         close(self->x_fd);
  311.         self->x_fd = -1;
  312.     }
  313.     Py_INCREF(Py_None);
  314.     return Py_None;
  315. }
  316.  
  317. static PyObject *
  318. sad_fileno(sadobject *self, PyObject *args)
  319. {
  320.     if (!PyArg_Parse(args, ""))
  321.         return NULL;
  322.  
  323.     return PyInt_FromLong(self->x_fd);
  324. }
  325.  
  326.  
  327. static PyMethodDef sad_methods[] = {
  328.         { "read",    (PyCFunction)sad_read },
  329.         { "write",    (PyCFunction)sad_write },
  330.         { "ibufcount",    (PyCFunction)sad_ibufcount },
  331.         { "obufcount",    (PyCFunction)sad_obufcount },
  332. #define CTL_METHODS 4
  333.         { "getinfo",    (PyCFunction)sad_getinfo },
  334.         { "setinfo",    (PyCFunction)sad_setinfo },
  335.         { "drain",    (PyCFunction)sad_drain },
  336.         { "flush",    (PyCFunction)sad_flush },
  337. #ifdef SOLARIS
  338.     { "getdev",    (PyCFunction)sad_getdev },
  339. #endif
  340.         { "close",    (PyCFunction)sad_close },
  341.     { "fileno",     (PyCFunction)sad_fileno },
  342.     {NULL,        NULL}        /* sentinel */
  343. };
  344.  
  345. static PyObject *
  346. sad_getattr(sadobject *xp, char *name)
  347. {
  348.     if (xp->x_isctl)
  349.         return Py_FindMethod(sad_methods+CTL_METHODS,
  350.                      (PyObject *)xp, name);
  351.     else
  352.         return Py_FindMethod(sad_methods, (PyObject *)xp, name);
  353. }
  354.  
  355. /* ----------------------------------------------------------------- */
  356.  
  357. static sadstatusobject *
  358. sads_alloc(void) {
  359.     return PyObject_New(sadstatusobject, &Sadstatustype);
  360. }
  361.  
  362. static void
  363. sads_dealloc(sadstatusobject *xp)
  364. {
  365.     PyMem_DEL(xp);
  366. }
  367.  
  368. #define OFF(x) offsetof(audio_info_t,x)
  369. static struct memberlist sads_ml[] = {
  370.     { "i_sample_rate",    T_UINT,        OFF(record.sample_rate) },
  371.     { "i_channels",        T_UINT,        OFF(record.channels) },
  372.     { "i_precision",    T_UINT,        OFF(record.precision) },
  373.     { "i_encoding",        T_UINT,        OFF(record.encoding) },
  374.     { "i_gain",        T_UINT,        OFF(record.gain) },
  375.     { "i_port",        T_UINT,        OFF(record.port) },
  376.     { "i_samples",        T_UINT,        OFF(record.samples) },
  377.     { "i_eof",        T_UINT,        OFF(record.eof) },
  378.     { "i_pause",        T_UBYTE,    OFF(record.pause) },
  379.     { "i_error",        T_UBYTE,    OFF(record.error) },
  380.     { "i_waiting",        T_UBYTE,    OFF(record.waiting) },
  381.     { "i_open",        T_UBYTE,    OFF(record.open) ,     RO},
  382.     { "i_active",        T_UBYTE,    OFF(record.active) ,     RO},
  383. #ifdef SOLARIS
  384.     { "i_buffer_size",    T_UINT,        OFF(record.buffer_size) },
  385.     { "i_balance",        T_UBYTE,    OFF(record.balance) },
  386.     { "i_avail_ports",    T_UINT,        OFF(record.avail_ports) },
  387. #endif
  388.  
  389.     { "o_sample_rate",    T_UINT,        OFF(play.sample_rate) },
  390.     { "o_channels",        T_UINT,        OFF(play.channels) },
  391.     { "o_precision",    T_UINT,        OFF(play.precision) },
  392.     { "o_encoding",        T_UINT,        OFF(play.encoding) },
  393.     { "o_gain",        T_UINT,        OFF(play.gain) },
  394.     { "o_port",        T_UINT,        OFF(play.port) },
  395.     { "o_samples",        T_UINT,        OFF(play.samples) },
  396.     { "o_eof",        T_UINT,        OFF(play.eof) },
  397.     { "o_pause",        T_UBYTE,    OFF(play.pause) },
  398.     { "o_error",        T_UBYTE,    OFF(play.error) },
  399.     { "o_waiting",        T_UBYTE,    OFF(play.waiting) },
  400.     { "o_open",        T_UBYTE,    OFF(play.open) ,     RO},
  401.     { "o_active",        T_UBYTE,    OFF(play.active) ,     RO},
  402. #ifdef SOLARIS
  403.     { "o_buffer_size",    T_UINT,        OFF(play.buffer_size) },
  404.     { "o_balance",        T_UBYTE,    OFF(play.balance) },
  405.     { "o_avail_ports",    T_UINT,        OFF(play.avail_ports) },
  406. #endif
  407.  
  408.     { "monitor_gain",    T_UINT,        OFF(monitor_gain) },
  409.         { NULL,                 0,              0},
  410. };
  411.  
  412. static PyObject *
  413. sads_getattr(sadstatusobject *xp, char *name)
  414. {
  415.     return PyMember_Get((char *)&xp->ai, sads_ml, name);
  416. }
  417.  
  418. static int
  419. sads_setattr(sadstatusobject *xp, char *name, PyObject *v)
  420. {
  421.  
  422.     if (v == NULL) {
  423.         PyErr_SetString(PyExc_TypeError,
  424.                 "can't delete sun audio status attributes");
  425.         return -1;
  426.     }
  427.     return PyMember_Set((char *)&xp->ai, sads_ml, name, v);
  428. }
  429.  
  430. /* ------------------------------------------------------------------- */
  431.  
  432.  
  433. static PyTypeObject Sadtype = {
  434.     PyObject_HEAD_INIT(&PyType_Type)
  435.     0,                /*ob_size*/
  436.     "sun_audio_device",        /*tp_name*/
  437.     sizeof(sadobject),        /*tp_size*/
  438.     0,                /*tp_itemsize*/
  439.     /* methods */
  440.     (destructor)sad_dealloc,    /*tp_dealloc*/
  441.     0,                /*tp_print*/
  442.     (getattrfunc)sad_getattr,    /*tp_getattr*/
  443.     0,                /*tp_setattr*/
  444.     0,                /*tp_compare*/
  445.     0,                /*tp_repr*/
  446. };
  447.  
  448. static PyTypeObject Sadstatustype = {
  449.     PyObject_HEAD_INIT(&PyType_Type)
  450.     0,                /*ob_size*/
  451.     "sun_audio_device_status",    /*tp_name*/
  452.     sizeof(sadstatusobject),    /*tp_size*/
  453.     0,                /*tp_itemsize*/
  454.     /* methods */
  455.     (destructor)sads_dealloc,    /*tp_dealloc*/
  456.     0,                /*tp_print*/
  457.     (getattrfunc)sads_getattr,    /*tp_getattr*/
  458.     (setattrfunc)sads_setattr,    /*tp_setattr*/
  459.     0,                /*tp_compare*/
  460.     0,                /*tp_repr*/
  461. };
  462. /* ------------------------------------------------------------------- */
  463.  
  464. static PyObject *
  465. sadopen(PyObject *self, PyObject *args)
  466. {
  467.     return (PyObject *)newsadobject(args);
  468. }
  469.     
  470. static PyMethodDef sunaudiodev_methods[] = {
  471.     { "open", sadopen },
  472.     { 0, 0 },
  473. };
  474.  
  475. void
  476. initsunaudiodev(void)
  477. {
  478.     PyObject *m, *d;
  479.  
  480.     m = Py_InitModule("sunaudiodev", sunaudiodev_methods);
  481.     d = PyModule_GetDict(m);
  482.     SunAudioError = PyErr_NewException("sunaudiodev.error", NULL, NULL);
  483.     if (SunAudioError)
  484.         PyDict_SetItemString(d, "error", SunAudioError);
  485. }
  486.