File: hwmixvolume

package info (click to toggle)
alsa-tools 1.0.28-1
  • links: PTS, VCS
  • area: main
  • in suites: jessie, jessie-kfreebsd
  • size: 12,464 kB
  • ctags: 5,787
  • sloc: ansic: 23,609; cpp: 15,057; sh: 12,305; pascal: 1,140; asm: 1,053; xml: 814; makefile: 733; python: 250
file content (310 lines) | stat: -rwxr-xr-x 8,704 bytes parent folder | download | duplicates (4)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
#!/usr/bin/env python

# hwmixvolume - ALSA hardware mixer volume control applet
# Copyright (c) 2009-2010 Clemens Ladisch
#
# Permission to use, copy, modify, and/or distribute this software for any
# purpose with or without fee is hereby granted, provided that the above
# copyright notice and this permission notice appear in all copies.
#
# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
# REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
# AND FITNESS.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
# INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
# LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
# OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
# PERFORMANCE OF THIS SOFTWARE.

import gobject, gtk
from pyalsa import alsacard, alsahcontrol

INTF_PCM = alsahcontrol.interface_id['PCM']
INTF_MIXER = alsahcontrol.interface_id['MIXER']
TYPE_INTEGER = alsahcontrol.element_type['INTEGER']
EVENT_VALUE = alsahcontrol.event_mask['VALUE']
EVENT_INFO = alsahcontrol.event_mask['INFO']
EVENT_REMOVE = alsahcontrol.event_mask_remove

class Stream:
	def __init__(self, element, parent):
		self.element = element
		self.element.set_callback(self)
		self.parent = parent
		self.label = None
		self.scales = []
		self.adjustments = []
		self.callback(self.element, EVENT_INFO)

	def destroy(self):
		self.deactivate()

	def callback(self, e, mask):
		if mask == EVENT_REMOVE:
			self.deactivate()
		elif (mask & EVENT_INFO) != 0:
			info = alsahcontrol.Info(self.element)
			if info.is_inactive:
				self.deactivate()
			else:
				self.activate()
		elif (mask & EVENT_VALUE) != 0:
			self.update_scales_from_ctl()

	def activate(self):
		if self.label:
			return
		info = alsahcontrol.Info(self.element)
		value = alsahcontrol.Value(self.element)
		value.read()
		values = value.get_tuple(TYPE_INTEGER, info.count)
		self.label = gtk.Label(self.get_label(info))
		self.label.set_single_line_mode(True)
		self.parent.scales_vbox.pack_start(self.label, expand=False)
		for i in range(info.count):
			adj = gtk.Adjustment(value=values[i],
					lower=info.min, upper=info.max,
					step_incr=1,
					page_incr=(info.max-info.min+1)/8)
			adj.connect('value-changed', self.update_ctl_from_scale, i)
			scale = gtk.HScale(adj)
			scale.set_draw_value(False)
			self.parent.scales_vbox.pack_start(scale, expand=False)
			self.scales.append(scale)
			self.adjustments.append(adj)
		self.parent.scales_vbox.show_all()
		self.parent.update_msg_label()

	def deactivate(self):
		if not self.label:
			return
		self.label.destroy()
		for s in self.scales:
			s.destroy()
		self.label = None
		self.scales = []
		self.adjustments = []
		self.parent.update_msg_label()

	def update_scales_from_ctl(self):
		if not self.label:
			return
		count = len(self.adjustments)
		value = alsahcontrol.Value(self.element)
		value.read()
		values = value.get_tuple(TYPE_INTEGER, count)
		for i in range(count):
			self.adjustments[i].set_value(values[i])

	def update_ctl_from_scale(self, adj, index):
		scale_value = adj.get_value()
		value_to_set = int(round(adj.get_value()))
		count = len(self.adjustments)
		value = alsahcontrol.Value(self.element)
		if self.parent.lock_check.get_active():
			values = [value_to_set  for i in range(count)]
		else:
			value.read()
			values = value.get_array(TYPE_INTEGER, count)
			values[index] = value_to_set
		value.set_array(TYPE_INTEGER, values)
		value.write()
		if value_to_set != scale_value:
			adj.set_value(value_to_set)

	def get_label(self, info):
		pid = self.get_pid(info)
		if pid:
			cmdline = self.get_pid_cmdline(pid)
			if cmdline:
				return cmdline
			else:
				return "PID %d" % pid
		else:
			name = info.name
			if name[-7:] == " Volume":
				name = name[:-7]
			if name[-9:] == " Playback":
				name = name[:-9]
			return name

	def get_pid(self, info):
		card = self.parent.current_card
		device = info.device
		subdevice = info.subdevice
		if subdevice == 0:
			subdevice = info.index
		filename = "/proc/asound/card%d/pcm%dp/sub%d/status" % (card, device, subdevice)
		try:
			f = open(filename, "r")
		except IOError:
			return None
		try:
			for line in f.readlines():
				if line[:9] == "owner_pid":
					return int(line.split(':')[1].strip())
		finally:
			f.close()
		return None

	def get_pid_cmdline(self, pid):
		try:
			f = open("/proc/%d/cmdline" % pid, "r")
		except IOError:
			return None
		try:
			cmdline = f.read()
		finally:
			f.close()
		return cmdline.replace('\x00', ' ').strip()

