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 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_set_property (GObject *object,
guint property_id, const GValue *value, GParamSpec *pspec)
{
switch (property_id)
{
case PROP_VOLUME:
empathy_audio_src_set_hw_volume (EMPATHY_GST_AUDIO_SRC (object),
g_value_get_double (value));
break;
case PROP_MUTE:
empathy_audio_set_hw_mute (EMPATHY_GST_AUDIO_SRC (object),
g_value_get_boolean (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
}
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 gboolean
empathy_audio_src_volume_changed (GObject *object,
GParamSpec *pspec,
gpointer user_data)
{
EmpathyGstAudioSrc *self = EMPATHY_GST_AUDIO_SRC (user_data);
g_mutex_lock (&self->priv->lock);
if (self->priv->volume_idle_id == 0)
self->priv->volume_idle_id = g_idle_add (
empathy_audio_src_volume_changed_idle, self);
g_mutex_unlock (&self->priv->lock);
return FALSE;
}
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_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_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);
}
}
static void
empathy_mic_menu_change_mic_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
EmpathyGstAudioSrc *audio = EMPATHY_GST_AUDIO_SRC (source_object);
EmpathyMicMenu *self = user_data;
GError *error = NULL;
if (!empathy_audio_src_change_microphone_finish (audio, result, &error))
{
DEBUG ("Failed to change microphone: %s", error->message);
g_clear_error (&error);
/* We call update here because if this change operation failed
* and we don't update the menu items, it'll point to the wrong
* device. We don't want to call it if the change was successful
* because we'll get the notify::microphone signal fired in a
* bit and the current value hasn't changed so it'd keep jumping
* between these values like there's no tomorrow, etc. */
empathy_mic_menu_update (self);
}
}
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);
}
