#include <stdlib.h>
#include <telepathy-glib/util.h>
+#include <telepathy-glib/interfaces.h>
#include <telepathy-farsight/channel.h>
#include <telepathy-farsight/stream.h>
-#include <gst/farsight/fs-element-added-notifier.h>
-
#include "empathy-call-handler.h"
#include "empathy-dispatcher.h"
#include "empathy-marshal.h"
SINK_PAD_ADDED,
REQUEST_RESOURCE,
CLOSED,
- VIDEO_STREAM_CHANGED,
+ STREAM_CLOSED,
LAST_SIGNAL
};
TfChannel *tfchannel;
gboolean initial_audio;
gboolean initial_video;
- FsElementAddedNotifier *fsnotifier;
} EmpathyCallHandlerPriv;
#define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyCallHandler)
-static void
-empathy_call_handler_call_video_stream_cb (EmpathyTpCall *call,
- GParamSpec *property, EmpathyCallHandler *self)
-{
- g_signal_emit (G_OBJECT (self), signals[VIDEO_STREAM_CHANGED], 0);
-}
-
static void
empathy_call_handler_dispose (GObject *object)
{
if (priv->call != NULL)
{
empathy_tp_call_close (priv->call);
- g_signal_handlers_disconnect_by_func (priv->call,
- empathy_call_handler_call_video_stream_cb, object);
g_object_unref (priv->call);
}
priv->call = NULL;
- if (priv->fsnotifier != NULL)
- {
- g_object_unref (priv->fsnotifier);
- }
- priv->fsnotifier = NULL;
-
/* release any references held by the object here */
if (G_OBJECT_CLASS (empathy_call_handler_parent_class)->dispose)
G_OBJECT_CLASS (empathy_call_handler_parent_class)->dispose (object);
G_TYPE_NONE,
0);
- signals[VIDEO_STREAM_CHANGED] =
- g_signal_new ("video-stream-changed", G_TYPE_FROM_CLASS (klass),
+ signals[STREAM_CLOSED] =
+ g_signal_new ("stream-closed", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, 0, NULL, NULL,
- g_cclosure_marshal_VOID__VOID,
- G_TYPE_NONE,
- 0);
+ g_cclosure_marshal_VOID__OBJECT,
+ G_TYPE_NONE, 1, TF_TYPE_STREAM);
}
/**
empathy_call_handler_new_for_channel (EmpathyTpCall *call)
{
return EMPATHY_CALL_HANDLER (g_object_new (EMPATHY_TYPE_CALL_HANDLER,
- "tp-call", call, NULL));
+ "tp-call", call,
+ "initial-video", empathy_tp_call_is_receiving_video (call),
+ NULL));
}
void
tf_channel_bus_message (priv->tfchannel, message);
}
-static void
-conference_element_added (FsElementAddedNotifier *notifier,
- GstBin *bin,
- GstElement *element,
- gpointer user_data)
-{
- GstElementFactory *factory;
- const gchar *name;
-
- factory = gst_element_get_factory (element);
- name = gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (factory));
-
- if (!tp_strdiff (name, "x264enc"))
- {
- /* Ensure that the encoder creates the baseline profile */
- g_object_set (element,
- "byte-stream", TRUE,
- "bframes", 0,
- "b-adapt", FALSE,
- "cabac", FALSE,
- "dct8x8", FALSE,
- NULL);
- }
- else if (!tp_strdiff (name, "gstrtpbin"))
- {
- /* Lower the jitterbuffer latency to make it more suitable for video
- * conferencing */
- g_object_set (element, "latency", 100, NULL);
- }
-}
-
static void
empathy_call_handler_tf_channel_session_created_cb (TfChannel *tfchannel,
FsConference *conference, FsParticipant *participant,
EmpathyCallHandler *self)
{
- EmpathyCallHandlerPriv *priv = GET_PRIV (self);
-
- priv->fsnotifier = fs_element_added_notifier_new ();
- fs_element_added_notifier_add (priv->fsnotifier, GST_BIN (conference));
-
- g_signal_connect (priv->fsnotifier, "element-added",
- G_CALLBACK (conference_element_added), NULL);
-
g_signal_emit (G_OBJECT (self), signals[CONFERENCE_ADDED], 0,
GST_ELEMENT (conference));
}
return ret;
}
+static void
+empathy_call_handler_tf_stream_closed_cb (TfStream *stream,
+ EmpathyCallHandler *handler)
+{
+ g_signal_emit (handler, signals[STREAM_CLOSED], 0, stream);
+}
+
static void
empathy_call_handler_tf_channel_stream_created_cb (TfChannel *tfchannel,
TfStream *stream, EmpathyCallHandler *handler)
g_signal_connect (stream, "request-resource",
G_CALLBACK (empathy_call_handler_tf_stream_request_resource_cb),
handler);
+ g_signal_connect (stream, "closed",
+ G_CALLBACK (empathy_call_handler_tf_stream_closed_cb), handler);
g_object_get (stream, "media-type", &media_type,
"sink-pad", &spad, NULL);
g_signal_emit (G_OBJECT (handler), signals[CLOSED], 0);
}
-static GList *
-empathy_call_handler_tf_channel_codec_config_get_defaults (FsCodec *codecs)
-{
- GList *l = NULL;
- int i;
-
- for (i = 0; codecs[i].encoding_name != NULL; i++)
- l = g_list_append (l, fs_codec_copy (codecs + i));
-
- return l;
-}
-
static GList *
empathy_call_handler_tf_channel_codec_config_cb (TfChannel *channel,
guint stream_id, FsMediaType media_type, guint direction, gpointer user_data)
{
- FsCodec audio_codecs[] = {
- { FS_CODEC_ID_ANY, "SPEEX", FS_MEDIA_TYPE_AUDIO, 16000, },
- { FS_CODEC_ID_ANY, "SPEEX", FS_MEDIA_TYPE_AUDIO, 8000, },
-
- { FS_CODEC_ID_DISABLE, "DV", FS_MEDIA_TYPE_AUDIO, },
- { FS_CODEC_ID_DISABLE, "MPA", FS_MEDIA_TYPE_AUDIO, },
- { FS_CODEC_ID_DISABLE, "VORBIS", FS_MEDIA_TYPE_AUDIO, },
- { FS_CODEC_ID_DISABLE, "MP3", FS_MEDIA_TYPE_AUDIO, },
- { 0, NULL, 0,}
- };
- FsCodec video_codecs[] = {
- { FS_CODEC_ID_ANY, "H264", FS_MEDIA_TYPE_VIDEO, },
- { FS_CODEC_ID_ANY, "THEORA", FS_MEDIA_TYPE_VIDEO, },
- { FS_CODEC_ID_ANY, "H263", FS_MEDIA_TYPE_VIDEO, },
-
- { FS_CODEC_ID_DISABLE, "DV", FS_MEDIA_TYPE_VIDEO, },
- { FS_CODEC_ID_DISABLE, "JPEG", FS_MEDIA_TYPE_VIDEO, },
- { FS_CODEC_ID_DISABLE, "MPV", FS_MEDIA_TYPE_VIDEO, },
- { 0, NULL, 0}
- };
-
- switch (media_type)
+ gchar *filename = empathy_file_lookup ("codec-preferences", "data");
+ GList *codecs;
+ GError *error = NULL;
+
+ codecs = fs_codec_list_from_keyfile (filename, &error);
+ g_free (filename);
+
+ if (!codecs)
{
- case FS_MEDIA_TYPE_AUDIO:
- return empathy_call_handler_tf_channel_codec_config_get_defaults
- (audio_codecs);
- case FS_MEDIA_TYPE_VIDEO:
- return empathy_call_handler_tf_channel_codec_config_get_defaults
- (video_codecs);
+ g_warning ("No codec-preferences file: %s",
+ error ? error->message : "No error message");
}
+ g_clear_error (&error);
- return NULL;
+ return codecs;
}
static void
empathy_dispatch_operation_get_channel_wrapper (operation));
g_object_ref (priv->call);
-
- g_signal_connect (priv->call, "notify::video-stream",
- G_CALLBACK (empathy_call_handler_call_video_stream_cb), self);
+ g_object_notify (G_OBJECT (self), "tp-call");
empathy_call_handler_start_tpfs (self);
if (priv->call != NULL)
{
empathy_call_handler_start_tpfs (handler);
- g_signal_connect (priv->call, "notify::video-stream",
- G_CALLBACK (empathy_call_handler_call_video_stream_cb), handler);
empathy_tp_call_accept_incoming_call (priv->call);
return;
}
}
priv->call = NULL;
-}
\ No newline at end of file
+}
+
+/**
+ * empathy_call_handler_has_initial_video:
+ * @handler: an #EmpathyCallHandler
+ *
+ * Return %TRUE if the call managed by this #EmpathyCallHandler was
+ * created with video enabled
+ *
+ * Return value: %TRUE if the call was created as a video conversation.
+ */
+gboolean
+empathy_call_handler_has_initial_video (EmpathyCallHandler *handler)
+{
+ EmpathyCallHandlerPriv *priv = GET_PRIV (handler);
+
+ return priv->initial_video;
+}
+
projects / empathy.git / blobdiff