diff options
Diffstat (limited to 'backends/oss/oss-stream-control.c')
| -rw-r--r-- | backends/oss/oss-stream-control.c | 529 |
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; +} |