class MixerWindow(gtk.Window):
	card_numbers = alsacard.card_list()
	current_card = -1
	hcontrol = None
	scales_vbox = None
	msg_label = None
	streams = []
	hctl_sources = []

	def __init__(self):
		gtk.Window.__init__(self)
		self.connect('destroy', lambda w: gtk.main_quit())
		self.set_title("Hardware Mixer Volumes")

		vbox = gtk.VBox()
		self.add(vbox)

		hbox = gtk.HBox()
		vbox.pack_start(hbox, expand=False)

		label = gtk.Label("_Sound Card: ")
		label.set_use_underline(True)
		hbox.pack_start(label, expand=False)

		combo = gtk.combo_box_new_text()
		for i in self.card_numbers:
			str = "%d: %s" % (i, alsacard.card_get_name(i))
			combo.append_text(str)
		if len(self.card_numbers) > 0:
			combo.set_active(0)
		combo.connect('changed', lambda c: self.change_card(self.card_numbers[combo.get_active()]))
		hbox.pack_start(combo)
		label.set_mnemonic_widget(combo)

		self.lock_check = gtk.CheckButton(label="_Lock Channels")
		self.lock_check.set_active(True)
		vbox.pack_start(self.lock_check, expand=False)

		scrollwin = gtk.ScrolledWindow()
		scrollwin.set_policy(hscrollbar_policy=gtk.POLICY_NEVER, vscrollbar_policy=gtk.POLICY_AUTOMATIC)
		scrollwin.set_shadow_type(gtk.SHADOW_NONE)
		vbox.pack_start(scrollwin)

		self.scales_vbox = gtk.VBox()
		scrollwin.add_with_viewport(self.scales_vbox)

		label = gtk.Label()
		label.set_single_line_mode(True)
		line_height = label.size_request()[1]
		label.destroy()
		scale = gtk.HScale()
		scale.set_draw_value(False)
		line_height += scale.size_request()[1]
		scale.destroy()
		# always have space for at least four sliders
		scrollwin.set_size_request(width=-1, height=line_height*4+4)

		# TODO: select the default card or the first card with stream controls
		if len(self.card_numbers) > 0:
			self.change_card(self.card_numbers[0])
		self.update_msg_label()

		self.show_all()

	def change_card(self, cardnum):
		for s in self.hctl_sources:
			gobject.source_remove(s)
		self.hctl_sources = []

		self.hcontrol = self.open_hcontrol_for_card(cardnum)

		for s in self.streams:
			s.destroy()
		self.streams = []

		self.current_card = cardnum

		if not self.hcontrol:
			self.update_msg_label()
			return

		for id in self.hcontrol.list():
			if not self.is_stream_elem(id):
				continue
			elem = alsahcontrol.Element(self.hcontrol, id[0])
			info = alsahcontrol.Info(elem)
			if not self.is_stream_info(info):
				continue
			stream = Stream(elem, self)
			self.streams.append(stream)

		for fd,condition in self.hcontrol.poll_fds:
			self.hctl_sources.append(gobject.io_add_watch(fd, condition, self.hctl_io_callback))

		self.update_msg_label()

		self.scales_vbox.show_all()

	def update_msg_label(self):
		needs_msg = len(self.scales_vbox.get_children()) < 2
		has_msg = self.msg_label
		if has_msg and not needs_msg:
			self.msg_label.destroy()
			self.msg_label = None
		elif needs_msg:
			if len(self.streams) > 0:
				msg = "There are no open streams."
			else:
				msg = "This card does not have stream controls."
			if not has_msg:
				self.msg_label = gtk.Label(msg)
				self.scales_vbox.pack_start(self.msg_label)
				self.scales_vbox.show_all()
			elif self.msg_label.get_text() != msg:
				self.msg_label.set_text(msg)

	def open_hcontrol_for_card(self, cardnum):
		devname = "hw:CARD=" + str(cardnum)
		try:
			hc = alsahcontrol.HControl(name=devname,
					mode=alsahcontrol.open_mode['NONBLOCK'])
		except:
			# TODO: alsa error msg
			dlg = gtk.MessageDialog(self,
					gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
					gtk.MESSAGE_ERROR, gtk.BUTTONS_OK,
					"Cannot open sound card control device.")
			dlg.run()
			dlg.destroy()
			return None
		return hc

	def is_stream_elem(self, id):
		return ((id[1] == INTF_PCM and
			 id[4] in ("PCM Playback Volume", "EMU10K1 PCM Volume")) or
			(id[1] == INTF_MIXER and
			 id[4] == "VIA DXS Playback Volume"))

	def is_stream_info(self, info):
		return info.is_readable and info.is_writable and info.type == TYPE_INTEGER

	def hctl_io_callback(self, source, condition):
		self.hcontrol.handle_events()
		return True

def main():
	MixerWindow()
	gtk.main()

main()