From 634afede7dcbf7ce5739310b6398d64a1221d25c Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Fri, 30 Jan 2009 00:14:28 +0100 Subject: properly deal with the case when l/r is silent when adjust balance --- src/pulse/volume.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/pulse/volume.c b/src/pulse/volume.c index 3434cb18..4da133df 100644 --- a/src/pulse/volume.c +++ b/src/pulse/volume.c @@ -487,12 +487,12 @@ pa_cvolume* pa_cvolume_set_balance(pa_cvolume *v, const pa_channel_map *map, flo for (c = 0; c < map->channels; c++) { if (on_left(map->map[c])) { if (left == 0) - v->values[c] = 0; + v->values[c] = nleft; else v->values[c] = (pa_volume_t) (((uint64_t) v->values[c] * (uint64_t) nleft) / (uint64_t) left); } else if (on_right(map->map[c])) { if (right == 0) - v->values[c] = 0; + v->values[c] = nright; else v->values[c] = (pa_volume_t) (((uint64_t) v->values[c] * (uint64_t) nright) / (uint64_t) right); } -- cgit From 9314db79db222ac60e0e911e8bfd6455fa433ba9 Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Fri, 30 Jan 2009 00:14:50 +0100 Subject: fix a bogus assert --- src/pulse/volume.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pulse/volume.c b/src/pulse/volume.c index 4da133df..711c3a9f 100644 --- a/src/pulse/volume.c +++ b/src/pulse/volume.c @@ -505,7 +505,7 @@ pa_cvolume* pa_cvolume_scale(pa_cvolume *v, pa_volume_t max) { unsigned c; pa_volume_t t = 0; - pa_assert(c); + pa_assert(v); for (c = 0; c < v->channels; c++) if (v->values[c] > t) -- cgit From 1b53f8297f7ee61b6d99dbbf1ae92aae3d7fdc8b Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Fri, 30 Jan 2009 00:15:40 +0100 Subject: implement pa_cvolume_{get|set}_fade --- src/map-file | 2 + src/pulse/volume.c | 111 +++++++++++++++++++++++++++++++++++++++++++++++++++++ src/pulse/volume.h | 19 ++++++++- 3 files changed, 130 insertions(+), 2 deletions(-) diff --git a/src/map-file b/src/map-file index d6137590..e076a435 100644 --- a/src/map-file +++ b/src/map-file @@ -110,12 +110,14 @@ pa_cvolume_channels_equal_to; pa_cvolume_compatible; pa_cvolume_equal; pa_cvolume_get_balance; +pa_cvolume_get_fade; pa_cvolume_init; pa_cvolume_max; pa_cvolume_remap; pa_cvolume_scale; pa_cvolume_set; pa_cvolume_set_balance; +pa_cvolume_set_fade; pa_cvolume_snprint; pa_cvolume_valid; pa_ext_stream_restore_delete; diff --git a/src/pulse/volume.c b/src/pulse/volume.c index 711c3a9f..a6abce2a 100644 --- a/src/pulse/volume.c +++ b/src/pulse/volume.c @@ -341,6 +341,28 @@ static pa_bool_t on_lfe(pa_channel_position_t p) { p == PA_CHANNEL_POSITION_LFE; } +static pa_bool_t on_front(pa_channel_position_t p) { + return + p == PA_CHANNEL_POSITION_FRONT_LEFT || + p == PA_CHANNEL_POSITION_FRONT_RIGHT || + p == PA_CHANNEL_POSITION_FRONT_CENTER || + p == PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER || + p == PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER || + p == PA_CHANNEL_POSITION_TOP_FRONT_LEFT || + p == PA_CHANNEL_POSITION_TOP_FRONT_RIGHT || + p == PA_CHANNEL_POSITION_TOP_FRONT_CENTER; +} + +static pa_bool_t on_rear(pa_channel_position_t p) { + return + p == PA_CHANNEL_POSITION_REAR_LEFT || + p == PA_CHANNEL_POSITION_REAR_RIGHT || + p == PA_CHANNEL_POSITION_REAR_CENTER || + p == PA_CHANNEL_POSITION_TOP_REAR_LEFT || + p == PA_CHANNEL_POSITION_TOP_REAR_RIGHT || + p == PA_CHANNEL_POSITION_TOP_REAR_CENTER; +} + pa_cvolume *pa_cvolume_remap(pa_cvolume *v, const pa_channel_map *from, const pa_channel_map *to) { int a, b; pa_cvolume result; @@ -519,3 +541,92 @@ pa_cvolume* pa_cvolume_scale(pa_cvolume *v, pa_volume_t max) { return v; } + +static void get_avg_fr(const pa_channel_map *map, const pa_cvolume *v, pa_volume_t *f, pa_volume_t *r) { + int c; + pa_volume_t front = 0, rear = 0; + unsigned n_front = 0, n_rear = 0; + + pa_assert(v); + pa_assert(map); + pa_assert(map->channels == v->channels); + pa_assert(f); + pa_assert(r); + + for (c = 0; c < map->channels; c++) { + if (on_front(map->map[c])) { + front += v->values[c]; + n_front++; + } else if (on_rear(map->map[c])) { + rear += v->values[c]; + n_rear++; + } + } + + if (n_front <= 0) + *f = PA_VOLUME_NORM; + else + *f = front / n_front; + + if (n_rear <= 0) + *r = PA_VOLUME_NORM; + else + *r = rear / n_rear; +} + +float pa_cvolume_get_fade(const pa_cvolume *v, const pa_channel_map *map) { + pa_volume_t front, rear; + + pa_assert(v); + pa_assert(map); + pa_assert(map->channels == v->channels); + + get_avg_fr(map, v, &front, &rear); + + if (front == rear) + return 0.0f; + + if (rear > front) + return -1.0f + ((float) front / (float) rear); + else + return 1.0f - ((float) rear / (float) front); +} + +pa_cvolume* pa_cvolume_set_fade(pa_cvolume *v, const pa_channel_map *map, float new_fade) { + pa_volume_t front, nfront, rear, nrear, m; + unsigned c; + + pa_assert(map->channels == v->channels); + pa_assert(map); + pa_assert(v); + pa_assert(new_fade >= -1.0f); + pa_assert(new_fade <= 1.0f); + + get_avg_fr(map, v, &front, &rear); + + m = PA_MAX(front, rear); + + if (new_fade <= 0) { + nfront = (new_fade + 1.0f) * m; + nrear = m; + } else { + nrear = (1.0f - new_fade) * m; + nfront = m; + } + + for (c = 0; c < map->channels; c++) { + if (on_front(map->map[c])) { + if (front == 0) + v->values[c] = nfront; + else + v->values[c] = (pa_volume_t) (((uint64_t) v->values[c] * (uint64_t) nfront) / (uint64_t) front); + } else if (on_rear(map->map[c])) { + if (rear == 0) + v->values[c] = nrear; + else + v->values[c] = (pa_volume_t) (((uint64_t) v->values[c] * (uint64_t) nrear) / (uint64_t) rear); + } + } + + return v; +} diff --git a/src/pulse/volume.h b/src/pulse/volume.h index 9a883ca7..8eef467f 100644 --- a/src/pulse/volume.h +++ b/src/pulse/volume.h @@ -242,12 +242,27 @@ float pa_cvolume_get_balance(const pa_cvolume *v, const pa_channel_map *map) PA_ /** Adjust the 'balance' value for the specified volume with the * specified channel map. v will be modified in place and * returned. The balance is a value between -1.0f and +1.0f. This - * operation might not be reversable! Also, after this call + * operation might not be reversible! Also, after this call * pa_cvolume_get_balance() is not guaranteed to actually return the - * requested balance (e.g. when the input volume was zero anyway for + * requested balance value (e.g. when the input volume was zero anyway for * all channels) \since 0.9.15 */ pa_cvolume* pa_cvolume_set_balance(pa_cvolume *v, const pa_channel_map *map, float new_balance); +/** Calculate a 'fade' value (i.e. 'balance' between front and rear) + * for the specified volume with the specified channel map. The return + * value will range from -1.0f (rear) to +1.0f (left) \since + * 0.9.15 */ +float pa_cvolume_get_fade(const pa_cvolume *v, const pa_channel_map *map) PA_GCC_PURE; + +/** Adjust the 'fade' value (i.e. 'balance' between front and rear) + * for the specified volume with the specified channel map. v will be + * modified in place and returned. The balance is a value between + * -1.0f and +1.0f. This operation might not be reversible! Also, + * after this call pa_cvolume_get_fade() is not guaranteed to + * actually return the requested fade value (e.g. when the input volume + * was zero anyway for all channels) \since 0.9.15 */ +pa_cvolume* pa_cvolume_set_fade(pa_cvolume *v, const pa_channel_map *map, float new_fade); + /** Scale the passed pa_cvolume structure so that the maximum volume * of all channels equals max. The proportions between the channel * volumes are kept. \since 0.9.15 */ -- cgit From 1c94cfe29f552c22fb5807ca048c255710a6b487 Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Fri, 30 Jan 2009 00:22:07 +0100 Subject: Add a little Gtk test tool to show how balance/fade/value and the channel volumes play together --- src/tests/volume-ui.py | 227 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 227 insertions(+) create mode 100644 src/tests/volume-ui.py diff --git a/src/tests/volume-ui.py b/src/tests/volume-ui.py new file mode 100644 index 00000000..a2b756e6 --- /dev/null +++ b/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() -- cgit