guint
empathy_audio_src_get_microphone (EmpathyGstAudioSrc *src)
{
EmpathyGstAudioSrcPrivate *priv = EMPATHY_GST_AUDIO_SRC_GET_PRIVATE (src);
return priv->source_idx;
}
static void
empathy_audio_src_get_property (GObject *object,
guint property_id, GValue *value, GParamSpec *pspec)
{
EmpathyGstAudioSrc *self = EMPATHY_GST_AUDIO_SRC (object);
EmpathyGstAudioSrcPrivate *priv = EMPATHY_GST_AUDIO_SRC_GET_PRIVATE (self);
switch (property_id)
{
case PROP_VOLUME:
g_value_set_double (value,
empathy_audio_src_get_volume (self));
break;
case PROP_PEAK_LEVEL:
g_mutex_lock (priv->lock);
g_value_set_double (value, priv->peak_level);
g_mutex_unlock (priv->lock);
break;
case PROP_RMS_LEVEL:
g_mutex_lock (priv->lock);
g_value_set_double (value, priv->rms_level);
g_mutex_unlock (priv->lock);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
}
static void
empathy_audio_src_get_current_mic_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
EmpathyMicMonitor *monitor = EMPATHY_MIC_MONITOR (source_object);
EmpathyGstAudioSrc *self = user_data;
EmpathyGstAudioSrcPrivate *priv = EMPATHY_GST_AUDIO_SRC_GET_PRIVATE (self);
guint source_idx;
GError *error = NULL;
source_idx = empathy_mic_monitor_get_current_mic_finish (monitor, result, &error);
if (error != NULL)
{
DEBUG ("Failed to get current mic: %s", error->message);
g_clear_error (&error);
return;
}
if (priv->source_idx == source_idx)
return;
priv->source_idx = source_idx;
g_object_notify (G_OBJECT (self), "microphone");
}
static gboolean
empathy_audio_src_volume_changed_idle (gpointer user_data)
{
EmpathyGstAudioSrc *self = EMPATHY_GST_AUDIO_SRC (user_data);
EmpathyGstAudioSrcPrivate *priv = EMPATHY_GST_AUDIO_SRC_GET_PRIVATE (self);
gdouble volume;
gboolean mute;
g_mutex_lock (&priv->lock);
priv->volume_idle_id = 0;
g_mutex_unlock (&priv->lock);
volume = empathy_audio_src_get_hw_volume (self);
if (volume != priv->volume)
{
priv->volume = volume;
g_object_notify (G_OBJECT (self), "volume");
}
mute = empathy_audio_src_get_hw_mute (self);
if (mute != priv->mute)
{
priv->mute = mute;
/* hw mute changed, follow with own volume */
g_object_set (self->priv->volume_element, "mute", mute, NULL);
g_object_notify (G_OBJECT (self), "mute");
}
return FALSE;
}
static void
empathy_audio_src_init (EmpathyGstAudioSrc *obj)
{
EmpathyGstAudioSrcPrivate *priv = EMPATHY_GST_AUDIO_SRC_GET_PRIVATE (obj);
GstPad *ghost, *src;
priv->peak_level = -G_MAXDOUBLE;
priv->lock = g_mutex_new ();
priv->notifier = fs_element_added_notifier_new ();
g_signal_connect (priv->notifier, "element-added",
G_CALLBACK (empathy_audio_src_element_added_cb), obj);
priv->src = gst_element_factory_make ("gconfaudiosrc", NULL);
gst_bin_add (GST_BIN (obj), priv->src);
fs_element_added_notifier_add (priv->notifier, GST_BIN (priv->src));
priv->volume = gst_element_factory_make ("volume", NULL);
g_object_ref (priv->volume);
gst_bin_add (GST_BIN (obj), priv->volume);
gst_element_link (priv->src, priv->volume);
priv->level = gst_element_factory_make ("level", NULL);
gst_bin_add (GST_BIN (obj), priv->level);
gst_element_link (priv->volume, priv->level);
src = gst_element_get_static_pad (priv->level, "src");
ghost = gst_ghost_pad_new ("src", src);
gst_element_add_pad (GST_ELEMENT (obj), ghost);
gst_object_unref (G_OBJECT (src));
}
gdouble
empathy_audio_src_get_volume (EmpathyGstAudioSrc *src)
{
EmpathyGstAudioSrcPrivate *priv = EMPATHY_GST_AUDIO_SRC_GET_PRIVATE (src);
gdouble volume;
g_object_get (G_OBJECT (priv->volume), "volume", &volume, NULL);
return volume;
}
gboolean
empathy_audio_src_supports_changing_mic (EmpathyGstAudioSrc *self)
{
EmpathyGstAudioSrcPrivate *priv = EMPATHY_GST_AUDIO_SRC_GET_PRIVATE (self);
GObjectClass *object_class;
object_class = G_OBJECT_GET_CLASS (priv->src);
return (g_object_class_find_property (object_class,
"source-output-index") != NULL);
}
void
empathy_audio_src_finalize (GObject *object)
{
EmpathyGstAudioSrc *self = EMPATHY_GST_AUDIO_SRC (object);
EmpathyGstAudioSrcPrivate *priv = EMPATHY_GST_AUDIO_SRC_GET_PRIVATE (self);
/* free any data held directly by the object here */
g_mutex_free (priv->lock);
G_OBJECT_CLASS (empathy_audio_src_parent_class)->finalize (object);
}
static guint
empathy_audio_src_get_mic_index (EmpathyGstAudioSrc *self)
{
EmpathyGstAudioSrcPrivate *priv = EMPATHY_GST_AUDIO_SRC_GET_PRIVATE (self);
guint audio_src_idx = PA_INVALID_INDEX;
if (empathy_audio_src_supports_changing_mic (self))
g_object_get (priv->src,
"source-output-index", &audio_src_idx,
NULL);
return audio_src_idx;
}
static gboolean
empathy_audio_src_levels_updated (gpointer user_data)
{
EmpathyGstAudioSrc *self = EMPATHY_GST_AUDIO_SRC (user_data);
EmpathyGstAudioSrcPrivate *priv = EMPATHY_GST_AUDIO_SRC_GET_PRIVATE (self);
g_mutex_lock (priv->lock);
g_signal_emit (self, signals[PEAK_LEVEL_CHANGED], 0, priv->peak_level);
g_signal_emit (self, signals[RMS_LEVEL_CHANGED], 0, priv->rms_level);
priv->idle_id = 0;
g_mutex_unlock (priv->lock);
return FALSE;
}
void
empathy_audio_src_set_volume (EmpathyGstAudioSrc *src, gdouble volume)
{
EmpathyGstAudioSrcPrivate *priv = EMPATHY_GST_AUDIO_SRC_GET_PRIVATE (src);
GParamSpec *pspec;
GParamSpecDouble *pspec_double;
pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (priv->volume),
"volume");
g_assert (pspec != NULL);
pspec_double = G_PARAM_SPEC_DOUBLE (pspec);
volume = CLAMP (volume, pspec_double->minimum, pspec_double->maximum);
g_object_set (G_OBJECT (priv->volume), "volume", volume, NULL);
}
static void
empathy_audio_src_element_added_cb (FsElementAddedNotifier *notifier,
GstBin *bin, GstElement *element, EmpathyGstAudioSrc *self)
{
EmpathyGstAudioSrcPrivate *priv = EMPATHY_GST_AUDIO_SRC_GET_PRIVATE (self);
if (g_object_class_find_property (G_OBJECT_GET_CLASS (element), "volume"))
{
gdouble volume;
volume = empathy_audio_src_get_volume (self);
empathy_audio_src_set_volume (self, 1.0);
if (priv->volume != NULL)
g_object_unref (priv->volume);
priv->volume = g_object_ref (element);
if (volume != 1.0)
empathy_audio_src_set_volume (self, volume);
}
}
void
empathy_audio_src_dispose (GObject *object)
{
EmpathyGstAudioSrc *self = EMPATHY_GST_AUDIO_SRC (object);
EmpathyGstAudioSrcPrivate *priv = EMPATHY_GST_AUDIO_SRC_GET_PRIVATE (self);
if (priv->dispose_has_run)
return;
priv->dispose_has_run = TRUE;
if (priv->idle_id != 0)
g_source_remove (priv->idle_id);
priv->idle_id = 0;
/* release any references held by the object here */
if (G_OBJECT_CLASS (empathy_audio_src_parent_class)->dispose)
G_OBJECT_CLASS (empathy_audio_src_parent_class)->dispose (object);
}
static void
empathy_audio_src_microphone_changed_cb (EmpathyMicMonitor *monitor,
guint source_output_idx,
guint source_idx,
gpointer user_data)
{
EmpathyGstAudioSrc *self = user_data;
EmpathyGstAudioSrcPrivate *priv = EMPATHY_GST_AUDIO_SRC_GET_PRIVATE (self);
guint audio_src_idx;
audio_src_idx = empathy_audio_src_get_mic_index (self);
if (source_output_idx == PA_INVALID_INDEX
|| source_output_idx != audio_src_idx)
return;
if (priv->source_idx == source_idx)
return;
priv->source_idx = source_idx;
g_object_notify (G_OBJECT (self), "microphone");
}
static void
empathy_audio_src_source_output_index_notify (GObject *object,
GParamSpec *pspec,
EmpathyGstAudioSrc *self)
{
EmpathyGstAudioSrcPrivate *priv = EMPATHY_GST_AUDIO_SRC_GET_PRIVATE (self);
guint source_output_idx;
source_output_idx = empathy_audio_src_get_mic_index (self);
if (source_output_idx == PA_INVALID_INDEX)
return;
if (priv->source_output_idx == source_output_idx)
return;
/* It's actually changed. */
priv->source_output_idx = source_output_idx;
empathy_mic_monitor_get_current_mic_async (priv->mic_monitor,
source_output_idx, empathy_audio_src_get_current_mic_cb, self);
}
static void
empathy_audio_src_get_property (GObject *object,
guint property_id, GValue *value, GParamSpec *pspec)
{
EmpathyGstAudioSrc *self = EMPATHY_GST_AUDIO_SRC (object);
EmpathyGstAudioSrcPrivate *priv = EMPATHY_GST_AUDIO_SRC_GET_PRIVATE (self);
switch (property_id)
{
case PROP_VOLUME:
g_value_set_double (value, priv->volume);
break;
case PROP_MUTE:
g_value_set_boolean (value, priv->mute);
break;
case PROP_MICROPHONE:
g_value_set_uint (value, priv->source_idx);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
}
void
empathy_audio_src_change_microphone_async (EmpathyGstAudioSrc *src,
guint microphone,
GAsyncReadyCallback callback,
gpointer user_data)
{
EmpathyGstAudioSrcPrivate *priv = EMPATHY_GST_AUDIO_SRC_GET_PRIVATE (src);
guint source_output_idx;
GSimpleAsyncResult *simple;
simple = g_simple_async_result_new (G_OBJECT (src), callback, user_data,
empathy_audio_src_change_microphone_async);
if (!empathy_audio_src_supports_changing_mic (src))
{
g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_FAILED,
"pulsesrc is not new enough to support changing microphone");
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
return;
}
source_output_idx = empathy_audio_src_get_mic_index (src);
if (source_output_idx == PA_INVALID_INDEX)
{
g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_FAILED,
"pulsesrc is not yet PLAYING");
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
return;
}
empathy_mic_monitor_change_microphone_async (priv->mic_monitor,
source_output_idx, microphone, empathy_audio_src_change_microphone_cb,
simple);
}
static void
empathy_audio_src_handle_message (GstBin *bin, GstMessage *message)
{
EmpathyGstAudioSrc *self = EMPATHY_GST_AUDIO_SRC (bin);
EmpathyGstAudioSrcPrivate *priv = EMPATHY_GST_AUDIO_SRC_GET_PRIVATE (self);
if (GST_MESSAGE_TYPE (message) == GST_MESSAGE_ELEMENT &&
GST_MESSAGE_SRC (message) == GST_OBJECT (priv->level))
{
const GstStructure *s;
const gchar *name;
const GValue *list;
guint i, len;
gdouble peak = -G_MAXDOUBLE;
gdouble rms = -G_MAXDOUBLE;
s = gst_message_get_structure (message);
name = gst_structure_get_name (s);
if (g_strcmp0 ("level", name) != 0)
goto out;
list = gst_structure_get_value (s, "peak");
len = gst_value_list_get_size (list);
for (i =0 ; i < len; i++)
{
const GValue *value;
gdouble db;
value = gst_value_list_get_value (list, i);
db = g_value_get_double (value);
peak = MAX (db, peak);
}
list = gst_structure_get_value (s, "rms");
len = gst_value_list_get_size (list);
for (i =0 ; i < len; i++)
{
const GValue *value;
gdouble db;
value = gst_value_list_get_value (list, i);
db = g_value_get_double (value);
rms = MAX (db, rms);
}
g_mutex_lock (priv->lock);
priv->peak_level = peak;
priv->rms_level = rms;
if (priv->idle_id == 0)
priv->idle_id = g_idle_add (empathy_audio_src_levels_updated, self);
g_mutex_unlock (priv->lock);
}
out:
GST_BIN_CLASS (empathy_audio_src_parent_class)->handle_message (bin,
message);
}
static void
empathy_audio_src_init (EmpathyGstAudioSrc *obj)
{
EmpathyGstAudioSrcPrivate *priv = EMPATHY_GST_AUDIO_SRC_GET_PRIVATE (obj);
GstPad *ghost, *src;
obj->priv = priv;
g_mutex_init (&priv->lock);
priv->volume = 1.0;
priv->src = create_src ();
if (priv->src == NULL)
return;
if (GST_IS_STREAM_VOLUME (priv->src))
{
gdouble volume;
gboolean mute;
priv->have_stream_volume = TRUE;
/* We can't do a bidirection bind as the ::notify comes from another
* thread, for other bits of empathy it's most simpler if it comes from
* the main thread */
g_object_bind_property (obj, "volume", priv->src, "volume",
G_BINDING_DEFAULT);
g_object_bind_property (obj, "mute", priv->src, "mute",
G_BINDING_DEFAULT);
/* sync and callback for bouncing */
g_object_get (priv->src, "volume", &volume, NULL);
g_object_set (obj, "volume", volume, NULL);
g_object_get (priv->src, "mute", &mute, NULL);
g_object_set (obj, "mute", mute, NULL);
g_signal_connect (priv->src, "notify::volume",
G_CALLBACK (empathy_audio_src_volume_changed), obj);
g_signal_connect (priv->src, "notify::mute",
G_CALLBACK (empathy_audio_src_volume_changed), obj);
}
else
{
g_message ("No stream volume available :(, mute will work though");
priv->have_stream_volume = FALSE;
}
gst_bin_add (GST_BIN (obj), priv->src);
priv->volume_element = gst_element_factory_make ("volume", NULL);
gst_bin_add (GST_BIN (obj), priv->volume_element);
{
GstElement *capsfilter;
GstCaps *caps;
/* Explicitly state what format we want from pulsesrc. This pushes resampling
* and format conversion as early as possible, lowering the amount of data
* transferred and thus improving performance. When moving to GStreamer
* 0.11/1.0, this should change so that we actually request what the encoder
* wants downstream. */
caps = gst_caps_new_simple ("audio/x-raw-int",
"channels", G_TYPE_INT, 1,
"width", G_TYPE_INT, 16,
"depth", G_TYPE_INT, 16,
"rate", G_TYPE_INT, 32000,
NULL);
capsfilter = gst_element_factory_make ("capsfilter", NULL);
g_object_set (G_OBJECT (capsfilter), "caps", caps, NULL);
gst_bin_add (GST_BIN (obj), capsfilter);
gst_element_link (priv->src, capsfilter);
gst_element_link (capsfilter, priv->volume_element);
}
src = gst_element_get_static_pad (priv->volume_element, "src");
ghost = gst_ghost_pad_new ("src", src);
gst_element_add_pad (GST_ELEMENT (obj), ghost);
gst_object_unref (G_OBJECT (src));
/* Listen to changes to GstPulseSrc:source-output-index so we know when
* it's no longer PA_INVALID_INDEX (starting for the first time) or if it
* changes (READY->NULL->READY...) */
g_signal_connect (priv->src, "notify::source-output-index",
G_CALLBACK (empathy_audio_src_source_output_index_notify),
obj);
priv->mic_monitor = empathy_mic_monitor_new ();
g_signal_connect (priv->mic_monitor, "microphone-changed",
G_CALLBACK (empathy_audio_src_microphone_changed_cb), obj);
priv->source_idx = PA_INVALID_INDEX;
}
