diff options
Diffstat (limited to 'libmatemixer/matemixer-stream-control.c')
-rw-r--r-- | libmatemixer/matemixer-stream-control.c | 627 |
1 files changed, 627 insertions, 0 deletions
diff --git a/libmatemixer/matemixer-stream-control.c b/libmatemixer/matemixer-stream-control.c new file mode 100644 index 0000000..ace584a --- /dev/null +++ b/libmatemixer/matemixer-stream-control.c @@ -0,0 +1,627 @@ +/* + * 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 "matemixer-enums.h" +#include "matemixer-enum-types.h" +#include "matemixer-stream-control.h" +#include "matemixer-stream-control-private.h" + +/** + * SECTION:matemixer-stream-control + * @include: libmatemixer/matemixer.h + */ + +struct _MateMixerStreamControlPrivate +{ + gchar *name; + gchar *label; + gboolean mute; + gfloat balance; + gfloat fade; + MateMixerStreamControlFlags flags; + MateMixerStreamControlRole role; +}; + +enum { + PROP_0, + PROP_NAME, + PROP_LABEL, + PROP_FLAGS, + PROP_ROLE, + PROP_MUTE, + PROP_VOLUME, + PROP_BALANCE, + PROP_FADE, + N_PROPERTIES +}; + +static GParamSpec *properties[N_PROPERTIES] = { NULL, }; + +static void mate_mixer_stream_control_class_init (MateMixerStreamControlClass *klass); + +static void mate_mixer_stream_control_get_property (GObject *object, + guint param_id, + GValue *value, + GParamSpec *pspec); +static void mate_mixer_stream_control_set_property (GObject *object, + guint param_id, + const GValue *value, + GParamSpec *pspec); + +static void mate_mixer_stream_control_init (MateMixerStreamControl *control); +static void mate_mixer_stream_control_finalize (GObject *object); + +G_DEFINE_ABSTRACT_TYPE (MateMixerStreamControl, mate_mixer_stream_control, G_TYPE_OBJECT) + +static void +mate_mixer_stream_control_class_init (MateMixerStreamControlClass *klass) +{ + GObjectClass *object_class; + + object_class = G_OBJECT_CLASS (klass); + object_class->finalize = mate_mixer_stream_control_finalize; + object_class->get_property = mate_mixer_stream_control_get_property; + object_class->set_property = mate_mixer_stream_control_set_property; + + properties[PROP_NAME] = + g_param_spec_string ("name", + "Name", + "Name of the stream control", + NULL, + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT_ONLY | + G_PARAM_STATIC_STRINGS); + + properties[PROP_LABEL] = + g_param_spec_string ("label", + "Label", + "Label of the stream control", + NULL, + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT_ONLY | + G_PARAM_STATIC_STRINGS); + + properties[PROP_FLAGS] = + g_param_spec_flags ("flags", + "Flags", + "Capability flags of the stream control", + MATE_MIXER_TYPE_STREAM_CONTROL_FLAGS, + MATE_MIXER_STREAM_CONTROL_NO_FLAGS, + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT_ONLY | + G_PARAM_STATIC_STRINGS); + + properties[PROP_ROLE] = + g_param_spec_enum ("role", + "Role", + "Role of the stream control", + MATE_MIXER_TYPE_STREAM_CONTROL_ROLE, + MATE_MIXER_STREAM_CONTROL_ROLE_UNKNOWN, + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT_ONLY | + G_PARAM_STATIC_STRINGS); + + properties[PROP_MUTE] = + g_param_spec_boolean ("mute", + "Mute", + "Mute state of the stream control", + FALSE, + G_PARAM_READABLE | + G_PARAM_STATIC_STRINGS); + + properties[PROP_VOLUME] = + g_param_spec_uint ("volume", + "Volume", + "Volume of the stream control", + 0, + G_MAXUINT, + 0, + G_PARAM_READABLE | + G_PARAM_STATIC_STRINGS); + + properties[PROP_BALANCE] = + g_param_spec_float ("balance", + "Balance", + "Balance value of the stream control", + -1.0f, + 1.0f, + 0.0f, + G_PARAM_READABLE | + G_PARAM_STATIC_STRINGS); + + properties[PROP_FADE] = + g_param_spec_float ("fade", + "Fade", + "Fade value of the stream control", + -1.0f, + 1.0f, + 0.0f, + G_PARAM_READABLE | + G_PARAM_STATIC_STRINGS); + + g_object_class_install_properties (object_class, N_PROPERTIES, properties); + + g_type_class_add_private (object_class, sizeof (MateMixerStreamControlPrivate)); +} + +static void +mate_mixer_stream_control_get_property (GObject *object, + guint param_id, + GValue *value, + GParamSpec *pspec) +{ + MateMixerStreamControl *control; + + control = MATE_MIXER_STREAM_CONTROL (object); + + switch (param_id) { + case PROP_NAME: + g_value_set_string (value, control->priv->name); + break; + case PROP_LABEL: + g_value_set_string (value, control->priv->label); + break; + case PROP_FLAGS: + g_value_set_flags (value, control->priv->flags); + break; + case PROP_ROLE: + g_value_set_enum (value, control->priv->role); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec); + break; + } +} + +static void +mate_mixer_stream_control_set_property (GObject *object, + guint param_id, + const GValue *value, + GParamSpec *pspec) +{ + MateMixerStreamControl *control; + + control = MATE_MIXER_STREAM_CONTROL (object); + + switch (param_id) { + case PROP_NAME: + /* Construct-only string */ + control->priv->name = g_value_dup_string (value); + break; + case PROP_LABEL: + /* Construct-only string */ + control->priv->label = g_value_dup_string (value); + break; + case PROP_FLAGS: + control->priv->flags = g_value_get_flags (value); + break; + case PROP_ROLE: + control->priv->role = g_value_get_enum (value); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec); + break; + } +} + +static void +mate_mixer_stream_control_init (MateMixerStreamControl *control) +{ + control->priv = G_TYPE_INSTANCE_GET_PRIVATE (control, + MATE_MIXER_TYPE_STREAM_CONTROL, + MateMixerStreamControlPrivate); +} + +static void +mate_mixer_stream_control_finalize (GObject *object) +{ + MateMixerStreamControl *control; + + control = MATE_MIXER_STREAM_CONTROL (object); + + g_free (control->priv->name); + g_free (control->priv->label); + + G_OBJECT_CLASS (mate_mixer_stream_control_parent_class)->finalize (object); +} + +const gchar * +mate_mixer_stream_control_get_name (MateMixerStreamControl *control) +{ + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), NULL); + + return control->priv->name; +} + +const gchar * +mate_mixer_stream_control_get_label (MateMixerStreamControl *control) +{ + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), NULL); + + return control->priv->label; +} + +MateMixerStreamControlFlags +mate_mixer_stream_control_get_flags (MateMixerStreamControl *control) +{ + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), MATE_MIXER_STREAM_CONTROL_NO_FLAGS); + + return control->priv->flags; +} + +MateMixerStreamControlRole +mate_mixer_stream_control_get_role (MateMixerStreamControl *control) +{ + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), MATE_MIXER_STREAM_CONTROL_ROLE_UNKNOWN); + + return control->priv->role; +} + +gboolean +mate_mixer_stream_control_get_mute (MateMixerStreamControl *control) +{ + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), FALSE); + + return control->priv->mute; +} + +gboolean +mate_mixer_stream_control_set_mute (MateMixerStreamControl *control, gboolean mute) +{ + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), FALSE); + + if (control->priv->mute == mute) + return TRUE; + + if (control->priv->flags & MATE_MIXER_STREAM_CONTROL_HAS_MUTE) { + MateMixerStreamControlClass *klass; + + klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control); + + if (G_LIKELY (klass->set_mute != NULL)) + return klass->set_mute (control, mute); + } + return FALSE; +} + +guint +mate_mixer_stream_control_get_num_channels (MateMixerStreamControl *control) +{ + MateMixerStreamControlClass *klass; + + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), 0); + + klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control); + + if (klass->get_num_channels != NULL) + return klass->get_num_channels (control); + + return 0; +} + +guint +mate_mixer_stream_control_get_volume (MateMixerStreamControl *control) +{ + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), 0); + + if (control->priv->flags & MATE_MIXER_STREAM_CONTROL_HAS_VOLUME) { + MateMixerStreamControlClass *klass; + + klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control); + + if G_LIKELY (klass->get_volume != NULL) + return klass->get_volume (control); + } + return 0; +} + +gboolean +mate_mixer_stream_control_set_volume (MateMixerStreamControl *control, guint volume) +{ + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), FALSE); + + if (control->priv->flags & MATE_MIXER_STREAM_CONTROL_HAS_VOLUME) { + MateMixerStreamControlClass *klass; + + klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control); + + if (G_LIKELY (klass->set_volume != NULL)) + return klass->set_volume (control, volume); + } + return FALSE; +} + +gdouble +mate_mixer_stream_control_get_decibel (MateMixerStreamControl *control) +{ + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), -MATE_MIXER_INFINITY); + + if (control->priv->flags & MATE_MIXER_STREAM_CONTROL_HAS_DECIBEL) { + MateMixerStreamControlClass *klass; + + klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control); + + if (G_LIKELY (klass->get_decibel != NULL)) + return klass->get_decibel (control); + } + return -MATE_MIXER_INFINITY; +} + +gboolean +mate_mixer_stream_control_set_decibel (MateMixerStreamControl *control, gdouble decibel) +{ + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), FALSE); + + if (control->priv->flags & MATE_MIXER_STREAM_CONTROL_HAS_DECIBEL) { + MateMixerStreamControlClass *klass; + + klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control); + + if (G_LIKELY (klass->set_decibel != NULL)) + return klass->set_decibel (control, decibel); + } + return FALSE; +} + +MateMixerChannelPosition +mate_mixer_stream_control_get_channel_position (MateMixerStreamControl *control, guint channel) +{ + MateMixerStreamControlClass *klass; + + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), MATE_MIXER_CHANNEL_UNKNOWN); + + klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control); + + if (klass->get_channel_position != NULL) + return klass->get_channel_position (control, channel); + + return MATE_MIXER_CHANNEL_UNKNOWN; +} + +guint +mate_mixer_stream_control_get_channel_volume (MateMixerStreamControl *control, guint channel) +{ + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), 0); + + if (control->priv->flags & MATE_MIXER_STREAM_CONTROL_HAS_VOLUME) { + MateMixerStreamControlClass *klass; + + klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control); + + if (G_LIKELY (klass->get_channel_volume != NULL)) + return klass->get_channel_volume (control, channel); + } + return 0; +} + +gboolean +mate_mixer_stream_control_set_channel_volume (MateMixerStreamControl *control, + guint channel, + guint volume) +{ + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), FALSE); + + if (control->priv->flags & MATE_MIXER_STREAM_CONTROL_HAS_VOLUME) { + MateMixerStreamControlClass *klass; + + klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control); + + if (G_LIKELY (klass->set_channel_volume != NULL)) + return klass->set_channel_volume (control, channel, volume); + } + return FALSE; +} + +gdouble +mate_mixer_stream_control_get_channel_decibel (MateMixerStreamControl *control, guint channel) +{ + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), -MATE_MIXER_INFINITY); + + if (control->priv->flags & MATE_MIXER_STREAM_CONTROL_HAS_DECIBEL) { + MateMixerStreamControlClass *klass; + + klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control); + + if (G_LIKELY (klass->get_channel_decibel != NULL)) + return klass->get_channel_decibel (control, channel); + } + return -MATE_MIXER_INFINITY; +} + +gboolean +mate_mixer_stream_control_set_channel_decibel (MateMixerStreamControl *control, + guint channel, + gdouble decibel) +{ + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), FALSE); + + if (control->priv->flags & MATE_MIXER_STREAM_CONTROL_HAS_DECIBEL) { + MateMixerStreamControlClass *klass; + + klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control); + + if (G_LIKELY (klass->set_channel_decibel != NULL)) + return klass->set_channel_decibel (control, channel, decibel); + } + return FALSE; +} + +gboolean +mate_mixer_stream_control_has_channel_position (MateMixerStreamControl *control, + MateMixerChannelPosition position) +{ + MateMixerStreamControlClass *klass; + + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), FALSE); + + klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control); + + if (klass->has_channel_position != NULL) + return klass->has_channel_position (control, position); + + return FALSE; +} + +gfloat +mate_mixer_stream_control_get_balance (MateMixerStreamControl *control) +{ + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), 0.0f); + + if (control->priv->flags & MATE_MIXER_STREAM_CONTROL_CAN_BALANCE) + return control->priv->balance; + else + return 0.0f; +} + +gboolean +mate_mixer_stream_control_set_balance (MateMixerStreamControl *control, gfloat balance) +{ + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), FALSE); + + if (control->priv->flags & MATE_MIXER_STREAM_CONTROL_CAN_BALANCE) { + MateMixerStreamControlClass *klass; + + if (balance < -1.0f || balance > 1.0f) + return FALSE; + + klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control); + + if (G_LIKELY (klass->set_balance != NULL)) + return klass->set_balance (control, balance); + } + return FALSE; +} + +gfloat +mate_mixer_stream_control_get_fade (MateMixerStreamControl *control) +{ + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), 0.0f); + + if (control->priv->flags & MATE_MIXER_STREAM_CONTROL_CAN_FADE) + return control->priv->fade; + else + return 0.0f; +} + +gboolean +mate_mixer_stream_control_set_fade (MateMixerStreamControl *control, gfloat fade) +{ + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), FALSE); + + if (control->priv->flags & MATE_MIXER_STREAM_CONTROL_CAN_FADE) { + MateMixerStreamControlClass *klass; + + if (fade < -1.0f || fade > 1.0f) + return FALSE; + + klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control); + + if (G_LIKELY (klass->set_fade != NULL)) + return klass->set_fade (control, fade); + } + return FALSE; +} + +guint +mate_mixer_stream_control_get_min_volume (MateMixerStreamControl *control) +{ + MateMixerStreamControlClass *klass; + + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), 0); + + klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control); + + if (klass->get_min_volume != NULL) + return klass->get_min_volume (control); + + return 0; +} + +guint +mate_mixer_stream_control_get_max_volume (MateMixerStreamControl *control) +{ + MateMixerStreamControlClass *klass; + + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), 0); + + klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control); + + if (klass->get_max_volume != NULL) + return klass->get_max_volume (control); + + return 0; +} + +guint +mate_mixer_stream_control_get_normal_volume (MateMixerStreamControl *control) +{ + MateMixerStreamControlClass *klass; + + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), 0); + + klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control); + + if (klass->get_normal_volume != NULL) + return klass->get_normal_volume (control); + + return 0; +} + +guint +mate_mixer_stream_control_get_base_volume (MateMixerStreamControl *control) +{ + MateMixerStreamControlClass *klass; + + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), 0); + + klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control); + + if (klass->get_base_volume != NULL) + return klass->get_base_volume (control); + + return 0; +} + +void +_mate_mixer_stream_control_set_flags (MateMixerStreamControl *control, + MateMixerStreamControlFlags flags) +{ + control->priv->flags = flags; +} + +void +_mate_mixer_stream_control_set_mute (MateMixerStreamControl *control, gboolean mute) +{ + control->priv->mute = mute; +} + +void +_mate_mixer_stream_control_set_balance (MateMixerStreamControl *control, gfloat balance) +{ + control->priv->balance = balance; +} + +void +_mate_mixer_stream_control_set_fade (MateMixerStreamControl *control, gfloat fade) +{ + control->priv->fade = fade; +} |