}
PyDoc_STRVAR(card_load__doc__,
-"cardLoad([card]) -- Load driver for given card.");
+"card_load([card]) -- Load driver for given card.");
static PyObject *
card_load(PyObject *self, PyObject *args, PyObject *kwds)
}
PyDoc_STRVAR(card_list__doc__,
-"cardList() -- Get a card number list in tuple.");
+"card_list() -- Get a card number list in tuple.");
static PyObject *
card_list(PyObject *self, PyObject *args)
}
PyDoc_STRVAR(card_get_index__doc__,
-"cardGetIndex(name) -- Get card index using ID string.");
+"card_get_index(name) -- Get card index using ID string.");
static PyObject *
card_get_index(PyObject *self, PyObject *args, PyObject *kwds)
}
PyDoc_STRVAR(card_get_name__doc__,
-"cardGetName(card) -- Get card name string using card index.");
+"card_get_name(card) -- Get card name string using card index.");
static PyObject *
card_get_name(PyObject *self, PyObject *args, PyObject *kwds)
}
PyDoc_STRVAR(card_get_longname__doc__,
-"cardGetLongname(card) -- Get long card name string using card index.");
+"card_get_longname(card) -- Get long card name string using card index.");
static PyObject *
card_get_longname(PyObject *self, PyObject *args, PyObject *kwds)
}
PyDoc_STRVAR(device_name_hint__doc__,
-"deviceNameHint(card, interface) -- Get device name hints.");
+"device_name_hint(card, interface) -- Get device name hints.");
static PyObject *
device_name_hint(PyObject *self, PyObject *args, PyObject *kwds)
*/
static PyMethodDef pyalsacardparse_methods[] = {
- {"asoundlibVersion", (PyCFunction)asoundlib_version, METH_NOARGS, asoundlib_version__doc__},
- {"cardLoad", (PyCFunction)card_load, METH_VARARGS|METH_KEYWORDS, card_load__doc__},
- {"cardList", (PyCFunction)card_list, METH_NOARGS, card_list__doc__},
- {"cardGetIndex", (PyCFunction)card_get_index, METH_VARARGS|METH_KEYWORDS, card_get_index__doc__},
- {"cardGetName", (PyCFunction)card_get_name, METH_VARARGS|METH_KEYWORDS, card_get_name__doc__},
- {"cardGetLongname", (PyCFunction)card_get_longname, METH_VARARGS|METH_KEYWORDS, card_get_longname__doc__},
- {"deviceNameHint", (PyCFunction)device_name_hint, METH_VARARGS|METH_KEYWORDS, device_name_hint__doc__},
+ {"asoundlib_version", (PyCFunction)asoundlib_version, METH_NOARGS, asoundlib_version__doc__},
+ {"card_load", (PyCFunction)card_load, METH_VARARGS|METH_KEYWORDS, card_load__doc__},
+ {"card_list", (PyCFunction)card_list, METH_NOARGS, card_list__doc__},
+ {"card_get_index", (PyCFunction)card_get_index, METH_VARARGS|METH_KEYWORDS, card_get_index__doc__},
+ {"card_get_name", (PyCFunction)card_get_name, METH_VARARGS|METH_KEYWORDS, card_get_name__doc__},
+ {"card_get_longname", (PyCFunction)card_get_longname, METH_VARARGS|METH_KEYWORDS, card_get_longname__doc__},
+ {"device_name_hint", (PyCFunction)device_name_hint, METH_VARARGS|METH_KEYWORDS, device_name_hint__doc__},
{NULL}
};
}
PyDoc_STRVAR(cardinfo__doc__,
-"cardInfo() -- Return a dictionary with card specific information.");
+"card_info() -- Return a dictionary with card specific information.");
static PyObject *
pyalsacontrol_cardinfo(struct pyalsacontrol *self, PyObject *args)
}
PyDoc_STRVAR(hwdepdevices__doc__,
-"hwdepDevices() -- Return a tuple with available hwdep devices.");
+"hwdep_devices() -- Return a tuple with available hwdep devices.");
static PyObject *
pyalsacontrol_hwdepdevices(struct pyalsacontrol *self, PyObject *args)
}
PyDoc_STRVAR(pcmdevices__doc__,
-"pcmDevices() -- Return a tuple with available PCM devices.");
+"pcm_devices() -- Return a tuple with available PCM devices.");
static PyObject *
pyalsacontrol_pcmdevices(struct pyalsacontrol *self, PyObject *args)
}
PyDoc_STRVAR(rawmididevices__doc__,
-"rawmidiDevices() -- Return a tuple with available RawMidi devices.");
+"rawmidi_devices() -- Return a tuple with available RawMidi devices.");
static PyObject *
pyalsacontrol_rawmididevices(struct pyalsacontrol *self, PyObject *args)
static PyMethodDef pyalsacontrol_methods[] = {
- {"cardInfo", (PyCFunction)pyalsacontrol_cardinfo, METH_NOARGS, cardinfo__doc__},
- {"hwdepDevices",(PyCFunction)pyalsacontrol_hwdepdevices, METH_NOARGS, hwdepdevices__doc__},
- {"pcmDevices", (PyCFunction)pyalsacontrol_pcmdevices, METH_NOARGS, pcmdevices__doc__},
- {"rawmidiDevices",(PyCFunction)pyalsacontrol_rawmididevices, METH_NOARGS, rawmididevices__doc__},
+ {"card_info", (PyCFunction)pyalsacontrol_cardinfo, METH_NOARGS, cardinfo__doc__},
+ {"hwdep_devices",(PyCFunction)pyalsacontrol_hwdepdevices, METH_NOARGS, hwdepdevices__doc__},
+ {"pcm_devices", (PyCFunction)pyalsacontrol_pcmdevices, METH_NOARGS, pcmdevices__doc__},
+ {"rawmidi_devices",(PyCFunction)pyalsacontrol_rawmididevices, METH_NOARGS, rawmididevices__doc__},
{NULL}
};
PyDict_SetItemString(d1, pname, o); \
Py_DECREF(o); }
- add_space1("Card", CARD);
- add_space1("HwDep", HWDEP);
- add_space1("Mixer", MIXER);
+ add_space1("CARD", CARD);
+ add_space1("HWDEP", HWDEP);
+ add_space1("MIXER", MIXER);
add_space1("PCM", PCM);
- add_space1("RawMidi", RAWMIDI);
- add_space1("Timer", TIMER);
- add_space1("Sequencer", SEQUENCER);
- add_space1("Last", LAST);
+ add_space1("RAWMIDI", RAWMIDI);
+ add_space1("TIMER", TIMER);
+ add_space1("SEQUENCER", SEQUENCER);
+ add_space1("LAST", LAST);
- PyDict_SetItemString(d, "InterfaceId", d1);
+ PyDict_SetItemString(d, "interface_id", d1);
Py_DECREF(d1);
/* ---- */
Py_DECREF(o);
}
- PyDict_SetItemString(d, "InterfaceName", l1);
+ PyDict_SetItemString(d, "interface_name", l1);
Py_DECREF(l1);
/* ---- */
PyDict_SetItemString(d1, pname, o); \
Py_DECREF(o); }
- add_space5("NonBlock", NONBLOCK);
- add_space5("Async", ASYNC);
- add_space5("ReadOnly", READONLY);
+ add_space5("NONBLOCK", NONBLOCK);
+ add_space5("ASYNC", ASYNC);
+ add_space5("READONLY", READONLY);
- PyDict_SetItemString(d, "OpenMode", d1);
+ PyDict_SetItemString(d, "open_mode", d1);
Py_DECREF(d1);
/* ---- */
}
PyDoc_STRVAR(handlevents__doc__,
-"handleEvents() -- Process waiting hcontrol events (and call appropriate callbacks).");
+"handle_events() -- Process waiting hcontrol events (and call appropriate callbacks).");
static PyObject *
pyalsahcontrol_handleevents(struct pyalsahcontrol *self, PyObject *args)
}
PyDoc_STRVAR(registerpoll__doc__,
-"registerPoll(pollObj) -- Register poll file descriptors.");
+"register_poll(pollObj) -- Register poll file descriptors.");
static PyObject *
pyalsahcontrol_registerpoll(struct pyalsahcontrol *self, PyObject *args)
}
PyDoc_STRVAR(elementnew__doc__,
-"elementNew(ElementType['Integer'], id, count, min, max, step)\n"
-"elementNew(ElementType['Integer64'], id, count, min64, max64, step64)\n"
-"elementNew(ElementType['Boolean'], id, count)\n"
-"elementNew(ElementType['IEC958'], id)\n"
+"element_new(element_type['INTEGER'], id, count, min, max, step)\n"
+"element_new(element_type['INTEGER64'], id, count, min64, max64, step64)\n"
+"element_new(element_type['BOOLEAN'], id, count)\n"
+"element_new(element_type['IEC958'], id)\n"
" -- Create a new hcontrol element.\n"
" -- The id argument is tuple (interface, device, subdevice, name, index).\n");
}
PyDoc_STRVAR(elementremove__doc__,
-"elementRemove(id)\n"
-"elementRemove(interface, device, subdevice, name, index)\n"
+"element_remove(id)\n"
+"element_remove(interface, device, subdevice, name, index)\n"
" -- Remove element.\n");
static PyObject *
}
PyDoc_STRVAR(elementlock__doc__,
-"elementLock(id)\n"
-"elementLock(interface, device, subdevice, name, index)\n"
+"element_lock(id)\n"
+"element_lock(interface, device, subdevice, name, index)\n"
" -- Lock element.\n");
static PyObject *
}
PyDoc_STRVAR(elementunlock__doc__,
-"elementUnlock(id)\n"
-"elementUnlock(interface, device, subdevice, name, index)\n"
+"element_unlock(id)\n"
+"element_unlock(interface, device, subdevice, name, index)\n"
" -- Unlock element.\n");
static PyObject *
static PyMethodDef pyalsahcontrol_methods[] = {
{"list", (PyCFunction)pyalsahcontrol_list, METH_NOARGS, list__doc__},
- {"elementNew", (PyCFunction)pyalsahcontrol_elementnew, METH_VARARGS, elementnew__doc__},
- {"elementRemove",(PyCFunction)pyalsahcontrol_elementremove, METH_VARARGS, elementremove__doc__},
- {"elementLock",(PyCFunction)pyalsahcontrol_elementlock, METH_VARARGS, elementlock__doc__},
- {"elementUnlock",(PyCFunction)pyalsahcontrol_elementunlock, METH_VARARGS, elementunlock__doc__},
- {"handleEvents",(PyCFunction)pyalsahcontrol_handleevents, METH_NOARGS, handlevents__doc__},
- {"registerPoll",(PyCFunction)pyalsahcontrol_registerpoll, METH_VARARGS|METH_KEYWORDS, registerpoll__doc__},
+ {"element_new", (PyCFunction)pyalsahcontrol_elementnew, METH_VARARGS, elementnew__doc__},
+ {"element_remove",(PyCFunction)pyalsahcontrol_elementremove, METH_VARARGS, elementremove__doc__},
+ {"element_lock",(PyCFunction)pyalsahcontrol_elementlock, METH_VARARGS, elementlock__doc__},
+ {"element_unlock",(PyCFunction)pyalsahcontrol_elementunlock, METH_VARARGS, elementunlock__doc__},
+ {"handle_events",(PyCFunction)pyalsahcontrol_handleevents, METH_NOARGS, handlevents__doc__},
+ {"register_poll",(PyCFunction)pyalsahcontrol_registerpoll, METH_VARARGS|METH_KEYWORDS, registerpoll__doc__},
{NULL}
};
}
PyDoc_STRVAR(setcallback__doc__,
-"setCallback(callObj) -- Set callback object.\n"
+"set_callback(callObj) -- Set callback object.\n"
"Note: callObj might have callObj.callback attribute.\n");
static PyObject *
{"lock", (PyCFunction)pyalsahcontrolelement_lock, METH_NOARGS, elock__doc__},
{"unlock", (PyCFunction)pyalsahcontrolelement_unlock, METH_NOARGS, eunlock__doc__},
- {"setCallback", (PyCFunction)pyalsahcontrolelement_setcallback, METH_VARARGS, setcallback__doc__},
+ {"set_callback",(PyCFunction)pyalsahcontrolelement_setcallback, METH_VARARGS, setcallback__doc__},
{NULL}
};
{"type", (getter)pyalsahcontrolinfo_uint, NULL, "hcontrol element index", snd_ctl_elem_info_get_type},
- {"isReadable", (getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is readable", snd_ctl_elem_info_is_readable},
- {"isWritable", (getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is writable",snd_ctl_elem_info_is_writable},
- {"isVolatile", (getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is volatile",snd_ctl_elem_info_is_volatile},
- {"isInactive", (getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is inactive",snd_ctl_elem_info_is_inactive},
- {"isLocked", (getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is locked",snd_ctl_elem_info_is_locked},
- {"isTlvReadable",(getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is TLV readable",snd_ctl_elem_info_is_tlv_readable},
- {"isTlvWritable",(getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is TLV writable",snd_ctl_elem_info_is_tlv_writable},
- {"isTlvCommandable",(getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is TLV commandable",snd_ctl_elem_info_is_tlv_commandable},
- {"isOwner", (getter)pyalsahcontrolinfo_bool, NULL, "this process is owner of this hcontrol element",snd_ctl_elem_info_is_owner},
- {"isUser", (getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is user element",snd_ctl_elem_info_is_user},
+ {"is_readable", (getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is readable", snd_ctl_elem_info_is_readable},
+ {"is_writable", (getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is writable",snd_ctl_elem_info_is_writable},
+ {"is_volatile", (getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is volatile",snd_ctl_elem_info_is_volatile},
+ {"is_inactive", (getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is inactive",snd_ctl_elem_info_is_inactive},
+ {"is_locked", (getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is locked",snd_ctl_elem_info_is_locked},
+ {"is_tlv_readable",(getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is TLV readable",snd_ctl_elem_info_is_tlv_readable},
+ {"is_tlv_Writable",(getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is TLV writable",snd_ctl_elem_info_is_tlv_writable},
+ {"is_tlv_Commandable",(getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is TLV commandable",snd_ctl_elem_info_is_tlv_commandable},
+ {"is_owner", (getter)pyalsahcontrolinfo_bool, NULL, "this process is owner of this hcontrol element",snd_ctl_elem_info_is_owner},
+ {"is_user", (getter)pyalsahcontrolinfo_bool, NULL, "hcontrol element is user element",snd_ctl_elem_info_is_user},
{"owner", (getter)pyalsahcontrolinfo_getowner, NULL, "get owner pid for this hcontrol element", NULL},
{"count", (getter)pyalsahcontrolinfo_uint, NULL, "get count of values", snd_ctl_elem_info_get_count},
{"items", (getter)pyalsahcontrolinfo_getitems, NULL, "get count of enumerated items", NULL},
{"dimensions", (getter)pyalsahcontrolinfo_dimensions, NULL, "get hcontrol element dimensions (in tuple)", NULL},
- {"itemNames", (getter)pyalsahcontrolinfo_itemnames, NULL, "get enumerated item names (in tuple)", NULL},
+ {"item_names", (getter)pyalsahcontrolinfo_itemnames, NULL, "get enumerated item names (in tuple)", NULL},
{NULL}
};
}
PyDoc_STRVAR(gettuple__doc__,
-"getTuple(type, count) -- Get hcontrol element values in tuple.");
+"get_tuple(type, count) -- Get hcontrol element values in tuple.");
PyDoc_STRVAR(getarray__doc__,
-"getArray(type, count) -- Get hcontrol element values in array.");
+"get_array(type, count) -- Get hcontrol element values in array.");
static PyObject *
pyalsahcontrolvalue_get1(struct pyalsahcontrolvalue *self, PyObject *args, int list)
PyDoc_STRVAR(settuple__doc__,
-"setTuple(type, val) -- Set hcontrol element values from tuple.");
+"set_tuple(type, val) -- Set hcontrol element values from tuple.");
PyDoc_STRVAR(setarray__doc__,
-"setArray(type, val) -- Set hcontrol element values from array.");
+"set_array(type, val) -- Set hcontrol element values from array.");
static PyObject *
pyalsahcontrolvalue_settuple(struct pyalsahcontrolvalue *self, PyObject *args)
static PyMethodDef pyalsahcontrolvalue_methods[] = {
- {"getTuple", (PyCFunction)pyalsahcontrolvalue_gettuple, METH_VARARGS, gettuple__doc__},
- {"getArray", (PyCFunction)pyalsahcontrolvalue_getarray, METH_VARARGS, getarray__doc__},
- {"setTuple", (PyCFunction)pyalsahcontrolvalue_settuple, METH_VARARGS, settuple__doc__},
- {"setArray", (PyCFunction)pyalsahcontrolvalue_settuple, METH_VARARGS, setarray__doc__},
+ {"get_tuple", (PyCFunction)pyalsahcontrolvalue_gettuple, METH_VARARGS, gettuple__doc__},
+ {"get_array", (PyCFunction)pyalsahcontrolvalue_getarray, METH_VARARGS, getarray__doc__},
+ {"set_tuple", (PyCFunction)pyalsahcontrolvalue_settuple, METH_VARARGS, settuple__doc__},
+ {"set_array", (PyCFunction)pyalsahcontrolvalue_settuple, METH_VARARGS, setarray__doc__},
{"read", (PyCFunction)pyalsahcontrolvalue_read, METH_NOARGS, read__doc__},
{"write", (PyCFunction)pyalsahcontrolvalue_write, METH_NOARGS, write__doc__},
PyDict_SetItemString(d1, pname, o); \
Py_DECREF(o); }
- add_space1("Card", CARD);
- add_space1("HwDep", HWDEP);
- add_space1("Mixer", MIXER);
+ add_space1("CARD", CARD);
+ add_space1("HWDEP", HWDEP);
+ add_space1("MIXER", MIXER);
add_space1("PCM", PCM);
- add_space1("RawMidi", RAWMIDI);
- add_space1("Timer", TIMER);
- add_space1("Sequencer", SEQUENCER);
- add_space1("Last", LAST);
+ add_space1("RAWMIDI", RAWMIDI);
+ add_space1("TIMER", TIMER);
+ add_space1("SEQUENCER", SEQUENCER);
+ add_space1("LAST", LAST);
- PyDict_SetItemString(d, "InterfaceId", d1);
+ PyDict_SetItemString(d, "interface_id", d1);
Py_DECREF(d1);
/* ---- */
Py_DECREF(o);
}
- PyDict_SetItemString(d, "InterfaceName", l1);
+ PyDict_SetItemString(d, "interface_name", l1);
Py_DECREF(l1);
/* ---- */
PyDict_SetItemString(d1, pname, o); \
Py_DECREF(o); }
- add_space2("None", NONE);
- add_space2("Boolean", BOOLEAN);
- add_space2("Integer", INTEGER);
- add_space2("Enumerated", ENUMERATED);
- add_space2("Bytes", BYTES);
+ add_space2("NONE", NONE);
+ add_space2("BOOLEAN", BOOLEAN);
+ add_space2("INTEGER", INTEGER);
+ add_space2("ENUMERATED", ENUMERATED);
+ add_space2("BYTES", BYTES);
add_space2("IEC958", IEC958);
- add_space2("Integer64", INTEGER64);
- add_space2("Last", LAST);
+ add_space2("INTEGER64", INTEGER64);
+ add_space2("LAST", LAST);
- PyDict_SetItemString(d, "ElementType", d1);
+ PyDict_SetItemString(d, "element_type", d1);
Py_DECREF(d1);
/* ---- */
Py_DECREF(o);
}
- PyDict_SetItemString(d, "ElementTypeName", l1);
+ PyDict_SetItemString(d, "element_type_name", l1);
Py_DECREF(l1);
/* ---- */
PyDict_SetItemString(d1, pname, o); \
Py_DECREF(o); }
- add_space3("Element", ELEM);
- add_space3("Last", LAST);
+ add_space3("ELEMENT", ELEM);
+ add_space3("LAST", LAST);
- PyDict_SetItemString(d, "EventClass", d1);
+ PyDict_SetItemString(d, "event_class", d1);
Py_DECREF(d1);
/* ---- */
PyDict_SetItemString(d1, pname, o); \
Py_DECREF(o); }
- add_space4("Value", VALUE);
- add_space4("Info", INFO);
- add_space4("Add", ADD);
+ add_space4("VALUS", VALUE);
+ add_space4("INFO", INFO);
+ add_space4("ADD", ADD);
add_space4("TLV", TLV);
- PyDict_SetItemString(d, "EventMask", d1);
+ PyDict_SetItemString(d, "event_mask", d1);
Py_DECREF(d1);
o = PyInt_FromLong(SND_CTL_EVENT_MASK_REMOVE);
- PyDict_SetItemString(d, "EventMaskRemove", o);
+ PyDict_SetItemString(d, "event_mask_remove", o);
Py_DECREF(o);
/* ---- */
PyDict_SetItemString(d1, pname, o); \
Py_DECREF(o); }
- add_space5("NonBlock", NONBLOCK);
- add_space5("Async", ASYNC);
- add_space5("ReadOnly", READONLY);
+ add_space5("NONBLOCK", NONBLOCK);
+ add_space5("ASYNC", ASYNC);
+ add_space5("READONLY", READONLY);
- PyDict_SetItemString(d, "OpenMode", d1);
+ PyDict_SetItemString(d, "open_mode", d1);
Py_DECREF(d1);
/* ---- */
}
PyDoc_STRVAR(handlevents__doc__,
-"handleEvents() -- Process waiting mixer events (and call appropriate callbacks).");
+"handle_events() -- Process waiting mixer events (and call appropriate callbacks).");
static PyObject *
pyalsamixer_handleevents(struct pyalsamixer *self, PyObject *args)
}
PyDoc_STRVAR(registerpoll__doc__,
-"registerPoll(pollObj) -- Register poll file descriptors.");
+"register_poll(pollObj) -- Register poll file descriptors.");
static PyObject *
pyalsamixer_registerpoll(struct pyalsamixer *self, PyObject *args)
{"load", (PyCFunction)pyalsamixer_load, METH_NOARGS, load__doc__},
{"free", (PyCFunction)pyalsamixer_free, METH_NOARGS, free__doc__},
{"list", (PyCFunction)pyalsamixer_list, METH_NOARGS, list__doc__},
- {"handleEvents",(PyCFunction)pyalsamixer_handleevents, METH_NOARGS, handlevents__doc__},
- {"registerPoll",(PyCFunction)pyalsamixer_registerpoll, METH_VARARGS, registerpoll__doc__},
+ {"handle_events",(PyCFunction)pyalsamixer_handleevents, METH_NOARGS, handlevents__doc__},
+ {"register_poll",(PyCFunction)pyalsamixer_registerpoll, METH_VARARGS, registerpoll__doc__},
{NULL}
};
}
PyDoc_STRVAR(ismono__doc__,
-"isMono([capture=False]]) -- Return if this control is mono.");
+"is_mono([capture=False]]) -- Return if this control is mono.");
static PyObject *
pyalsamixerelement_ismono(struct pyalsamixerelement *pyelem, PyObject *args)
}
PyDoc_STRVAR(haschannel__doc__,
-"hasChannel([channel=ChannelId['MONO'], [capture=False]]) -- Return if channel exists.");
+"has_channel([channel=channel_id['MONO'], [capture=False]]) -- Return if channel exists.");
static PyObject *
pyalsamixerelement_haschannel(struct pyalsamixerelement *pyelem, PyObject *args)
}
PyDoc_STRVAR(hasvolume__doc__,
-"hasVolume([capture=False]]) -- Return if volume exists.\n"
+"has_volume([capture=False]]) -- Return if volume exists.\n"
"Note: String 'Joined' is returned when volume is joined.");
static PyObject *
}
PyDoc_STRVAR(hasswitch__doc__,
-"hasSwitch([capture=False]) -- Return if switch exists."
+"has_switch([capture=False]) -- Return if switch exists."
"Note: String 'Joined' is returned when switch is joined.");
static PyObject *
}
PyDoc_STRVAR(getvolume__doc__,
-"getVolume([channel=ChannelId['MONO'], [capture=False]]) -- Get volume.");
+"get_volume([channel=ChannelId['MONO'], [capture=False]]) -- Get volume.");
static PyObject *
pyalsamixerelement_getvolume(struct pyalsamixerelement *pyelem, PyObject *args)
}
PyDoc_STRVAR(getvolumetuple__doc__,
-"getVolumeTuple([capture=False]]) -- Get volume and store result to tuple.");
+"get_volume_tuple([capture=False]]) -- Get volume and store result to tuple.");
static PyObject *
pyalsamixerelement_getvolumetuple(struct pyalsamixerelement *pyelem, PyObject *args)
}
PyDoc_STRVAR(getvolumearray__doc__,
-"getVolumeArray([capture=False]]) -- Get volume and store result to array.");
+"get_volume_array([capture=False]]) -- Get volume and store result to array.");
static PyObject *
pyalsamixerelement_getvolumearray(struct pyalsamixerelement *pyelem, PyObject *args)
}
PyDoc_STRVAR(setvolume__doc__,
-"setVolume(value, [channel=ChannelId['MONO'], [capture=False]]) -- Set volume.");
+"set_volume(value, [channel=ChannelId['MONO'], [capture=False]]) -- Set volume.");
static PyObject *
pyalsamixerelement_setvolume(struct pyalsamixerelement *pyelem, PyObject *args)
}
PyDoc_STRVAR(setvolumetuple__doc__,
-"setVolumeTuple(value, [capture=False]]) -- Set volume level from tuple.");
+"set_volume_tuple(value, [capture=False]]) -- Set volume level from tuple.");
PyDoc_STRVAR(setvolumearray__doc__,
-"setVolumeArray(value, [capture=False]]) -- Set volume level from array.");
+"set_volume_array(value, [capture=False]]) -- Set volume level from array.");
static PyObject *
pyalsamixerelement_setvolumetuple(struct pyalsamixerelement *pyelem, PyObject *args)
}
PyDoc_STRVAR(setvolumeall__doc__,
-"setVolumeAll(value, [capture=False]]) -- Set volume for all channels.");
+"set_volume_all(value, [capture=False]]) -- Set volume for all channels.");
static PyObject *
pyalsamixerelement_setvolumeall(struct pyalsamixerelement *pyelem, PyObject *args)
}
PyDoc_STRVAR(getrange__doc__,
-"getVolumeRange([capture=False]]) -- Get volume range in (min,max) tuple.");
+"get_volume_range([capture=False]]) -- Get volume range in (min,max) tuple.");
static PyObject *
pyalsamixerelement_getrange(struct pyalsamixerelement *pyelem, PyObject *args)
}
PyDoc_STRVAR(setrange__doc__,
-"setVolumeRange(min, max, [capture=False]]) -- Set volume range limits.");
+"set_volume_range(min, max, [capture=False]]) -- Set volume range limits.");
static PyObject *
pyalsamixerelement_setrange(struct pyalsamixerelement *pyelem, PyObject *args)
}
PyDoc_STRVAR(getswitch__doc__,
-"getSwitch([channel=ChannelId['MONO'], [capture=False]]) -- Get switch state.");
+"get_switch([channel=ChannelId['MONO'], [capture=False]]) -- Get switch state.");
static PyObject *
pyalsamixerelement_getswitch(struct pyalsamixerelement *pyelem, PyObject *args)
}
PyDoc_STRVAR(getswitchtuple__doc__,
-"getSwitchTuple([capture=False]]) -- Get switch state and store result to tuple.");
+"get_switch_tuple([capture=False]]) -- Get switch state and store result to tuple.");
static PyObject *
pyalsamixerelement_getswitchtuple(struct pyalsamixerelement *pyelem, PyObject *args)
}
PyDoc_STRVAR(setswitch__doc__,
-"setSwitch(value, [channel=ChannelId['MONO'], [capture=False]]) -- Set switch state.");
+"set_switch(value, [channel=ChannelId['MONO'], [capture=False]]) -- Set switch state.");
static PyObject *
pyalsamixerelement_setswitch(struct pyalsamixerelement *pyelem, PyObject *args)
}
PyDoc_STRVAR(setswitchtuple__doc__,
-"setSwitchTuple(value, [capture=False]]) -- Set switch state from tuple.");
+"set_switch_tuple(value, [capture=False]]) -- Set switch state from tuple.");
static PyObject *
pyalsamixerelement_setswitchtuple(struct pyalsamixerelement *pyelem, PyObject *args)
}
PyDoc_STRVAR(setswitchall__doc__,
-"setSwitchAll(value, [capture=False]]) -- Set switch for all channels.");
+"set_switch_all(value, [capture=False]]) -- Set switch for all channels.");
static PyObject *
pyalsamixerelement_setswitchall(struct pyalsamixerelement *pyelem, PyObject *args)
}
PyDoc_STRVAR(getvolumedb__doc__,
-"getVolume_dB([channel=ChannelId['MONO'], [capture=False]]) -- Get volume in dB.");
+"get_volume_dB([channel=ChannelId['MONO'], [capture=False]]) -- Get volume in dB.");
static PyObject *
pyalsamixerelement_getvolumedb(struct pyalsamixerelement *pyelem, PyObject *args)
}
PyDoc_STRVAR(setvolumedb__doc__,
-"setVolume_dB(value, [channel=ChannelId['MONO'], [capture=False], [dir=0]]) -- Set volume in dB.");
+"set_volume_dB(value, [channel=ChannelId['MONO'], [capture=False], [dir=0]]) -- Set volume in dB.");
static PyObject *
pyalsamixerelement_setvolumedb(struct pyalsamixerelement *pyelem, PyObject *args)
}
PyDoc_STRVAR(setvolumealldb__doc__,
-"setVolumeAll_dB(value, [[capture=False], [dir=0]]) -- Set volume for all channels in dB.");
+"set_volume_all_dB(value, [[capture=False], [dir=0]]) -- Set volume for all channels in dB.");
static PyObject *
pyalsamixerelement_setvolumealldb(struct pyalsamixerelement *pyelem, PyObject *args)
}
PyDoc_STRVAR(getrangedb__doc__,
-"getVolumeRange_dB([capture=False]]) -- Get volume range in dB in (min,max) tuple.");
+"get_volume_range_dB([capture=False]]) -- Get volume range in dB in (min,max) tuple.");
static PyObject *
pyalsamixerelement_getrangedb(struct pyalsamixerelement *pyelem, PyObject *args)
}
PyDoc_STRVAR(setcallback__doc__,
-"setCallback(callObj) -- Set callback object.\n"
+"set_callback(callObj) -- Set callback object.\n"
"Note: callObj might have callObj.callback attribute.\n");
static PyObject *
{"name", (getter)pyalsamixerelement_getname, NULL, "mixer element name", NULL},
{"index", (getter)pyalsamixerelement_getindex, NULL, "mixer element index", NULL},
- {"isActive", (getter)pyalsamixerelement_bool, NULL, "element is in active status", snd_mixer_selem_is_active},
- {"isEnumerated",(getter)pyalsamixerelement_bool, NULL, "element is enumerated type", snd_mixer_selem_is_enumerated},
- {"hasCommonVolume",(getter)pyalsamixerelement_bool, NULL, "element has common volume control", snd_mixer_selem_has_common_volume},
- {"hasCommonSwitch",(getter)pyalsamixerelement_bool, NULL, "element has common switch control", snd_mixer_selem_has_common_switch},
- {"hasCaptureSwitchExclusive", (getter)pyalsamixerelement_bool, NULL, "element has exclusive capture switch", snd_mixer_selem_has_capture_switch_exclusive},
+ {"is_active", (getter)pyalsamixerelement_bool, NULL, "element is in active status", snd_mixer_selem_is_active},
+ {"is_enumerated",(getter)pyalsamixerelement_bool, NULL, "element is enumerated type", snd_mixer_selem_is_enumerated},
+ {"has_common_volume",(getter)pyalsamixerelement_bool, NULL, "element has common volume control", snd_mixer_selem_has_common_volume},
+ {"has_common_switch",(getter)pyalsamixerelement_bool, NULL, "element has common switch control", snd_mixer_selem_has_common_switch},
+ {"has_capture_switch_exclusive", (getter)pyalsamixerelement_bool, NULL, "element has exclusive capture switch", snd_mixer_selem_has_capture_switch_exclusive},
- {"getCaptureGroup",(getter)pyalsamixerelement_getcapgroup, NULL, "element get capture group", NULL},
+ {"get_capture_group",(getter)pyalsamixerelement_getcapgroup, NULL, "element get capture group", NULL},
{NULL}
};
static PyMethodDef pyalsamixerelement_methods[] = {
- {"getVolume", (PyCFunction)pyalsamixerelement_getvolume, METH_VARARGS, getvolume__doc__},
- {"getVolumeTuple", (PyCFunction)pyalsamixerelement_getvolumetuple, METH_VARARGS,getvolumetuple__doc__},
- {"getVolumeArray", (PyCFunction)pyalsamixerelement_getvolumearray, METH_VARARGS,getvolumearray__doc__},
- {"setVolume", (PyCFunction)pyalsamixerelement_setvolume, METH_VARARGS, setvolume__doc__},
- {"setVolumeTuple", (PyCFunction)pyalsamixerelement_setvolumetuple, METH_VARARGS,setvolumetuple__doc__},
- {"setVolumeArray", (PyCFunction)pyalsamixerelement_setvolumetuple, METH_VARARGS,setvolumearray__doc__},
- {"setVolumeAll",(PyCFunction)pyalsamixerelement_setvolumeall, METH_VARARGS, setvolumeall__doc__},
- {"getVolumeRange", (PyCFunction)pyalsamixerelement_getrange, METH_VARARGS, getrange__doc__},
- {"setVolumeRange", (PyCFunction)pyalsamixerelement_setrange, METH_VARARGS, setrange__doc__},
-
- {"getVolume_dB",(PyCFunction)pyalsamixerelement_getvolumedb, METH_VARARGS, getvolumedb__doc__},
- {"setVolume_dB",(PyCFunction)pyalsamixerelement_setvolumedb, METH_VARARGS, setvolumedb__doc__},
- {"setVolumeAll_dB",(PyCFunction)pyalsamixerelement_setvolumealldb,METH_VARARGS, setvolumealldb__doc__},
- {"getVolumeRange_dB", (PyCFunction)pyalsamixerelement_getrangedb, METH_VARARGS, getrangedb__doc__},
-
- {"getSwitch", (PyCFunction)pyalsamixerelement_getswitch, METH_VARARGS, getswitch__doc__},
- {"getSwitchTuple", (PyCFunction)pyalsamixerelement_getswitchtuple, METH_VARARGS,getswitchtuple__doc__},
- {"setSwitch", (PyCFunction)pyalsamixerelement_setswitch, METH_VARARGS, setswitch__doc__},
- {"setSwitchTuple", (PyCFunction)pyalsamixerelement_setswitchtuple, METH_VARARGS,setswitchtuple__doc__},
- {"setSwitchAll",(PyCFunction)pyalsamixerelement_setswitchall, METH_VARARGS, setswitchall__doc__},
-
- {"isMono", (PyCFunction)pyalsamixerelement_ismono, METH_VARARGS, ismono__doc__},
- {"hasChannel", (PyCFunction)pyalsamixerelement_haschannel, METH_VARARGS, haschannel__doc__},
- {"hasVolume", (PyCFunction)pyalsamixerelement_hasvolume, METH_VARARGS, hasvolume__doc__},
- {"hasSwitch", (PyCFunction)pyalsamixerelement_hasswitch, METH_VARARGS, hasswitch__doc__},
-
- {"setCallback", (PyCFunction)pyalsamixerelement_setcallback, METH_VARARGS, setcallback__doc__},
+ {"get_volume", (PyCFunction)pyalsamixerelement_getvolume, METH_VARARGS, getvolume__doc__},
+ {"get_volume_tuple", (PyCFunction)pyalsamixerelement_getvolumetuple, METH_VARARGS,getvolumetuple__doc__},
+ {"get_volume_array", (PyCFunction)pyalsamixerelement_getvolumearray, METH_VARARGS,getvolumearray__doc__},
+ {"set_volume", (PyCFunction)pyalsamixerelement_setvolume, METH_VARARGS, setvolume__doc__},
+ {"set_volume_tuple", (PyCFunction)pyalsamixerelement_setvolumetuple, METH_VARARGS,setvolumetuple__doc__},
+ {"set_volume_array", (PyCFunction)pyalsamixerelement_setvolumetuple, METH_VARARGS,setvolumearray__doc__},
+ {"set_volume_all",(PyCFunction)pyalsamixerelement_setvolumeall, METH_VARARGS, setvolumeall__doc__},
+ {"get_volume_range", (PyCFunction)pyalsamixerelement_getrange, METH_VARARGS, getrange__doc__},
+ {"set_volume_range", (PyCFunction)pyalsamixerelement_setrange, METH_VARARGS, setrange__doc__},
+
+ {"get_volume_dB",(PyCFunction)pyalsamixerelement_getvolumedb, METH_VARARGS, getvolumedb__doc__},
+ {"set_volume_dB",(PyCFunction)pyalsamixerelement_setvolumedb, METH_VARARGS, setvolumedb__doc__},
+ {"set_volume_all_dB",(PyCFunction)pyalsamixerelement_setvolumealldb,METH_VARARGS, setvolumealldb__doc__},
+ {"get_volume_range_dB", (PyCFunction)pyalsamixerelement_getrangedb, METH_VARARGS, getrangedb__doc__},
+
+ {"get_switch", (PyCFunction)pyalsamixerelement_getswitch, METH_VARARGS, getswitch__doc__},
+ {"get_switch_tuple", (PyCFunction)pyalsamixerelement_getswitchtuple, METH_VARARGS,getswitchtuple__doc__},
+ {"set_switch", (PyCFunction)pyalsamixerelement_setswitch, METH_VARARGS, setswitch__doc__},
+ {"set_switch_tuple", (PyCFunction)pyalsamixerelement_setswitchtuple, METH_VARARGS,setswitchtuple__doc__},
+ {"set_switch_all",(PyCFunction)pyalsamixerelement_setswitchall, METH_VARARGS, setswitchall__doc__},
+
+ {"is_mono", (PyCFunction)pyalsamixerelement_ismono, METH_VARARGS, ismono__doc__},
+ {"has_channel", (PyCFunction)pyalsamixerelement_haschannel, METH_VARARGS, haschannel__doc__},
+ {"has_volume", (PyCFunction)pyalsamixerelement_hasvolume, METH_VARARGS, hasvolume__doc__},
+ {"has_switch", (PyCFunction)pyalsamixerelement_hasswitch, METH_VARARGS, hasswitch__doc__},
+
+ {"set_callback",(PyCFunction)pyalsamixerelement_setcallback, METH_VARARGS, setcallback__doc__},
{NULL}
};
PyDict_SetItemString(d1, pname, o); \
Py_DECREF(o); }
- add_space1("Unknown", UNKNOWN);
- add_space1("FrontLeft", FRONT_LEFT);
- add_space1("FrontRight", FRONT_RIGHT);
- add_space1("RearLeft", REAR_LEFT);
- add_space1("RearRight", REAR_RIGHT);
- add_space1("FrontCenter", FRONT_CENTER);
- add_space1("Woofer", WOOFER);
- add_space1("SideLeft", SIDE_LEFT);
- add_space1("SideRight", SIDE_RIGHT);
- add_space1("RearCenter", REAR_CENTER);
- add_space1("Last", LAST);
- add_space1("Mono", MONO);
-
- PyDict_SetItemString(d, "ChannelId", d1);
+ add_space1("UNKNOWN", UNKNOWN);
+ add_space1("FRONT_LEFT", FRONT_LEFT);
+ add_space1("FRONT_RIGHT", FRONT_RIGHT);
+ add_space1("REAR_LEFT", REAR_LEFT);
+ add_space1("REAR_RIGHT", REAR_RIGHT);
+ add_space1("FRONT_CENTER", FRONT_CENTER);
+ add_space1("WOOFER", WOOFER);
+ add_space1("SIDE_LEFT", SIDE_LEFT);
+ add_space1("SIDE_RIGHT", SIDE_RIGHT);
+ add_space1("REAR_CENTER", REAR_CENTER);
+ add_space1("LAST", LAST);
+ add_space1("MONO", MONO);
+
+ PyDict_SetItemString(d, "channel_id", d1);
Py_DECREF(d1);
/* ---- */
Py_DECREF(o);
}
- PyDict_SetItemString(d, "ChannelName", l1);
+ PyDict_SetItemString(d, "channel_name", l1);
Py_DECREF(l1);
/* ---- */
PyDict_SetItemString(d1, pname, o); \
Py_DECREF(o); }
- add_space2("None", NONE);
- add_space2("Basic", BASIC);
+ add_space2("NONE", NONE);
+ add_space2("BASIC", BASIC);
- PyDict_SetItemString(d, "RegoptAbstract", d1);
+ PyDict_SetItemString(d, "regopt_abstract", d1);
Py_DECREF(d1);
/* ---- */
PyDict_SetItemString(d1, pname, o); \
Py_DECREF(o); }
- add_space3("Value", VALUE);
- add_space3("Info", INFO);
- add_space3("Add", ADD);
+ add_space3("VALUE", VALUE);
+ add_space3("INFO", INFO);
+ add_space3("ADD", ADD);
add_space3("TLV", TLV);
- PyDict_SetItemString(d, "EventMask", d1);
+ PyDict_SetItemString(d, "event_mask", d1);
Py_DECREF(d1);
o = PyInt_FromLong(SND_CTL_EVENT_MASK_REMOVE);
- PyDict_SetItemString(d, "EventMaskRemove", o);
+ PyDict_SetItemString(d, "event_mask_remove", o);
Py_DECREF(o);
/* ---- */
del sys
import alsacard
-print 'asoundlibVersion:', alsacard.asoundlibVersion()
-print 'cardLoad:', alsacard.cardLoad(0)
-print 'cardList:', alsacard.cardList()
+print 'asoundlibVersion:', alsacard.asoundlib_version()
+print 'cardLoad:', alsacard.card_load(0)
+print 'cardList:', alsacard.card_list()
print 'deviceNameHint for all cards:'
-print alsacard.deviceNameHint(-1, "pcm")
-for card in alsacard.cardList():
+print alsacard.device_name_hint(-1, "pcm")
+for card in alsacard.card_list():
print 'deviceNameHint for card #%i:' % card
- print alsacard.deviceNameHint(card, "pcm")
+ print alsacard.device_name_hint(card, "pcm")
def info(element):
info = alsahcontrol.Info(element)
- enumerated = alsahcontrol.ElementType['Enumerated']
- integer = alsahcontrol.ElementType['Integer']
- integer64 = alsahcontrol.ElementType['Integer64']
+ enumerated = alsahcontrol.element_type['ENUMERATED']
+ integer = alsahcontrol.element_type['INTEGER']
+ integer64 = alsahcontrol.element_type['INTEGER64']
for a in dir(info):
if a.startswith('__'):
continue
- if a in ['items', 'itemNames'] and info.type != enumerated:
+ if a in ['items', 'item_names'] and info.type != enumerated:
continue
if a in ['min', 'max', 'step'] and info.type != integer:
continue
continue
extra = ''
if a == 'type':
- extra = ' (%s)' % alsahcontrol.ElementTypeName[info.type]
+ extra = ' (%s)' % alsahcontrol.element_type_name[info.type]
print ' %s: %s%s' % (a, getattr(info, a), extra)
def value(element):
if a.startswith('__'):
continue
print ' %s: %s' % (a, getattr(value, a))
- values = value.getTuple(info.type, info.count)
+ values = value.get_tuple(info.type, info.count)
print ' Values: ', values
- value.setTuple(info.type, values)
+ value.set_tuple(info.type, values)
value.read()
- if info.isWritable:
+ if info.is_writable:
value.write()
-print 'InterfaceId:'
-print ' ', alsahcontrol.InterfaceId
-print 'InterfaceName:'
-print ' ', alsahcontrol.InterfaceName
-print 'ElementType:'
-print ' ', alsahcontrol.ElementType
-print 'ElementTypeName:'
-print ' ', alsahcontrol.ElementTypeName
-print 'EventClass:'
-print ' ', alsahcontrol.EventClass
-print 'EventMask:'
-print ' ', alsahcontrol.EventMask
-print 'EventMaskRemove:', alsahcontrol.EventMaskRemove
-print ' ', alsahcontrol.OpenMode
-print 'EventMaskRemove:', alsahcontrol.OpenMode
+print 'interface_id:'
+print ' ', alsahcontrol.interface_id
+print 'interface_name:'
+print ' ', alsahcontrol.interface_name
+print 'element_type:'
+print ' ', alsahcontrol.element_type
+print 'element_type_name:'
+print ' ', alsahcontrol.element_type_name
+print 'event_class:'
+print ' ', alsahcontrol.event_class
+print 'event_mask:'
+print ' ', alsahcontrol.event_mask
+print 'event_mask_remove:', alsahcontrol.event_mask_remove
+print ' ', alsahcontrol.open_mode
+print 'event_mask_remove:', alsahcontrol.open_mode
hctl = alsahcontrol.HControl()
print 'Count: ', hctl.count
def parse_event_mask(events):
if events == 0:
return 'None'
- if events == alsahcontrol.EventMaskRemove:
+ if events == alsahcontrol.event_mask_remove:
return 'Removed'
s = ''
- for i in alsahcontrol.EventMask.keys():
- if events & alsahcontrol.EventMask[i]:
+ for i in alsahcontrol.event_mask.keys():
+ if events & alsahcontrol.event_mask[i]:
s += '%s ' % i
return s[:-1]
info = alsahcontrol.Info(element)
value = alsahcontrol.Value(element)
print 'CALLBACK (DEF)! [%s] %s:%i' % (parse_event_mask(events), element.name, element.index)
- print ' ', value.getTuple(info.type, info.count)
+ print ' ', value.get_tuple(info.type, info.count)
class MyElementEvent:
info = alsahcontrol.Info(element)
value = alsahcontrol.Value(element)
print 'CALLBACK (CLASS)! [%s] %s:%i' % (parse_event_mask(events), element.name, element.index)
- print ' ', value.getTuple(info.type, info.count)
+ print ' ', value.get_tuple(info.type, info.count)
-hctl = alsahcontrol.HControl(mode=alsahcontrol.OpenMode['NonBlock'])
+hctl = alsahcontrol.HControl(mode=alsahcontrol.open_mode['NONBLOCK'])
list = hctl.list()
element1 = alsahcontrol.Element(hctl, list[0][1:])
-element1.setCallback(event_callback)
+element1.set_callback(event_callback)
element2 = alsahcontrol.Element(hctl, list[1][1:])
-element2.setCallback(MyElementEvent())
-nelementid = (alsahcontrol.InterfaceId['Mixer'], 0, 0, "Z Test Volume", 1)
+element2.set_callback(MyElementEvent())
+nelementid = (alsahcontrol.interface_id['MIXER'], 0, 0, "Z Test Volume", 1)
try:
- hctl.elementRemove(nelementid)
+ hctl.element_remove(nelementid)
except IOError:
pass
-hctl.elementNew(alsahcontrol.ElementType['Integer'],
+hctl.element_new(alsahcontrol.element_type['INTEGER'],
nelementid, 2, 0, 100, 1)
-hctl.elementUnlock(nelementid)
+hctl.element_unlock(nelementid)
# handleEvents() must be here to update internal alsa-lib's element list
-hctl.handleEvents()
+hctl.handle_events()
element3 = alsahcontrol.Element(hctl, nelementid)
-element3.setCallback(event_callback)
+element3.set_callback(event_callback)
print 'Watching (DEF): %s,%i' % (element1.name, element1.index)
print 'Watching (CLASS): %s,%i' % (element2.name, element2.index)
print 'Watching (DEF): %s,%i' % (element3.name, element3.index)
poller = select.poll()
-hctl.registerPoll(poller)
+hctl.register_poll(poller)
while True:
poller.poll()
print 'Poll OK!'
- hctl.handleEvents()
+ hctl.handle_events()
import alsamixer
def print_elem(e):
- direction = ["Playback", "Capture"]
+ direction = ["playback", "capture"]
print "Mixer Element '%s:%i':" % (e.name, e.index)
- print ' isActive: %s' % e.isActive
- print ' isEnumerated: %s' % e.isEnumerated
- print ' hasCommonVolume: %s' % e.hasCommonVolume
- print ' hasCommonSwitch: %s' % e.hasCommonSwitch
- print ' hasCaptureSwitchExclusive: %s' % e.hasCaptureSwitchExclusive
- if e.hasSwitch(True):
- print ' getCaptureGroup: %s' % e.getCaptureGroup
+ print ' is_active: %s' % e.is_active
+ print ' is_enumerated: %s' % e.is_enumerated
+ print ' has_common_volume: %s' % e.has_common_volume
+ print ' has_common_switch: %s' % e.has_common_switch
+ print ' has_capture_switch_exclusive: %s' % e.has_capture_switch_exclusive
+ if e.has_switch(True):
+ print ' getCaptureGroup: %s' % e.get_capture_group
for capture in [False, True]:
- print ' is%sMono: %s' % (direction[capture], e.isMono(capture))
- print ' has%sVolume: %s' % (direction[capture], e.hasVolume(capture))
- if e.hasVolume(capture):
- print ' get%sVolumeRange: %s' % (direction[capture], e.getVolumeRange(capture))
- print ' get%sVolumeRange_dB: %s' % (direction[capture], e.getVolumeRange_dB(capture))
- print ' get%sVolumeTuple: %s' % (direction[capture], e.getVolumeTuple(capture))
- print ' get%sVolumeArray: %s' % (direction[capture], e.getVolumeArray(capture))
- print ' has%sSwitch: %s' % (direction[capture], e.hasSwitch(capture))
- if e.hasSwitch(capture):
- print ' get%sSwitchTuple: %s' % (direction[capture], e.getSwitchTuple(capture))
- for channel in range(alsamixer.ChannelId['Last']+1):
- if e.hasChannel(channel, capture):
- print ' has%sChannel%s: %s' % (direction[capture], channel, alsamixer.ChannelName[channel])
+ print ' is_%s_mono: %s' % (direction[capture], e.is_mono(capture))
+ print ' has_%s_volume: %s' % (direction[capture], e.has_volume(capture))
+ if e.has_volume(capture):
+ print ' get_%s_volume_range: %s' % (direction[capture], e.get_volume_range(capture))
+ print ' get_%s_volume_range_dB: %s' % (direction[capture], e.get_volume_range_dB(capture))
+ print ' get_%s_volume_tuple: %s' % (direction[capture], e.get_volume_tuple(capture))
+ print ' get_%s_volume_array: %s' % (direction[capture], e.get_volume_array(capture))
+ print ' has_%s_switch: %s' % (direction[capture], e.has_switch(capture))
+ if e.has_switch(capture):
+ print ' get_%s_switch_tuple: %s' % (direction[capture], e.get_switch_tuple(capture))
+ for channel in range(alsamixer.channel_id['LAST']+1):
+ if e.has_channel(channel, capture):
+ print ' has_%s_channel%s: %s' % (direction[capture], channel, alsamixer.channel_name[channel])
debuginit()
-print 'ChannelId:'
-print alsamixer.ChannelId
+print 'channel_id:'
+print alsamixer.channel_id
-print 'ChannelName:'
-print alsamixer.ChannelName
+print 'channel_name:'
+print alsamixer.channel_name
-print 'RegoptAbstracts:'
-print alsamixer.RegoptAbstract
+print 'regopt_abstracts:'
+print alsamixer.regopt_abstract
-print 'EventMask:'
-print alsamixer.EventMask
+print 'event_mask:'
+print alsamixer.event_mask
-print 'EventMaskRemove:', alsamixer.EventMaskRemove
+print 'event_mask_remove:', alsamixer.event_mask_remove
mixer = alsamixer.Mixer()
mixer.attach()
print 'Elements:'
print mixer.list()
element = alsamixer.Element(mixer, "PCM")
-element.setVolumeArray([128, 128])
+element.set_volume_array([128, 128])
print_elem(element)
-element.setVolumeTuple([127, 127])
+element.set_volume_tuple([127, 127])
print_elem(element)
print_elem(alsamixer.Element(mixer, "Off-hook"))
git://git.alsa-project.org / alsa-python.git / commitdiff