gst-libs/gst/interfaces/mixer.c

   1 /* GStreamer Mixer
   2  * Copyright (C) 2003 Ronald Bultje <rbultje@ronald.bitfreak.net>
   3  *
   4  * mixer.c: mixer design virtual class function wrappers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include "config.h"
  24 #endif
  25
  26 #include "mixer.h"
  27 #include "interfaces-marshal.h"
  28
  29 /**
  30  * SECTION:gstmixer
  31  * @short_description: Interface for elements that provide mixer operations
  32  */
  33
  34 enum
  35 {
  36   SIGNAL_MUTE_TOGGLED,
  37   SIGNAL_RECORD_TOGGLED,
  38   SIGNAL_VOLUME_CHANGED,
  39   SIGNAL_OPTION_CHANGED,
  40   LAST_SIGNAL
  41 };
  42
  43 static void gst_mixer_class_init (GstMixerClass * klass);
  44
  45 static guint gst_mixer_signals[LAST_SIGNAL] = { 0 };
  46
  47 GType
  48 gst_mixer_get_type (void)
  49 {
  50   static GType gst_mixer_type = 0;
  51
  52   if (!gst_mixer_type) {
  53     static const GTypeInfo gst_mixer_info = {
  54       sizeof (GstMixerClass),
  55       (GBaseInitFunc) gst_mixer_class_init,
  56       NULL,
  57       NULL,
  58       NULL,
  59       NULL,
  60       0,
  61       0,
  62       NULL,
  63     };
  64
  65     gst_mixer_type = g_type_register_static (G_TYPE_INTERFACE,
  66         "GstMixer", &gst_mixer_info, 0);
  67     g_type_interface_add_prerequisite (gst_mixer_type,
  68         GST_TYPE_IMPLEMENTS_INTERFACE);
  69   }
  70
  71   return gst_mixer_type;
  72 }
  73
  74 static void
  75 gst_mixer_class_init (GstMixerClass * klass)
  76 {
  77   static gboolean initialized = FALSE;
  78
  79   if (!initialized) {
  80     gst_mixer_signals[SIGNAL_RECORD_TOGGLED] =
  81         g_signal_new ("record-toggled",
  82         GST_TYPE_MIXER, G_SIGNAL_RUN_LAST,
  83         G_STRUCT_OFFSET (GstMixerClass, record_toggled),
  84         NULL, NULL,
  85         gst_interfaces_marshal_VOID__OBJECT_BOOLEAN, G_TYPE_NONE, 2,
  86         GST_TYPE_MIXER_TRACK, G_TYPE_BOOLEAN);
  87     gst_mixer_signals[SIGNAL_MUTE_TOGGLED] =
  88         g_signal_new ("mute-toggled",
  89         GST_TYPE_MIXER, G_SIGNAL_RUN_LAST,
  90         G_STRUCT_OFFSET (GstMixerClass, mute_toggled),
  91         NULL, NULL,
  92         gst_interfaces_marshal_VOID__OBJECT_BOOLEAN, G_TYPE_NONE, 2,
  93         GST_TYPE_MIXER_TRACK, G_TYPE_BOOLEAN);
  94     gst_mixer_signals[SIGNAL_VOLUME_CHANGED] =
  95         g_signal_new ("volume-changed",
  96         GST_TYPE_MIXER, G_SIGNAL_RUN_LAST,
  97         G_STRUCT_OFFSET (GstMixerClass, volume_changed),
  98         NULL, NULL,
  99         gst_interfaces_marshal_VOID__OBJECT_POINTER, G_TYPE_NONE, 2,
 100         GST_TYPE_MIXER_TRACK, G_TYPE_POINTER);
 101     gst_mixer_signals[SIGNAL_OPTION_CHANGED] =
 102         g_signal_new ("option-changed",
 103         GST_TYPE_MIXER, G_SIGNAL_RUN_LAST,
 104         G_STRUCT_OFFSET (GstMixerClass, option_changed),
 105         NULL, NULL,
 106         gst_interfaces_marshal_VOID__OBJECT_STRING, G_TYPE_NONE, 2,
 107         GST_TYPE_MIXER_OPTIONS, G_TYPE_STRING);
 108
 109     initialized = TRUE;
 110   }
 111
 112   klass->mixer_type = GST_MIXER_SOFTWARE;
 113
 114   /* default virtual functions */
 115   klass->list_tracks = NULL;
 116   klass->set_volume = NULL;
 117   klass->get_volume = NULL;
 118   klass->set_mute = NULL;
 119   klass->set_record = NULL;
 120   klass->set_option = NULL;
 121   klass->get_option = NULL;
 122 }
 123
 124 /**
 125  * gst_mixer_list_tracks:
 126  * @mixer: the #GstMixer (a #GstElement) to get the tracks from.
 127  *
 128  * Returns a list of available tracks for this mixer/element. Note
 129  * that it is allowed for sink (output) elements to only provide
 130  * the output tracks in this list. Likewise, for sources (inputs),
 131  * it is allowed to only provide input elements in this list.
 132  *
 133  * Returns: A #GList consisting of zero or more #GstMixerTracks.
 134  */
 135
 136 const GList *
 137 gst_mixer_list_tracks (GstMixer * mixer)
 138 {
 139   GstMixerClass *klass = GST_MIXER_GET_CLASS (mixer);
 140
 141   if (klass->list_tracks) {
 142     return klass->list_tracks (mixer);
 143   }
 144
 145   return NULL;
 146 }
 147
 148 /**
 149  * gst_mixer_set_volume:
 150  * @mixer: The #GstMixer (a #GstElement) that owns the track.
 151  * @track: The #GstMixerTrack to set the volume on.
 152  * @volumes: an array of integers (of size track->num_channels)
 153  *           that gives the wanted volume for each channel in
 154  *           this track.
 155  *
 156  * Sets the volume on each channel in a track. Short note about
 157  * naming: a track is defined as one separate stream owned by
 158  * the mixer/element, such as 'Line-in' or 'Microphone'. A
 159  * channel is said to be a mono-stream inside this track. A
 160  * stereo track thus contains two channels.
 161  */
 162
 163 void
 164 gst_mixer_set_volume (GstMixer * mixer, GstMixerTrack * track, gint * volumes)
 165 {
 166   GstMixerClass *klass = GST_MIXER_GET_CLASS (mixer);
 167
 168   if (klass->set_volume) {
 169     klass->set_volume (mixer, track, volumes);
 170   }
 171 }
 172
 173 /*
 174  * gst_mixer_get_volume:
 175  * @mixer: the #GstMixer (a #GstElement) that owns the track
 176  * @track: the GstMixerTrack to get the volume from.
 177  * @volumes: a pre-allocated array of integers (of size
 178  *           track->num_channels) to store the current volume
 179  *           of each channel in the given track in.
 180  *
 181  * Get the current volume(s) on the given track.
 182  */
 183
 184 void
 185 gst_mixer_get_volume (GstMixer * mixer, GstMixerTrack * track, gint * volumes)
 186 {
 187   GstMixerClass *klass = GST_MIXER_GET_CLASS (mixer);
 188
 189   if (klass->get_volume) {
 190     klass->get_volume (mixer, track, volumes);
 191   } else {
 192     gint i;
 193
 194     for (i = 0; i < track->num_channels; i++) {
 195       volumes[i] = 0;
 196     }
 197   }
 198 }
 199
 200 /**
 201  * gst_mixer_set_mute:
 202  * @mixer: the #GstMixer (a #GstElement) that owns the track.
 203  * @track: the #GstMixerTrack to operate on.
 204  * @mute: a boolean value indicating whether to turn on or off
 205  *        muting.
 206  *
 207  * Mutes or unmutes the given channel. To find out whether a
 208  * track is currently muted, use GST_MIXER_TRACK_HAS_FLAG ().
 209  */
 210
 211 void
 212 gst_mixer_set_mute (GstMixer * mixer, GstMixerTrack * track, gboolean mute)
 213 {
 214   GstMixerClass *klass = GST_MIXER_GET_CLASS (mixer);
 215
 216   if (klass->set_mute) {
 217     klass->set_mute (mixer, track, mute);
 218   }
 219 }
 220
 221 /**
 222  * gst_mixer_set_record:
 223  * @mixer: The #GstMixer (a #GstElement) that owns the track.
 224  * @track: the #GstMixerTrack to operate on.
 225  * @record: a boolean value that indicates whether to turn on
 226  *          or off recording.
 227  *
 228  * Enables or disables recording on the given track. Note that
 229  * this is only possible on input tracks, not on output tracks
 230  * (see GST_MIXER_TRACK_HAS_FLAG () and the GST_MIXER_TRACK_INPUT
 231  * flag).
 232  */
 233
 234 void
 235 gst_mixer_set_record (GstMixer * mixer, GstMixerTrack * track, gboolean record)
 236 {
 237   GstMixerClass *klass = GST_MIXER_GET_CLASS (mixer);
 238
 239   if (klass->set_record) {
 240     klass->set_record (mixer, track, record);
 241   }
 242 }
 243
 244 /**
 245  * gst_mixer_set_option:
 246  * @mixer: The #GstMixer (a #GstElement) that owns the optionlist.
 247  * @opts: The #GstMixerOptions that we operate on.
 248  * @value: The requested new option value.
 249  *
 250  * Sets a name/value option in the mixer to the requested value.
 251  */
 252
 253 void
 254 gst_mixer_set_option (GstMixer * mixer, GstMixerOptions * opts, gchar * value)
 255 {
 256   GstMixerClass *klass = GST_MIXER_GET_CLASS (mixer);
 257
 258   if (klass->set_option) {
 259     klass->set_option (mixer, opts, value);
 260   }
 261 }
 262
 263 /**
 264  * gst_mixer_get_option:
 265  * @mixer: The #GstMixer (a #GstElement) that owns the optionlist.
 266  * @opts: The #GstMixerOptions that we operate on.
 267  *
 268  * Get the current value of a name/value option in the mixer.
 269  *
 270  * Returns: current value of the name/value option.
 271  */
 272
 273 const gchar *
 274 gst_mixer_get_option (GstMixer * mixer, GstMixerOptions * opts)
 275 {
 276   GstMixerClass *klass = GST_MIXER_GET_CLASS (mixer);
 277
 278   if (klass->get_option) {
 279     return klass->get_option (mixer, opts);
 280   }
 281
 282   return NULL;
 283 }
 284
 285 void
 286 gst_mixer_mute_toggled (GstMixer * mixer, GstMixerTrack * track, gboolean mute)
 287 {
 288   g_signal_emit (G_OBJECT (mixer),
 289       gst_mixer_signals[SIGNAL_MUTE_TOGGLED], 0, track, mute);
 290
 291   g_signal_emit_by_name (G_OBJECT (track), "mute_toggled", mute);
 292 }
 293
 294 void
 295 gst_mixer_record_toggled (GstMixer * mixer,
 296     GstMixerTrack * track, gboolean record)
 297 {
 298   g_signal_emit (G_OBJECT (mixer),
 299       gst_mixer_signals[SIGNAL_RECORD_TOGGLED], 0, track, record);
 300
 301   g_signal_emit_by_name (G_OBJECT (track), "record_toggled", record);
 302 }
 303
 304 void
 305 gst_mixer_volume_changed (GstMixer * mixer,
 306     GstMixerTrack * track, gint * volumes)
 307 {
 308   g_signal_emit (G_OBJECT (mixer),
 309       gst_mixer_signals[SIGNAL_VOLUME_CHANGED], 0, track, volumes);
 310
 311   g_signal_emit_by_name (G_OBJECT (track), "volume_changed", volumes);
 312 }
 313
 314 void
 315 gst_mixer_option_changed (GstMixer * mixer,
 316     GstMixerOptions * opts, gchar * value)
 317 {
 318   g_signal_emit (G_OBJECT (mixer),
 319       gst_mixer_signals[SIGNAL_OPTION_CHANGED], 0, opts, value);
 320
 321   g_signal_emit_by_name (G_OBJECT (opts), "value_changed", value);
 322 }