1 files changed, 529 insertions, 0 deletions
diff --git a/backends/oss/oss-stream-control.c b/backends/oss/oss-stream-control.c
new file mode 100644
index 0000000..0b1db26
--- /dev/null
+++ b/backends/oss/oss-stream-control.c
@@ -0,0 +1,529 @@
+/*
+ * 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 <unistd.h>
+#include <errno.h>
+#include <glib.h>
+#include <glib/gstdio.h>
+#include <glib-object.h>
+
+#include <libmatemixer/matemixer-port.h>
+#include <libmatemixer/matemixer-stream-control.h>
+
+#include "oss-common.h"
+#include "oss-stream-control.h"
+
+struct _OssStreamControlPrivate
+{
+ gint fd;
+ gint dev_number;
+ gchar *name;
+ gchar *description;
+ guint volume[2];
+ gfloat balance;
+ gboolean stereo;
+ MateMixerPort *port;
+ MateMixerStreamControlRole role;
+ MateMixerStreamControlFlags flags;
+};
+
+enum {
+ PROP_0,
+ PROP_NAME,
+ PROP_DESCRIPTION,
+ PROP_FLAGS,
+ PROP_MUTE,
+ PROP_VOLUME,
+ PROP_BALANCE,
+ PROP_FADE,
+ PROP_FD,
+ PROP_DEV_NUMBER,
+ PROP_STEREO
+};
+
+static void mate_mixer_stream_control_interface_init (MateMixerStreamControlInterface *iface);
+
+static void oss_stream_control_class_init (OssStreamControlClass *klass);
+
+static void oss_stream_control_get_property (GObject *object,
+ guint param_id,
+ GValue *value,
+ GParamSpec *pspec);
+static void oss_stream_control_set_property (GObject *object,
+ guint param_id,
+ const GValue *value,
+ GParamSpec *pspec);
+
+static void oss_stream_control_init (OssStreamControl *octl);
+static void oss_stream_control_finalize (GObject *object);
+
+G_DEFINE_TYPE_WITH_CODE (OssStreamControl, oss_stream_control, G_TYPE_OBJECT,
+ G_IMPLEMENT_INTERFACE (MATE_MIXER_TYPE_STREAM_CONTROL,
+ mate_mixer_stream_control_interface_init))
+
+static const gchar * oss_stream_control_get_name (MateMixerStreamControl *ctl);
+static const gchar * oss_stream_control_get_description (MateMixerStreamControl *ctl);
+
+static guint oss_stream_control_get_num_channels (MateMixerStreamControl *ctl);
+
+static gboolean oss_stream_control_set_volume (MateMixerStreamControl *ctl,
+ guint volume);
+
+static guint oss_stream_control_get_channel_volume (MateMixerStreamControl *ctl,
+ guint channel);
+static gboolean oss_stream_control_set_channel_volume (MateMixerStreamControl *ctl,
+ guint channel,
+ guint volume);
+
+static MateMixerChannelPosition oss_stream_control_get_channel_position (MateMixerStreamControl *ctl,
+ guint channel);
+static gboolean oss_stream_control_has_channel_position (MateMixerStreamControl *ctl,
+ MateMixerChannelPosition position);
+
+static gboolean oss_stream_control_set_balance (MateMixerStreamControl *ctl,
+ gfloat balance);
+
+static guint oss_stream_control_get_min_volume (MateMixerStreamControl *ctl);
+static guint oss_stream_control_get_max_volume (MateMixerStreamControl *ctl);
+static guint oss_stream_control_get_normal_volume (MateMixerStreamControl *ctl);
+static guint oss_stream_control_get_base_volume (MateMixerStreamControl *ctl);
+
+static void
+mate_mixer_stream_control_interface_init (MateMixerStreamControlInterface *iface)
+{
+ iface->get_name = oss_stream_control_get_name;
+ iface->get_description = oss_stream_control_get_description;
+ iface->get_num_channels = oss_stream_control_get_num_channels;
+ iface->set_volume = oss_stream_control_set_volume;
+ iface->get_channel_volume = oss_stream_control_get_channel_volume;
+ iface->set_channel_volume = oss_stream_control_set_channel_volume;
+ iface->get_channel_position = oss_stream_control_get_channel_position;
+ iface->has_channel_position = oss_stream_control_has_channel_position;
+ iface->set_balance = oss_stream_control_set_balance;
+ iface->get_min_volume = oss_stream_control_get_min_volume;
+ iface->get_max_volume = oss_stream_control_get_max_volume;
+ iface->get_normal_volume = oss_stream_control_get_normal_volume;
+ iface->get_base_volume = oss_stream_control_get_base_volume;
+}
+
+static void
+oss_stream_control_class_init (OssStreamControlClass *klass)
+{
+ GObjectClass *object_class;
+
+ object_class = G_OBJECT_CLASS (klass);
+ object_class->finalize = oss_stream_control_finalize;
+ object_class->get_property = oss_stream_control_get_property;
+ object_class->set_property = oss_stream_control_set_property;
+
+ g_object_class_install_property (object_class,
+ PROP_FD,
+ g_param_spec_int ("fd",
+ "File descriptor",
+ "File descriptor of the device",
+ G_MININT,
+ G_MAXINT,
+ -1,
+ G_PARAM_CONSTRUCT_ONLY |
+ G_PARAM_READWRITE |
+ G_PARAM_STATIC_STRINGS));
+
+ g_object_class_install_property (object_class,
+ PROP_DEV_NUMBER,
+ g_param_spec_int ("dev-number",
+ "Dev number",
+ "OSS device number",
+ G_MININT,
+ G_MAXINT,
+ 0,
+ G_PARAM_CONSTRUCT_ONLY |
+ G_PARAM_READWRITE |
+ G_PARAM_STATIC_STRINGS));
+
+ g_object_class_install_property (object_class,
+ PROP_STEREO,
+ g_param_spec_boolean ("stereo",
+ "Stereo",
+ "Stereo",
+ FALSE,
+ G_PARAM_CONSTRUCT_ONLY |
+ G_PARAM_READWRITE |
+ G_PARAM_STATIC_STRINGS));
+
+ g_object_class_override_property (object_class, PROP_NAME, "name");
+ g_object_class_override_property (object_class, PROP_DESCRIPTION, "description");
+ g_object_class_override_property (object_class, PROP_FLAGS, "flags");
+ g_object_class_override_property (object_class, PROP_MUTE, "mute");
+ g_object_class_override_property (object_class, PROP_VOLUME, "volume");
+ g_object_class_override_property (object_class, PROP_BALANCE, "balance");
+ g_object_class_override_property (object_class, PROP_FADE, "fade");
+
+ g_type_class_add_private (object_class, sizeof (OssStreamControlPrivate));
+}
+
+static void
+oss_stream_control_get_property (GObject *object,
+ guint param_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ OssStreamControl *octl;
+
+ octl = OSS_STREAM_CONTROL (object);
+
+ switch (param_id) {
+ case PROP_NAME:
+ g_value_set_string (value, octl->priv->name);
+ break;
+ case PROP_DESCRIPTION:
+ g_value_set_string (value, octl->priv->description);
+ break;
+ case PROP_FLAGS:
+ g_value_set_flags (value, octl->priv->flags);
+ break;
+ case PROP_MUTE:
+ /* Not supported */
+ g_value_set_boolean (value, FALSE);
+ break;
+ case PROP_VOLUME:
+ g_value_set_uint (value, MAX (octl->priv->volume[0], octl->priv->volume[1]));
+ break;
+ case PROP_BALANCE:
+ g_value_set_float (value, octl->priv->balance);
+ break;
+ case PROP_FADE:
+ /* Not supported */
+ g_value_set_float (value, 0.0f);
+ break;
+ case PROP_FD:
+ g_value_set_int (value, octl->priv->fd);
+ break;
+ case PROP_DEV_NUMBER:
+ g_value_set_int (value, octl->priv->dev_number);
+ break;
+ case PROP_STEREO:
+ g_value_set_boolean (value, octl->priv->stereo);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
+ break;
+ }
+}
+
+static void
+oss_stream_control_set_property (GObject *object,
+ guint param_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ OssStreamControl *octl;
+
+ octl = OSS_STREAM_CONTROL (object);
+
+ switch (param_id) {
+ case PROP_FD:
+ octl->priv->fd = dup (g_value_get_int (value));
+ break;
+ case PROP_DEV_NUMBER:
+ octl->priv->dev_number = g_value_get_int (value);
+ break;
+ case PROP_STEREO:
+ octl->priv->stereo = g_value_get_boolean (value);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
+ break;
+ }
+}
+
+static void
+oss_stream_control_init (OssStreamControl *octl)
+{
+ octl->priv = G_TYPE_INSTANCE_GET_PRIVATE (octl,
+ OSS_TYPE_STREAM_CONTROL,
+ OssStreamControlPrivate);
+}
+
+static void
+oss_stream_control_finalize (GObject *object)
+{
+ OssStreamControl *octl;
+
+ octl = OSS_STREAM_CONTROL (object);
+
+ g_free (octl->priv->name);
+ g_free (octl->priv->description);
+
+ if (octl->priv->fd != -1)
+ g_close (octl->priv->fd, NULL);
+
+ G_OBJECT_CLASS (oss_stream_control_parent_class)->finalize (object);
+}
+
+OssStreamControl *
+oss_stream_control_new (gint fd,
+ gint dev_number,
+ const gchar *name,
+ const gchar *description,
+ gboolean stereo)
+{
+ OssStreamControl *ctl;
+
+ ctl = g_object_new (OSS_TYPE_STREAM_CONTROL,
+ "fd", fd,
+ "dev-number", dev_number,
+ "stereo", stereo,
+ NULL);
+
+ ctl->priv->name = g_strdup (name);
+ ctl->priv->description = g_strdup (description);
+
+ return ctl;
+}
+
+gboolean
+oss_stream_control_update (OssStreamControl *octl)
+{
+ gint v;
+ gint ret;
+
+ g_return_val_if_fail (OSS_IS_STREAM_CONTROL (octl), FALSE);
+
+ ret = ioctl (octl->priv->fd, MIXER_READ (octl->priv->dev_number), &v);
+ if (ret < 0) {
+ g_warning ("Failed to read volume: %s", g_strerror (errno));
+ return FALSE;
+ }
+
+ octl->priv->volume[0] = v & 0xFF;
+
+ if (octl->priv->stereo == TRUE)
+ octl->priv->volume[1] = (v >> 8) & 0xFF;
+
+ return TRUE;
+}
+
+gboolean
+oss_stream_control_set_port (OssStreamControl *octl, MateMixerPort *port)
+{
+ g_return_val_if_fail (OSS_IS_STREAM_CONTROL (octl), FALSE);
+
+ // XXX provide property
+
+ if (octl->priv->port != NULL)
+ g_object_unref (octl->priv->port);
+
+ octl->priv->port = g_object_ref (port);
+ return TRUE;
+}
+
+gboolean
+oss_stream_control_set_role (OssStreamControl *octl, MateMixerStreamControlRole role)
+{
+ g_return_val_if_fail (OSS_IS_STREAM_CONTROL (octl), FALSE);
+
+ octl->priv->role = role;
+ return TRUE;
+}
+
+static const gchar *
+oss_stream_control_get_name (MateMixerStreamControl *ctl)
+{
+ g_return_val_if_fail (OSS_IS_STREAM_CONTROL (ctl), NULL);
+
+ return OSS_STREAM_CONTROL (ctl)->priv->name;
+}
+
+static const gchar *
+oss_stream_control_get_description (MateMixerStreamControl *ctl)
+{
+ g_return_val_if_fail (OSS_IS_STREAM_CONTROL (ctl), NULL);
+
+ return OSS_STREAM_CONTROL (ctl)->priv->description;
+}
+
+static guint
+oss_stream_control_get_num_channels (MateMixerStreamControl *ctl)
+{
+ g_return_val_if_fail (OSS_IS_STREAM_CONTROL (ctl), 0);
+
+ if (OSS_STREAM_CONTROL (ctl)->priv->stereo == TRUE)
+ return 2;
+ else
+ return 1;
+}
+
+static gboolean
+oss_stream_control_set_volume (MateMixerStreamControl *ctl, guint volume)
+{
+ OssStreamControl *octl;
+ int v;
+ int ret;
+
+ g_return_val_if_fail (OSS_IS_STREAM_CONTROL (ctl), FALSE);
+
+ octl = OSS_STREAM_CONTROL (ctl);
+
+ /* Some backends may allow setting higher value than maximum, but not here */
+ if (volume > 100)
+ volume = 100;
+
+ v = volume;
+ if (octl->priv->stereo == TRUE)
+ v |= (volume & 0xFF) << 8;
+
+ ret = ioctl (octl->priv->fd, MIXER_WRITE (octl->priv->dev_number), &v);
+ if (ret < 0) {
+ g_warning ("Failed to set volume: %s", g_strerror (errno));
+ return FALSE;
+ }
+ return TRUE;
+}
+
+static guint
+oss_stream_control_get_channel_volume (MateMixerStreamControl *ctl, guint channel)
+{
+ OssStreamControl *octl;
+
+ g_return_val_if_fail (OSS_IS_STREAM_CONTROL (ctl), 0);
+
+ octl = OSS_STREAM_CONTROL (ctl);
+
+ if (channel > 1)
+ return 0;
+
+ /* Right channel on mono stream will always have zero volume */
+ return octl->priv->volume[channel];
+}
+
+static gboolean
+oss_stream_control_set_channel_volume (MateMixerStreamControl *ctl,
+ guint channel,
+ guint volume)
+{
+ OssStreamControl *octl;
+ int ret;
+ int v;
+
+ g_return_val_if_fail (OSS_IS_STREAM_CONTROL (ctl), FALSE);
+
+ if (channel > 1)
+ return FALSE;
+
+ octl = OSS_STREAM_CONTROL (ctl);
+
+ /* Some backends may allow setting higher value than maximum, but not here */
+ if (volume > 100)
+ volume = 100;
+
+ if (channel == 0)
+ v = volume;
+ else
+ v = octl->priv->volume[0];
+
+ if (channel == 1) {
+ if (octl->priv->stereo == FALSE)
+ return FALSE;
+
+ v |= volume << 8;
+ } else
+ v |= octl->priv->volume[1] << 8;
+
+ ret = ioctl (octl->priv->fd, MIXER_WRITE (octl->priv->dev_number), &v);
+ if (ret < 0) {
+ g_warning ("Failed to set channel volume: %s", g_strerror (errno));
+ return FALSE;
+ }
+ return TRUE;
+}
+
+static MateMixerChannelPosition
+oss_stream_control_get_channel_position (MateMixerStreamControl *ctl, guint channel)
+{
+ OssStreamControl *octl;
+
+ g_return_val_if_fail (OSS_IS_STREAM_CONTROL (ctl), MATE_MIXER_CHANNEL_UNKNOWN);
+
+ octl = OSS_STREAM_CONTROL (ctl);
+
+ if (octl->priv->stereo == TRUE) {
+ if (channel == 0)
+ return MATE_MIXER_CHANNEL_FRONT_LEFT;
+ else if (channel == 1)
+ return MATE_MIXER_CHANNEL_FRONT_RIGHT;
+ } else {
+ if (channel == 0)
+ return MATE_MIXER_CHANNEL_MONO;
+ }
+ return MATE_MIXER_CHANNEL_UNKNOWN;
+}
+
+static gboolean
+oss_stream_control_has_channel_position (MateMixerStreamControl *ctl,
+ MateMixerChannelPosition position)
+{
+ g_return_val_if_fail (OSS_IS_STREAM_CONTROL (ctl), FALSE);
+
+ if (position == MATE_MIXER_CHANNEL_MONO)
+ return OSS_STREAM_CONTROL (ctl)->priv->stereo == FALSE;
+
+ if (position == MATE_MIXER_CHANNEL_FRONT_LEFT ||
+ position == MATE_MIXER_CHANNEL_FRONT_RIGHT)
+ return OSS_STREAM_CONTROL (ctl)->priv->stereo == TRUE;
+
+ return FALSE;
+}
+
+static gboolean
+oss_stream_control_set_balance (MateMixerStreamControl *ctl, gfloat balance)
+{
+ OssStreamControl *octl;
+
+ g_return_val_if_fail (OSS_IS_STREAM_CONTROL (ctl), FALSE);
+
+ octl = OSS_STREAM_CONTROL (ctl);
+
+ if (octl->priv->stereo == FALSE)
+ return FALSE;
+
+ // XXX
+ return TRUE;
+}
+
+static guint
+oss_stream_control_get_min_volume (MateMixerStreamControl *ctl)
+{
+ return 0;
+}
+
+static guint
+oss_stream_control_get_max_volume (MateMixerStreamControl *ctl)
+{
+ return 100;
+}
+
+static guint
+oss_stream_control_get_normal_volume (MateMixerStreamControl *ctl)
+{
+ return 100;
+}
+
+static guint
+oss_stream_control_get_base_volume (MateMixerStreamControl *ctl)
+{
+ return 100;
+}