From 59a9aabf7b66e130f68b797c5a3674798fae437b Mon Sep 17 00:00:00 2001 From: Michal Ratajsky Date: Fri, 25 Jul 2014 23:47:46 +0200 Subject: Support OSS --- libmatemixer/Makefile.am | 4 +- libmatemixer/matemixer-backend.c | 33 ++- libmatemixer/matemixer-enum-types.c | 31 ++- libmatemixer/matemixer-enum-types.h | 3 + libmatemixer/matemixer-enums.h | 55 ++-- libmatemixer/matemixer-stream-control.c | 445 ++++++++++++++++++++++++++++++ libmatemixer/matemixer-stream-control.h | 148 ++++++++++ libmatemixer/matemixer-stream.c | 475 ++++++-------------------------- libmatemixer/matemixer-stream.h | 156 ++++------- 9 files changed, 813 insertions(+), 537 deletions(-) create mode 100644 libmatemixer/matemixer-stream-control.c create mode 100644 libmatemixer/matemixer-stream-control.h (limited to 'libmatemixer') diff --git a/libmatemixer/Makefile.am b/libmatemixer/Makefile.am index 8c219d4..9666684 100644 --- a/libmatemixer/Makefile.am +++ b/libmatemixer/Makefile.am @@ -17,6 +17,7 @@ libmatemixer_include_HEADERS = \ matemixer-enums.h \ matemixer-port.h \ matemixer-stream.h \ + matemixer-stream-control.h \ matemixer-version.h libmatemixer_la_CFLAGS = $(GLIB_CFLAGS) @@ -37,7 +38,8 @@ libmatemixer_la_SOURCES = \ matemixer-enum-types.h \ matemixer-port.c \ matemixer-port-private.h \ - matemixer-stream.c + matemixer-stream.c \ + matemixer-stream-control.c libmatemixer_la_LIBADD = $(GLIB_LIBS) diff --git a/libmatemixer/matemixer-backend.c b/libmatemixer/matemixer-backend.c index be5c704..e070090 100644 --- a/libmatemixer/matemixer-backend.c +++ b/libmatemixer/matemixer-backend.c @@ -176,10 +176,15 @@ mate_mixer_backend_close (MateMixerBackend *backend) MateMixerState mate_mixer_backend_get_state (MateMixerBackend *backend) { + MateMixerState state = MATE_MIXER_STATE_UNKNOWN; + g_return_val_if_fail (MATE_MIXER_IS_BACKEND (backend), MATE_MIXER_STATE_UNKNOWN); - /* Implementation required */ - return MATE_MIXER_BACKEND_GET_INTERFACE (backend)->get_state (backend); + g_object_get (G_OBJECT (backend), + "state", &state, + NULL); + + return state; } GList * @@ -230,16 +235,18 @@ mate_mixer_backend_list_cached_streams (MateMixerBackend *backend) MateMixerStream * mate_mixer_backend_get_default_input_stream (MateMixerBackend *backend) { - MateMixerBackendInterface *iface; + MateMixerStream *stream = NULL; g_return_val_if_fail (MATE_MIXER_IS_BACKEND (backend), NULL); - iface = MATE_MIXER_BACKEND_GET_INTERFACE (backend); + g_object_get (G_OBJECT (stream), + "default-input", &stream, + NULL); - if (iface->get_default_input_stream) - return iface->get_default_input_stream (backend); + if (stream != NULL) + g_object_unref (stream); - return NULL; + return stream; } gboolean @@ -261,16 +268,18 @@ mate_mixer_backend_set_default_input_stream (MateMixerBackend *backend, MateMixerStream * mate_mixer_backend_get_default_output_stream (MateMixerBackend *backend) { - MateMixerBackendInterface *iface; + MateMixerStream *stream = NULL; g_return_val_if_fail (MATE_MIXER_IS_BACKEND (backend), NULL); - iface = MATE_MIXER_BACKEND_GET_INTERFACE (backend); + g_object_get (G_OBJECT (stream), + "default-output", &stream, + NULL); - if (iface->get_default_output_stream) - return iface->get_default_output_stream (backend); + if (stream != NULL) + g_object_unref (stream); - return NULL; + return stream; } gboolean diff --git a/libmatemixer/matemixer-enum-types.c b/libmatemixer/matemixer-enum-types.c index 339b673..50e3bf4 100644 --- a/libmatemixer/matemixer-enum-types.c +++ b/libmatemixer/matemixer-enum-types.c @@ -94,14 +94,7 @@ mate_mixer_stream_flags_get_type (void) { MATE_MIXER_STREAM_INPUT, "MATE_MIXER_STREAM_INPUT", "input" }, { MATE_MIXER_STREAM_OUTPUT, "MATE_MIXER_STREAM_OUTPUT", "output" }, { MATE_MIXER_STREAM_CLIENT, "MATE_MIXER_STREAM_CLIENT", "client" }, - { MATE_MIXER_STREAM_HAS_MUTE, "MATE_MIXER_STREAM_HAS_MUTE", "has-mute" }, - { MATE_MIXER_STREAM_HAS_VOLUME, "MATE_MIXER_STREAM_HAS_VOLUME", "has-volume" }, - { MATE_MIXER_STREAM_HAS_DECIBEL_VOLUME, "MATE_MIXER_STREAM_HAS_DECIBEL_VOLUME", "has-decibel-volume" }, - { MATE_MIXER_STREAM_HAS_FLAT_VOLUME, "MATE_MIXER_STREAM_HAS_FLAT_VOLUME", "has-flat-volume" }, { MATE_MIXER_STREAM_HAS_MONITOR, "MATE_MIXER_STREAM_HAS_MONITOR", "has-monitor" }, - { MATE_MIXER_STREAM_CAN_SET_VOLUME, "MATE_MIXER_STREAM_CAN_SET_VOLUME", "can-set-volume" }, - { MATE_MIXER_STREAM_CAN_BALANCE, "MATE_MIXER_STREAM_CAN_BALANCE", "can-balance" }, - { MATE_MIXER_STREAM_CAN_FADE, "MATE_MIXER_STREAM_CAN_FADE", "can-fade" }, { MATE_MIXER_STREAM_CAN_SUSPEND, "MATE_MIXER_STREAM_CAN_SUSPEND", "can-suspend" }, { 0, NULL, NULL } }; @@ -132,6 +125,30 @@ mate_mixer_stream_state_get_type (void) return etype; } +GType +mate_mixer_stream_control_flags_get_type (void) +{ + static GType etype = 0; + + if (etype == 0) { + static const GFlagsValue values[] = { + { MATE_MIXER_STREAM_CONTROL_NO_FLAGS, "MATE_MIXER_STREAM_CONTROL_NO_FLAGS", "no-flags" }, + { MATE_MIXER_STREAM_CONTROL_HAS_MUTE, "MATE_MIXER_STREAM_CONTROL_HAS_MUTE", "has-mute" }, + { MATE_MIXER_STREAM_CONTROL_HAS_VOLUME, "MATE_MIXER_STREAM_CONTROL_HAS_VOLUME", "has-volume" }, + { MATE_MIXER_STREAM_CONTROL_HAS_DECIBEL_VOLUME, "MATE_MIXER_STREAM_CONTROL_HAS_DECIBEL_VOLUME", "has-decibel-volume" }, + { MATE_MIXER_STREAM_CONTROL_HAS_FLAT_VOLUME, "MATE_MIXER_STREAM_CONTROL_HAS_FLAT_VOLUME", "has-flat-volume" }, + { MATE_MIXER_STREAM_CONTROL_CAN_SET_VOLUME, "MATE_MIXER_STREAM_CONTROL_CAN_SET_VOLUME", "can-set-volume" }, + { MATE_MIXER_STREAM_CONTROL_CAN_BALANCE, "MATE_MIXER_STREAM_CONTROL_CAN_BALANCE", "can-balance" }, + { MATE_MIXER_STREAM_CONTROL_CAN_FADE, "MATE_MIXER_STREAM_CONTROL_CAN_FADE", "can-fade" }, + { 0, NULL, NULL } + }; + etype = g_flags_register_static ( + g_intern_static_string ("MateMixerStreamControlFlags"), + values); + } + return etype; +} + GType mate_mixer_client_stream_flags_get_type (void) { diff --git a/libmatemixer/matemixer-enum-types.h b/libmatemixer/matemixer-enum-types.h index 03c1297..1dc13cc 100644 --- a/libmatemixer/matemixer-enum-types.h +++ b/libmatemixer/matemixer-enum-types.h @@ -43,6 +43,9 @@ GType mate_mixer_stream_flags_get_type (void) G_GNUC_CONST; #define MATE_MIXER_TYPE_STREAM_STATE (mate_mixer_stream_state_get_type ()) GType mate_mixer_stream_state_get_type (void) G_GNUC_CONST; +#define MATE_MIXER_TYPE_STREAM_CONTROL_FLAGS (mate_mixer_stream_control_flags_get_type ()) +GType mate_mixer_stream_control_flags_get_type (void) G_GNUC_CONST; + #define MATE_MIXER_TYPE_CLIENT_STREAM_FLAGS (mate_mixer_client_stream_flags_get_type ()) GType mate_mixer_client_stream_flags_get_type (void) G_GNUC_CONST; diff --git a/libmatemixer/matemixer-enums.h b/libmatemixer/matemixer-enums.h index 7e523bb..b99f4c5 100644 --- a/libmatemixer/matemixer-enums.h +++ b/libmatemixer/matemixer-enums.h @@ -48,6 +48,7 @@ typedef enum { * will be the first one to try unless you select a specific backend * to connect to. * @MATE_MIXER_BACKEND_OSS: + * @MATE_MIXER_BACKEND_OSS4: * @MATE_MIXER_BACKEND_NULL: * Fallback backend which never fails to initialize, but provides no * functionality. This backend has the lowest priority and will be used @@ -58,6 +59,7 @@ typedef enum { MATE_MIXER_BACKEND_UNKNOWN, MATE_MIXER_BACKEND_PULSEAUDIO, MATE_MIXER_BACKEND_OSS, + MATE_MIXER_BACKEND_OSS4, MATE_MIXER_BACKEND_NULL } MateMixerBackendType; @@ -81,14 +83,7 @@ typedef enum { /*< flags >*/ * @MATE_MIXER_STREAM_INPUT: * @MATE_MIXER_STREAM_OUTPUT: * @MATE_MIXER_STREAM_CLIENT: - * @MATE_MIXER_STREAM_HAS_MUTE: - * @MATE_MIXER_STREAM_HAS_VOLUME: - * @MATE_MIXER_STREAM_HAS_DECIBEL_VOLUME: - * @MATE_MIXER_STREAM_HAS_FLAT_VOLUME: * @MATE_MIXER_STREAM_HAS_MONITOR: - * @MATE_MIXER_STREAM_CAN_SET_VOLUME: - * @MATE_MIXER_STREAM_CAN_BALANCE: - * @MATE_MIXER_STREAM_CAN_FADE: * @MATE_MIXER_STREAM_CAN_SUSPEND: */ typedef enum { /*< flags >*/ @@ -96,15 +91,10 @@ typedef enum { /*< flags >*/ MATE_MIXER_STREAM_INPUT = 1 << 0, MATE_MIXER_STREAM_OUTPUT = 1 << 1, MATE_MIXER_STREAM_CLIENT = 1 << 2, - MATE_MIXER_STREAM_HAS_MUTE = 1 << 3, - MATE_MIXER_STREAM_HAS_VOLUME = 1 << 4, - MATE_MIXER_STREAM_HAS_DECIBEL_VOLUME = 1 << 5, - MATE_MIXER_STREAM_HAS_FLAT_VOLUME = 1 << 6, - MATE_MIXER_STREAM_HAS_MONITOR = 1 << 7, - MATE_MIXER_STREAM_CAN_SET_VOLUME = 1 << 8, - MATE_MIXER_STREAM_CAN_BALANCE = 1 << 9, - MATE_MIXER_STREAM_CAN_FADE = 1 << 10, - MATE_MIXER_STREAM_CAN_SUSPEND = 1 << 11 + MATE_MIXER_STREAM_HAS_MONITOR = 1 << 3, + MATE_MIXER_STREAM_CAN_SUSPEND = 1 << 4, + MATE_MIXER_STREAM_PORTS_FIXED = 1 << 5, + MATE_MIXER_STREAM_PORTS_EXCLUSIVE = 1 << 6, } MateMixerStreamFlags; /** @@ -121,6 +111,39 @@ typedef enum { MATE_MIXER_STREAM_STATE_SUSPENDED } MateMixerStreamState; +/** + * MateMixerStreamControlFlags: + * @MATE_MIXER_STREAM_CONTROL_NO_FLAGS: + * @MATE_MIXER_STREAM_CONTROL_HAS_MUTE: + * @MATE_MIXER_STREAM_CONTROL_HAS_VOLUME: + * @MATE_MIXER_STREAM_CONTROL_HAS_DECIBEL_VOLUME: + * @MATE_MIXER_STREAM_CONTROL_HAS_FLAT_VOLUME: + * @MATE_MIXER_STREAM_CONTROL_CAN_SET_VOLUME: + * @MATE_MIXER_STREAM_CONTROL_CAN_BALANCE: + * @MATE_MIXER_STREAM_CONTROL_CAN_FADE: + */ +typedef enum { + MATE_MIXER_STREAM_CONTROL_NO_FLAGS = 0, + MATE_MIXER_STREAM_CONTROL_HAS_MUTE = 1 << 0, + MATE_MIXER_STREAM_CONTROL_HAS_VOLUME = 1 << 1, + MATE_MIXER_STREAM_CONTROL_HAS_DECIBEL_VOLUME = 1 << 2, + MATE_MIXER_STREAM_CONTROL_HAS_FLAT_VOLUME = 1 << 3, + MATE_MIXER_STREAM_CONTROL_CAN_SET_VOLUME = 1 << 4, + MATE_MIXER_STREAM_CONTROL_CAN_BALANCE = 1 << 5, + MATE_MIXER_STREAM_CONTROL_CAN_FADE = 1 << 6 +} MateMixerStreamControlFlags; + +typedef enum { + MATE_MIXER_STREAM_CONTROL_ROLE_UNKNOWN, + MATE_MIXER_STREAM_CONTROL_ROLE_MASTER, + MATE_MIXER_STREAM_CONTROL_ROLE_PCM, + MATE_MIXER_STREAM_CONTROL_ROLE_BASS, + MATE_MIXER_STREAM_CONTROL_ROLE_TREBLE, + MATE_MIXER_STREAM_CONTROL_ROLE_CD, + MATE_MIXER_STREAM_CONTROL_ROLE_SPEAKER, + MATE_MIXER_STREAM_CONTROL_ROLE_PORT +} MateMixerStreamControlRole; + /** * MateMixerClientStreamFlags: * @MATE_MIXER_CLIENT_STREAM_NO_FLAGS: diff --git a/libmatemixer/matemixer-stream-control.c b/libmatemixer/matemixer-stream-control.c new file mode 100644 index 0000000..19d35a1 --- /dev/null +++ b/libmatemixer/matemixer-stream-control.c @@ -0,0 +1,445 @@ +/* + * Copyright (C) 2014 Michal Ratajsky + * + * 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 . + */ + +#include +#include + +#include "matemixer-enums.h" +#include "matemixer-enum-types.h" +#include "matemixer-stream-control.h" + +/** + * SECTION:matemixer-stream-control + * @include: libmatemixer/matemixer.h + */ + +G_DEFINE_INTERFACE (MateMixerStreamControl, mate_mixer_stream_control, G_TYPE_OBJECT) + +static void +mate_mixer_stream_control_default_init (MateMixerStreamControlInterface *iface) +{ + g_object_interface_install_property (iface, + g_param_spec_string ("name", + "Name", + "Name of the stream control", + NULL, + G_PARAM_READABLE | + G_PARAM_STATIC_STRINGS)); + + g_object_interface_install_property (iface, + g_param_spec_string ("description", + "Description", + "Description of the stream control", + NULL, + G_PARAM_READABLE | + G_PARAM_STATIC_STRINGS)); + + g_object_interface_install_property (iface, + 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_READABLE | + G_PARAM_STATIC_STRINGS)); + + g_object_interface_install_property (iface, + g_param_spec_boolean ("mute", + "Mute", + "Mute state of the stream control", + FALSE, + G_PARAM_READABLE | + G_PARAM_STATIC_STRINGS)); + + g_object_interface_install_property (iface, + g_param_spec_uint ("volume", + "Volume", + "Volume of the stream control", + 0, + G_MAXUINT, + 0, + G_PARAM_READABLE | + G_PARAM_STATIC_STRINGS)); + + g_object_interface_install_property (iface, + 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)); + + g_object_interface_install_property (iface, + 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)); +} + +const gchar * +mate_mixer_stream_control_get_name (MateMixerStreamControl *ctl) +{ + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), NULL); + + /* Implementation required */ + return MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl)->get_name (ctl); +} + +const gchar * +mate_mixer_stream_control_get_description (MateMixerStreamControl *ctl) +{ + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), NULL); + + /* Implementation required */ + return MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl)->get_description (ctl); +} + +MateMixerStreamControlFlags +mate_mixer_stream_control_get_flags (MateMixerStreamControl *ctl) +{ + MateMixerStreamControlFlags flags = MATE_MIXER_STREAM_CONTROL_NO_FLAGS; + + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), MATE_MIXER_STREAM_CONTROL_NO_FLAGS); + + g_object_get (G_OBJECT (ctl), + "flags", &flags, + NULL); + + return flags; +} + +gboolean +mate_mixer_stream_control_get_mute (MateMixerStreamControl *ctl) +{ + gboolean mute = FALSE; + + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), FALSE); + + g_object_get (G_OBJECT (ctl), + "mute", &mute, + NULL); + + return mute; +} + +gboolean +mate_mixer_stream_control_set_mute (MateMixerStreamControl *ctl, gboolean mute) +{ + MateMixerStreamControlInterface *iface; + + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), FALSE); + + iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl); + + if (iface->set_mute != NULL) + return iface->set_mute (ctl, mute); + + return FALSE; +} + +guint +mate_mixer_stream_control_get_volume (MateMixerStreamControl *ctl) +{ + guint volume = 0; + + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), 0); + + g_object_get (G_OBJECT (ctl), + "volume", &volume, + NULL); + + return volume; +} + +gboolean +mate_mixer_stream_control_set_volume (MateMixerStreamControl *ctl, guint volume) +{ + MateMixerStreamControlInterface *iface; + + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), FALSE); + + iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl); + + if (iface->set_volume != NULL) + return iface->set_volume (ctl, volume); + + return FALSE; +} + +gdouble +mate_mixer_stream_control_get_decibel (MateMixerStreamControl *ctl) +{ + MateMixerStreamControlInterface *iface; + + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), -MATE_MIXER_INFINITY); + + iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl); + + if (iface->get_decibel != NULL) + return iface->get_decibel (ctl); + + return -MATE_MIXER_INFINITY; +} + +gboolean +mate_mixer_stream_control_set_decibel (MateMixerStreamControl *ctl, gdouble decibel) +{ + MateMixerStreamControlInterface *iface; + + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), FALSE); + + iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl); + + if (iface->set_decibel != NULL) + return iface->set_decibel (ctl, decibel); + + return FALSE; +} + +guint +mate_mixer_stream_control_get_num_channels (MateMixerStreamControl *ctl) +{ + MateMixerStreamControlInterface *iface; + + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), 0); + + iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl); + + if (iface->get_num_channels != NULL) + return iface->get_num_channels (ctl); + + return 0; +} + +MateMixerChannelPosition +mate_mixer_stream_control_get_channel_position (MateMixerStreamControl *ctl, guint channel) +{ + MateMixerStreamControlInterface *iface; + + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), MATE_MIXER_CHANNEL_UNKNOWN); + + iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl); + + if (iface->get_channel_position != NULL) + return iface->get_channel_position (ctl, channel); + + return MATE_MIXER_CHANNEL_UNKNOWN; +} + +guint +mate_mixer_stream_control_get_channel_volume (MateMixerStreamControl *ctl, guint channel) +{ + MateMixerStreamControlInterface *iface; + + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), 0); + + iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl); + + if (iface->get_channel_volume != NULL) + return iface->get_channel_volume (ctl, channel); + + return 0; +} + +gboolean +mate_mixer_stream_control_set_channel_volume (MateMixerStreamControl *ctl, + guint channel, + guint volume) +{ + MateMixerStreamControlInterface *iface; + + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), FALSE); + + iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl); + + if (iface->set_channel_volume != NULL) + return iface->set_channel_volume (ctl, channel, volume); + + return FALSE; +} + +gdouble +mate_mixer_stream_control_get_channel_decibel (MateMixerStreamControl *ctl, guint channel) +{ + MateMixerStreamControlInterface *iface; + + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), -MATE_MIXER_INFINITY); + + iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl); + + if (iface->get_channel_decibel != NULL) + return iface->get_channel_decibel (ctl, channel); + + return -MATE_MIXER_INFINITY; +} + +gboolean +mate_mixer_stream_control_set_channel_decibel (MateMixerStreamControl *ctl, + guint channel, + gdouble decibel) +{ + MateMixerStreamControlInterface *iface; + + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), FALSE); + + iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl); + + if (iface->set_channel_decibel != NULL) + return iface->set_channel_decibel (ctl, channel, decibel); + + return FALSE; +} + +gboolean +mate_mixer_stream_control_has_channel_position (MateMixerStreamControl *ctl, + MateMixerChannelPosition position) +{ + MateMixerStreamControlInterface *iface; + + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), FALSE); + + iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl); + + if (iface->has_channel_position != NULL) + return iface->has_channel_position (ctl, position); + + return FALSE; +} + +gfloat +mate_mixer_stream_control_get_balance (MateMixerStreamControl *ctl) +{ + gfloat balance = 0.0f; + + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), 0.0f); + + g_object_get (G_OBJECT (ctl), + "balance", &balance, + NULL); + + return 0.0f; +} + +gboolean +mate_mixer_stream_control_set_balance (MateMixerStreamControl *ctl, gfloat balance) +{ + MateMixerStreamControlInterface *iface; + + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), FALSE); + + iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl); + + if (iface->set_balance != NULL) + return iface->set_balance (ctl, balance); + + return FALSE; +} + +gfloat +mate_mixer_stream_control_get_fade (MateMixerStreamControl *ctl) +{ + gfloat fade = 0.0f; + + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), 0.0f); + + g_object_get (G_OBJECT (ctl), + "fade", &fade, + NULL); + + return fade; +} + +gboolean +mate_mixer_stream_control_set_fade (MateMixerStreamControl *ctl, gfloat fade) +{ + MateMixerStreamControlInterface *iface; + + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), FALSE); + + iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl); + + if (iface->set_fade != NULL) + return iface->set_fade (ctl, fade); + + return FALSE; +} + +guint +mate_mixer_stream_control_get_min_volume (MateMixerStreamControl *ctl) +{ + MateMixerStreamControlInterface *iface; + + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), 0); + + iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl); + + if (iface->get_min_volume != NULL) + return iface->get_min_volume (ctl); + + return 0; +} + +guint +mate_mixer_stream_control_get_max_volume (MateMixerStreamControl *ctl) +{ + MateMixerStreamControlInterface *iface; + + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), 0); + + iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl); + + if (iface->get_max_volume != NULL) + return iface->get_max_volume (ctl); + + return 0; +} + +guint +mate_mixer_stream_control_get_normal_volume (MateMixerStreamControl *ctl) +{ + MateMixerStreamControlInterface *iface; + + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), 0); + + iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl); + + if (iface->get_normal_volume != NULL) + return iface->get_normal_volume (ctl); + + return 0; +} + +guint +mate_mixer_stream_control_get_base_volume (MateMixerStreamControl *ctl) +{ + MateMixerStreamControlInterface *iface; + + g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), 0); + + iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl); + + if (iface->get_base_volume != NULL) + return iface->get_base_volume (ctl); + + return 0; +} diff --git a/libmatemixer/matemixer-stream-control.h b/libmatemixer/matemixer-stream-control.h new file mode 100644 index 0000000..727ed54 --- /dev/null +++ b/libmatemixer/matemixer-stream-control.h @@ -0,0 +1,148 @@ +/* + * Copyright (C) 2014 Michal Ratajsky + * + * 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 . + */ + +#ifndef MATEMIXER_STREAM_CONTROL_H +#define MATEMIXER_STREAM_CONTROL_H + +#include +#include +#include + +#include + +G_BEGIN_DECLS + +#ifdef INFINITY +# define MATE_MIXER_INFINITY INFINITY +#else +# define MATE_MIXER_INFINITY G_MAXDOUBLE +#endif + +#define MATE_MIXER_TYPE_STREAM_CONTROL \ + (mate_mixer_stream_control_get_type ()) +#define MATE_MIXER_STREAM_CONTROL(o) \ + (G_TYPE_CHECK_INSTANCE_CAST ((o), MATE_MIXER_TYPE_STREAM_CONTROL, MateMixerStreamControl)) +#define MATE_MIXER_IS_STREAM_CONTROL(o) \ + (G_TYPE_CHECK_INSTANCE_TYPE ((o), MATE_MIXER_TYPE_STREAM_CONTROL)) +#define MATE_MIXER_STREAM_CONTROL_GET_INTERFACE(o) \ + (G_TYPE_INSTANCE_GET_INTERFACE ((o), MATE_MIXER_TYPE_STREAM_CONTROL, MateMixerStreamControlInterface)) + +typedef struct _MateMixerStreamControl MateMixerStreamControl; /* dummy object */ +typedef struct _MateMixerStreamControlInterface MateMixerStreamControlInterface; + +struct _MateMixerStreamControlInterface +{ + GTypeInterface parent_iface; + + /*< private >*/ + const gchar * (*get_name) (MateMixerStreamControl *ctl); + const gchar * (*get_description) (MateMixerStreamControl *ctl); + + gboolean (*set_mute) (MateMixerStreamControl *ctl, + gboolean mute); + + guint (*get_num_channels) (MateMixerStreamControl *ctl); + + gboolean (*set_volume) (MateMixerStreamControl *ctl, + guint volume); + + gdouble (*get_decibel) (MateMixerStreamControl *ctl); + gboolean (*set_decibel) (MateMixerStreamControl *ctl, + gdouble decibel); + + gboolean (*has_channel_position) (MateMixerStreamControl *ctl, + MateMixerChannelPosition position); + MateMixerChannelPosition (*get_channel_position) (MateMixerStreamControl *ctl, + guint channel); + + guint (*get_channel_volume) (MateMixerStreamControl *ctl, + guint channel); + gboolean (*set_channel_volume) (MateMixerStreamControl *ctl, + guint channel, + guint volume); + + gdouble (*get_channel_decibel) (MateMixerStreamControl *ctl, + guint channel); + gboolean (*set_channel_decibel) (MateMixerStreamControl *ctl, + guint channel, + gdouble decibel); + + gboolean (*set_balance) (MateMixerStreamControl *ctl, + gfloat balance); + + gboolean (*set_fade) (MateMixerStreamControl *ctl, + gfloat fade); + + guint (*get_min_volume) (MateMixerStreamControl *ctl); + guint (*get_max_volume) (MateMixerStreamControl *ctl); + guint (*get_normal_volume) (MateMixerStreamControl *ctl); + guint (*get_base_volume) (MateMixerStreamControl *ctl); +}; + +GType mate_mixer_stream_control_get_type (void) G_GNUC_CONST; + +const gchar * mate_mixer_stream_control_get_name (MateMixerStreamControl *ctl); +const gchar * mate_mixer_stream_control_get_description (MateMixerStreamControl *ctl); +MateMixerStreamControlFlags mate_mixer_stream_control_get_flags (MateMixerStreamControl *ctl); + +gboolean mate_mixer_stream_control_get_mute (MateMixerStreamControl *ctl); +gboolean mate_mixer_stream_control_set_mute (MateMixerStreamControl *ctl, + gboolean mute); + +guint mate_mixer_stream_control_get_num_channels (MateMixerStreamControl *ctl); + +guint mate_mixer_stream_control_get_volume (MateMixerStreamControl *ctl); +gboolean mate_mixer_stream_control_set_volume (MateMixerStreamControl *ctl, + guint volume); + +gdouble mate_mixer_stream_control_get_decibel (MateMixerStreamControl *ctl); +gboolean mate_mixer_stream_control_set_decibel (MateMixerStreamControl *ctl, + gdouble decibel); + +gboolean mate_mixer_stream_control_has_channel_position (MateMixerStreamControl *ctl, + MateMixerChannelPosition position); +MateMixerChannelPosition mate_mixer_stream_control_get_channel_position (MateMixerStreamControl *ctl, + guint channel); + +guint mate_mixer_stream_control_get_channel_volume (MateMixerStreamControl *ctl, + guint channel); +gboolean mate_mixer_stream_control_set_channel_volume (MateMixerStreamControl *ctl, + guint channel, + guint volume); + +gdouble mate_mixer_stream_control_get_channel_decibel (MateMixerStreamControl *ctl, + guint channel); +gboolean mate_mixer_stream_control_set_channel_decibel (MateMixerStreamControl *ctl, + guint channel, + gdouble decibel); + +gfloat mate_mixer_stream_control_get_balance (MateMixerStreamControl *ctl); +gboolean mate_mixer_stream_control_set_balance (MateMixerStreamControl *ctl, + gfloat balance); + +gfloat mate_mixer_stream_control_get_fade (MateMixerStreamControl *ctl); +gboolean mate_mixer_stream_control_set_fade (MateMixerStreamControl *ctl, + gfloat fade); + +guint mate_mixer_stream_control_get_min_volume (MateMixerStreamControl *ctl); +guint mate_mixer_stream_control_get_max_volume (MateMixerStreamControl *ctl); +guint mate_mixer_stream_control_get_normal_volume (MateMixerStreamControl *ctl); +guint mate_mixer_stream_control_get_base_volume (MateMixerStreamControl *ctl); + +G_END_DECLS + +#endif /* MATEMIXER_STREAM_CONTROL_H */ diff --git a/libmatemixer/matemixer-stream.c b/libmatemixer/matemixer-stream.c index 6bec2be..888fddb 100644 --- a/libmatemixer/matemixer-stream.c +++ b/libmatemixer/matemixer-stream.c @@ -83,44 +83,6 @@ mate_mixer_stream_default_init (MateMixerStreamInterface *iface) G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)); - g_object_interface_install_property (iface, - g_param_spec_boolean ("mute", - "Mute", - "Mute state of the stream", - FALSE, - G_PARAM_READABLE | - G_PARAM_STATIC_STRINGS)); - - g_object_interface_install_property (iface, - g_param_spec_uint ("volume", - "Volume", - "Volume of the stream", - 0, - G_MAXUINT, - 0, - G_PARAM_READABLE | - G_PARAM_STATIC_STRINGS)); - - g_object_interface_install_property (iface, - g_param_spec_float ("balance", - "Balance", - "Balance value of the stream", - -1.0f, - 1.0f, - 0.0f, - G_PARAM_READABLE | - G_PARAM_STATIC_STRINGS)); - - g_object_interface_install_property (iface, - g_param_spec_float ("fade", - "Fade", - "Fade value of the stream", - -1.0f, - 1.0f, - 0.0f, - G_PARAM_READABLE | - G_PARAM_STATIC_STRINGS)); - g_object_interface_install_property (iface, g_param_spec_object ("active-port", "Active port", @@ -145,327 +107,161 @@ mate_mixer_stream_default_init (MateMixerStreamInterface *iface) const gchar * mate_mixer_stream_get_name (MateMixerStream *stream) { + g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), NULL); + + /* Implementation required */ return MATE_MIXER_STREAM_GET_INTERFACE (stream)->get_name (stream); } const gchar * mate_mixer_stream_get_description (MateMixerStream *stream) { - MateMixerStreamInterface *iface; - g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), NULL); - iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); - - if (iface->get_description) - return iface->get_description (stream); - - return NULL; + /* Implementation required */ + return MATE_MIXER_STREAM_GET_INTERFACE (stream)->get_description (stream); } MateMixerDevice * mate_mixer_stream_get_device (MateMixerStream *stream) { - MateMixerStreamInterface *iface; + MateMixerDevice *device = NULL; g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), NULL); - iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); + g_object_get (G_OBJECT (stream), + "device", &device, + NULL); - if (iface->get_device) - return iface->get_device (stream); + if (device != NULL) + g_object_unref (device); + + return device; - return NULL; } MateMixerStreamFlags mate_mixer_stream_get_flags (MateMixerStream *stream) { - MateMixerStreamInterface *iface; + MateMixerStreamFlags flags = MATE_MIXER_STREAM_NO_FLAGS; g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), MATE_MIXER_STREAM_NO_FLAGS); - iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); - - if (iface->get_flags) - return iface->get_flags (stream); + g_object_get (G_OBJECT (stream), + "flags", &flags, + NULL); - return MATE_MIXER_STREAM_NO_FLAGS; + return flags; } MateMixerStreamState mate_mixer_stream_get_state (MateMixerStream *stream) { - MateMixerStreamInterface *iface; + MateMixerStreamState state = MATE_MIXER_STREAM_STATE_UNKNOWN; g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), MATE_MIXER_STREAM_STATE_UNKNOWN); - iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); - - if (iface->get_state) - return iface->get_state (stream); + g_object_get (G_OBJECT (stream), + "state", &state, + NULL); - return MATE_MIXER_STREAM_STATE_UNKNOWN; + return state; } -gboolean -mate_mixer_stream_get_mute (MateMixerStream *stream) +MateMixerStreamControl * +mate_mixer_stream_get_control (MateMixerStream *stream, const gchar *name) { - MateMixerStreamInterface *iface; - - g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), FALSE); - - iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); - - if (iface->get_mute) - return iface->get_mute (stream); - - return FALSE; -} - -gboolean -mate_mixer_stream_set_mute (MateMixerStream *stream, gboolean mute) -{ - MateMixerStreamInterface *iface; - - g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), FALSE); - - iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); - - if (iface->set_mute) - return iface->set_mute (stream, mute); - - return FALSE; -} - -guint -mate_mixer_stream_get_volume (MateMixerStream *stream) -{ - MateMixerStreamInterface *iface; - - g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), 0); - - iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); - - if (iface->get_volume) - return iface->get_volume (stream); - - return 0; -} - -gboolean -mate_mixer_stream_set_volume (MateMixerStream *stream, guint volume) -{ - MateMixerStreamInterface *iface; - - g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), FALSE); - - iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); - - if (iface->set_volume) - return iface->set_volume (stream, volume); - - return FALSE; -} - -gdouble -mate_mixer_stream_get_decibel (MateMixerStream *stream) -{ - MateMixerStreamInterface *iface; - - g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), -MATE_MIXER_INFINITY); - - iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); - - if (iface->get_decibel) - return iface->get_decibel (stream); - - return -MATE_MIXER_INFINITY; -} - -gboolean -mate_mixer_stream_set_decibel (MateMixerStream *stream, gdouble decibel) -{ - MateMixerStreamInterface *iface; - - g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), FALSE); - - iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); - - if (iface->set_decibel) - return iface->set_decibel (stream, decibel); - - return FALSE; -} - -guint -mate_mixer_stream_get_num_channels (MateMixerStream *stream) -{ - MateMixerStreamInterface *iface; - - g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), 0); - - iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); - - if (iface->get_num_channels) - return iface->get_num_channels (stream); - - return 0; -} - -MateMixerChannelPosition -mate_mixer_stream_get_channel_position (MateMixerStream *stream, guint channel) -{ - MateMixerStreamInterface *iface; - - g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), MATE_MIXER_CHANNEL_UNKNOWN); - - iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); - - if (iface->get_channel_position) - return iface->get_channel_position (stream, channel); - - return MATE_MIXER_CHANNEL_UNKNOWN; -} - -guint -mate_mixer_stream_get_channel_volume (MateMixerStream *stream, guint channel) -{ - MateMixerStreamInterface *iface; - - g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), 0); - - iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); - - if (iface->get_channel_volume) - return iface->get_channel_volume (stream, channel); - - return 0; -} - -gboolean -mate_mixer_stream_set_channel_volume (MateMixerStream *stream, - guint channel, - guint volume) -{ - MateMixerStreamInterface *iface; - - g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), FALSE); - - iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); - - if (iface->set_channel_volume) - return iface->set_channel_volume (stream, channel, volume); - - return FALSE; -} - -gdouble -mate_mixer_stream_get_channel_decibel (MateMixerStream *stream, guint channel) -{ - MateMixerStreamInterface *iface; - - g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), -MATE_MIXER_INFINITY); - - iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); - - if (iface->get_channel_decibel) - return iface->get_channel_decibel (stream, channel); + g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), NULL); - return -MATE_MIXER_INFINITY; + /* Implementation required */ + return MATE_MIXER_STREAM_GET_INTERFACE (stream)->get_control (stream, name); } -gboolean -mate_mixer_stream_set_channel_decibel (MateMixerStream *stream, - guint channel, - gdouble decibel) +MateMixerStreamControl * +mate_mixer_stream_get_default_control (MateMixerStream *stream) { - MateMixerStreamInterface *iface; - - g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), FALSE); - - iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); - - if (iface->set_channel_decibel) - return iface->set_channel_decibel (stream, channel, decibel); + g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), NULL); - return FALSE; + /* Implementation required */ + return MATE_MIXER_STREAM_GET_INTERFACE (stream)->get_default_control (stream); } -gboolean -mate_mixer_stream_has_channel_position (MateMixerStream *stream, - MateMixerChannelPosition position) +MateMixerPort * +mate_mixer_stream_get_port (MateMixerStream *stream, const gchar *name) { MateMixerStreamInterface *iface; - g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), FALSE); + g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), NULL); iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); - if (iface->has_channel_position) - return iface->has_channel_position (stream, position); + if (iface->get_port != NULL) + return iface->get_port (stream, name); return FALSE; } -gfloat -mate_mixer_stream_get_balance (MateMixerStream *stream) +MateMixerPort * +mate_mixer_stream_get_active_port (MateMixerStream *stream) { - MateMixerStreamInterface *iface; + MateMixerPort *port = NULL; - g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), 0.0f); + g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), NULL); - iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); + g_object_get (G_OBJECT (stream), + "active-port", &port, + NULL); - if (iface->get_balance) - return iface->get_balance (stream); + if (port != NULL) + g_object_unref (port); - return 0.0f; + return port; } gboolean -mate_mixer_stream_set_balance (MateMixerStream *stream, gfloat balance) +mate_mixer_stream_set_active_port (MateMixerStream *stream, MateMixerPort *port) { MateMixerStreamInterface *iface; g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), FALSE); + g_return_val_if_fail (MATE_MIXER_IS_PORT (port), FALSE); iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); - if (iface->set_balance) - return iface->set_balance (stream, balance); + if (iface->set_active_port != NULL) + return iface->set_active_port (stream, port); return FALSE; } -gfloat -mate_mixer_stream_get_fade (MateMixerStream *stream) +const GList * +mate_mixer_stream_list_controls (MateMixerStream *stream) { MateMixerStreamInterface *iface; - g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), 0.0f); + g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), NULL); iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); - if (iface->get_fade) - return iface->get_fade (stream); + if (iface->list_controls != NULL) + return iface->list_controls (stream); - return 0.0f; + return NULL; } -gboolean -mate_mixer_stream_set_fade (MateMixerStream *stream, gfloat fade) +const GList * +mate_mixer_stream_list_ports (MateMixerStream *stream) { MateMixerStreamInterface *iface; - g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), FALSE); + g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), NULL); iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); - if (iface->set_fade) - return iface->set_fade (stream, fade); + if (iface->list_ports != NULL) + return iface->list_ports (stream); - return FALSE; + return NULL; } gboolean @@ -477,7 +273,7 @@ mate_mixer_stream_suspend (MateMixerStream *stream) iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); - if (iface->suspend) + if (iface->suspend != NULL) return iface->suspend (stream); return FALSE; @@ -492,57 +288,28 @@ mate_mixer_stream_resume (MateMixerStream *stream) iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); - if (iface->resume) + if (iface->resume != NULL) return iface->resume (stream); return FALSE; } gboolean -mate_mixer_stream_monitor_start (MateMixerStream *stream) -{ - MateMixerStreamInterface *iface; - - g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), FALSE); - - iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); - - if (iface->monitor_start) - return iface->monitor_start (stream); - - return FALSE; -} - -void -mate_mixer_stream_monitor_stop (MateMixerStream *stream) -{ - MateMixerStreamInterface *iface; - - g_return_if_fail (MATE_MIXER_IS_STREAM (stream)); - - iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); - - if (iface->monitor_stop) - iface->monitor_stop (stream); -} - -gboolean -mate_mixer_stream_monitor_is_running (MateMixerStream *stream) +mate_mixer_stream_monitor_get_enabled (MateMixerStream *stream) { - MateMixerStreamInterface *iface; + gboolean enabled = FALSE; g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), FALSE); - iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); - - if (iface->monitor_is_running) - return iface->monitor_is_running (stream); + g_object_get (G_OBJECT (stream), + "monitor-enabled", &enabled, + NULL); - return FALSE; + return enabled; } gboolean -mate_mixer_stream_monitor_set_name (MateMixerStream *stream, const gchar *name) +mate_mixer_stream_monitor_set_enabled (MateMixerStream *stream, gboolean enabled) { MateMixerStreamInterface *iface; @@ -550,29 +317,14 @@ mate_mixer_stream_monitor_set_name (MateMixerStream *stream, const gchar *name) iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); - if (iface->monitor_set_name) - return iface->monitor_set_name (stream, name); + if (iface->monitor_set_enabled != NULL) + return iface->monitor_set_enabled (stream, enabled); return FALSE; } -const GList * -mate_mixer_stream_list_ports (MateMixerStream *stream) -{ - MateMixerStreamInterface *iface; - - g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), NULL); - - iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); - - if (iface->list_ports) - return iface->list_ports (stream); - - return NULL; -} - -MateMixerPort * -mate_mixer_stream_get_active_port (MateMixerStream *stream) +const gchar * +mate_mixer_stream_monitor_get_name (MateMixerStream *stream) { MateMixerStreamInterface *iface; @@ -580,84 +332,23 @@ mate_mixer_stream_get_active_port (MateMixerStream *stream) iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); - if (iface->get_active_port) - return iface->get_active_port (stream); + if (iface->monitor_get_name != NULL) + return iface->monitor_get_name (stream); - return NULL; + return FALSE; } gboolean -mate_mixer_stream_set_active_port (MateMixerStream *stream, MateMixerPort *port) +mate_mixer_stream_monitor_set_name (MateMixerStream *stream, const gchar *name) { MateMixerStreamInterface *iface; g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), FALSE); - g_return_val_if_fail (MATE_MIXER_IS_PORT (port), FALSE); iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); - if (iface->set_active_port) - return iface->set_active_port (stream, port); + if (iface->monitor_set_name != NULL) + return iface->monitor_set_name (stream, name); return FALSE; } - -guint -mate_mixer_stream_get_min_volume (MateMixerStream *stream) -{ - MateMixerStreamInterface *iface; - - g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), 0); - - iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); - - if (iface->get_min_volume) - return iface->get_min_volume (stream); - - return 0; -} - -guint -mate_mixer_stream_get_max_volume (MateMixerStream *stream) -{ - MateMixerStreamInterface *iface; - - g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), 0); - - iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); - - if (iface->get_max_volume) - return iface->get_max_volume (stream); - - return 0; -} - -guint -mate_mixer_stream_get_normal_volume (MateMixerStream *stream) -{ - MateMixerStreamInterface *iface; - - g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), 0); - - iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); - - if (iface->get_normal_volume) - return iface->get_normal_volume (stream); - - return 0; -} - -guint -mate_mixer_stream_get_base_volume (MateMixerStream *stream) -{ - MateMixerStreamInterface *iface; - - g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), 0); - - iface = MATE_MIXER_STREAM_GET_INTERFACE (stream); - - if (iface->get_base_volume) - return iface->get_base_volume (stream); - - return 0; -} diff --git a/libmatemixer/matemixer-stream.h b/libmatemixer/matemixer-stream.h index e91a2a5..aecf40e 100644 --- a/libmatemixer/matemixer-stream.h +++ b/libmatemixer/matemixer-stream.h @@ -18,13 +18,13 @@ #ifndef MATEMIXER_STREAM_H #define MATEMIXER_STREAM_H -#include #include #include #include #include #include +#include G_BEGIN_DECLS @@ -51,131 +51,69 @@ struct _MateMixerStreamInterface GTypeInterface parent_iface; /*< private >*/ - /* Virtual table */ - const gchar * (*get_name) (MateMixerStream *stream); - const gchar * (*get_description) (MateMixerStream *stream); - MateMixerDevice * (*get_device) (MateMixerStream *stream); - MateMixerStreamFlags (*get_flags) (MateMixerStream *stream); - MateMixerStreamState (*get_state) (MateMixerStream *stream); - gboolean (*get_mute) (MateMixerStream *stream); - gboolean (*set_mute) (MateMixerStream *stream, - gboolean mute); - guint (*get_num_channels) (MateMixerStream *stream); - guint (*get_volume) (MateMixerStream *stream); - gboolean (*set_volume) (MateMixerStream *stream, - guint volume); - gdouble (*get_decibel) (MateMixerStream *stream); - gboolean (*set_decibel) (MateMixerStream *stream, - gdouble decibel); - MateMixerChannelPosition (*get_channel_position) (MateMixerStream *stream, - guint channel); - guint (*get_channel_volume) (MateMixerStream *stream, - guint channel); - gboolean (*set_channel_volume) (MateMixerStream *stream, - guint channel, - guint volume); - gdouble (*get_channel_decibel) (MateMixerStream *stream, - guint channel); - gboolean (*set_channel_decibel) (MateMixerStream *stream, - guint channel, - gdouble decibel); - gboolean (*has_channel_position) (MateMixerStream *stream, - MateMixerChannelPosition position); - gfloat (*get_balance) (MateMixerStream *stream); - gboolean (*set_balance) (MateMixerStream *stream, - gfloat balance); - gfloat (*get_fade) (MateMixerStream *stream); - gboolean (*set_fade) (MateMixerStream *stream, - gfloat fade); - gboolean (*suspend) (MateMixerStream *stream); - gboolean (*resume) (MateMixerStream *stream); - gboolean (*monitor_start) (MateMixerStream *stream); - void (*monitor_stop) (MateMixerStream *stream); - gboolean (*monitor_is_running) (MateMixerStream *stream); - gboolean (*monitor_set_name) (MateMixerStream *stream, - const gchar *name); - const GList * (*list_ports) (MateMixerStream *stream); - MateMixerPort * (*get_active_port) (MateMixerStream *stream); - gboolean (*set_active_port) (MateMixerStream *stream, - MateMixerPort *port); - guint (*get_min_volume) (MateMixerStream *stream); - guint (*get_max_volume) (MateMixerStream *stream); - guint (*get_normal_volume) (MateMixerStream *stream); - guint (*get_base_volume) (MateMixerStream *stream); + const gchar * (*get_name) (MateMixerStream *stream); + const gchar * (*get_description) (MateMixerStream *stream); - /* Signals */ - void (*monitor_value) (MateMixerStream *stream, - gdouble value); -}; - -GType mate_mixer_stream_get_type (void) G_GNUC_CONST; + MateMixerStreamControl *(*get_control) (MateMixerStream *stream, + const gchar *name); + MateMixerStreamControl *(*get_default_control) (MateMixerStream *stream); -const gchar * mate_mixer_stream_get_name (MateMixerStream *stream); -const gchar * mate_mixer_stream_get_description (MateMixerStream *stream); -MateMixerDevice * mate_mixer_stream_get_device (MateMixerStream *stream); -MateMixerStreamFlags mate_mixer_stream_get_flags (MateMixerStream *stream); -MateMixerStreamState mate_mixer_stream_get_state (MateMixerStream *stream); + MateMixerPort * (*get_port) (MateMixerStream *stream, + const gchar *name); -gboolean mate_mixer_stream_get_mute (MateMixerStream *stream); -gboolean mate_mixer_stream_set_mute (MateMixerStream *stream, - gboolean mute); + gboolean (*set_active_port) (MateMixerStream *stream, + MateMixerPort *port); -guint mate_mixer_stream_get_num_channels (MateMixerStream *stream); + const GList * (*list_controls) (MateMixerStream *stream); + const GList * (*list_ports) (MateMixerStream *stream); -guint mate_mixer_stream_get_volume (MateMixerStream *stream); -gboolean mate_mixer_stream_set_volume (MateMixerStream *stream, - guint volume); + gboolean (*suspend) (MateMixerStream *stream); + gboolean (*resume) (MateMixerStream *stream); -gdouble mate_mixer_stream_get_decibel (MateMixerStream *stream); -gboolean mate_mixer_stream_set_decibel (MateMixerStream *stream, - gdouble decibel); + gboolean (*monitor_set_enabled) (MateMixerStream *stream, + gboolean enabled); -MateMixerChannelPosition mate_mixer_stream_get_channel_position (MateMixerStream *stream, - guint channel); + const gchar * (*monitor_get_name) (MateMixerStream *stream); + gboolean (*monitor_set_name) (MateMixerStream *stream, + const gchar *name); -guint mate_mixer_stream_get_channel_volume (MateMixerStream *stream, - guint channel); -gboolean mate_mixer_stream_set_channel_volume (MateMixerStream *stream, - guint channel, - guint volume); - -gdouble mate_mixer_stream_get_channel_decibel (MateMixerStream *stream, - guint channel); -gboolean mate_mixer_stream_set_channel_decibel (MateMixerStream *stream, - guint channel, - gdouble decibel); + /* Signals */ + void (*monitor_value) (MateMixerStream *stream, + gdouble value); +}; -gboolean mate_mixer_stream_has_channel_position (MateMixerStream *stream, - MateMixerChannelPosition position); +GType mate_mixer_stream_get_type (void) G_GNUC_CONST; -gfloat mate_mixer_stream_get_balance (MateMixerStream *stream); -gboolean mate_mixer_stream_set_balance (MateMixerStream *stream, - gfloat balance); +const gchar * mate_mixer_stream_get_name (MateMixerStream *stream); +const gchar * mate_mixer_stream_get_description (MateMixerStream *stream); +MateMixerDevice * mate_mixer_stream_get_device (MateMixerStream *stream); +MateMixerStreamFlags mate_mixer_stream_get_flags (MateMixerStream *stream); +MateMixerStreamState mate_mixer_stream_get_state (MateMixerStream *stream); -gfloat mate_mixer_stream_get_fade (MateMixerStream *stream); -gboolean mate_mixer_stream_set_fade (MateMixerStream *stream, - gfloat fade); +MateMixerStreamControl *mate_mixer_stream_get_control (MateMixerStream *stream, + const gchar *name); +MateMixerStreamControl *mate_mixer_stream_get_default_control (MateMixerStream *stream); -gboolean mate_mixer_stream_suspend (MateMixerStream *stream); -gboolean mate_mixer_stream_resume (MateMixerStream *stream); +MateMixerPort * mate_mixer_stream_get_port (MateMixerStream *stream, + const gchar *name); -gboolean mate_mixer_stream_monitor_start (MateMixerStream *stream); -void mate_mixer_stream_monitor_stop (MateMixerStream *stream); +MateMixerPort * mate_mixer_stream_get_active_port (MateMixerStream *stream); +gboolean mate_mixer_stream_set_active_port (MateMixerStream *stream, + MateMixerPort *port); -gboolean mate_mixer_stream_monitor_is_running (MateMixerStream *stream); -gboolean mate_mixer_stream_monitor_set_name (MateMixerStream *stream, - const gchar *name); +const GList * mate_mixer_stream_list_controls (MateMixerStream *stream); +const GList * mate_mixer_stream_list_ports (MateMixerStream *stream); -const GList * mate_mixer_stream_list_ports (MateMixerStream *stream); +gboolean mate_mixer_stream_suspend (MateMixerStream *stream); +gboolean mate_mixer_stream_resume (MateMixerStream *stream); -MateMixerPort * mate_mixer_stream_get_active_port (MateMixerStream *stream); -gboolean mate_mixer_stream_set_active_port (MateMixerStream *stream, - MateMixerPort *port); +gboolean mate_mixer_stream_monitor_get_enabled (MateMixerStream *stream); +gboolean mate_mixer_stream_monitor_set_enabled (MateMixerStream *stream, + gboolean enabled); -guint mate_mixer_stream_get_min_volume (MateMixerStream *stream); -guint mate_mixer_stream_get_max_volume (MateMixerStream *stream); -guint mate_mixer_stream_get_normal_volume (MateMixerStream *stream); -guint mate_mixer_stream_get_base_volume (MateMixerStream *stream); +const gchar * mate_mixer_stream_monitor_get_name (MateMixerStream *stream); +gboolean mate_mixer_stream_monitor_set_name (MateMixerStream *stream, + const gchar *name); G_END_DECLS -- cgit v1.2.1