Merge branch 'oss-alsa'

1 files changed, 739 insertions, 0 deletions

diff --git a/backends/alsa/alsa-stream-control.c b/backends/alsa/alsa-stream-control.c
new file mode 100644
index 0000000..bc7a937
--- /dev/null
+++ b/backends/alsa/alsa-stream-control.c
@@ -0,0 +1,739 @@
+/*
+ * Copyright (C) 2014 Michal Ratajsky <[email protected]>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the licence, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <glib.h>
+#include <glib-object.h>
+#include <alsa/asoundlib.h>
+#include <libmatemixer/matemixer.h>
+#include <libmatemixer/matemixer-private.h>
+
+#include "alsa-constants.h"
+#include "alsa-element.h"
+#include "alsa-stream-control.h"
+
+struct _AlsaStreamControlPrivate
+{
+    AlsaControlData   data;
+    guint32           channel_mask;
+    snd_mixer_elem_t *element;
+};
+
+static void alsa_element_interface_init    (AlsaElementInterface   *iface);
+
+static void alsa_stream_control_class_init (AlsaStreamControlClass *klass);
+static void alsa_stream_control_init       (AlsaStreamControl      *control);
+
+G_DEFINE_ABSTRACT_TYPE_WITH_CODE (AlsaStreamControl, alsa_stream_control,
+                                  MATE_MIXER_TYPE_STREAM_CONTROL,
+                                  G_IMPLEMENT_INTERFACE (ALSA_TYPE_ELEMENT,
+                                                         alsa_element_interface_init))
+
+static snd_mixer_elem_t *       alsa_stream_control_get_snd_element      (AlsaElement             *element);
+static void                     alsa_stream_control_set_snd_element      (AlsaElement             *element,
+                                                                          snd_mixer_elem_t        *el);
+
+static gboolean                 alsa_stream_control_load                 (AlsaElement             *element);
+
+static gboolean                 alsa_stream_control_set_mute             (MateMixerStreamControl  *mmsc,
+                                                                          gboolean                 mute);
+
+static guint                    alsa_stream_control_get_num_channels     (MateMixerStreamControl  *mmsc);
+
+static guint                    alsa_stream_control_get_volume           (MateMixerStreamControl  *mmsc);
+
+static gboolean                 alsa_stream_control_set_volume           (MateMixerStreamControl  *mmsc,
+                                                                          guint                    volume);
+
+static gdouble                  alsa_stream_control_get_decibel          (MateMixerStreamControl  *mmsc);
+
+static gboolean                 alsa_stream_control_set_decibel          (MateMixerStreamControl  *mmsc,
+                                                                          gdouble                  decibel);
+
+static gboolean                 alsa_stream_control_has_channel_position (MateMixerStreamControl  *mmsc,
+                                                                          MateMixerChannelPosition position);
+static MateMixerChannelPosition alsa_stream_control_get_channel_position (MateMixerStreamControl  *mmsc,
+                                                                          guint                    channel);
+
+static guint                    alsa_stream_control_get_channel_volume   (MateMixerStreamControl  *mmsc,
+                                                                          guint                    channel);
+static gboolean                 alsa_stream_control_set_channel_volume   (MateMixerStreamControl  *mmsc,
+                                                                          guint                    channel,
+                                                                          guint                    volume);
+
+static gdouble                  alsa_stream_control_get_channel_decibel  (MateMixerStreamControl  *mmsc,
+                                                                          guint                    channel);
+static gboolean                 alsa_stream_control_set_channel_decibel  (MateMixerStreamControl  *mmsc,
+                                                                          guint                    channel,
+                                                                          gdouble                  decibel);
+
+static gboolean                 alsa_stream_control_set_balance          (MateMixerStreamControl  *mmsc,
+                                                                          gfloat                   balance);
+
+static gboolean                 alsa_stream_control_set_fade             (MateMixerStreamControl  *mmsc,
+                                                                          gfloat                   fade);
+
+static guint                    alsa_stream_control_get_min_volume       (MateMixerStreamControl  *mmsc);
+static guint                    alsa_stream_control_get_max_volume       (MateMixerStreamControl  *mmsc);
+static guint                    alsa_stream_control_get_normal_volume    (MateMixerStreamControl  *mmsc);
+static guint                    alsa_stream_control_get_base_volume      (MateMixerStreamControl  *mmsc);
+
+static void                     control_data_get_average_left_right      (AlsaControlData         *data,
+                                                                          guint                   *left,
+                                                                          guint                   *right);
+static void                     control_data_get_average_front_back      (AlsaControlData         *data,
+                                                                          guint                   *front,
+                                                                          guint                   *back);
+
+static gfloat                   control_data_get_balance                 (AlsaControlData         *data);
+static gfloat                   control_data_get_fade                    (AlsaControlData         *data);
+
+static void
+alsa_element_interface_init (AlsaElementInterface *iface)
+{
+    iface->get_snd_element = alsa_stream_control_get_snd_element;
+    iface->set_snd_element = alsa_stream_control_set_snd_element;
+    iface->load            = alsa_stream_control_load;
+}
+
+static void
+alsa_stream_control_class_init (AlsaStreamControlClass *klass)
+{
+    MateMixerStreamControlClass *control_class;
+
+    control_class = MATE_MIXER_STREAM_CONTROL_CLASS (klass);
+
+    control_class->set_mute             = alsa_stream_control_set_mute;
+    control_class->get_num_channels     = alsa_stream_control_get_num_channels;
+    control_class->get_volume           = alsa_stream_control_get_volume;
+    control_class->set_volume           = alsa_stream_control_set_volume;
+    control_class->get_decibel          = alsa_stream_control_get_decibel;
+    control_class->set_decibel          = alsa_stream_control_set_decibel;
+    control_class->has_channel_position = alsa_stream_control_has_channel_position;
+    control_class->get_channel_position = alsa_stream_control_get_channel_position;
+    control_class->get_channel_volume   = alsa_stream_control_get_channel_volume;
+    control_class->set_channel_volume   = alsa_stream_control_set_channel_volume;
+    control_class->get_channel_decibel  = alsa_stream_control_get_channel_decibel;
+    control_class->set_channel_decibel  = alsa_stream_control_set_channel_decibel;
+    control_class->set_balance          = alsa_stream_control_set_balance;
+    control_class->set_fade             = alsa_stream_control_set_fade;
+    control_class->get_min_volume       = alsa_stream_control_get_min_volume;
+    control_class->get_max_volume       = alsa_stream_control_get_max_volume;
+    control_class->get_normal_volume    = alsa_stream_control_get_normal_volume;
+    control_class->get_base_volume      = alsa_stream_control_get_base_volume;
+
+    g_type_class_add_private (G_OBJECT_CLASS (klass), sizeof (AlsaStreamControlPrivate));
+}
+
+static void
+alsa_stream_control_init (AlsaStreamControl *control)
+{
+    control->priv = G_TYPE_INSTANCE_GET_PRIVATE (control,
+                                                 ALSA_TYPE_STREAM_CONTROL,
+                                                 AlsaStreamControlPrivate);
+}
+
+AlsaControlData *
+alsa_stream_control_get_data (AlsaStreamControl *control)
+{
+    g_return_val_if_fail (ALSA_IS_STREAM_CONTROL (control), NULL);
+
+    return &control->priv->data;
+}
+
+void
+alsa_stream_control_set_data (AlsaStreamControl *control, AlsaControlData *data)
+{
+    MateMixerStreamControlFlags flags = MATE_MIXER_STREAM_CONTROL_NO_FLAGS;
+    MateMixerStreamControl     *mmsc;
+
+    g_return_if_fail (ALSA_IS_STREAM_CONTROL (control));
+    g_return_if_fail (data != NULL);
+
+    mmsc = MATE_MIXER_STREAM_CONTROL (control);
+
+    g_object_freeze_notify (G_OBJECT (control));
+
+    if (data->channels > 0) {
+        if (data->switch_usable == TRUE) {
+            flags |= MATE_MIXER_STREAM_CONTROL_HAS_MUTE;
+            if (data->active == TRUE)
+                flags |= MATE_MIXER_STREAM_CONTROL_CAN_SET_MUTE;
+        }
+        flags |= MATE_MIXER_STREAM_CONTROL_HAS_VOLUME;
+        if (data->active == TRUE)
+            flags |= MATE_MIXER_STREAM_CONTROL_CAN_SET_VOLUME;
+    }
+    if (data->max_decibel > -MATE_MIXER_INFINITY)
+        flags |= MATE_MIXER_STREAM_CONTROL_HAS_DECIBEL;
+
+    control->priv->data = *data;
+    control->priv->channel_mask = _mate_mixer_create_channel_mask (data->c, data->channels);
+
+    if (data->volume_joined == FALSE) {
+        if (MATE_MIXER_CHANNEL_MASK_HAS_LEFT (control->priv->channel_mask) &&
+            MATE_MIXER_CHANNEL_MASK_HAS_RIGHT (control->priv->channel_mask))
+            flags |= MATE_MIXER_STREAM_CONTROL_CAN_BALANCE;
+
+        if (MATE_MIXER_CHANNEL_MASK_HAS_FRONT (control->priv->channel_mask) &&
+            MATE_MIXER_CHANNEL_MASK_HAS_BACK (control->priv->channel_mask))
+            flags |= MATE_MIXER_STREAM_CONTROL_CAN_FADE;
+    }
+
+    _mate_mixer_stream_control_set_flags (mmsc, flags);
+
+    if (data->switch_usable == TRUE) {
+        gboolean mute;
+
+        /* If the mute switch is joined, all the channels get the same value,
+         * otherwise the element has per-channel mute, which we don't support.
+         * In that case, treat the control as unmuted if any channel is
+         * unmuted. */
+        if (data->channels == 1 || data->switch_joined == TRUE) {
+            mute = data->m[0];
+        } else {
+            gint i;
+            mute = TRUE;
+            for (i = 0; i < data->channels; i++)
+                if (data->m[i] == FALSE) {
+                    mute = FALSE;
+                    break;
+                }
+        }
+        _mate_mixer_stream_control_set_mute (mmsc, mute);
+    } else
+        _mate_mixer_stream_control_set_mute (mmsc, FALSE);
+
+    if (flags & MATE_MIXER_STREAM_CONTROL_CAN_BALANCE)
+        _mate_mixer_stream_control_set_balance (mmsc, control_data_get_balance (data));
+    if (flags & MATE_MIXER_STREAM_CONTROL_CAN_FADE)
+        _mate_mixer_stream_control_set_fade (mmsc, control_data_get_fade (data));
+
+    g_object_thaw_notify (G_OBJECT (control));
+}
+
+static snd_mixer_elem_t *
+alsa_stream_control_get_snd_element (AlsaElement *element)
+{
+    g_return_val_if_fail (ALSA_IS_STREAM_CONTROL (element), NULL);
+
+    return ALSA_STREAM_CONTROL (element)->priv->element;
+}
+
+static void
+alsa_stream_control_set_snd_element (AlsaElement *element, snd_mixer_elem_t *el)
+{
+    g_return_if_fail (ALSA_IS_STREAM_CONTROL (element));
+    g_return_if_fail (el != NULL);
+
+    ALSA_STREAM_CONTROL (element)->priv->element = el;
+}
+
+static gboolean
+alsa_stream_control_load (AlsaElement *element)
+{
+    AlsaStreamControl *control;
+
+    g_return_val_if_fail (ALSA_IS_STREAM_CONTROL (element), FALSE);
+
+    control = ALSA_STREAM_CONTROL (element);
+
+    return ALSA_STREAM_CONTROL_GET_CLASS (control)->load (control);
+}
+
+static gboolean
+alsa_stream_control_set_mute (MateMixerStreamControl *mmsc, gboolean mute)
+{
+    AlsaStreamControl *control;
+    gboolean           change = FALSE;
+    gint               i;
+
+    g_return_val_if_fail (ALSA_IS_STREAM_CONTROL (mmsc), FALSE);
+
+    control = ALSA_STREAM_CONTROL (mmsc);
+
+    /* If the switch is joined, only verify the first channel */
+    if (control->priv->data.switch_joined == TRUE) {
+        if (control->priv->data.m[0] != mute)
+            change = TRUE;
+    } else {
+        /* Avoid trying to set the mute if all channels are already at the
+         * selected mute value */
+        for (i = 0; i < control->priv->data.channels; i++)
+            if (control->priv->data.m[i] != mute) {
+                change = TRUE;
+                break;
+            }
+    }
+
+    if (change == TRUE) {
+        AlsaStreamControlClass *klass;
+
+        klass = ALSA_STREAM_CONTROL_GET_CLASS (control);
+        if (klass->set_mute (control, mute) == FALSE)
+            return FALSE;
+
+        for (i = 0; i < control->priv->data.channels; i++)
+            control->priv->data.m[i] = mute;
+    }
+    return TRUE;
+}
+
+static guint
+alsa_stream_control_get_num_channels (MateMixerStreamControl *mmsc)
+{
+    g_return_val_if_fail (ALSA_IS_STREAM_CONTROL (mmsc), 0);
+
+    return ALSA_STREAM_CONTROL (mmsc)->priv->data.channels;
+}
+
+static guint
+alsa_stream_control_get_volume (MateMixerStreamControl *mmsc)
+{
+    g_return_val_if_fail (ALSA_IS_STREAM_CONTROL (mmsc), 0);
+
+    return ALSA_STREAM_CONTROL (mmsc)->priv->data.volume;
+}
+
+static gboolean
+alsa_stream_control_set_volume (MateMixerStreamControl *mmsc, guint volume)
+{
+    AlsaStreamControl *control;
+    gboolean           change = FALSE;
+    gint               i;
+
+    g_return_val_if_fail (ALSA_IS_STREAM_CONTROL (mmsc), FALSE);
+
+    control = ALSA_STREAM_CONTROL (mmsc);
+    volume  = CLAMP (volume, control->priv->data.min, control->priv->data.max);
+
+    /* If the volume is joined, only verify the first channel */
+    if (control->priv->data.volume_joined == TRUE) {
+        if (control->priv->data.v[0] != volume)
+            change = TRUE;
+    } else {
+        /* Avoid trying to set the volume if all channels are already at the
+         * selected volume */
+        for (i = 0; i < control->priv->data.channels; i++)
+            if (control->priv->data.v[i] != volume) {
+                change = TRUE;
+                break;
+            }
+    }
+
+    if (change == TRUE) {
+        AlsaStreamControlClass *klass;
+
+        klass = ALSA_STREAM_CONTROL_GET_CLASS (control);
+        if (klass->set_volume (control, volume) == FALSE)
+            return FALSE;
+
+        for (i = 0; i < control->priv->data.channels; i++)
+            control->priv->data.v[i] = volume;
+
+        g_object_notify (G_OBJECT (control), "volume");
+    }
+    return TRUE;
+}
+
+static gdouble
+alsa_stream_control_get_decibel (MateMixerStreamControl *mmsc)
+{
+    AlsaStreamControl      *control;
+    AlsaStreamControlClass *klass;
+    guint                   volume;
+    gdouble                 decibel;
+
+    g_return_val_if_fail (ALSA_IS_STREAM_CONTROL (mmsc), -MATE_MIXER_INFINITY);
+
+    control = ALSA_STREAM_CONTROL (mmsc);
+    klass   = ALSA_STREAM_CONTROL_GET_CLASS (control);
+    volume  = alsa_stream_control_get_volume (mmsc);
+
+    if (klass->get_decibel_from_volume (control, volume, &decibel) == FALSE)
+        return FALSE;
+
+    return decibel;
+}
+
+static gboolean
+alsa_stream_control_set_decibel (MateMixerStreamControl *mmsc, gdouble decibel)
+{
+    AlsaStreamControl      *control;
+    AlsaStreamControlClass *klass;
+    guint                   volume;
+
+    g_return_val_if_fail (ALSA_IS_STREAM_CONTROL (mmsc), FALSE);
+
+    control = ALSA_STREAM_CONTROL (mmsc);
+    klass   = ALSA_STREAM_CONTROL_GET_CLASS (control);
+
+    if (klass->get_volume_from_decibel (control, decibel, &volume) == FALSE)
+        return FALSE;
+
+    return alsa_stream_control_set_volume (mmsc, volume);
+}
+
+static gboolean
+alsa_stream_control_has_channel_position (MateMixerStreamControl  *mmsc,
+                                          MateMixerChannelPosition position)
+{
+    AlsaStreamControl *control;
+
+    g_return_val_if_fail (ALSA_IS_STREAM_CONTROL (mmsc), FALSE);
+
+    control = ALSA_STREAM_CONTROL (mmsc);
+
+    if MATE_MIXER_CHANNEL_MASK_HAS_CHANNEL (control->priv->channel_mask, position)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+static MateMixerChannelPosition
+alsa_stream_control_get_channel_position (MateMixerStreamControl *mmsc, guint channel)
+{
+    AlsaStreamControl *control;
+
+    g_return_val_if_fail (ALSA_IS_STREAM_CONTROL (mmsc), MATE_MIXER_CHANNEL_UNKNOWN);
+
+    control = ALSA_STREAM_CONTROL (mmsc);
+
+    if (channel >= control->priv->data.channels)
+        return MATE_MIXER_CHANNEL_UNKNOWN;
+
+    return control->priv->data.c[channel];
+}
+
+static guint
+alsa_stream_control_get_channel_volume (MateMixerStreamControl *mmsc, guint channel)
+{
+    AlsaStreamControl *control;
+
+    g_return_val_if_fail (ALSA_IS_STREAM_CONTROL (mmsc), 0);
+
+    control = ALSA_STREAM_CONTROL (mmsc);
+
+    if (channel >= control->priv->data.channels)
+        return FALSE;
+
+    return control->priv->data.v[channel];
+}
+
+static gboolean
+alsa_stream_control_set_channel_volume (MateMixerStreamControl *mmsc, guint channel, guint volume)
+{
+    AlsaStreamControl *control;
+
+    g_return_val_if_fail (ALSA_IS_STREAM_CONTROL (mmsc), FALSE);
+
+    control = ALSA_STREAM_CONTROL (mmsc);
+
+    if (channel >= control->priv->data.channels)
+        return FALSE;
+
+    /* Set volume for all channels at once when channels are joined */
+    if (control->priv->data.volume_joined == TRUE)
+        return alsa_stream_control_set_volume (mmsc, volume);
+
+    if (volume != control->priv->data.v[channel]) {
+        AlsaStreamControlClass *klass;
+
+        /* Convert channel index to ALSA channel position and make sure it is valid */
+        snd_mixer_selem_channel_id_t c = alsa_channel_map_to[control->priv->data.c[channel]];
+        if G_UNLIKELY (c == SND_MIXER_SCHN_UNKNOWN) {
+            g_warn_if_reached ();
+            return FALSE;
+        }
+
+        klass = ALSA_STREAM_CONTROL_GET_CLASS (control);
+        if (klass->set_channel_volume (control, c, volume) == FALSE)
+            return FALSE;
+
+        control->priv->data.v[channel] = volume;
+
+        g_object_notify (G_OBJECT (control), "volume");
+    }
+    return TRUE;
+}
+
+static gdouble
+alsa_stream_control_get_channel_decibel (MateMixerStreamControl *mmsc, guint channel)
+{
+    AlsaStreamControl      *control;
+    AlsaStreamControlClass *klass;
+    guint                   volume;
+    gdouble                 decibel;
+
+    g_return_val_if_fail (ALSA_IS_STREAM_CONTROL (mmsc), -MATE_MIXER_INFINITY);
+
+    control = ALSA_STREAM_CONTROL (mmsc);
+
+    if (channel >= control->priv->data.channels)
+        return FALSE;
+
+    klass  = ALSA_STREAM_CONTROL_GET_CLASS (control);
+    volume = control->priv->data.v[channel];
+
+    if (klass->get_decibel_from_volume (control, volume, &decibel) == FALSE)
+        return FALSE;
+
+    return decibel;
+}
+
+static gboolean
+alsa_stream_control_set_channel_decibel (MateMixerStreamControl *mmsc,
+                                         guint                   channel,
+                                         gdouble                 decibel)
+{
+    AlsaStreamControl      *control;
+    AlsaStreamControlClass *klass;
+    guint                   volume;
+
+    g_return_val_if_fail (ALSA_IS_STREAM_CONTROL (mmsc), FALSE);
+
+    control = ALSA_STREAM_CONTROL (mmsc);
+    klass   = ALSA_STREAM_CONTROL_GET_CLASS (control);
+
+    if (klass->get_volume_from_decibel (control, decibel, &volume) == FALSE)
+        return FALSE;
+
+    return alsa_stream_control_set_channel_volume (mmsc, channel, volume);
+}
+
+static gboolean
+alsa_stream_control_set_balance (MateMixerStreamControl *mmsc, gfloat balance)
+{
+    AlsaStreamControlClass *klass;
+    AlsaStreamControl      *control;
+    AlsaControlData        *data;
+    guint                   left,
+                            right;
+    guint                   nleft,
+                            nright;
+    guint                   max;
+    guint                   channel;
+
+    g_return_val_if_fail (ALSA_IS_STREAM_CONTROL (mmsc), FALSE);
+
+    control = ALSA_STREAM_CONTROL (mmsc);
+    klass   = ALSA_STREAM_CONTROL_GET_CLASS (control);
+
+    data = &control->priv->data;
+    control_data_get_average_left_right (data, &left, &right);
+
+    max = MAX (left, right);
+    if (balance <= 0) {
+        nright = (balance + 1.0f) * max;
+        nleft  = max;
+    } else {
+        nleft  = (1.0f - balance) * max;
+        nright = max;
+    }
+
+    for (channel = 0; channel < data->channels; channel++) {
+        gboolean lc = MATE_MIXER_IS_LEFT_CHANNEL (data->c[channel]);
+        gboolean rc = MATE_MIXER_IS_RIGHT_CHANNEL (data->c[channel]);
+
+        if (lc == TRUE || rc == TRUE) {
+            guint volume;
+            if (lc == TRUE) {
+                if (left == 0)
+                    volume = nleft;
+                else
+                    volume = CLAMP (((guint64) data->v[channel] * (guint64) nleft) / (guint64) left,
+                                    data->min,
+                                    data->max);
+            } else {
+                if (right == 0)
+                    volume = nright;
+                else
+                    volume = CLAMP (((guint64) data->v[channel] * (guint64) nright) / (guint64) right,
+                                    data->min,
+                                    data->max);
+            }
+
+            if (klass->set_channel_volume (control,
+                                           alsa_channel_map_to[data->c[channel]],
+                                           volume) == TRUE)
+                data->v[channel] = volume;
+        }
+    }
+    return TRUE;
+}
+
+static gboolean
+alsa_stream_control_set_fade (MateMixerStreamControl *mmsc, gfloat fade)
+{
+    AlsaStreamControlClass *klass;
+    AlsaStreamControl      *control;
+    AlsaControlData        *data;
+    guint                   front,
+                            back;
+    guint                   nfront,
+                            nback;
+    guint                   max;
+    guint                   channel;
+
+    g_return_val_if_fail (ALSA_IS_STREAM_CONTROL (mmsc), FALSE);
+
+    control = ALSA_STREAM_CONTROL (mmsc);
+    klass   = ALSA_STREAM_CONTROL_GET_CLASS (control);
+
+    data = &control->priv->data;
+    control_data_get_average_front_back (data, &front, &back);
+
+    max = MAX (front, back);
+    if (fade <= 0) {
+        nback  = (fade + 1.0f) * max;
+        nfront = max;
+    } else {
+        nfront = (1.0f - fade) * max;
+        nback  = max;
+    }
+
+    for (channel = 0; channel < data->channels; channel++) {
+        gboolean fc = MATE_MIXER_IS_FRONT_CHANNEL (data->c[channel]);
+        gboolean bc = MATE_MIXER_IS_BACK_CHANNEL (data->c[channel]);
+
+        if (fc == TRUE || bc == TRUE) {
+            guint volume;
+            if (fc == TRUE) {
+                if (front == 0)
+                    volume = nfront;
+                else
+                    volume = CLAMP (((guint64) data->v[channel] * (guint64) nfront) / (guint64) front,
+                                    data->min,
+                                    data->max);
+            } else {
+                if (back == 0)
+                    volume = nback;
+                else
+                    volume = CLAMP (((guint64) data->v[channel] * (guint64) nback) / (guint64) back,
+                                    data->min,
+                                    data->max);
+            }
+
+            if (klass->set_channel_volume (control,
+                                           alsa_channel_map_to[data->c[channel]],
+                                           volume) == TRUE)
+                data->v[channel] = volume;
+        }
+    }
+    return TRUE;
+}
+
+static guint
+alsa_stream_control_get_min_volume (MateMixerStreamControl *msc)
+{
+    return ALSA_STREAM_CONTROL (msc)->priv->data.min;
+}
+
+static guint
+alsa_stream_control_get_max_volume (MateMixerStreamControl *msc)
+{
+    return ALSA_STREAM_CONTROL (msc)->priv->data.max;
+}
+
+static guint
+alsa_stream_control_get_normal_volume (MateMixerStreamControl *msc)
+{
+    return ALSA_STREAM_CONTROL (msc)->priv->data.max;
+}
+
+static guint
+alsa_stream_control_get_base_volume (MateMixerStreamControl *msc)
+{
+    return ALSA_STREAM_CONTROL (msc)->priv->data.max;
+}
+
+static void
+control_data_get_average_left_right (AlsaControlData *data, guint *left, guint *right)
+{
+    guint l = 0,
+          r = 0;
+    guint nl = 0,
+          nr = 0;
+    guint channel;
+
+    for (channel = 0; channel < data->channels; channel++)
+        if MATE_MIXER_IS_LEFT_CHANNEL (data->c[channel]) {
+            l += data->v[channel];
+            nl++;
+        }
+        else if MATE_MIXER_IS_RIGHT_CHANNEL (data->c[channel]) {
+            r += data->v[channel];
+            nr++;
+        }
+
+    *left  = (nl > 0) ? l / nl : data->max;
+    *right = (nr > 0) ? r / nr : data->max;
+}
+
+static void
+control_data_get_average_front_back (AlsaControlData *data, guint *front, guint *back)
+{
+    guint f = 0,
+          b = 0;
+    guint nf = 0,
+          nb = 0;
+    guint channel;
+
+    for (channel = 0; channel < data->channels; channel++)
+        if MATE_MIXER_IS_FRONT_CHANNEL (data->c[channel]) {
+            f += data->v[channel];
+            nf++;
+        }
+        else if MATE_MIXER_IS_RIGHT_CHANNEL (data->c[channel]) {
+            b += data->v[channel];
+            nb++;
+        }
+
+    *front = (nf > 0) ? f / nf : data->max;
+    *back  = (nb > 0) ? b / nb : data->max;
+}
+
+static gfloat
+control_data_get_balance (AlsaControlData *data)
+{
+    guint left;
+    guint right;
+
+    control_data_get_average_left_right (data, &left, &right);
+    if (left == right)
+        return 0.0f;
+
+    if (left > right)
+        return -1.0f + ((gfloat) right / (gfloat) left);
+    else
+        return +1.0f - ((gfloat) left / (gfloat) right);
+}
+
+static gfloat
+control_data_get_fade (AlsaControlData *data)
+{
+    guint front;
+    guint back;
+
+    control_data_get_average_front_back (data, &front, &back);
+    if (front == back)
+        return 0.0f;
+
+    if (front > back)
+        return -1.0f + ((gfloat) back / (gfloat) front);
+    else
+        return +1.0f - ((gfloat) front / (gfloat) back);
+}