| #!/usr/bin/python |
| # -*- coding: utf-8 -*- |
| # -*- Python -*- |
| |
| from pyalsa.alsahcontrol import HControl, Element as HElement, \ |
| Info as HInfo, Value as HValue, InterfaceId, \ |
| EventMask, EventMaskRemove |
| |
| MIXER = InterfaceId['Mixer'] |
| MIXERS = str(MIXER) |
| |
| class BaseElement(InternalMElement): |
| |
| def __init__(self, mixer, name, index, weight): |
| InternalMElement.__init__(self, mixer, name, index, weight) |
| self.channels = 0 |
| self.min = [0, 0] |
| self.max = [0, 0] |
| |
| def opsIsChannel(self, dir, chn): |
| return chn >= 0 and chn < self.channels |
| |
| def opsGetRange(self, dir): |
| return (0, self.min[dir], self.max[dir]) |
| |
| def opsSetRange(self, dir, min, max): |
| self.min[dir] = min |
| self.max[dir] = max |
| |
| def volumeToUser(self, info, dir, value): |
| min = info.min |
| max = info.max |
| if min == max: |
| return self.min[dir] |
| n = (value - min) * (self.max[dir] - self.min[dir]) |
| return self.min[dir] + (n + (max - min) / 2) / (max - min) |
| |
| def volumeFromUser(self, info, dir, value): |
| min = info.min |
| max = info.max |
| if self.max[dir] == self.min[dir]: |
| return min |
| n = (value - self.min[dir]) * (max - min) |
| return min + (n + (self.max[dir] - self.min[dir]) / 2) / (self.max[dir] - self.min[dir]) |
| |
| class StandardElement(BaseElement): |
| |
| def __init__(self, mixer, name, index, weight): |
| BaseElement.__init__(self, mixer, name, index, weight) |
| self.channels = 1 |
| self.volume = [None, None] |
| self.volumeinfo = [None, None] |
| self.volumearray = [None, None] |
| self.switch = [None, None] |
| self.switchinfo = [None, None] |
| self.switcharray = [None, None] |
| |
| def decideChannels(self): |
| max = 0 |
| for i in [0, 1]: |
| if self.volume[i]: |
| count = self.volumeinfo[i].count |
| if count > max: |
| max = count |
| if self.switch[i]: |
| count = self.switchinfo[i].count |
| if count > max: |
| max = count |
| self.channels = max |
| |
| def attachVolume(self, helem, dir): |
| self.volume[dir] = helem |
| self.volumeinfo[dir] = HInfo(helem) |
| self.min[dir] = self.volumeinfo[dir].min |
| self.max[dir] = self.volumeinfo[dir].max |
| self.volumearray[dir] = HValue(helem).getArray(self.volumeinfo[dir].type, self.volumeinfo[dir].count) |
| |
| def attachSwitch(self, helem, dir): |
| self.switch[dir] = helem |
| self.switchinfo[dir] = HInfo(helem) |
| self.switcharray[dir] = HValue(helem).getArray(self.switchinfo[dir].type, self.switchinfo[dir].count) |
| |
| def attach(self, helem): |
| BaseElement.attach(self, helem) |
| if helem.name.endswith('Playback Volume'): |
| self.attachVolume(helem, 0) |
| self.caps |= self.CAP_PVOLUME |
| elif helem.name.endswith('Capture Volume'): |
| self.attachVolume(helem, 1) |
| self.caps |= self.CAP_CVOLUME |
| elif helem.name.endswith('Playback Switch'): |
| self.attachSwitch(helem, 0) |
| self.caps |= self.CAP_PSWITCH |
| elif helem.name.endswith('Capture Switch'): |
| self.attachSwitch(helem, 1) |
| self.caps |= self.CAP_CSWITCH |
| self.decideChannels() |
| self.eventInfo() |
| |
| def opsGetVolume(self, dir, chn): |
| return (0, self.volumeToUser(self.volumeinfo[dir], dir, self.volumearray[dir][chn])) |
| |
| def opsSetVolume(self, dir, chn, value): |
| val = self.volumeFromUser(self.volumeinfo[dir], dir, value) |
| if self.volumearray[dir][chn] == val: |
| return |
| self.volumearray[dir][chn] = val |
| hv = HValue(self.volume[dir]) |
| hv.setArray(self.volumeinfo[dir].type, self.volumearray[dir]) |
| hv.write() |
| |
| def opsGetSwitch(self, dir, chn): |
| return (0, self.switcharray[dir][chn]) |
| |
| def opsSetSwitch(self, dir, chn, value): |
| if self.switcharray[dir][chn] and value: |
| return |
| if not self.switcharray[dir][chn] and not value: |
| return |
| self.switcharray[dir] = int(value) |
| hv = HValue(self.switch[dir]) |
| hv.setArray(self.switchinfo[dir].type, self.switcharray[dir]) |
| hv.write() |
| |
| def update(self, helem): |
| for i in [0, 1]: |
| if helem == self.volume[i]: |
| self.volumearray[i] = HValue(helem).getArray(self.volumeinfo[i].type, self.volumeinfo[i].count) |
| elif helem == self.switch[i]: |
| self.switcharray[i] = HValue(helem).getArray(self.switchinfo[i].type, self.switchinfo[i].count) |
| self.eventValue() |
| |
| class EnumElement(BaseElement): |
| |
| def __init__(self, mixer, name, index, weight): |
| BaseElement.__init__(self, mixer, name, index, weight) |
| self.mycaps = 0 |
| |
| def attach(self, helem): |
| BaseElement.attach(self, helem) |
| self.enum = helem |
| self.enuminfo = HInfo(helem) |
| self.enumarray = HValue(helem).getArray(self.enuminfo.type, self.enuminfo.count) |
| self.channels = self.enuminfo.count |
| self.texts = self.enuminfo.itemNames |
| self.caps |= self.mycaps |
| |
| def opsIsEnumerated(self, dir=-1): |
| if dir < 0: |
| return 1 |
| if dir == 0 and self.mycaps & self.CAP_PENUM: |
| return 1 |
| if dir == 1 and self.mycaps & self.CAP_CENUM: |
| return 1 |
| |
| def opsIsEnumCnt(self, dir): |
| return self.enuminfo.items |
| |
| def opsGetEnumItemName(self, item): |
| return (0, self.texts[item]) |
| |
| def opsGetEnumItem(self, chn): |
| if chn >= self.channels: |
| return -1 |
| return (0, self.enumarray[chn]) |
| |
| def opsSetEnumItem(self, chn, value): |
| if chn >= self.channels: |
| return -1 |
| if self.enumarray[chn] == value: |
| return |
| self.enumarray[chn] = int(value) |
| hv = HValue(self.enum) |
| hv.setArray(self.enuminfo.type, self.enumarray) |
| hv.write() |
| |
| def update(self, helem): |
| self.enumarray = HValue(helem).getArray(self.enuminfo.type, self.enuminfo.count) |
| self.eventValue() |
| |
| class EnumElementPlayback(EnumElement): |
| |
| def __init__(self, mixer, name, index, weight): |
| EnumElement.__init__(self, mixer, name, index, weight) |
| self.mycaps = self.CAP_PENUM |
| |
| class EnumElementCapture(EnumElement): |
| |
| def __init__(self, mixer, name, index, weight): |
| EnumElement.__init__(self, mixer, name, index, weight) |
| self.mycaps = self.CAP_CENUM |
| |
| ELEMS = [] |
| |
| def element_add(helem): |
| key = helem.name+'//'+str(helem.index)+'//'+str(helem.interface) |
| if not CONTROLS.has_key(key): |
| return |
| val = CONTROLS[key] |
| felem = None |
| for elem in ELEMS: |
| if elem.name == val[0] and elem.index == val[1]: |
| felem = elem |
| break |
| if not felem: |
| felem = mixer.newMElement(val[3], val[0], val[1], val[2]) |
| mixer.addMElement(felem) |
| ELEMS.append(felem) |
| felem.attach(helem) |
| |
| def eventHandler(evmask, helem, melem): |
| if evmask == EventMaskRemove: |
| return |
| if evmask & EventMask['Add']: |
| element_add(helem) |
| if evmask & EventMask['Value']: |
| melem.update(helem) |
| |
| def init(): |
| hctl = HControl(device, load=False) |
| mixer.attachHCtl(hctl) |
| mixer.register() |
