Add a little Gtk test tool to show how balance/fade/value and the channel volumes play together

src/tests/volume-ui.py

@@ -0,0 +1,227 @@
+#!/usr/bin/python
+
+import pygtk, gtk
+from ctypes import *
+
+libpulse = cdll.LoadLibrary("../.libs/libpulse.so")
+
+class ChannelMap(Structure):
+    _fields_ = [("channels", c_ubyte),
+                ("map", c_uint * 32)]
+
+    _to_name = libpulse.pa_channel_map_to_name
+    _to_name.restype = c_char_p
+    _to_name.argtypes = [c_void_p]
+
+    _to_pretty_name = libpulse.pa_channel_map_to_pretty_name
+    _to_pretty_name.restype = c_char_p
+    _to_pretty_name.argtypes = [c_void_p]
+
+    _snprint = libpulse.pa_channel_map_snprint
+    _snprint.restype = c_char_p
+    _snprint.argtypes = [c_char_p, c_ulong, c_void_p]
+
+    _position_to_string = libpulse.pa_channel_position_to_string
+    _position_to_string.restype = c_char_p
+    _position_to_string.argtypes = [c_uint]
+
+    _position_to_pretty_string = libpulse.pa_channel_position_to_pretty_string
+    _position_to_pretty_string.restype = c_char_p
+    _position_to_pretty_string.argtypes = [c_uint]
+
+    def to_name(this):
+        return this._to_name(byref(this))
+
+    def to_pretty_name(this):
+        return this._to_pretty_name(byref(this))
+
+    def snprint(this):
+        s = create_string_buffer(336)
+        r = this._snprint(s, len(s), byref(this))
+
+        if r is None:
+            return None
+        else:
+            return s.raw
+
+    def position_to_string(this, pos):
+        return this._position_to_string(pos)
+
+    def position_to_pretty_string(this, pos):
+        return this._position_to_pretty_string(pos)
+
+class CVolume(Structure):
+    _fields_ = [("channels", c_ubyte),
+                ("values", c_uint32 * 32)]
+
+
+    _snprint = libpulse.pa_cvolume_snprint
+    _snprint.restype = c_char_p
+    _snprint.argtypes = [c_char_p, c_ulong, c_void_p]
+
+    _max = libpulse.pa_cvolume_max
+    _max.restype = c_uint32
+    _max.argtypes = [c_void_p]
+
+    _scale = libpulse.pa_cvolume_scale
+    _scale.restype = c_void_p
+    _scale.argtypes = [c_void_p, c_uint32]
+
+    _get_balance = libpulse.pa_cvolume_get_balance
+    _get_balance.restype = c_float
+    _get_balance.argtypes = [c_void_p, c_void_p]
+
+    _get_fade = libpulse.pa_cvolume_get_fade
+    _get_fade.restype = c_float
+    _get_fade.argtypes = [c_void_p, c_void_p]
+
+    _set_balance = libpulse.pa_cvolume_set_balance
+    _set_balance.restype = c_void_p
+    _set_balance.argtypes = [c_void_p, c_void_p, c_float]
+
+    _set_fade = libpulse.pa_cvolume_set_fade
+    _set_fade.restype = c_void_p
+    _set_fade.argtypes = [c_void_p, c_void_p, c_float]
+
+    def snprint(this):
+        s = create_string_buffer(320)
+        r = this._snprint(s, len(s), byref(this))
+
+        if r is None:
+            return None
+        else:
+            return s.raw
+
+    def max(this):
+        return this._max(byref(this))
+
+    def scale(this, v):
+        return this._scale(byref(this), v)
+
+    def get_balance(this, cm):
+        return this._get_balance(byref(this), byref(cm))
+
+    def get_fade(this, cm):
+        return this._get_fade(byref(this), byref(cm))
+
+    def set_balance(this, cm, f):
+        return this._set_balance(byref(this), byref(cm), f)
+
+    def set_fade(this, cm, f):
+        return this._set_fade(byref(this), byref(cm), f)
+
+
+
+cm = ChannelMap()
+cm.channels = 6
+cm.map[0] = 1
+cm.map[1] = 2
+cm.map[2] = 3
+cm.map[3] = 5
+cm.map[4] = 6
+cm.map[5] = 7
+
+print "Channel map name: %s" % cm.to_name()
+print "Channel map mapping: %s" % cm.snprint()
+
+v = CVolume()
+v.channels = cm.channels
+
+for i in range(cm.channels):
+    v.values[i] = 65536/2
+
+print v.max()
+print v.snprint()
+print v.get_balance(cm)
+print v.get_fade(cm)
+
+window = gtk.Window(gtk.WINDOW_TOPLEVEL)
+window.set_title(cm.to_pretty_name())
+window.set_border_width(12)
+
+vbox = gtk.VBox(spacing=6)
+
+channel_labels = {}
+channel_scales = {}
+
+def update_volume(update_channels = True, update_fade = True, update_balance = True, update_scale = True):
+    if update_channels:
+        for i in range(cm.channels):
+            channel_scales[i].set_value(v.values[i])
+
+    if update_scale:
+        value_scale.set_value(v.max())
+
+    if update_balance:
+        balance_scale.set_value(v.get_balance(cm))
+
+    if update_fade:
+        fade_scale.set_value(v.get_fade(cm))
+
+def fade_value_changed(fs):
+    v.set_fade(cm, fade_scale.get_value())
+    update_volume(update_fade = False)
+
+def balance_value_changed(fs):
+    v.set_balance(cm, balance_scale.get_value())
+    update_volume(update_balance = False)
+
+def value_value_changed(fs):
+    v.scale(int(value_scale.get_value()))
+    update_volume(update_scale = False)
+
+def channel_value_changed(fs, i):
+    v.values[i] = int(channel_scales[i].get_value())
+    update_volume(update_channels = False)
+
+for i in range(cm.channels):
+    channel_labels[i] = gtk.Label(cm.position_to_pretty_string(cm.map[i]))
+    channel_labels[i].set_alignment(0, 1)
+    vbox.pack_start(channel_labels[i], expand=False, fill=True)
+
+    channel_scales[i] = gtk.HScale()
+    channel_scales[i].set_range(0, 65536)
+    channel_scales[i].set_digits(0)
+    channel_scales[i].set_value_pos(gtk.POS_RIGHT)
+    vbox.pack_start(channel_scales[i], expand=False, fill=True)
+
+value_label = gtk.Label("Value")
+value_label.set_alignment(0, .5)
+vbox.pack_start(value_label, expand=False, fill=True)
+value_scale = gtk.HScale()
+value_scale.set_range(0, 65536)
+value_scale.set_value_pos(gtk.POS_RIGHT)
+value_scale.set_digits(0)
+vbox.pack_start(value_scale, expand=False, fill=True)
+
+balance_label = gtk.Label("Balance")
+balance_label.set_alignment(0, .5)
+vbox.pack_start(balance_label, expand=False, fill=True)
+balance_scale = gtk.HScale()
+balance_scale.set_range(-1.0, +1.0)
+balance_scale.set_value_pos(gtk.POS_RIGHT)
+balance_scale.set_digits(2)
+vbox.pack_start(balance_scale, expand=False, fill=True)
+
+fade_label = gtk.Label("Fade")
+fade_label.set_alignment(0, .5)
+vbox.pack_start(fade_label, expand=False, fill=True)
+fade_scale = gtk.HScale()
+fade_scale.set_range(-1.0, +1.0)
+fade_scale.set_value_pos(gtk.POS_RIGHT)
+fade_scale.set_digits(2)
+vbox.pack_start(fade_scale, expand=False, fill=True)
+
+window.add(vbox)
+window.set_default_size(600, 400)
+
+update_volume()
+
+for i in range(cm.channels):
+    channel_scales[i].connect("value_changed", channel_value_changed, i)
+fade_scale.connect("value_changed", fade_value_changed)
+balance_scale.connect("value_changed", balance_value_changed)
+value_scale.connect("value_changed", value_value_changed)
+
+window.show_all()
+gtk.main()