HGKeeper

* Pidgin - Internet Messenger

* Copyright (C) Pidgin Developers <devel@pidgin.im>

* Pidgin is the legal property of its developers, whose names are too numerous

* to list here. Please refer to the COPYRIGHT file distributed with this

* source distribution.

* This program is free software; you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation; either version 2 of the License, or

* (at your option) any later version.

* This program 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 General Public License for more details.

* You should have received a copy of the GNU General Public License

* along with this program; if not, see <https://www.gnu.org/licenses/>.

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <math.h>

#include <glib/gi18n-lib.h>

#include <purple.h>

#include <adwaita.h>

#include "pidginvvprefs.h"

#include "pidgincore.h"

#include "pidginprefsinternal.h"

struct _PidginVVPrefs {

AdwPreferencesPage parent;

struct {

PidginPrefCombo input;

PidginPrefCombo output;

GtkWidget *threshold_row;

GtkWidget *threshold;

GtkWidget *volume;

GtkWidget *test;

GtkWidget *level;

GtkWidget *drop;

GstElement *pipeline;

} voice;

struct {

PidginPrefCombo input;

PidginPrefCombo output;

GtkWidget *frame;

GtkWidget *test;

GstElement *pipeline;

} video;

};

G_DEFINE_TYPE(PidginVVPrefs, pidgin_vv_prefs, ADW_TYPE_PREFERENCES_PAGE)

/* Keep in sync with voice.level's GtkLevelBar::max-value in the

* pidgin/resources/Prefs.vv.ui builder file. */

#define MAX_AUDIO_LEVEL (19.0)

/******************************************************************************

* Helpers

*****************************************************************************/

static void

populate_vv_device_menuitems(PurpleMediaElementType type, GtkListStore *store)

