diff options
Diffstat (limited to 'backends/oss/oss-stream-control.c')
| -rw-r--r-- | backends/oss/oss-stream-control.c | 527 |
1 files changed, 195 insertions, 332 deletions
diff --git a/backends/oss/oss-stream-control.c b/backends/oss/oss-stream-control.c index 0b1db26..5161528 100644 --- a/backends/oss/oss-stream-control.c +++ b/backends/oss/oss-stream-control.c @@ -15,14 +15,13 @@ * 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 <libmatemixer/matemixer.h> +#include <libmatemixer/matemixer-private.h> #include "oss-common.h" #include "oss-stream-control.h" @@ -30,437 +29,279 @@ struct _OssStreamControlPrivate { gint fd; - gint dev_number; - gchar *name; - gchar *description; + gint devnum; 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_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 *control); +static void oss_stream_control_finalize (GObject *object); -static void oss_stream_control_init (OssStreamControl *octl); -static void oss_stream_control_finalize (GObject *object); +G_DEFINE_TYPE (OssStreamControl, oss_stream_control, MATE_MIXER_TYPE_STREAM_CONTROL) -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 gboolean oss_stream_control_set_mute (MateMixerStreamControl *mmsc, + gboolean mute); -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 *mmsc); -static guint oss_stream_control_get_num_channels (MateMixerStreamControl *ctl); +static guint oss_stream_control_get_volume (MateMixerStreamControl *mmsc); -static gboolean oss_stream_control_set_volume (MateMixerStreamControl *ctl, +static gboolean oss_stream_control_set_volume (MateMixerStreamControl *mmsc, guint volume); -static guint oss_stream_control_get_channel_volume (MateMixerStreamControl *ctl, +static gboolean oss_stream_control_has_channel_position (MateMixerStreamControl *mmsc, + MateMixerChannelPosition position); +static MateMixerChannelPosition oss_stream_control_get_channel_position (MateMixerStreamControl *mmsc, 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, +static guint oss_stream_control_get_channel_volume (MateMixerStreamControl *mmsc, guint channel); -static gboolean oss_stream_control_has_channel_position (MateMixerStreamControl *ctl, - MateMixerChannelPosition position); +static gboolean oss_stream_control_set_channel_volume (MateMixerStreamControl *mmsc, + guint channel, + guint volume); -static gboolean oss_stream_control_set_balance (MateMixerStreamControl *ctl, +static gboolean oss_stream_control_set_balance (MateMixerStreamControl *mmsc, 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 guint oss_stream_control_get_min_volume (MateMixerStreamControl *mmsc); +static guint oss_stream_control_get_max_volume (MateMixerStreamControl *mmsc); +static guint oss_stream_control_get_normal_volume (MateMixerStreamControl *mmsc); +static guint oss_stream_control_get_base_volume (MateMixerStreamControl *mmsc); -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 gboolean write_volume (OssStreamControl *control, + gint volume); static void oss_stream_control_class_init (OssStreamControlClass *klass) { - GObjectClass *object_class; + GObjectClass *object_class; + MateMixerStreamControlClass *control_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"); + object_class->finalize = oss_stream_control_finalize; + + control_class = MATE_MIXER_STREAM_CONTROL_CLASS (klass); + control_class->set_mute = oss_stream_control_set_mute; + control_class->get_num_channels = oss_stream_control_get_num_channels; + control_class->get_volume = oss_stream_control_get_volume; + control_class->set_volume = oss_stream_control_set_volume; + control_class->get_channel_volume = oss_stream_control_get_channel_volume; + control_class->set_channel_volume = oss_stream_control_set_channel_volume; + control_class->get_channel_position = oss_stream_control_get_channel_position; + control_class->has_channel_position = oss_stream_control_has_channel_position; + control_class->set_balance = oss_stream_control_set_balance; + control_class->get_min_volume = oss_stream_control_get_min_volume; + control_class->get_max_volume = oss_stream_control_get_max_volume; + control_class->get_normal_volume = oss_stream_control_get_normal_volume; + control_class->get_base_volume = oss_stream_control_get_base_volume; 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) +oss_stream_control_init (OssStreamControl *control) { - 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); + control->priv = G_TYPE_INSTANCE_GET_PRIVATE (control, + OSS_TYPE_STREAM_CONTROL, + OssStreamControlPrivate); } static void oss_stream_control_finalize (GObject *object) { - OssStreamControl *octl; - - octl = OSS_STREAM_CONTROL (object); + OssStreamControl *control; - g_free (octl->priv->name); - g_free (octl->priv->description); + control = OSS_STREAM_CONTROL (object); - if (octl->priv->fd != -1) - g_close (octl->priv->fd, NULL); + close (control->priv->fd); 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) +oss_stream_control_new (const gchar *name, + const gchar *label, + MateMixerStreamControlRole role, + gint fd, + gint devnum, + 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); + OssStreamControl *control; + MateMixerStreamControlFlags flags; - return ctl; + flags = MATE_MIXER_STREAM_CONTROL_HAS_VOLUME | + MATE_MIXER_STREAM_CONTROL_CAN_SET_VOLUME; + if (stereo == TRUE) + flags |= MATE_MIXER_STREAM_CONTROL_CAN_BALANCE; + + control = g_object_new (OSS_TYPE_STREAM_CONTROL, + "name", name, + "label", label, + "flags", flags, + NULL); + + control->priv->fd = fd; + control->priv->devnum = devnum; + control->priv->stereo = stereo; + return control; } gboolean -oss_stream_control_update (OssStreamControl *octl) +oss_stream_control_update (OssStreamControl *control) { gint v; gint ret; - g_return_val_if_fail (OSS_IS_STREAM_CONTROL (octl), FALSE); + g_return_val_if_fail (OSS_IS_STREAM_CONTROL (control), FALSE); - ret = ioctl (octl->priv->fd, MIXER_READ (octl->priv->dev_number), &v); + ret = ioctl (control->priv->fd, MIXER_READ (control->priv->devnum), &v); if (ret < 0) { g_warning ("Failed to read volume: %s", g_strerror (errno)); return FALSE; } - octl->priv->volume[0] = v & 0xFF; + control->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); + if (control->priv->stereo == TRUE) { + gfloat balance; + guint left; + guint right; - // XXX provide property + control->priv->volume[1] = (v >> 8) & 0xFF; - if (octl->priv->port != NULL) - g_object_unref (octl->priv->port); + /* Calculate balance */ + left = control->priv->volume[0]; + right = control->priv->volume[1]; + if (left == right) + balance = 0.0f; + else if (left > right) + balance = -1.0f + ((gfloat) right / (gfloat) left); + else + balance = +1.0f - ((gfloat) left / (gfloat) right); - octl->priv->port = g_object_ref (port); + _mate_mixer_stream_control_set_balance (MATE_MIXER_STREAM_CONTROL (control), + balance); + } return TRUE; } -gboolean -oss_stream_control_set_role (OssStreamControl *octl, MateMixerStreamControlRole role) +static gboolean +oss_stream_control_set_mute (MateMixerStreamControl *mmsc, gboolean mute) { - g_return_val_if_fail (OSS_IS_STREAM_CONTROL (octl), FALSE); + g_return_val_if_fail (OSS_IS_STREAM_CONTROL (mmsc), FALSE); - octl->priv->role = role; + // TODO return TRUE; } -static const gchar * -oss_stream_control_get_name (MateMixerStreamControl *ctl) +static guint +oss_stream_control_get_num_channels (MateMixerStreamControl *mmsc) { - g_return_val_if_fail (OSS_IS_STREAM_CONTROL (ctl), NULL); + g_return_val_if_fail (OSS_IS_STREAM_CONTROL (mmsc), 0); - return OSS_STREAM_CONTROL (ctl)->priv->name; + return (OSS_STREAM_CONTROL (mmsc)->priv->stereo == TRUE) ? 2 : 1; } -static const gchar * -oss_stream_control_get_description (MateMixerStreamControl *ctl) +static guint +oss_stream_control_get_volume (MateMixerStreamControl *mmsc) { - g_return_val_if_fail (OSS_IS_STREAM_CONTROL (ctl), NULL); + OssStreamControl *control; - return OSS_STREAM_CONTROL (ctl)->priv->description; -} + g_return_val_if_fail (OSS_IS_STREAM_CONTROL (mmsc), 0); -static guint -oss_stream_control_get_num_channels (MateMixerStreamControl *ctl) -{ - g_return_val_if_fail (OSS_IS_STREAM_CONTROL (ctl), 0); + control = OSS_STREAM_CONTROL (mmsc); - if (OSS_STREAM_CONTROL (ctl)->priv->stereo == TRUE) - return 2; + if (control->priv->stereo == TRUE) + return MAX (control->priv->volume[0], control->priv->volume[1]); else - return 1; + return control->priv->volume[0]; } static gboolean -oss_stream_control_set_volume (MateMixerStreamControl *ctl, guint volume) +oss_stream_control_set_volume (MateMixerStreamControl *mmsc, guint volume) { - OssStreamControl *octl; - int v; - int ret; - - g_return_val_if_fail (OSS_IS_STREAM_CONTROL (ctl), FALSE); + OssStreamControl *control; + gint v; - octl = OSS_STREAM_CONTROL (ctl); + g_return_val_if_fail (OSS_IS_STREAM_CONTROL (mmsc), FALSE); - /* Some backends may allow setting higher value than maximum, but not here */ - if (volume > 100) - volume = 100; + control = OSS_STREAM_CONTROL (mmsc); - v = volume; - if (octl->priv->stereo == TRUE) + v = CLAMP (volume, 0, 100); + if (control->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; + return write_volume (control, v); } static guint -oss_stream_control_get_channel_volume (MateMixerStreamControl *ctl, guint channel) +oss_stream_control_get_channel_volume (MateMixerStreamControl *mmsc, guint channel) { - OssStreamControl *octl; + OssStreamControl *control; - g_return_val_if_fail (OSS_IS_STREAM_CONTROL (ctl), 0); + g_return_val_if_fail (OSS_IS_STREAM_CONTROL (mmsc), 0); - octl = OSS_STREAM_CONTROL (ctl); + control = OSS_STREAM_CONTROL (mmsc); - if (channel > 1) - return 0; - - /* Right channel on mono stream will always have zero volume */ - return octl->priv->volume[channel]; + if (control->priv->stereo == TRUE) { + if (channel == 0 || channel == 1) + return control->priv->volume[channel]; + } else { + if (channel == 0) + return control->priv->volume[0]; + } + return 0; } static gboolean -oss_stream_control_set_channel_volume (MateMixerStreamControl *ctl, +oss_stream_control_set_channel_volume (MateMixerStreamControl *mmsc, guint channel, guint volume) { - OssStreamControl *octl; - int ret; - int v; + OssStreamControl *control; + gint v; - g_return_val_if_fail (OSS_IS_STREAM_CONTROL (ctl), FALSE); + g_return_val_if_fail (OSS_IS_STREAM_CONTROL (mmsc), 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]; + control = OSS_STREAM_CONTROL (mmsc); + volume = CLAMP (volume, 0, 100); - if (channel == 1) { - if (octl->priv->stereo == FALSE) + if (control->priv->stereo == TRUE) { + if (channel > 1) return FALSE; - v |= volume << 8; - } else - v |= octl->priv->volume[1] << 8; + /* Stereo channel volume - left channel is in the lowest 8 bits and + * right channel is in the higher 8 bits */ + if (channel == 0) + v = volume | (control->priv->volume[1] << 8); + else + v = control->priv->volume[0] | (volume << 8); + } else { + if (channel > 0) + return FALSE; - 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; + /* Single channel volume - only lowest 8 bits are used */ + v = volume; } - return TRUE; + + return write_volume (control, v); } static MateMixerChannelPosition -oss_stream_control_get_channel_position (MateMixerStreamControl *ctl, guint channel) +oss_stream_control_get_channel_position (MateMixerStreamControl *mmsc, guint channel) { - OssStreamControl *octl; + OssStreamControl *control; - g_return_val_if_fail (OSS_IS_STREAM_CONTROL (ctl), MATE_MIXER_CHANNEL_UNKNOWN); + g_return_val_if_fail (OSS_IS_STREAM_CONTROL (mmsc), MATE_MIXER_CHANNEL_UNKNOWN); - octl = OSS_STREAM_CONTROL (ctl); + control = OSS_STREAM_CONTROL (mmsc); - if (octl->priv->stereo == TRUE) { + if (control->priv->stereo == TRUE) { if (channel == 0) return MATE_MIXER_CHANNEL_FRONT_LEFT; else if (channel == 1) @@ -473,57 +314,79 @@ oss_stream_control_get_channel_position (MateMixerStreamControl *ctl, guint chan } static gboolean -oss_stream_control_has_channel_position (MateMixerStreamControl *ctl, +oss_stream_control_has_channel_position (MateMixerStreamControl *mmsc, MateMixerChannelPosition position) { - g_return_val_if_fail (OSS_IS_STREAM_CONTROL (ctl), FALSE); + g_return_val_if_fail (OSS_IS_STREAM_CONTROL (mmsc), FALSE); if (position == MATE_MIXER_CHANNEL_MONO) - return OSS_STREAM_CONTROL (ctl)->priv->stereo == FALSE; + return OSS_STREAM_CONTROL (mmsc)->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 OSS_STREAM_CONTROL (mmsc)->priv->stereo == TRUE; return FALSE; } static gboolean -oss_stream_control_set_balance (MateMixerStreamControl *ctl, gfloat balance) +oss_stream_control_set_balance (MateMixerStreamControl *mmsc, gfloat balance) { - OssStreamControl *octl; + OssStreamControl *control; + guint max; + gint v; - g_return_val_if_fail (OSS_IS_STREAM_CONTROL (ctl), FALSE); + g_return_val_if_fail (OSS_IS_STREAM_CONTROL (mmsc), FALSE); - octl = OSS_STREAM_CONTROL (ctl); + control = OSS_STREAM_CONTROL (mmsc); - if (octl->priv->stereo == FALSE) - return FALSE; + max = MAX (control->priv->volume[0], control->priv->volume[1]); + if (balance <= 0) { + control->priv->volume[1] = (balance + 1.0f) * max; + control->priv->volume[0] = max; + } else { + control->priv->volume[0] = (1.0f - balance) * max; + control->priv->volume[1] = max; + } - // XXX - return TRUE; + v = control->priv->volume[0] | (control->priv->volume[1] << 8); + + return write_volume (control, v); } static guint -oss_stream_control_get_min_volume (MateMixerStreamControl *ctl) +oss_stream_control_get_min_volume (MateMixerStreamControl *mmsc) { return 0; } static guint -oss_stream_control_get_max_volume (MateMixerStreamControl *ctl) +oss_stream_control_get_max_volume (MateMixerStreamControl *mmsc) { return 100; } static guint -oss_stream_control_get_normal_volume (MateMixerStreamControl *ctl) +oss_stream_control_get_normal_volume (MateMixerStreamControl *mmsc) { return 100; } static guint -oss_stream_control_get_base_volume (MateMixerStreamControl *ctl) +oss_stream_control_get_base_volume (MateMixerStreamControl *mmsc) { return 100; } + +static gboolean +write_volume (OssStreamControl *control, gint volume) +{ + gint ret; + + ret = ioctl (control->priv->fd, MIXER_WRITE (control->priv->devnum), &volume); + if (ret < 0) { + g_warning ("Failed to set volume: %s", g_strerror (errno)); + return FALSE; + } + return TRUE; +} |