src/empathy-audio-sink.c

   1 /*
   2  * empathy-gst-audio-sink.c - Source for EmpathyGstAudioSink
   3  * Copyright (C) 2008 Collabora Ltd.
   4  * @author Sjoerd Simons <sjoerd.simons@collabora.co.uk>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 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  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  */
  20
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24
  25 #include <gst/audio/audio.h>
  26 #include <gst/interfaces/streamvolume.h>
  27
  28 #include <telepathy-glib/telepathy-glib.h>
  29
  30 #include <libempathy-gtk/empathy-call-utils.h>
  31
  32 #include "empathy-audio-sink.h"
  33
  34 #define DEBUG_FLAG EMPATHY_DEBUG_VOIP
  35 #include <libempathy/empathy-debug.h>
  36
  37 G_DEFINE_TYPE(EmpathyGstAudioSink, empathy_audio_sink, GST_TYPE_BIN)
  38
  39 /* signal enum */
  40 #if 0
  41 enum
  42 {
  43     LAST_SIGNAL
  44 };
  45
  46 static guint signals[LAST_SIGNAL] = {0};
  47 #endif
  48
  49 static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE(
  50     "sink%d",
  51     GST_PAD_SINK,
  52     GST_PAD_REQUEST,
  53     GST_STATIC_CAPS ( GST_AUDIO_INT_PAD_TEMPLATE_CAPS " ; "
  54         GST_AUDIO_FLOAT_PAD_TEMPLATE_CAPS)
  55 );
  56
  57 enum {
  58   PROP_VOLUME = 1,
  59 };
  60
  61 struct _EmpathyGstAudioSinkPrivate
  62 {
  63   GstElement *sink;
  64   gboolean echo_cancel;
  65   gdouble volume;
  66   gint volume_idle_id;
  67   GStaticMutex volume_mutex;
  68 };
  69
  70 #define EMPATHY_GST_AUDIO_SINK_GET_PRIVATE(o) \
  71   (G_TYPE_INSTANCE_GET_PRIVATE ((o), EMPATHY_TYPE_GST_AUDIO_SINK, \
  72   EmpathyGstAudioSinkPrivate))
  73
  74 static void
  75 empathy_audio_sink_init (EmpathyGstAudioSink *self)
  76 {
  77   self->priv = EMPATHY_GST_AUDIO_SINK_GET_PRIVATE (self);
  78   self->priv->echo_cancel = TRUE;
  79   g_static_mutex_init (&self->priv->volume_mutex);
  80 }
  81
  82 static GstPad * empathy_audio_sink_request_new_pad (GstElement *self,
  83   GstPadTemplate *templ,
  84   const gchar* name);
  85
  86 static void empathy_audio_sink_release_pad (GstElement *self,
  87   GstPad *pad);
  88
  89 static void
  90 empathy_audio_sink_set_property (GObject *object,
  91   guint property_id, const GValue *value, GParamSpec *pspec)
  92 {
  93   EmpathyGstAudioSink *self = EMPATHY_GST_AUDIO_SINK (object);
  94   switch (property_id)
  95     {
  96       case PROP_VOLUME:
  97         g_static_mutex_lock (&self->priv->volume_mutex);
  98         self->priv->volume = g_value_get_double (value);
  99         g_static_mutex_unlock (&self->priv->volume_mutex);
 100         break;
 101       default:
 102         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 103     }
 104 }
 105
 106 static void
 107 empathy_audio_sink_get_property (GObject *object,
 108   guint property_id, GValue *value, GParamSpec *pspec)
 109 {
 110   EmpathyGstAudioSink *self = EMPATHY_GST_AUDIO_SINK (object);
 111   switch (property_id)
 112     {
 113       case PROP_VOLUME:
 114         g_value_set_double (value, self->priv->volume);
 115         break;
 116       default:
 117         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 118     }
 119 }
 120
 121 static void
 122 empathy_audio_sink_dispose (GObject *object)
 123 {
 124   EmpathyGstAudioSink *self = EMPATHY_GST_AUDIO_SINK (object);
 125   EmpathyGstAudioSinkPrivate *priv = self->priv;
 126
 127   if (priv->volume_idle_id != 0)
 128     g_source_remove (priv->volume_idle_id);
 129   priv->volume_idle_id = 0;
 130
 131   g_static_mutex_free (&self->priv->volume_mutex);
 132
 133   /* release any references held by the object here */
 134   if (G_OBJECT_CLASS (empathy_audio_sink_parent_class)->dispose)
 135     G_OBJECT_CLASS (empathy_audio_sink_parent_class)->dispose (object);
 136 }
 137
 138 static void
 139 empathy_audio_sink_class_init (EmpathyGstAudioSinkClass
 140   *empathy_audio_sink_class)
 141 {
 142   GObjectClass *object_class = G_OBJECT_CLASS (empathy_audio_sink_class);
 143   GstElementClass *element_class =
 144     GST_ELEMENT_CLASS (empathy_audio_sink_class);
 145   GParamSpec *param_spec;
 146
 147   gst_element_class_add_pad_template (element_class,
 148     gst_static_pad_template_get (&sink_template));
 149
 150   g_type_class_add_private (empathy_audio_sink_class,
 151     sizeof (EmpathyGstAudioSinkPrivate));
 152
 153   object_class->set_property = empathy_audio_sink_set_property;
 154   object_class->get_property = empathy_audio_sink_get_property;
 155   object_class->dispose = empathy_audio_sink_dispose;
 156
 157   element_class->request_new_pad = empathy_audio_sink_request_new_pad;
 158   element_class->release_pad = empathy_audio_sink_release_pad;
 159
 160   param_spec = g_param_spec_double ("volume", "Volume", "volume control",
 161     0.0, 5.0, 1.0,
 162     G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
 163   g_object_class_install_property (object_class, PROP_VOLUME, param_spec);
 164 }
 165
 166 GstElement *
 167 empathy_audio_sink_new (void)
 168 {
 169   static gboolean registered = FALSE;
 170
 171   if (!registered) {
 172     if (!gst_element_register (NULL, "empathyaudiosink",
 173             GST_RANK_NONE, EMPATHY_TYPE_GST_AUDIO_SINK))
 174       return NULL;
 175     registered = TRUE;
 176   }
 177   return gst_element_factory_make ("empathyaudiosink", NULL);
 178 }
 179
 180 void
 181 empathy_audio_sink_set_volume (EmpathyGstAudioSink *sink, gdouble volume)
 182 {
 183   g_object_set (sink, "volume", volume, NULL);
 184 }
 185
 186 gdouble
 187 empathy_audio_sink_get_volume (EmpathyGstAudioSink *sink)
 188 {
 189   EmpathyGstAudioSinkPrivate *priv = EMPATHY_GST_AUDIO_SINK_GET_PRIVATE (sink);
 190
 191   return priv->volume;
 192 }
 193
 194 static GstElement *
 195 create_sink (EmpathyGstAudioSink *self)
 196 {
 197   GstElement *sink;
 198   const gchar *description;
 199
 200   description = g_getenv ("EMPATHY_AUDIO_SINK");
 201
 202   if (description != NULL)
 203     {
 204       GError *error = NULL;
 205
 206       sink = gst_parse_bin_from_description (description, TRUE, &error);
 207       if (sink == NULL)
 208         {
 209           DEBUG ("Failed to create bin %s: %s", description, error->message);
 210           g_error_free (error);
 211         }
 212
 213       return sink;
 214     }
 215
 216   /* Use pulsesink as default */
 217   sink = gst_element_factory_make ("pulsesink", NULL);
 218   if (sink == NULL)
 219     return NULL;
 220
 221   empathy_call_set_stream_properties (sink, self->priv->echo_cancel);
 222
 223   /* Set latency (buffering on the PulseAudio side) of 40ms and transfer data
 224    * in 10ms chunks */
 225   g_object_set (sink, "buffer-time", 40000, "latency-time", 10000, NULL);
 226
 227   return sink;
 228 }
 229
 230 static gboolean
 231 empathy_audio_sink_volume_idle_updated (gpointer user_data)
 232 {
 233   EmpathyGstAudioSink *self = EMPATHY_GST_AUDIO_SINK (user_data);
 234
 235   g_static_mutex_lock (&self->priv->volume_mutex);
 236   self->priv->volume_idle_id = 0;
 237   g_static_mutex_unlock (&self->priv->volume_mutex);
 238
 239   g_object_notify (G_OBJECT (self), "volume");
 240
 241   return FALSE;
 242 }
 243
 244 static void
 245 empathy_audio_sink_volume_updated (GObject *object,
 246   GParamSpec *pspec,
 247   gpointer user_data)
 248 {
 249   EmpathyGstAudioSink *self = EMPATHY_GST_AUDIO_SINK (user_data);
 250   gdouble volume;
 251
 252   g_static_mutex_lock (&self->priv->volume_mutex);
 253
 254   g_object_get (object, "volume", &volume, NULL);
 255   if (self->priv->volume == volume)
 256     goto out;
 257
 258   self->priv->volume = volume;
 259   if (self->priv->volume_idle_id == 0)
 260     self->priv->volume_idle_id = g_idle_add (
 261       empathy_audio_sink_volume_idle_updated, self);
 262
 263 out:
 264   g_static_mutex_unlock (&self->priv->volume_mutex);
 265 }
 266
 267 static gboolean
 268 empathy_audio_sink_volume_idle_setup (gpointer user_data)
 269 {
 270   EmpathyGstAudioSink *self = EMPATHY_GST_AUDIO_SINK (user_data);
 271   gdouble volume;
 272
 273   g_static_mutex_lock (&self->priv->volume_mutex);
 274   self->priv->volume_idle_id = 0;
 275   g_static_mutex_unlock (&self->priv->volume_mutex);
 276
 277   /* We can't do a bidirection bind as the ::notify comes from another
 278    * thread, for other bits of empathy it's most simpler if it comes from
 279    * the main thread */
 280   g_object_bind_property (self, "volume", self->priv->sink, "volume",
 281     G_BINDING_DEFAULT);
 282
 283   /* sync and callback for bouncing */
 284   g_object_get (self->priv->sink, "volume", &volume, NULL);
 285   g_object_set (self, "volume", volume, NULL);
 286   g_signal_connect (self->priv->sink, "notify::volume",
 287     G_CALLBACK (empathy_audio_sink_volume_updated), self);
 288
 289   return FALSE;
 290 }
 291
 292 static GstPad *
 293 empathy_audio_sink_request_new_pad (GstElement *element,
 294   GstPadTemplate *templ,
 295   const gchar* name)
 296 {
 297   EmpathyGstAudioSink *self = EMPATHY_GST_AUDIO_SINK (element);
 298   GstElement *bin, *resample, *audioconvert0, *audioconvert1;
 299   GstPad *pad = NULL;
 300   GstPad *subpad, *filterpad;
 301
 302   bin = gst_bin_new (NULL);
 303
 304   audioconvert0 = gst_element_factory_make ("audioconvert", NULL);
 305   if (audioconvert0 == NULL)
 306     goto error;
 307
 308   gst_bin_add (GST_BIN (bin), audioconvert0);
 309
 310   resample = gst_element_factory_make ("audioresample", NULL);
 311   if (resample == NULL)
 312     goto error;
 313
 314   gst_bin_add (GST_BIN (bin), resample);
 315
 316   audioconvert1 = gst_element_factory_make ("audioconvert", NULL);
 317   if (audioconvert1 == NULL)
 318     goto error;
 319
 320   gst_bin_add (GST_BIN (bin), audioconvert1);
 321
 322   self->priv->sink = create_sink (self);
 323   if (self->priv->sink == NULL)
 324     goto error;
 325
 326   if (GST_IS_STREAM_VOLUME (self->priv->sink))
 327     {
 328       g_static_mutex_lock (&self->priv->volume_mutex);
 329       if (self->priv->volume_idle_id == 0)
 330         self->priv->volume_idle_id = g_idle_add (
 331           empathy_audio_sink_volume_idle_setup, self);
 332       g_static_mutex_unlock (&self->priv->volume_mutex);
 333     }
 334   else
 335     {
 336       gchar *n = gst_element_get_name (self->priv->sink);
 337
 338       DEBUG ("Element %s doesn't support volume", n);
 339       g_free (n);
 340     }
 341
 342   gst_bin_add (GST_BIN (bin), self->priv->sink);
 343
 344   if (!gst_element_link_many (audioconvert0, resample, audioconvert1,
 345       self->priv->sink, NULL))
 346     goto error;
 347
 348   filterpad = gst_element_get_static_pad (audioconvert0, "sink");
 349
 350   if (filterpad == NULL)
 351     goto error;
 352
 353   subpad = gst_ghost_pad_new ("sink", filterpad);
 354   if (!gst_element_add_pad (GST_ELEMENT (bin), subpad))
 355     goto error;
 356
 357   gst_bin_add (GST_BIN (self), bin);
 358
 359   pad = gst_ghost_pad_new (name, subpad);
 360   g_assert (pad != NULL);
 361
 362   if (!gst_element_sync_state_with_parent (bin))
 363     goto error;
 364
 365   if (!gst_pad_set_active (pad, TRUE))
 366     goto error;
 367
 368   if (!gst_element_add_pad (GST_ELEMENT (self), pad))
 369     goto error;
 370
 371   return pad;
 372
 373 error:
 374   if (pad != NULL)
 375     {
 376       gst_object_unref (pad);
 377     }
 378
 379   gst_object_unref (bin);
 380   g_warning ("Failed to create output subpipeline");
 381   return NULL;
 382 }
 383
 384 static void
 385 empathy_audio_sink_release_pad (GstElement *element,
 386   GstPad *pad)
 387 {
 388   gst_pad_set_active (pad, FALSE);
 389   gst_element_remove_pad (element, pad);
 390 }
 391
 392 void
 393 empathy_audio_sink_set_echo_cancel (EmpathyGstAudioSink *sink,
 394   gboolean echo_cancel)
 395 {
 396   DEBUG ("Sink echo cancellation setting: %s", echo_cancel ? "on" : "off");
 397   sink->priv->echo_cancel = echo_cancel;
 398   if (sink->priv->sink != NULL)
 399     empathy_call_set_stream_properties (sink->priv->sink,
 400       sink->priv->echo_cancel);
 401 }