{

PurpleMediaManager *manager = NULL;

GList *devices;

gtk_list_store_clear(store);

manager = purple_media_manager_get();

devices = purple_media_manager_enumerate_elements(manager, type);

for (; devices; devices = g_list_delete_link(devices, devices)) {

PurpleMediaElementInfo *info = devices->data;

GtkTreeIter iter;

char *name, *id;

name = purple_media_element_info_get_name(info);

id = purple_media_element_info_get_id(info);

gtk_list_store_append(store, &iter);

gtk_list_store_set(store, &iter, PIDGIN_PREF_COMBO_TEXT, name,

PIDGIN_PREF_COMBO_VALUE, id, -1);

g_free(name);

g_free(id);

g_object_unref(info);

}

static GstElement *

create_test_element(PurpleMediaElementType type)

{

PurpleMediaElementInfo *element_info;

element_info = purple_media_manager_get_active_element(purple_media_manager_get(), type);

g_return_val_if_fail(element_info, NULL);

return purple_media_element_info_call_create(element_info,

NULL, NULL, NULL);

}

static GstElement *

create_voice_pipeline(PidginVVPrefs *prefs)

{

GstElement *pipeline;

GstElement *src, *sink;

GstElement *volume;

GstElement *level;

GstElement *valve;

pipeline = gst_pipeline_new("voicetest");

src = create_test_element(PURPLE_MEDIA_ELEMENT_AUDIO | PURPLE_MEDIA_ELEMENT_SRC);

sink = create_test_element(PURPLE_MEDIA_ELEMENT_AUDIO | PURPLE_MEDIA_ELEMENT_SINK);

volume = gst_element_factory_make("volume", "volume");

level = gst_element_factory_make("level", "level");

valve = gst_element_factory_make("valve", "valve");

g_object_set(volume, "volume",

gtk_scale_button_get_value(GTK_SCALE_BUTTON(prefs->voice.volume)) / 100.0,

NULL);

gst_bin_add_many(GST_BIN(pipeline), src, volume, level, valve, sink, NULL);

gst_element_link_many(src, volume, level, valve, sink, NULL);

purple_debug_info("gtkprefs", "create_voice_pipeline: setting pipeline "

"state to GST_STATE_PLAYING - it may hang here on win32\n");

gst_element_set_state(GST_ELEMENT(pipeline), GST_STATE_PLAYING);

purple_debug_info("gtkprefs", "create_voice_pipeline: state is set\n");

return pipeline;

}

static void

on_volume_change_cb(GtkWidget *w, G_GNUC_UNUSED gdouble value, gpointer data)

{

PidginVVPrefs *prefs = PIDGIN_VV_PREFS(data);

GstElement *volume;

if (!prefs->voice.pipeline) {

return;

}

volume = gst_bin_get_by_name(GST_BIN(prefs->voice.pipeline), "volume");

g_object_set(volume, "volume",

gtk_scale_button_get_value(GTK_SCALE_BUTTON(w)) / 100.0, NULL);

}

static gdouble

gst_msg_db_to_percent(GstMessage *msg, gchar *value_name)

{

const GValue *list;

const GValue *value;

gdouble value_db;

gdouble percent;

list = gst_structure_get_value(gst_message_get_structure(msg), value_name);

G_GNUC_BEGIN_IGNORE_DEPRECATIONS

value = g_value_array_get_nth(g_value_get_boxed(list), 0);

G_GNUC_END_IGNORE_DEPRECATIONS

value_db = g_value_get_double(value);

percent = pow(10, value_db / 20);

return (percent > 1.0) ? 1.0 : percent;

}

static gboolean

gst_bus_cb(G_GNUC_UNUSED GstBus *bus, GstMessage *msg, gpointer data)

{

PidginVVPrefs *prefs = PIDGIN_VV_PREFS(data);

if (GST_MESSAGE_TYPE(msg) == GST_MESSAGE_ELEMENT &&

gst_structure_has_name(gst_message_get_structure(msg), "level")) {

GstElement *src = GST_ELEMENT(GST_MESSAGE_SRC(msg));

gchar *name = gst_element_get_name(src);

if (purple_strequal(name, "level")) {

gdouble percent;

gdouble threshold;

gboolean drop;

GstElement *valve;

percent = gst_msg_db_to_percent(msg, "rms");

gtk_level_bar_set_value(GTK_LEVEL_BAR(prefs->voice.level),

percent * MAX_AUDIO_LEVEL);

percent = gst_msg_db_to_percent(msg, "decay");

threshold = gtk_range_get_value(GTK_RANGE(

prefs->voice.threshold)) /

100.0;

drop = percent < threshold;

valve = gst_bin_get_by_name(GST_BIN(GST_ELEMENT_PARENT(src)), "valve");

g_object_set(valve, "drop", drop, NULL);

gtk_label_set_text(GTK_LABEL(prefs->voice.drop),

drop ? _("DROP") : "");

}

g_free(name);

}

return TRUE;

}

static void

voice_test_destroy_cb(G_GNUC_UNUSED GtkWidget *w, gpointer data)

{

PidginVVPrefs *prefs = PIDGIN_VV_PREFS(data);

if (!prefs->voice.pipeline) {

return;

}

gst_element_set_state(prefs->voice.pipeline, GST_STATE_NULL);

g_clear_pointer(&prefs->voice.pipeline, gst_object_unref);

}

static void

enable_voice_test(PidginVVPrefs *prefs)

{

GstBus *bus;

prefs->voice.pipeline = create_voice_pipeline(prefs);

bus = gst_pipeline_get_bus(GST_PIPELINE(prefs->voice.pipeline));

gst_bus_add_signal_watch(bus);

g_signal_connect(bus, "message", G_CALLBACK(gst_bus_cb), prefs);

gst_object_unref(bus);

}

static void

toggle_voice_test_cb(GtkToggleButton *test, gpointer data)

{

PidginVVPrefs *prefs = PIDGIN_VV_PREFS(data);

if (gtk_toggle_button_get_active(test)) {

enable_voice_test(prefs);

g_signal_connect(prefs->voice.volume, "value-changed",

G_CALLBACK(on_volume_change_cb), prefs);

g_signal_connect(test, "destroy",

G_CALLBACK(voice_test_destroy_cb), prefs);

} else {

gtk_level_bar_set_value(GTK_LEVEL_BAR(prefs->voice.level), 0.0);

gtk_label_set_text(GTK_LABEL(prefs->voice.drop), "");

g_object_disconnect(prefs->voice.volume,

"any-signal::value-changed",

G_CALLBACK(on_volume_change_cb), prefs, NULL);

g_object_disconnect(test, "any-signal::destroy",

G_CALLBACK(voice_test_destroy_cb), prefs,

NULL);

voice_test_destroy_cb(NULL, prefs);

}

static void

volume_changed_cb(G_GNUC_UNUSED GtkScaleButton *button, gdouble value,

G_GNUC_UNUSED gpointer data)

{

purple_prefs_set_int("/purple/media/audio/volume/input", value * 100);

}

static void

threshold_value_changed_cb(GtkScale *scale, gpointer data)

{

PidginVVPrefs *prefs = data;

int value;

char *tmp;

value = (int)gtk_range_get_value(GTK_RANGE(scale));

tmp = g_strdup_printf(_("Silence threshold: %d%%"), value);

adw_preferences_row_set_title(ADW_PREFERENCES_ROW(prefs->voice.threshold_row),

tmp);

g_free(tmp);

gtk_level_bar_add_offset_value(GTK_LEVEL_BAR(prefs->voice.level),

GTK_LEVEL_BAR_OFFSET_LOW,

value / 100.0 * MAX_AUDIO_LEVEL);

purple_prefs_set_int("/purple/media/audio/silence_threshold", value);

}

static void

bind_voice_test(PidginVVPrefs *prefs)

{

char *tmp;

gtk_scale_button_set_value(GTK_SCALE_BUTTON(prefs->voice.volume),

purple_prefs_get_int("/purple/media/audio/volume/input") / 100.0);

tmp = g_strdup_printf(_("Silence threshold: %d%%"),

purple_prefs_get_int("/purple/media/audio/silence_threshold"));

adw_preferences_row_set_title(ADW_PREFERENCES_ROW(prefs->voice.threshold_row),

tmp);

g_free(tmp);

/* Move the default high levels to the end (low is set by

* threshold_value_changed_cb when set below.) */

gtk_level_bar_add_offset_value(GTK_LEVEL_BAR(prefs->voice.level),

GTK_LEVEL_BAR_OFFSET_HIGH,

MAX_AUDIO_LEVEL);

gtk_level_bar_add_offset_value(GTK_LEVEL_BAR(prefs->voice.level),

GTK_LEVEL_BAR_OFFSET_FULL,

MAX_AUDIO_LEVEL);

gtk_range_set_value(GTK_RANGE(prefs->voice.threshold),

purple_prefs_get_int("/purple/media/audio/silence_threshold"));

}

static GstElement *

create_video_pipeline(void)

{

GstElement *pipeline;

GstElement *src, *sink;

GstElement *videoconvert;

GstElement *videoscale;

pipeline = gst_pipeline_new("videotest");

src = create_test_element(PURPLE_MEDIA_ELEMENT_VIDEO | PURPLE_MEDIA_ELEMENT_SRC);

sink = create_test_element(PURPLE_MEDIA_ELEMENT_VIDEO | PURPLE_MEDIA_ELEMENT_SINK);

videoconvert = gst_element_factory_make("videoconvert", NULL);

videoscale = gst_element_factory_make("videoscale", NULL);

g_object_set_data(G_OBJECT(pipeline), "sink", sink);

gst_bin_add_many(GST_BIN(pipeline), src, videoconvert, videoscale, sink,

NULL);

gst_element_link_many(src, videoconvert, videoscale, sink, NULL);

return pipeline;

}

static void

video_test_destroy_cb(G_GNUC_UNUSED GtkWidget *w, gpointer data)

{

PidginVVPrefs *prefs = PIDGIN_VV_PREFS(data);

if (!prefs->video.pipeline) {

return;

}

gst_element_set_state(prefs->video.pipeline, GST_STATE_NULL);

g_clear_pointer(&prefs->video.pipeline, gst_object_unref);

}

static void

enable_video_test(PidginVVPrefs *prefs)

{

GtkWidget *video = NULL;

GstElement *sink = NULL;

prefs->video.pipeline = create_video_pipeline();

sink = g_object_get_data(G_OBJECT(prefs->video.pipeline), "sink");

g_object_get(sink, "widget", &video, NULL);

gtk_widget_show(video);

gtk_widget_set_size_request(prefs->video.frame, 400, 300);

gtk_aspect_frame_set_child(GTK_ASPECT_FRAME(prefs->video.frame), video);

gst_element_set_state(GST_ELEMENT(prefs->video.pipeline),

GST_STATE_PLAYING);

g_object_unref(video);

}

static void

toggle_video_test_cb(GtkToggleButton *test, gpointer data)

{

PidginVVPrefs *prefs = PIDGIN_VV_PREFS(data);

if (gtk_toggle_button_get_active(test)) {

enable_video_test(prefs);

g_signal_connect(test, "destroy",

G_CALLBACK(video_test_destroy_cb), prefs);

} else {

g_object_disconnect(test, "any-signal::destroy",

G_CALLBACK(video_test_destroy_cb), prefs,

NULL);

video_test_destroy_cb(NULL, prefs);

}

static void

vv_device_changed_cb(const gchar *name, G_GNUC_UNUSED PurplePrefType type,

gconstpointer value, gpointer data)

{

PidginVVPrefs *prefs = PIDGIN_VV_PREFS(data);

PurpleMediaManager *manager;

PurpleMediaElementInfo *info;

manager = purple_media_manager_get();

info = purple_media_manager_get_element_info(manager, value);

purple_media_manager_set_active_element(manager, info);

/* Refresh test viewers */

if (strstr(name, "audio") && prefs->voice.pipeline) {

voice_test_destroy_cb(NULL, prefs);

enable_voice_test(prefs);

} else if (strstr(name, "video") && prefs->video.pipeline) {

video_test_destroy_cb(NULL, prefs);

enable_video_test(prefs);

}

static const char *

purple_media_type_to_preference_key(PurpleMediaElementType type)

{

if (type & PURPLE_MEDIA_ELEMENT_AUDIO) {

if (type & PURPLE_MEDIA_ELEMENT_SRC) {

return PIDGIN_PREFS_ROOT "/vvconfig/audio/src/device";

} else if (type & PURPLE_MEDIA_ELEMENT_SINK) {

return PIDGIN_PREFS_ROOT "/vvconfig/audio/sink/device";

}

} else if (type & PURPLE_MEDIA_ELEMENT_VIDEO) {

if (type & PURPLE_MEDIA_ELEMENT_SRC) {

return PIDGIN_PREFS_ROOT "/vvconfig/video/src/device";

} else if (type & PURPLE_MEDIA_ELEMENT_SINK) {

return PIDGIN_PREFS_ROOT "/vvconfig/video/sink/device";

}

return NULL;

}

static void

bind_vv_dropdown(PidginPrefCombo *combo, PurpleMediaElementType element_type)

{

const gchar *preference_key;

GtkTreeModel *model;

preference_key = purple_media_type_to_preference_key(element_type);

model = gtk_combo_box_get_model(GTK_COMBO_BOX(combo->combo));

populate_vv_device_menuitems(element_type, GTK_LIST_STORE(model));

combo->type = PURPLE_PREF_STRING;

combo->key = preference_key;

pidgin_prefs_bind_dropdown(combo);

}

static void

bind_vv_frame(PidginVVPrefs *prefs, PidginPrefCombo *combo,

PurpleMediaElementType type)

{

bind_vv_dropdown(combo, type);

purple_prefs_connect_callback(combo->combo,

purple_media_type_to_preference_key(type),

vv_device_changed_cb, prefs);

g_signal_connect_swapped(combo->combo, "destroy",

G_CALLBACK(purple_prefs_disconnect_by_handle),

combo->combo);

g_object_set_data(G_OBJECT(combo->combo), "vv_media_type",

(gpointer)type);

g_object_set_data(G_OBJECT(combo->combo), "vv_combo", combo);

}

static void

device_list_changed_cb(G_GNUC_UNUSED PurpleMediaManager *manager,

GtkWidget *widget)

{

PidginPrefCombo *combo;

PurpleMediaElementType media_type;

const gchar *preference_key;

guint signal_id;

GtkTreeModel *model;

combo = g_object_get_data(G_OBJECT(widget), "vv_combo");

media_type = (PurpleMediaElementType)GPOINTER_TO_INT(g_object_get_data(

G_OBJECT(widget),

"vv_media_type"));

preference_key = purple_media_type_to_preference_key(media_type);

/* Block signals so pref doesn't get re-saved while changing UI. */

signal_id = g_signal_lookup("changed", GTK_TYPE_COMBO_BOX);

g_signal_handlers_block_matched(combo->combo, G_SIGNAL_MATCH_ID, signal_id,

0, NULL, NULL, NULL);

model = gtk_combo_box_get_model(GTK_COMBO_BOX(combo->combo));

populate_vv_device_menuitems(media_type, GTK_LIST_STORE(model));

gtk_combo_box_set_active_id(GTK_COMBO_BOX(combo->combo),

purple_prefs_get_string(preference_key));

g_signal_handlers_unblock_matched(combo->combo, G_SIGNAL_MATCH_ID,

signal_id, 0, NULL, NULL, NULL);

}

/******************************************************************************

* GObject Implementation

*****************************************************************************/

static void

pidgin_vv_prefs_class_init(PidginVVPrefsClass *klass)

{

GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(klass);

gtk_widget_class_set_template_from_resource(

widget_class,

"/im/pidgin/Pidgin3/Prefs/vv.ui"

);

gtk_widget_class_bind_template_child(widget_class, PidginVVPrefs,

voice.input.combo);

gtk_widget_class_bind_template_child(widget_class, PidginVVPrefs,

voice.output.combo);

gtk_widget_class_bind_template_child(widget_class, PidginVVPrefs,

voice.volume);

gtk_widget_class_bind_template_child(widget_class, PidginVVPrefs,

voice.threshold_row);

gtk_widget_class_bind_template_child(widget_class, PidginVVPrefs,

voice.threshold);

gtk_widget_class_bind_template_child(widget_class, PidginVVPrefs,

voice.level);

gtk_widget_class_bind_template_child(widget_class, PidginVVPrefs,

voice.drop);

gtk_widget_class_bind_template_child(widget_class, PidginVVPrefs,

voice.test);

gtk_widget_class_bind_template_callback(widget_class, volume_changed_cb);

gtk_widget_class_bind_template_callback(widget_class,

threshold_value_changed_cb);

gtk_widget_class_bind_template_callback(widget_class,

toggle_voice_test_cb);

gtk_widget_class_bind_template_child(widget_class, PidginVVPrefs,

video.input.combo);

gtk_widget_class_bind_template_child(widget_class, PidginVVPrefs,

video.output.combo);

gtk_widget_class_bind_template_child(widget_class, PidginVVPrefs,

video.frame);

gtk_widget_class_bind_template_child(widget_class, PidginVVPrefs,

video.test);

gtk_widget_class_bind_template_callback(widget_class,

toggle_video_test_cb);

}

static void

pidgin_vv_prefs_init(PidginVVPrefs *prefs)

{

PurpleMediaManager *manager = NULL;

gtk_widget_init_template(GTK_WIDGET(prefs));

manager = purple_media_manager_get();

bind_vv_frame(prefs, &prefs->voice.input,

PURPLE_MEDIA_ELEMENT_AUDIO | PURPLE_MEDIA_ELEMENT_SRC);

g_signal_connect_object(manager, "elements-changed::audiosrc",

G_CALLBACK(device_list_changed_cb),

prefs->voice.input.combo, 0);

bind_vv_frame(prefs, &prefs->voice.output,

PURPLE_MEDIA_ELEMENT_AUDIO | PURPLE_MEDIA_ELEMENT_SINK);

g_signal_connect_object(manager, "elements-changed::audiosink",

G_CALLBACK(device_list_changed_cb),

prefs->voice.output.combo, 0);

bind_voice_test(prefs);

bind_vv_frame(prefs, &prefs->video.input,

PURPLE_MEDIA_ELEMENT_VIDEO | PURPLE_MEDIA_ELEMENT_SRC);

g_signal_connect_object(manager, "elements-changed::videosrc",

G_CALLBACK(device_list_changed_cb),

prefs->video.input.combo, 0);

bind_vv_frame(prefs, &prefs->video.output,

PURPLE_MEDIA_ELEMENT_VIDEO | PURPLE_MEDIA_ELEMENT_SINK);

g_signal_connect_object(manager, "elements-changed::videosink",

G_CALLBACK(device_list_changed_cb),

prefs->video.output.combo, 0);

}

/******************************************************************************

* API

*****************************************************************************/

GtkWidget *

pidgin_vv_prefs_new(void) {

return GTK_WIDGET(g_object_new(PIDGIN_TYPE_VV_PREFS, NULL));

}

void

pidgin_vv_prefs_disable_test_pipelines(PidginVVPrefs *prefs) {

g_return_if_fail(PIDGIN_IS_VV_PREFS(prefs));

gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(prefs->voice.test), FALSE);

gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(prefs->video.test), FALSE);

}

pidgin/pidgin