From b0b6de5e6c61fe92452bf057d2f0677a3d1fec9b Mon Sep 17 00:00:00 2001 From: Walter Bender Date: Fri, 20 Feb 2009 16:12:44 +0000 Subject: silbe patch to build alsaaudio on first launch --- (limited to 'arch_src/pyalsaaudio-0.2/.svn/text-base/alsaaudio.c.svn-base') diff --git a/arch_src/pyalsaaudio-0.2/.svn/text-base/alsaaudio.c.svn-base b/arch_src/pyalsaaudio-0.2/.svn/text-base/alsaaudio.c.svn-base new file mode 100644 index 0000000..1828148 --- /dev/null +++ b/arch_src/pyalsaaudio-0.2/.svn/text-base/alsaaudio.c.svn-base @@ -0,0 +1,1013 @@ +/* + * alsaaudio -- Python interface to ALSA (Advanced Linux Sound Architecture). + * The standard audio API for Linux since kernel 2.6 + * + * Contributed by Unispeed A/S (http://www.unispeed.com) + * Author: Casper Wilstup (cwi@unispeed.dk) + * + * License: Python Software Foundation License + * + */ + +#include "Python.h" +#include +#include + +PyDoc_STRVAR(alsaaudio_module_doc, + "This modules provides support for the ALSA audio API.\n" + "\n" + "To control the PCM device, use the PCM class, Mixers\n" + "are controlled using the Mixer class.\n" + "\n" + "The following functions are also provided:\n" + "mixers() -- Return a list of available mixer names\n" + ); + +typedef struct { + PyObject_HEAD; + int pcmtype; + int pcmmode; + char *cardname; + + snd_pcm_t *handle; + + // Configurable parameters + int channels; + int rate; + int format; + snd_pcm_uframes_t periodsize; + int framesize; + +} alsapcm_t; + +typedef struct { + PyObject_HEAD; + + /* Mixer identification */ + char *cardname; + char *controlname; + int controlid; + + /* Capabilities */ + unsigned int volume_cap; + unsigned int switch_cap; + unsigned int pchannels; + unsigned int cchannels; + + /* min and max values for playback and capture volumes */ + long pmin; + long pmax; + long cmin; + long cmax; + snd_mixer_t *handle; + +} alsamixer_t; + +static PyObject *ALSAAudioError; + + +/******************************************/ +/* PCM object wrapper */ +/******************************************/ + +static PyTypeObject ALSAPCMType; + +static int alsapcm_setup(alsapcm_t *self) { + int res,dir; + unsigned int val; + snd_pcm_uframes_t frames; + snd_pcm_hw_params_t *hwparams; + + if (self->handle) { + snd_pcm_close(self->handle); + self->handle = 0; + } + res = snd_pcm_open(&(self->handle),self->cardname,self->pcmtype,self->pcmmode); + if (res < 0) return res; + + /* Allocate a hwparam structure, and fill it in with configuration space */ + snd_pcm_hw_params_alloca(&hwparams); + res = snd_pcm_hw_params_any(self->handle, hwparams); + if (res < 0) return res; + + /* Fill it in with default values. */ + snd_pcm_hw_params_any(self->handle, hwparams); + snd_pcm_hw_params_set_access(self->handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED); + snd_pcm_hw_params_set_format(self->handle, hwparams, self->format); + snd_pcm_hw_params_set_channels(self->handle, hwparams, self->channels); + dir = 0; + snd_pcm_hw_params_set_rate(self->handle, hwparams, self->rate, dir); + snd_pcm_hw_params_set_period_size(self->handle, hwparams, self->periodsize, dir); + snd_pcm_hw_params_set_periods(self->handle,hwparams,4,0); + + /* Write it to the device */ + res = snd_pcm_hw_params(self->handle, hwparams); + if (res) return res; + + /* Query current settings. These may differ from the requested values, + which should therefore be sync'ed with actual values */ + snd_pcm_hw_params_current(self->handle,hwparams); + + snd_pcm_hw_params_get_format(hwparams,&val); self->format = val; + snd_pcm_hw_params_get_channels(hwparams,&val); self->channels = val; + snd_pcm_hw_params_get_rate(hwparams,&val,&dir); self->rate = val; + snd_pcm_hw_params_get_period_size(hwparams,&frames,&dir); self->periodsize = (int) frames; + + self->framesize = self->channels * snd_pcm_hw_params_get_sbits(hwparams)/8; + return res; +} + +static PyObject * +alsapcm_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { + int res; + alsapcm_t *self; + int pcmtype=0; + int pcmmode=0; + char *cardname = "default"; + if (!PyArg_ParseTuple(args,"|iis",&pcmtype,&pcmmode,&cardname)) return NULL; + if (!(self = (alsapcm_t *)PyObject_New(alsapcm_t, &ALSAPCMType))) return NULL; + + if (pcmtype != SND_PCM_STREAM_PLAYBACK && pcmtype != SND_PCM_STREAM_CAPTURE) { + PyErr_SetString(ALSAAudioError, "PCM type must be PCM_PLAYBACK (0) or PCM_CAPTUPE (1)"); + return NULL; + } + if (pcmmode < 0 || pcmmode > SND_PCM_ASYNC) { + PyErr_SetString(ALSAAudioError, "Invalid PCM mode"); + return NULL; + } + self->pcmtype = pcmtype; + self->pcmmode = pcmmode; + self->cardname = strdup(cardname); + + self->channels = 2; + self->rate = 44100; + self->format = SND_PCM_FORMAT_S16_LE; + self->periodsize = 32; + + self->handle = 0; + res = alsapcm_setup(self); + + if (res < 0) { + if (self->handle) { + snd_pcm_close(self->handle); + self->handle = 0; + } + PyErr_SetString(ALSAAudioError, snd_strerror(res)); + return NULL; + } + return (PyObject *)self; +} + +static void alsapcm_dealloc(alsapcm_t *self) { + if (self->handle) { + snd_pcm_drain(self->handle); + snd_pcm_close(self->handle); + } + free(self->cardname); + PyObject_Del(self); +} + +static PyObject * +alsapcm_dumpinfo(alsapcm_t *self, PyObject *args) { + unsigned int val,val2; + int dir; + snd_pcm_uframes_t frames; + snd_pcm_hw_params_t *hwparams; + snd_pcm_hw_params_alloca(&hwparams); + snd_pcm_hw_params_current(self->handle,hwparams); + + + if (!PyArg_ParseTuple(args,"")) return NULL; + + printf("PCM handle name = '%s'\n", snd_pcm_name(self->handle)); + printf("PCM state = %s\n", snd_pcm_state_name(snd_pcm_state(self->handle))); + + snd_pcm_hw_params_get_access(hwparams, (snd_pcm_access_t *) &val); + printf("access type = %s\n", snd_pcm_access_name((snd_pcm_access_t)val)); + + snd_pcm_hw_params_get_format(hwparams, &val); + printf("format = '%s' (%s)\n", + snd_pcm_format_name((snd_pcm_format_t)val), + snd_pcm_format_description((snd_pcm_format_t)val)); + + snd_pcm_hw_params_get_subformat(hwparams, (snd_pcm_subformat_t *)&val); + printf("subformat = '%s' (%s)\n", + snd_pcm_subformat_name((snd_pcm_subformat_t)val), + snd_pcm_subformat_description((snd_pcm_subformat_t)val)); + + snd_pcm_hw_params_get_channels(hwparams, &val); + printf("channels = %d\n", val); + + snd_pcm_hw_params_get_rate(hwparams, &val, &dir); + printf("rate = %d bps\n", val); + + snd_pcm_hw_params_get_period_time(hwparams, &val, &dir); + printf("period time = %d us\n", val); + + snd_pcm_hw_params_get_period_size(hwparams, &frames, &dir); + printf("period size = %d frames\n", (int)frames); + + snd_pcm_hw_params_get_buffer_time(hwparams, &val, &dir); + printf("buffer time = %d us\n", val); + + snd_pcm_hw_params_get_buffer_size(hwparams, (snd_pcm_uframes_t *) &val); + printf("buffer size = %d frames\n", val); + + snd_pcm_hw_params_get_periods(hwparams, &val, &dir); + printf("periods per buffer = %d frames\n", val); + + snd_pcm_hw_params_get_rate_numden(hwparams, &val, &val2); + printf("exact rate = %d/%d bps\n", val, val2); + + val = snd_pcm_hw_params_get_sbits(hwparams); + printf("significant bits = %d\n", val); + + snd_pcm_hw_params_get_tick_time(hwparams, &val, &dir); + printf("tick time = %d us\n", val); + + val = snd_pcm_hw_params_is_batch(hwparams); + printf("is batch = %d\n", val); + + val = snd_pcm_hw_params_is_block_transfer(hwparams); + printf("is block transfer = %d\n", val); + + val = snd_pcm_hw_params_is_double(hwparams); + printf("is double = %d\n", val); + + val = snd_pcm_hw_params_is_half_duplex(hwparams); + printf("is half duplex = %d\n", val); + + val = snd_pcm_hw_params_is_joint_duplex(hwparams); + printf("is joint duplex = %d\n", val); + + val = snd_pcm_hw_params_can_overrange(hwparams); + printf("can overrange = %d\n", val); + + val = snd_pcm_hw_params_can_mmap_sample_resolution(hwparams); + printf("can mmap = %d\n", val); + + val = snd_pcm_hw_params_can_pause(hwparams); + printf("can pause = %d\n", val); + + val = snd_pcm_hw_params_can_resume(hwparams); + printf("can resume = %d\n", val); + + val = snd_pcm_hw_params_can_sync_start(hwparams); + printf("can sync start = %d\n", val); + + Py_INCREF(Py_None); + return Py_None; + +} + +static PyObject * +alsapcm_pcmtype(alsapcm_t *self, PyObject *args) { + if (!PyArg_ParseTuple(args,"")) return NULL; + return PyInt_FromLong(self->pcmtype); +} + +static PyObject * +alsapcm_pcmmode(alsapcm_t *self, PyObject *args) { + if (!PyArg_ParseTuple(args,"")) return NULL; + return PyInt_FromLong(self->pcmmode); +} + +static PyObject * +alsapcm_cardname(alsapcm_t *self, PyObject *args) { + if (!PyArg_ParseTuple(args,"")) return NULL; + return PyString_FromString(self->cardname); +} + +static PyObject * +alsapcm_setchannels(alsapcm_t *self, PyObject *args) { + int channels; + int res; + if (!PyArg_ParseTuple(args,"i",&channels)) return NULL; + self->channels = channels; + res = alsapcm_setup(self); + if (res < 0) { + PyErr_SetString(ALSAAudioError, snd_strerror(res)); + return NULL; + } + return PyInt_FromLong(self->channels); +} + +static PyObject * +alsapcm_setrate(alsapcm_t *self, PyObject *args) { + int rate; + int res; + if (!PyArg_ParseTuple(args,"i",&rate)) return NULL; + self->rate = rate; + res = alsapcm_setup(self); + if (res < 0) { + PyErr_SetString(ALSAAudioError, snd_strerror(res)); + return NULL; + } + return PyInt_FromLong(self->rate); +} + +static PyObject * +alsapcm_setformat(alsapcm_t *self, PyObject *args) { + int format; + int res; + if (!PyArg_ParseTuple(args,"i",&format)) return NULL; + self->format = format; + res = alsapcm_setup(self); + if (res < 0) { + PyErr_SetString(ALSAAudioError, snd_strerror(res)); + return NULL; + } + return PyInt_FromLong(self->format); +} + +static PyObject * +alsapcm_setperiodsize(alsapcm_t *self, PyObject *args) { + int periodsize; + int res; + if (!PyArg_ParseTuple(args,"i",&periodsize)) return NULL; + self->periodsize = periodsize; + res = alsapcm_setup(self); + if (res < 0) { + PyErr_SetString(ALSAAudioError, snd_strerror(res)); + return NULL; + } + return PyInt_FromLong(self->periodsize); +} + + +static PyObject * +alsapcm_read(alsapcm_t *self, PyObject *args) { + int res; + char buffer[8000]; + + if (self->framesize * self->periodsize > 8000) { + PyErr_SetString(ALSAAudioError,"Capture data too large. Try decreasing period size"); + return NULL; + } + + if (!PyArg_ParseTuple(args,"")) return NULL; + if (self->pcmtype != SND_PCM_STREAM_CAPTURE) { + PyErr_SetString(ALSAAudioError,"Cannot read from playback PCM"); + return NULL; + } + + res = snd_pcm_readi(self->handle, buffer, self->periodsize); + if (res == -EPIPE) { + /* EPIPE means overrun */ + snd_pcm_prepare(self->handle); + } + else if (res == -EAGAIN) { + res = 0; + } + else if (res < 0) { + PyErr_SetString(ALSAAudioError,snd_strerror(res)); + return NULL; + } + + return Py_BuildValue("is#",res,buffer,res*self->framesize); +} + +static PyObject *alsapcm_write(alsapcm_t *self, PyObject *args) { + char *data; + int datalen; + int res; + if (!PyArg_ParseTuple(args,"s#",&data,&datalen)) return NULL; + if (datalen%self->framesize) { + PyErr_SetString(ALSAAudioError,"Data size must be a multiple of framesize"); + return NULL; + } + res = snd_pcm_writei(self->handle, data, datalen/self->framesize); + if (res == -EPIPE) { + /* EPIPE means underrun */ + snd_pcm_prepare(self->handle); + snd_pcm_writei(self->handle, data, datalen/self->framesize); + snd_pcm_writei(self->handle, data, datalen/self->framesize); + } + else if (res == -EAGAIN) { + return PyInt_FromLong(0); + } + else if (res < 0) { + PyErr_SetString(ALSAAudioError,snd_strerror(res)); + return NULL; + } + return PyInt_FromLong(res); +} + + +/* ALSA PCM Object Bureaucracy */ + +static PyMethodDef alsapcm_methods[] = { + {"pcmtype", (PyCFunction)alsapcm_pcmtype, METH_VARARGS}, + {"pcmmode", (PyCFunction)alsapcm_pcmmode, METH_VARARGS}, + {"cardname", (PyCFunction)alsapcm_cardname, METH_VARARGS}, + {"setchannels", (PyCFunction)alsapcm_setchannels, METH_VARARGS}, + {"setrate", (PyCFunction)alsapcm_setrate, METH_VARARGS}, + {"setformat", (PyCFunction)alsapcm_setformat, METH_VARARGS}, + {"setperiodsize", (PyCFunction)alsapcm_setperiodsize, METH_VARARGS}, + + {"dumpinfo", (PyCFunction)alsapcm_dumpinfo, METH_VARARGS}, + + {"read", (PyCFunction)alsapcm_read, METH_VARARGS}, + {"write", (PyCFunction)alsapcm_write, METH_VARARGS}, + + {NULL, NULL} +}; + +static PyObject * +alsapcm_getattr(alsapcm_t *self, char *name) { + return Py_FindMethod(alsapcm_methods, (PyObject *)self, name); +} + +static PyTypeObject ALSAPCMType = { + PyObject_HEAD_INIT(&PyType_Type) + 0, /*ob_size*/ + "alsaaudio.pcm", /*tp_name*/ + sizeof(alsapcm_t), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) alsapcm_dealloc, /*tp_dealloc*/ + 0, /*print*/ + (getattrfunc)alsapcm_getattr, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT, /*tp_flags*/ + "ALSA PCM device", /*tp_doc*/ +}; + + +/******************************************/ +/* Mixer object wrapper */ +/******************************************/ + +static PyTypeObject ALSAMixerType; + +#define MIXER_CAP_VOLUME 0x0001 +#define MIXER_CAP_VOLUME_JOINED 0x0002 +#define MIXER_CAP_PVOLUME 0x0004 +#define MIXER_CAP_PVOLUME_JOINED 0x0008 +#define MIXER_CAP_CVOLUME 0x0010 +#define MIXER_CAP_CVOLUME_JOINED 0x0020 + +#define MIXER_CAP_SWITCH 0x0001 +#define MIXER_CAP_SWITCH_JOINED 0x0002 +#define MIXER_CAP_PSWITCH 0x0004 +#define MIXER_CAP_PSWITCH_JOINED 0x0008 +#define MIXER_CAP_CSWITCH 0x0010 +#define MIXER_CAP_CSWITCH_JOINED 0x0020 +#define MIXER_CAP_CSWITCH_EXCLUSIVE 0x0040 + +#define MIXER_CHANNEL_ALL -1 + +int +alsamixer_gethandle(char *cardname, snd_mixer_t **handle) { + int err; + if ((err = snd_mixer_open(handle, 0)) < 0) return err; + if ((err = snd_mixer_attach(*handle, cardname)) < 0) return err; + if ((err = snd_mixer_selem_register(*handle, NULL, NULL)) < 0) return err; + if ((err = snd_mixer_load(*handle)) < 0) return err; + + return 0; +} + +static PyObject * +alsamixer_list(PyObject *self, PyObject *args) { + snd_mixer_t *handle; + snd_mixer_selem_id_t *sid; + snd_mixer_elem_t *elem; + int err; + char *cardname = "default"; + PyObject *result = PyList_New(0); + + if (!PyArg_ParseTuple(args,"|s",&cardname)) return NULL; + + snd_mixer_selem_id_alloca(&sid); + err = alsamixer_gethandle(cardname,&handle); + if (err < 0) { + PyErr_SetString(ALSAAudioError,snd_strerror(err)); + snd_mixer_close(handle); + return NULL; + } + for (elem = snd_mixer_first_elem(handle); elem; elem = snd_mixer_elem_next(elem)) { + PyObject *mixer; + snd_mixer_selem_get_id(elem, sid); + mixer = PyString_FromString(snd_mixer_selem_id_get_name(sid)); + PyList_Append(result,mixer); + Py_DECREF(mixer); + } + snd_mixer_close(handle); + + return result; +} + +static snd_mixer_elem_t * +alsamixer_find_elem(snd_mixer_t *handle, char *control, int id) { + snd_mixer_selem_id_t *sid; + + snd_mixer_selem_id_alloca(&sid); + snd_mixer_selem_id_set_index(sid, id); + snd_mixer_selem_id_set_name(sid, control); + return snd_mixer_find_selem(handle, sid); +} + +static PyObject * +alsamixer_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { + alsamixer_t *self; + int err; + char *cardname = "default"; + char *control = "Master"; + int id = 0; + snd_mixer_elem_t *elem; + int channel; + + if (!PyArg_ParseTuple(args,"|sis",&control,&id,&cardname)) return NULL; + if (!(self = (alsamixer_t *)PyObject_New(alsamixer_t, &ALSAMixerType))) return NULL; + + err = alsamixer_gethandle(cardname,&self->handle); + if (err<0) { + PyErr_SetString(ALSAAudioError,snd_strerror(err)); + return NULL; + } + self->cardname = strdup(cardname); + self->controlname = strdup(control); + self->controlid = id; + + elem = alsamixer_find_elem(self->handle,control,id); + if (!elem) { + char errtext[128]; + sprintf(errtext,"Unable to find mixer control '%s',%i",self->controlname,self->controlid); + snd_mixer_close(self->handle); + PyErr_SetString(ALSAAudioError,errtext); + return NULL; + } + /* Determine mixer capabilities */ + self->volume_cap = self->switch_cap = 0; + if (snd_mixer_selem_has_common_volume(elem)) { + self->volume_cap |= MIXER_CAP_VOLUME; + if (snd_mixer_selem_has_playback_volume_joined(elem)) self->volume_cap |= MIXER_CAP_VOLUME_JOINED; + } + else { + if (snd_mixer_selem_has_playback_volume(elem)) { + self->volume_cap |= MIXER_CAP_PVOLUME; + if (snd_mixer_selem_has_playback_volume_joined(elem)) self->volume_cap |= MIXER_CAP_PVOLUME_JOINED; + } + if (snd_mixer_selem_has_capture_volume(elem)) { + self->volume_cap |= MIXER_CAP_CVOLUME; + if (snd_mixer_selem_has_capture_volume_joined(elem)) self->volume_cap |= MIXER_CAP_CVOLUME_JOINED; + } + } + + if (snd_mixer_selem_has_common_switch(elem)) { + self->switch_cap |= MIXER_CAP_SWITCH; + if (snd_mixer_selem_has_playback_switch_joined(elem)) self->switch_cap |= MIXER_CAP_SWITCH_JOINED; + } + else { + if (snd_mixer_selem_has_playback_switch(elem)) { + self->switch_cap |= MIXER_CAP_PSWITCH; + if (snd_mixer_selem_has_playback_switch_joined(elem)) self->switch_cap |= MIXER_CAP_PSWITCH_JOINED; + } + if (snd_mixer_selem_has_capture_switch(elem)) { + self->switch_cap |= MIXER_CAP_CSWITCH; + if (snd_mixer_selem_has_capture_switch_joined(elem)) self->switch_cap |= MIXER_CAP_CSWITCH_JOINED; + if (snd_mixer_selem_has_capture_switch_exclusive(elem)) self->switch_cap |= MIXER_CAP_CSWITCH_EXCLUSIVE; + } + } + self->pchannels = 0; + if (self->volume_cap | MIXER_CAP_PVOLUME || self->switch_cap | MIXER_CAP_PSWITCH) { + if (snd_mixer_selem_is_playback_mono(elem)) self->pchannels = 1; + else { + for (channel=0; channel <= SND_MIXER_SCHN_LAST; channel++) { + if (snd_mixer_selem_has_playback_channel(elem, channel)) self->pchannels++; + else break; + } + } + } + self->cchannels = 0; + if (self->volume_cap | MIXER_CAP_CVOLUME || self->switch_cap | MIXER_CAP_CSWITCH) { + if (snd_mixer_selem_is_capture_mono(elem)) self->cchannels = 1; + else { + for (channel=0; channel <= SND_MIXER_SCHN_LAST; channel++) { + if (snd_mixer_selem_has_capture_channel(elem, channel)) self->cchannels++; + else break; + } + } + } + snd_mixer_selem_get_playback_volume_range(elem, &self->pmin, &self->pmax); + snd_mixer_selem_get_capture_volume_range(elem, &self->cmin, &self->cmax); + return (PyObject *)self; +} + +static void alsamixer_dealloc(alsamixer_t *self) { + if (self->handle) { + snd_mixer_close(self->handle); + free(self->cardname); + free(self->controlname); + self->handle = 0; + } + PyObject_Del(self); +} + +static PyObject * +alsamixer_cardname(alsamixer_t *self, PyObject *args) { + if (!PyArg_ParseTuple(args,"")) return NULL; + return PyString_FromString(self->cardname); +} + +static PyObject * +alsamixer_mixer(alsamixer_t *self, PyObject *args) { + if (!PyArg_ParseTuple(args,"")) return NULL; + return PyString_FromString(self->controlname); +} + +static PyObject * +alsamixer_mixerid(alsamixer_t *self, PyObject *args) { + if (!PyArg_ParseTuple(args,"")) return NULL; + return PyInt_FromLong(self->controlid); +} + +static PyObject * +alsamixer_volumecap(alsamixer_t *self, PyObject *args) { + PyObject *result; + if (!PyArg_ParseTuple(args,"")) return NULL; + result = PyList_New(0); + if (self->volume_cap&MIXER_CAP_VOLUME) + PyList_Append(result,PyString_FromString("Volume")); + if (self->volume_cap&MIXER_CAP_VOLUME_JOINED) + PyList_Append(result,PyString_FromString("Joined Volume")); + if (self->volume_cap&MIXER_CAP_PVOLUME) + PyList_Append(result,PyString_FromString("Playback Volume")); + if (self->volume_cap&MIXER_CAP_PVOLUME_JOINED) + PyList_Append(result,PyString_FromString("Joined Playback Volume")); + if (self->volume_cap&MIXER_CAP_CVOLUME) + PyList_Append(result,PyString_FromString("Capture Volume")); + if (self->volume_cap&MIXER_CAP_CVOLUME_JOINED) + PyList_Append(result,PyString_FromString("Joined Capture Volume")); + + return result; +} +static PyObject * +alsamixer_switchcap(alsamixer_t *self, PyObject *args) { + PyObject *result; + if (!PyArg_ParseTuple(args,"")) return NULL; + result = PyList_New(0); + if (self->volume_cap&MIXER_CAP_SWITCH) + PyList_Append(result,PyString_FromString("Mute")); + if (self->volume_cap&MIXER_CAP_SWITCH_JOINED) + PyList_Append(result,PyString_FromString("Joined Mute")); + if (self->volume_cap&MIXER_CAP_PSWITCH) + PyList_Append(result,PyString_FromString("Playback Mute")); + if (self->volume_cap&MIXER_CAP_PSWITCH_JOINED) + PyList_Append(result,PyString_FromString("Joined Playback Mute")); + if (self->volume_cap&MIXER_CAP_CSWITCH) + PyList_Append(result,PyString_FromString("Capture Mute")); + if (self->volume_cap&MIXER_CAP_CSWITCH_JOINED) + PyList_Append(result,PyString_FromString("Joined Capture Mute")); + if (self->volume_cap&MIXER_CAP_CSWITCH_EXCLUSIVE) + PyList_Append(result,PyString_FromString("Capture Exclusive")); + return result; +} + +static int alsamixer_getpercentage(long min, long max, long value) { + /* Convert from number in range to percentage */ + int range = max - min; + int tmp; + + if (range == 0) return 0; + value -= min; + tmp = rint((double)value/(double)range * 100); + return tmp; + +} + +static long alsamixer_getphysvolume(long min, long max, int percentage) { + /* Convert from percentage to number in range */ + int range = max - min; + int tmp; + + if (range == 0) return 0; + tmp = rint((double)range * ((double)percentage*.01)) + min; + return tmp; +} + +static PyObject * +alsamixer_getvolume(alsamixer_t *self, PyObject *args) { + snd_mixer_elem_t *elem; + int direction; + int channel; + long ival; + char *dirstr = 0; + PyObject *result; + + if (!PyArg_ParseTuple(args,"|s",&dirstr)) return NULL; + + elem = alsamixer_find_elem(self->handle,self->controlname,self->controlid); + + if (!dirstr) { + if (self->pchannels) direction = 0; + else direction = 1; + } + else if (strcasecmp(dirstr,"playback")==0) direction = 0; + else if (strcasecmp(dirstr,"capture")==0) direction = 1; + else { + PyErr_SetString(ALSAAudioError,"Invalid direction argument for mixer"); + return NULL; + } + result = PyList_New(0); + for (channel = 0; channel <= SND_MIXER_SCHN_LAST; channel++) { + if (direction == 0 && snd_mixer_selem_has_playback_channel(elem, channel)) { + snd_mixer_selem_get_playback_volume(elem, channel, &ival); + PyList_Append(result,PyInt_FromLong(alsamixer_getpercentage(self->pmin,self->pmax,ival))); + } + else if (direction == 1 && snd_mixer_selem_has_capture_channel(elem, channel) + && snd_mixer_selem_has_capture_volume(elem)) { + snd_mixer_selem_get_capture_volume(elem, channel, &ival); + PyList_Append(result,PyInt_FromLong(alsamixer_getpercentage(self->cmin,self->cmax,ival))); + } + } + return result; +} + +static PyObject * +alsamixer_getmute(alsamixer_t *self, PyObject *args) { + snd_mixer_elem_t *elem; + int i; + int ival; + PyObject *result; + if (!PyArg_ParseTuple(args,"")) return NULL; + + elem = alsamixer_find_elem(self->handle,self->controlname,self->controlid); + if (!snd_mixer_selem_has_playback_switch(elem)) { + PyErr_SetString(ALSAAudioError,"Mixer has no mute switch"); + return NULL; + } + result = PyList_New(0); + for (i = 0; i <= SND_MIXER_SCHN_LAST; i++) { + if (snd_mixer_selem_has_playback_channel(elem, i)) { + snd_mixer_selem_get_playback_switch(elem, i, &ival); + PyList_Append(result,PyInt_FromLong(!ival)); + } + } + return result; +} + +static PyObject * +alsamixer_getrec(alsamixer_t *self, PyObject *args) { + snd_mixer_elem_t *elem; + int i; + int ival; + PyObject *result; + if (!PyArg_ParseTuple(args,"")) return NULL; + + elem = alsamixer_find_elem(self->handle,self->controlname,self->controlid); + if (!snd_mixer_selem_has_capture_switch(elem)) { + PyErr_SetString(ALSAAudioError,"Mixer has no record switch"); + return NULL; + } + result = PyList_New(0); + for (i = 0; i <= SND_MIXER_SCHN_LAST; i++) { + if (snd_mixer_selem_has_capture_channel(elem, i)) { + snd_mixer_selem_get_capture_switch(elem, i, &ival); + PyList_Append(result,PyInt_FromLong(!ival)); + } + } + return result; +} + +static PyObject * +alsamixer_setvolume(alsamixer_t *self, PyObject *args) { + snd_mixer_elem_t *elem; + int direction; + int i; + long volume; + int physvolume; + char *dirstr = 0; + int channel = MIXER_CHANNEL_ALL; + int done = 0; + + if (!PyArg_ParseTuple(args,"l|is",&volume,&channel,&dirstr)) return NULL; + if (volume < 0 || volume > 100) { + PyErr_SetString(ALSAAudioError,"Volume must be between 0 and 100"); + return NULL; + } + + elem = alsamixer_find_elem(self->handle,self->controlname,self->controlid); + + if (!dirstr) { + if (self->pchannels) direction = 0; + else direction = 1; + } + else if (strcasecmp(dirstr,"playback")==0) direction = 0; + else if (strcasecmp(dirstr,"capture")==0) direction = 1; + else { + PyErr_SetString(ALSAAudioError,"Invalid direction argument. Use 'playback' or 'capture'"); + return NULL; + } + for (i = 0; i <= SND_MIXER_SCHN_LAST; i++) { + if (channel == -1 || channel == i) { + if (direction == 0 && snd_mixer_selem_has_playback_channel(elem, i)) { + physvolume = alsamixer_getphysvolume(self->pmin,self->pmax,volume); + snd_mixer_selem_set_playback_volume(elem, i, physvolume); + done++; + } + else if (direction == 1 && snd_mixer_selem_has_capture_channel(elem, channel) + && snd_mixer_selem_has_capture_volume(elem)) { + physvolume = alsamixer_getphysvolume(self->cmin,self->cmax,volume); + snd_mixer_selem_set_capture_volume(elem, i, physvolume); + done++; + } + } + } + if(!done) { + PyErr_SetString(ALSAAudioError,"No such channel"); + return NULL; + } + Py_INCREF(Py_None); + return Py_None; +} + +static PyObject * +alsamixer_setmute(alsamixer_t *self, PyObject *args) { + snd_mixer_elem_t *elem; + int i; + int mute = 0; + int done = 0; + int channel = MIXER_CHANNEL_ALL; + if (!PyArg_ParseTuple(args,"i|i",&mute,&channel)) return NULL; + + elem = alsamixer_find_elem(self->handle,self->controlname,self->controlid); + if (!snd_mixer_selem_has_playback_switch(elem)) { + PyErr_SetString(ALSAAudioError,"Mixer has no mute switch"); + return NULL; + } + for (i = 0; i <= SND_MIXER_SCHN_LAST; i++) { + if (channel == MIXER_CHANNEL_ALL || channel == i) { + if (snd_mixer_selem_has_playback_channel(elem, i)) { + snd_mixer_selem_set_playback_switch(elem, i, !mute); + done++; + } + } + } + if (!done) { + PyErr_SetString(ALSAAudioError,"Invalid channel number"); + return NULL; + } + Py_INCREF(Py_None); + return Py_None; +} + +static PyObject * +alsamixer_setrec(alsamixer_t *self, PyObject *args) { + snd_mixer_elem_t *elem; + int i; + int rec = 0; + int done = 0; + int channel = MIXER_CHANNEL_ALL; + if (!PyArg_ParseTuple(args,"i|i",&rec,&channel)) return NULL; + + elem = alsamixer_find_elem(self->handle,self->controlname,self->controlid); + if (!snd_mixer_selem_has_capture_switch(elem)) { + PyErr_SetString(ALSAAudioError,"Mixer has no record switch"); + return NULL; + } + for (i = 0; i <= SND_MIXER_SCHN_LAST; i++) { + if (channel == MIXER_CHANNEL_ALL || channel == i) { + if (snd_mixer_selem_has_capture_channel(elem, i)) { + snd_mixer_selem_set_playback_switch(elem, i, rec); + done++; + } + } + } + if (!done) { + PyErr_SetString(ALSAAudioError,"Invalid channel number"); + return NULL; + } + Py_INCREF(Py_None); + return Py_None; +} + +static PyMethodDef alsamixer_methods[] = { + {"cardname", (PyCFunction)alsamixer_cardname, METH_VARARGS}, + {"mixer", (PyCFunction)alsamixer_mixer, METH_VARARGS}, + {"mixerid", (PyCFunction)alsamixer_mixerid, METH_VARARGS}, + {"switchcap", (PyCFunction)alsamixer_switchcap, METH_VARARGS}, + {"volumecap", (PyCFunction)alsamixer_volumecap, METH_VARARGS}, + {"getvolume", (PyCFunction)alsamixer_getvolume, METH_VARARGS}, + {"getmute", (PyCFunction)alsamixer_getmute, METH_VARARGS}, + {"getrec", (PyCFunction)alsamixer_getrec, METH_VARARGS}, + {"setvolume", (PyCFunction)alsamixer_setvolume, METH_VARARGS}, + {"setmute", (PyCFunction)alsamixer_setmute, METH_VARARGS}, + {"setrec", (PyCFunction)alsamixer_setrec, METH_VARARGS}, + {NULL, NULL} +}; + + +static PyObject * +alsamixer_getattr(alsapcm_t *self, char *name) { + return Py_FindMethod(alsamixer_methods, (PyObject *)self, name); +} + +static PyTypeObject ALSAMixerType = { + PyObject_HEAD_INIT(&PyType_Type) + 0, /*ob_size*/ + "alsaaudio.mixer", /*tp_name*/ + sizeof(alsamixer_t), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) alsamixer_dealloc, /*tp_dealloc*/ + 0, /*print*/ + (getattrfunc)alsamixer_getattr, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT, /*tp_flags*/ + "ALSA Mixer Control", /*tp_doc*/ +}; + + +/******************************************/ +/* Module initialization */ +/******************************************/ + +static PyMethodDef alsaaudio_methods[] = { + { "mixers", alsamixer_list, METH_VARARGS }, + { 0, 0 }, +}; + +#define _EXPORT_INT(mod, name, value) \ + if (PyModule_AddIntConstant(mod, name, (long) value) == -1) return; + +void initalsaaudio(void) { + PyObject *m; + ALSAPCMType.tp_new = alsapcm_new; + ALSAMixerType.tp_new = alsamixer_new; + m = Py_InitModule3("alsaaudio",alsaaudio_methods,alsaaudio_module_doc); + + ALSAAudioError = PyErr_NewException("alsaaudio.ALSAAudioError", NULL, NULL); + if (ALSAAudioError) { + /* Each call to PyModule_AddObject decrefs it; compensate: */ + + Py_INCREF(&ALSAPCMType); + PyModule_AddObject(m,"PCM",(PyObject *)&ALSAPCMType); + + Py_INCREF(&ALSAMixerType); + PyModule_AddObject(m,"Mixer",(PyObject *)&ALSAMixerType); + + Py_INCREF(ALSAAudioError); + PyModule_AddObject(m, "ALSAAudioError", ALSAAudioError); + } + + + _EXPORT_INT(m,"PCM_PLAYBACK",SND_PCM_STREAM_PLAYBACK); + _EXPORT_INT(m,"PCM_CAPTURE",SND_PCM_STREAM_CAPTURE); + + _EXPORT_INT(m,"PCM_NORMAL",0); + _EXPORT_INT(m,"PCM_NONBLOCK",SND_PCM_NONBLOCK); + _EXPORT_INT(m,"PCM_ASYNC",SND_PCM_ASYNC); + + /* PCM Formats */ + _EXPORT_INT(m,"PCM_FORMAT_S8",SND_PCM_FORMAT_S8); + _EXPORT_INT(m,"PCM_FORMAT_U8",SND_PCM_FORMAT_U8); + _EXPORT_INT(m,"PCM_FORMAT_S16_LE",SND_PCM_FORMAT_S16_LE); + _EXPORT_INT(m,"PCM_FORMAT_S16_BE",SND_PCM_FORMAT_S16_BE); + _EXPORT_INT(m,"PCM_FORMAT_U16_LE",SND_PCM_FORMAT_U16_LE); + _EXPORT_INT(m,"PCM_FORMAT_U16_BE",SND_PCM_FORMAT_U16_BE); + _EXPORT_INT(m,"PCM_FORMAT_S24_LE",SND_PCM_FORMAT_S24_LE); + _EXPORT_INT(m,"PCM_FORMAT_S24_BE",SND_PCM_FORMAT_S24_BE); + _EXPORT_INT(m,"PCM_FORMAT_U24_LE",SND_PCM_FORMAT_U24_LE); + _EXPORT_INT(m,"PCM_FORMAT_U24_BE",SND_PCM_FORMAT_U24_BE); + _EXPORT_INT(m,"PCM_FORMAT_S32_LE",SND_PCM_FORMAT_S32_LE); + _EXPORT_INT(m,"PCM_FORMAT_S32_BE",SND_PCM_FORMAT_S32_BE); + _EXPORT_INT(m,"PCM_FORMAT_U32_LE",SND_PCM_FORMAT_U32_LE); + _EXPORT_INT(m,"PCM_FORMAT_U32_BE",SND_PCM_FORMAT_U32_BE); + _EXPORT_INT(m,"PCM_FORMAT_FLOAT_LE",SND_PCM_FORMAT_FLOAT_LE); + _EXPORT_INT(m,"PCM_FORMAT_FLOAT_BE",SND_PCM_FORMAT_FLOAT_BE); + _EXPORT_INT(m,"PCM_FORMAT_FLOAT64_LE",SND_PCM_FORMAT_FLOAT64_LE); + _EXPORT_INT(m,"PCM_FORMAT_FLOAT64_BE",SND_PCM_FORMAT_FLOAT64_BE); + _EXPORT_INT(m,"PCM_FORMAT_MU_LAW",SND_PCM_FORMAT_MU_LAW); + _EXPORT_INT(m,"PCM_FORMAT_A_LAW",SND_PCM_FORMAT_A_LAW); + _EXPORT_INT(m,"PCM_FORMAT_IMA_ADPCM",SND_PCM_FORMAT_IMA_ADPCM); + _EXPORT_INT(m,"PCM_FORMAT_MPEG",SND_PCM_FORMAT_MPEG); + _EXPORT_INT(m,"PCM_FORMAT_GSM",SND_PCM_FORMAT_GSM); + + /* Mixer stuff */ + _EXPORT_INT(m,"MIXER_CHANNEL_ALL",MIXER_CHANNEL_ALL); + +} -- cgit v0.9.1