History

add hg and python

cinap_lenrek committed 15 years ago

Commit 4bb9e221 parent 987265c3706 files · +1228772 −-233Browse files

Showing the changes to sys/src/cmd/python/Modules/linuxaudiodev.c (1 of 3706 files). Show all

Unified · Split

sys/src/cmd/python/Modules/linuxaudiodev.c+502−0
@@ -0,0 +1,502 @@
1+/* Hey Emacs, this is -*-C-*-
2+ ******************************************************************************
3+ * linuxaudiodev.c -- Linux audio device for python.
4+ *
5+ * Author : Peter Bosch
6+ * Created On : Thu Mar 2 21:10:33 2000
7+ * Status : Unknown, Use with caution!
8+ *
9+ * Unless other notices are present in any part of this file
10+ * explicitly claiming copyrights for other people and/or
11+ * organizations, the contents of this file is fully copyright
12+ * (C) 2000 Peter Bosch, all rights reserved.
13+ ******************************************************************************
14+ */
15+
16+#include "Python.h"
17+#include "structmember.h"
18+
19+#ifdef HAVE_FCNTL_H
20+#include <fcntl.h>
21+#else
22+#define O_RDONLY 00
23+#define O_WRONLY 01
24+#endif
25+
26+
27+#include <sys/ioctl.h>
28+#if defined(linux)
29+#include <linux/soundcard.h>
30+
31+#ifndef HAVE_STDINT_H
32+typedef unsigned long uint32_t;
33+#endif
34+
35+#elif defined(__FreeBSD__)
36+#include <machine/soundcard.h>
37+
38+#ifndef SNDCTL_DSP_CHANNELS
39+#define SNDCTL_DSP_CHANNELS SOUND_PCM_WRITE_CHANNELS
40+#endif
41+
42+#endif
43+
44+typedef struct {
45+ PyObject_HEAD
46+ int x_fd; /* The open file */
47+ int x_mode; /* file mode */
48+ int x_icount; /* Input count */
49+ int x_ocount; /* Output count */
50+ uint32_t x_afmts; /* Audio formats supported by hardware*/
51+} lad_t;
52+
53+/* XXX several format defined in soundcard.h are not supported,
54+ including _NE (native endian) options and S32 options
55+*/
56+
57+static struct {
58+ int a_bps;
59+ uint32_t a_fmt;
60+ char *a_name;
61+} audio_types[] = {
62+ { 8, AFMT_MU_LAW, "logarithmic mu-law 8-bit audio" },
63+ { 8, AFMT_A_LAW, "logarithmic A-law 8-bit audio" },
64+ { 8, AFMT_U8, "linear unsigned 8-bit audio" },
65+ { 8, AFMT_S8, "linear signed 8-bit audio" },
66+ { 16, AFMT_U16_BE, "linear unsigned 16-bit big-endian audio" },
67+ { 16, AFMT_U16_LE, "linear unsigned 16-bit little-endian audio" },
68+ { 16, AFMT_S16_BE, "linear signed 16-bit big-endian audio" },
69+ { 16, AFMT_S16_LE, "linear signed 16-bit little-endian audio" },
70+ { 16, AFMT_S16_NE, "linear signed 16-bit native-endian audio" },
71+};
72+
73+static int n_audio_types = sizeof(audio_types) / sizeof(audio_types[0]);
74+
75+static PyTypeObject Ladtype;
76+
77+static PyObject *LinuxAudioError;
78+
79+static lad_t *
80+newladobject(PyObject *arg)
81+{
82+ lad_t *xp;
83+ int fd, afmts, imode;
84+ char *basedev = NULL;
85+ char *mode = NULL;
86+
87+ /* Two ways to call linuxaudiodev.open():
88+ open(device, mode) (for consistency with builtin open())
89+ open(mode) (for backwards compatibility)
90+ because the *first* argument is optional, parsing args is
91+ a wee bit tricky. */
92+ if (!PyArg_ParseTuple(arg, "s|s:open", &basedev, &mode))
93+ return NULL;
94+ if (mode == NULL) { /* only one arg supplied */
95+ mode = basedev;
96+ basedev = NULL;
97+ }
98+
99+ if (strcmp(mode, "r") == 0)
100+ imode = O_RDONLY;
101+ else if (strcmp(mode, "w") == 0)
102+ imode = O_WRONLY;
103+ else {
104+ PyErr_SetString(LinuxAudioError, "mode should be 'r' or 'w'");
105+ return NULL;
106+ }
107+
108+ /* Open the correct device. The base device name comes from the
109+ * AUDIODEV environment variable first, then /dev/dsp. The
110+ * control device tacks "ctl" onto the base device name.
111+ *
112+ * Note that the only difference between /dev/audio and /dev/dsp
113+ * is that the former uses logarithmic mu-law encoding and the
114+ * latter uses 8-bit unsigned encoding.
115+ */
116+
117+ if (basedev == NULL) { /* called with one arg */
118+ basedev = getenv("AUDIODEV");
119+ if (basedev == NULL) /* $AUDIODEV not set */
120+ basedev = "/dev/dsp";
121+ }
122+
123+ if ((fd = open(basedev, imode)) == -1) {
124+ PyErr_SetFromErrnoWithFilename(LinuxAudioError, basedev);
125+ return NULL;
126+ }
127+ if (imode == O_WRONLY && ioctl(fd, SNDCTL_DSP_NONBLOCK, NULL) == -1) {
128+ PyErr_SetFromErrnoWithFilename(LinuxAudioError, basedev);
129+ return NULL;
130+ }
131+ if (ioctl(fd, SNDCTL_DSP_GETFMTS, &afmts) == -1) {
132+ PyErr_SetFromErrnoWithFilename(LinuxAudioError, basedev);
133+ return NULL;
134+ }
135+ /* Create and initialize the object */
136+ if ((xp = PyObject_New(lad_t, &Ladtype)) == NULL) {
137+ close(fd);
138+ return NULL;
139+ }
140+ xp->x_fd = fd;
141+ xp->x_mode = imode;
142+ xp->x_icount = xp->x_ocount = 0;
143+ xp->x_afmts = afmts;
144+ return xp;
145+}
146+
147+static void
148+lad_dealloc(lad_t *xp)
149+{
150+ /* if already closed, don't reclose it */
151+ if (xp->x_fd != -1)
152+ close(xp->x_fd);
153+ PyObject_Del(xp);
154+}
155+
156+static PyObject *
157+lad_read(lad_t *self, PyObject *args)
158+{
159+ int size, count;
160+ char *cp;
161+ PyObject *rv;
162+
163+ if (!PyArg_ParseTuple(args, "i:read", &size))
164+ return NULL;
165+ rv = PyString_FromStringAndSize(NULL, size);
166+ if (rv == NULL)
167+ return NULL;
168+ cp = PyString_AS_STRING(rv);
169+ if ((count = read(self->x_fd, cp, size)) < 0) {
170+ PyErr_SetFromErrno(LinuxAudioError);
171+ Py_DECREF(rv);
172+ return NULL;
173+ }
174+ self->x_icount += count;
175+ _PyString_Resize(&rv, count);
176+ return rv;
177+}
178+
179+static PyObject *
180+lad_write(lad_t *self, PyObject *args)
181+{
182+ char *cp;
183+ int rv, size;
184+ fd_set write_set_fds;
185+ struct timeval tv;
186+ int select_retval;
187+
188+ if (!PyArg_ParseTuple(args, "s#:write", &cp, &size))
189+ return NULL;
190+
191+ /* use select to wait for audio device to be available */
192+ FD_ZERO(&write_set_fds);
193+ FD_SET(self->x_fd, &write_set_fds);
194+ tv.tv_sec = 4; /* timeout values */
195+ tv.tv_usec = 0;
196+
197+ while (size > 0) {
198+ select_retval = select(self->x_fd+1, NULL, &write_set_fds, NULL, &tv);
199+ tv.tv_sec = 1; tv.tv_usec = 0; /* willing to wait this long next time*/
200+ if (select_retval) {
201+ if ((rv = write(self->x_fd, cp, size)) == -1) {
202+ if (errno != EAGAIN) {
203+ PyErr_SetFromErrno(LinuxAudioError);
204+ return NULL;
205+ } else {
206+ errno = 0; /* EAGAIN: buffer is full, try again */
207+ }
208+ } else {
209+ self->x_ocount += rv;
210+ size -= rv;
211+ cp += rv;
212+ }
213+ } else {
214+ /* printf("Not able to write to linux audio device within %ld seconds\n", tv.tv_sec); */
215+ PyErr_SetFromErrno(LinuxAudioError);
216+ return NULL;
217+ }
218+ }
219+ Py_INCREF(Py_None);
220+ return Py_None;
221+}
222+
223+static PyObject *
224+lad_close(lad_t *self, PyObject *unused)
225+{
226+ if (self->x_fd >= 0) {
227+ close(self->x_fd);
228+ self->x_fd = -1;
229+ }
230+ Py_RETURN_NONE;
231+}
232+
233+static PyObject *
234+lad_fileno(lad_t *self, PyObject *unused)
235+{
236+ return PyInt_FromLong(self->x_fd);
237+}
238+
239+static PyObject *
240+lad_setparameters(lad_t *self, PyObject *args)
241+{
242+ int rate, ssize, nchannels, n, fmt, emulate=0;
243+
244+ if (!PyArg_ParseTuple(args, "iiii|i:setparameters",
245+ &rate, &ssize, &nchannels, &fmt, &emulate))
246+ return NULL;
247+
248+ if (rate < 0) {
249+ PyErr_Format(PyExc_ValueError, "expected rate >= 0, not %d",
250+ rate);
251+ return NULL;
252+ }
253+ if (ssize < 0) {
254+ PyErr_Format(PyExc_ValueError, "expected sample size >= 0, not %d",
255+ ssize);
256+ return NULL;
257+ }
258+ if (nchannels != 1 && nchannels != 2) {
259+ PyErr_Format(PyExc_ValueError, "nchannels must be 1 or 2, not %d",
260+ nchannels);
261+ return NULL;
262+ }
263+
264+ for (n = 0; n < n_audio_types; n++)
265+ if (fmt == audio_types[n].a_fmt)
266+ break;
267+ if (n == n_audio_types) {
268+ PyErr_Format(PyExc_ValueError, "unknown audio encoding: %d", fmt);
269+ return NULL;
270+ }
271+ if (audio_types[n].a_bps != ssize) {
272+ PyErr_Format(PyExc_ValueError,
273+ "for %s, expected sample size %d, not %d",
274+ audio_types[n].a_name, audio_types[n].a_bps, ssize);
275+ return NULL;
276+ }
277+
278+ if (emulate == 0) {
279+ if ((self->x_afmts & audio_types[n].a_fmt) == 0) {
280+ PyErr_Format(PyExc_ValueError,
281+ "%s format not supported by device",
282+ audio_types[n].a_name);
283+ return NULL;
284+ }
285+ }
286+ if (ioctl(self->x_fd, SNDCTL_DSP_SETFMT,
287+ &audio_types[n].a_fmt) == -1) {
288+ PyErr_SetFromErrno(LinuxAudioError);
289+ return NULL;
290+ }
291+ if (ioctl(self->x_fd, SNDCTL_DSP_CHANNELS, &nchannels) == -1) {
292+ PyErr_SetFromErrno(LinuxAudioError);
293+ return NULL;
294+ }
295+ if (ioctl(self->x_fd, SNDCTL_DSP_SPEED, &rate) == -1) {
296+ PyErr_SetFromErrno(LinuxAudioError);
297+ return NULL;
298+ }
299+
300+ Py_INCREF(Py_None);
301+ return Py_None;
302+}
303+
304+static int
305+_ssize(lad_t *self, int *nchannels, int *ssize)
306+{
307+ int fmt;
308+
309+ fmt = 0;
310+ if (ioctl(self->x_fd, SNDCTL_DSP_SETFMT, &fmt) < 0)
311+ return -errno;
312+
313+ switch (fmt) {
314+ case AFMT_MU_LAW:
315+ case AFMT_A_LAW:
316+ case AFMT_U8:
317+ case AFMT_S8:
318+ *ssize = sizeof(char);
319+ break;
320+ case AFMT_S16_LE:
321+ case AFMT_S16_BE:
322+ case AFMT_U16_LE:
323+ case AFMT_U16_BE:
324+ *ssize = sizeof(short);
325+ break;
326+ case AFMT_MPEG:
327+ case AFMT_IMA_ADPCM:
328+ default:
329+ return -EOPNOTSUPP;
330+ }
331+ if (ioctl(self->x_fd, SNDCTL_DSP_CHANNELS, nchannels) < 0)
332+ return -errno;
333+ return 0;
334+}
335+
336+
337+/* bufsize returns the size of the hardware audio buffer in number
338+ of samples */
339+static PyObject *
340+lad_bufsize(lad_t *self, PyObject *unused)
341+{
342+ audio_buf_info ai;
343+ int nchannels=0, ssize=0;
344+
345+ if (_ssize(self, &nchannels, &ssize) < 0 || !ssize || !nchannels) {
346+ PyErr_SetFromErrno(LinuxAudioError);
347+ return NULL;
348+ }
349+ if (ioctl(self->x_fd, SNDCTL_DSP_GETOSPACE, &ai) < 0) {
350+ PyErr_SetFromErrno(LinuxAudioError);
351+ return NULL;
352+ }
353+ return PyInt_FromLong((ai.fragstotal * ai.fragsize) / (nchannels * ssize));
354+}
355+
356+/* obufcount returns the number of samples that are available in the
357+ hardware for playing */
358+static PyObject *
359+lad_obufcount(lad_t *self, PyObject *unused)
360+{
361+ audio_buf_info ai;
362+ int nchannels=0, ssize=0;
363+
364+ if (_ssize(self, &nchannels, &ssize) < 0 || !ssize || !nchannels) {
365+ PyErr_SetFromErrno(LinuxAudioError);
366+ return NULL;
367+ }
368+ if (ioctl(self->x_fd, SNDCTL_DSP_GETOSPACE, &ai) < 0) {
369+ PyErr_SetFromErrno(LinuxAudioError);
370+ return NULL;
371+ }
372+ return PyInt_FromLong((ai.fragstotal * ai.fragsize - ai.bytes) /
373+ (ssize * nchannels));
374+}
375+
376+/* obufcount returns the number of samples that can be played without
377+ blocking */
378+static PyObject *
379+lad_obuffree(lad_t *self, PyObject *unused)
380+{
381+ audio_buf_info ai;
382+ int nchannels=0, ssize=0;
383+
384+ if (_ssize(self, &nchannels, &ssize) < 0 || !ssize || !nchannels) {
385+ PyErr_SetFromErrno(LinuxAudioError);
386+ return NULL;
387+ }
388+ if (ioctl(self->x_fd, SNDCTL_DSP_GETOSPACE, &ai) < 0) {
389+ PyErr_SetFromErrno(LinuxAudioError);
390+ return NULL;
391+ }
392+ return PyInt_FromLong(ai.bytes / (ssize * nchannels));
393+}
394+
395+/* Flush the device */
396+static PyObject *
397+lad_flush(lad_t *self, PyObject *unused)
398+{
399+ if (ioctl(self->x_fd, SNDCTL_DSP_SYNC, NULL) == -1) {
400+ PyErr_SetFromErrno(LinuxAudioError);
401+ return NULL;
402+ }
403+ Py_RETURN_NONE;
404+}
405+
406+static PyObject *
407+lad_getptr(lad_t *self, PyObject *unused)
408+{
409+ count_info info;
410+ int req;
411+
412+ if (self->x_mode == O_RDONLY)
413+ req = SNDCTL_DSP_GETIPTR;
414+ else
415+ req = SNDCTL_DSP_GETOPTR;
416+ if (ioctl(self->x_fd, req, &info) == -1) {
417+ PyErr_SetFromErrno(LinuxAudioError);
418+ return NULL;
419+ }
420+ return Py_BuildValue("iii", info.bytes, info.blocks, info.ptr);
421+}
422+
423+static PyMethodDef lad_methods[] = {
424+ { "read", (PyCFunction)lad_read, METH_VARARGS },
425+ { "write", (PyCFunction)lad_write, METH_VARARGS },
426+ { "setparameters", (PyCFunction)lad_setparameters, METH_VARARGS },
427+ { "bufsize", (PyCFunction)lad_bufsize, METH_VARARGS },
428+ { "obufcount", (PyCFunction)lad_obufcount, METH_NOARGS },
429+ { "obuffree", (PyCFunction)lad_obuffree, METH_NOARGS },
430+ { "flush", (PyCFunction)lad_flush, METH_NOARGS },
431+ { "close", (PyCFunction)lad_close, METH_NOARGS },
432+ { "fileno", (PyCFunction)lad_fileno, METH_NOARGS },
433+ { "getptr", (PyCFunction)lad_getptr, METH_NOARGS },
434+ { NULL, NULL} /* sentinel */
435+};
436+
437+static PyObject *
438+lad_getattr(lad_t *xp, char *name)
439+{
440+ return Py_FindMethod(lad_methods, (PyObject *)xp, name);
441+}
442+
443+static PyTypeObject Ladtype = {
444+ PyObject_HEAD_INIT(&PyType_Type)
445+ 0, /*ob_size*/
446+ "linuxaudiodev.linux_audio_device", /*tp_name*/
447+ sizeof(lad_t), /*tp_size*/
448+ 0, /*tp_itemsize*/
449+ /* methods */
450+ (destructor)lad_dealloc, /*tp_dealloc*/
451+ 0, /*tp_print*/
452+ (getattrfunc)lad_getattr, /*tp_getattr*/
453+ 0, /*tp_setattr*/
454+ 0, /*tp_compare*/
455+ 0, /*tp_repr*/
456+};
457+
458+static PyObject *
459+ladopen(PyObject *self, PyObject *args)
460+{
461+ return (PyObject *)newladobject(args);
462+}
463+
464+static PyMethodDef linuxaudiodev_methods[] = {
465+ { "open", ladopen, METH_VARARGS },
466+ { 0, 0 },
467+};
468+
469+void
470+initlinuxaudiodev(void)
471+{
472+ PyObject *m;
473+
474+ m = Py_InitModule("linuxaudiodev", linuxaudiodev_methods);
475+ if (m == NULL)
476+ return;
477+
478+ LinuxAudioError = PyErr_NewException("linuxaudiodev.error", NULL, NULL);
479+ if (LinuxAudioError)
480+ PyModule_AddObject(m, "error", LinuxAudioError);
481+
482+ if (PyModule_AddIntConstant(m, "AFMT_MU_LAW", (long)AFMT_MU_LAW) == -1)
483+ return;
484+ if (PyModule_AddIntConstant(m, "AFMT_A_LAW", (long)AFMT_A_LAW) == -1)
485+ return;
486+ if (PyModule_AddIntConstant(m, "AFMT_U8", (long)AFMT_U8) == -1)
487+ return;
488+ if (PyModule_AddIntConstant(m, "AFMT_S8", (long)AFMT_S8) == -1)
489+ return;
490+ if (PyModule_AddIntConstant(m, "AFMT_U16_BE", (long)AFMT_U16_BE) == -1)
491+ return;
492+ if (PyModule_AddIntConstant(m, "AFMT_U16_LE", (long)AFMT_U16_LE) == -1)
493+ return;
494+ if (PyModule_AddIntConstant(m, "AFMT_S16_BE", (long)AFMT_S16_BE) == -1)
495+ return;
496+ if (PyModule_AddIntConstant(m, "AFMT_S16_LE", (long)AFMT_S16_LE) == -1)
497+ return;
498+ if (PyModule_AddIntConstant(m, "AFMT_S16_NE", (long)AFMT_S16_NE) == -1)
499+ return;
500+
501+ return;
502+}

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t