/*------------------------------------------------------------------------ * Does this client support Voice and Video? */ gboolean mxit_video_enabled(void) { PurpleMediaManager *manager = purple_media_manager_get(); PurpleMediaCaps caps = purple_media_manager_get_ui_caps(manager); return (caps & PURPLE_MEDIA_CAPS_VIDEO); }
void jabber_google_session_parse(JabberStream *js, const char *from, JabberIqType type, const char *iq_id, xmlnode *session_node) { GoogleSession *session = NULL; GoogleSessionId id; xmlnode *desc_node; GList *iter = NULL; if (type != JABBER_IQ_SET) return; id.id = (gchar*)xmlnode_get_attrib(session_node, "id"); if (!id.id) return; id.initiator = (gchar*)xmlnode_get_attrib(session_node, "initiator"); if (!id.initiator) return; iter = purple_media_manager_get_media_by_account( purple_media_manager_get(), purple_connection_get_account(js->gc)); for (; iter; iter = g_list_delete_link(iter, iter)) { GoogleSession *gsession = purple_media_get_prpl_data(iter->data); if (google_session_id_equal(&(gsession->id), &id)) { session = gsession; break; } } if (iter != NULL) { g_list_free(iter); } if (session) { google_session_parse_iq(js, session, session_node, iq_id); return; } /* If the session doesn't exist, this has to be an initiate message */ if (strcmp(xmlnode_get_attrib(session_node, "type"), "initiate")) return; desc_node = xmlnode_get_child(session_node, "description"); if (!desc_node) return; session = g_new0(GoogleSession, 1); session->id.id = g_strdup(id.id); session->id.initiator = g_strdup(id.initiator); session->state = UNINIT; session->js = js; session->remote_jid = g_strdup(session->id.initiator); session->session_data = g_new0(GoogleAVSessionData, 1); google_session_handle_initiate(js, session, session_node, iq_id); }
static void purple_media_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { PurpleMedia *media; g_return_if_fail(PURPLE_IS_MEDIA(object)); media = PURPLE_MEDIA(object); switch (prop_id) { case PROP_MANAGER: media->priv->manager = g_value_dup_object(value); break; case PROP_ACCOUNT: media->priv->account = g_value_get_pointer(value); break; case PROP_CONFERENCE_TYPE: media->priv->conference_type = g_value_dup_string(value); media->priv->backend = g_object_new( purple_media_manager_get_backend_type( purple_media_manager_get()), "conference-type", media->priv->conference_type, "media", media, NULL); g_signal_connect(media->priv->backend, "active-candidate-pair", G_CALLBACK( purple_media_candidate_pair_established_cb), media); g_signal_connect(media->priv->backend, "candidates-prepared", G_CALLBACK( purple_media_candidates_prepared_cb), media); g_signal_connect(media->priv->backend, "codecs-changed", G_CALLBACK( purple_media_codecs_changed_cb), media); g_signal_connect(media->priv->backend, "new-candidate", G_CALLBACK( purple_media_new_local_candidate_cb), media); break; case PROP_INITIATOR: media->priv->initiator = g_value_get_boolean(value); break; case PROP_PRPL_DATA: media->priv->prpl_data = g_value_get_pointer(value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
void pidgin_medias_init(void) { #ifdef USE_VV PurpleMediaManager *manager = purple_media_manager_get(); PurpleMediaElementInfo *default_video_src = g_object_new(PURPLE_TYPE_MEDIA_ELEMENT_INFO, "id", "pidgindefaultvideosrc", "name", "Pidgin Default Video Source", "type", PURPLE_MEDIA_ELEMENT_VIDEO | PURPLE_MEDIA_ELEMENT_SRC | PURPLE_MEDIA_ELEMENT_ONE_SRC | PURPLE_MEDIA_ELEMENT_UNIQUE, "create-cb", create_default_video_src, NULL); PurpleMediaElementInfo *default_video_sink = g_object_new(PURPLE_TYPE_MEDIA_ELEMENT_INFO, "id", "pidgindefaultvideosink", "name", "Pidgin Default Video Sink", "type", PURPLE_MEDIA_ELEMENT_VIDEO | PURPLE_MEDIA_ELEMENT_SINK | PURPLE_MEDIA_ELEMENT_ONE_SINK, "create-cb", create_default_video_sink, NULL); PurpleMediaElementInfo *default_audio_src = g_object_new(PURPLE_TYPE_MEDIA_ELEMENT_INFO, "id", "pidgindefaultaudiosrc", "name", "Pidgin Default Audio Source", "type", PURPLE_MEDIA_ELEMENT_AUDIO | PURPLE_MEDIA_ELEMENT_SRC | PURPLE_MEDIA_ELEMENT_ONE_SRC | PURPLE_MEDIA_ELEMENT_UNIQUE, "create-cb", create_default_audio_src, NULL); PurpleMediaElementInfo *default_audio_sink = g_object_new(PURPLE_TYPE_MEDIA_ELEMENT_INFO, "id", "pidgindefaultaudiosink", "name", "Pidgin Default Audio Sink", "type", PURPLE_MEDIA_ELEMENT_AUDIO | PURPLE_MEDIA_ELEMENT_SINK | PURPLE_MEDIA_ELEMENT_ONE_SINK, "create-cb", create_default_audio_sink, NULL); g_signal_connect(G_OBJECT(manager), "init-media", G_CALLBACK(pidgin_media_new_cb), NULL); purple_media_manager_set_ui_caps(manager, PURPLE_MEDIA_CAPS_AUDIO | PURPLE_MEDIA_CAPS_AUDIO_SINGLE_DIRECTION | PURPLE_MEDIA_CAPS_VIDEO | PURPLE_MEDIA_CAPS_VIDEO_SINGLE_DIRECTION | PURPLE_MEDIA_CAPS_AUDIO_VIDEO); purple_debug_info("gtkmedia", "Registering media element types\n"); purple_media_manager_set_active_element(manager, default_video_src); purple_media_manager_set_active_element(manager, default_video_sink); purple_media_manager_set_active_element(manager, default_audio_src); purple_media_manager_set_active_element(manager, default_audio_sink); #endif }
static gboolean plugin_unload(PurplePlugin *plugin) { PurpleMediaManager *manager = purple_media_manager_get(); purple_media_manager_set_active_element(manager, old_video_src); purple_media_manager_set_active_element(manager, old_video_sink); purple_media_manager_set_active_element(manager, old_audio_src); purple_media_manager_set_active_element(manager, old_audio_sink); return TRUE; }
static void set_element_info_cond(PurpleMediaElementInfo *old_info, PurpleMediaElementInfo *new_info, const gchar *id) { gchar *element_id = purple_media_element_info_get_id(old_info); if (!strcmp(element_id, id)) purple_media_manager_set_active_element( purple_media_manager_get(), new_info); g_free(element_id); }
static gboolean google_session_handle_initiate(JabberStream *js, GoogleSession *session, xmlnode *sess, const char *iq_id) { const gchar *xmlns; GoogleAVSessionData *session_data = (GoogleAVSessionData *) session->session_data; if (session->state != UNINIT) { purple_debug_error("jabber", "Received initiate for active session.\n"); return FALSE; } session->description = xmlnode_copy(xmlnode_get_child(sess, "description")); xmlns = xmlnode_get_namespace(session->description); if (purple_strequal(xmlns, NS_GOOGLE_SESSION_PHONE)) session_data->video = FALSE; else if (purple_strequal(xmlns, NS_GOOGLE_SESSION_VIDEO)) session_data->video = TRUE; else { purple_debug_error("jabber", "Received initiate with " "invalid namespace %s.\n", xmlns); return FALSE; } session_data->media = purple_media_manager_create_media( purple_media_manager_get(), purple_connection_get_account(js->gc), "fsrtpconference", session->remote_jid, FALSE); purple_media_set_prpl_data(session_data->media, session); g_signal_connect_swapped(G_OBJECT(session_data->media), "candidates-prepared", G_CALLBACK(google_session_ready), session); g_signal_connect_swapped(G_OBJECT(session_data->media), "codecs-changed", G_CALLBACK(google_session_ready), session); g_signal_connect(G_OBJECT(session_data->media), "state-changed", G_CALLBACK(google_session_state_changed_cb), session); g_signal_connect(G_OBJECT(session_data->media), "stream-info", G_CALLBACK(google_session_stream_info_cb), session); session->iq_id = g_strdup(iq_id); if (js->google_relay_host && js->google_relay_token) { jabber_google_do_relay_request(js, session, jabber_google_relay_response_session_handle_initiate_cb); } else { jabber_google_relay_response_session_handle_initiate_cb(session, NULL, 0, 0, 0, NULL, NULL); } return TRUE; }
static void jabber_google_relay_response_session_initiate_cb(GoogleSession *session, const gchar *relay_ip, guint relay_udp, guint relay_tcp, guint relay_ssltcp, const gchar *relay_username, const gchar *relay_password) { GParameter *params; guint num_params; JabberStream *js = session->js; GoogleAVSessionData *session_data = (GoogleAVSessionData *) session->session_data; session_data->media = purple_media_manager_create_media( purple_media_manager_get(), purple_connection_get_account(js->gc), "fsrtpconference", session->remote_jid, TRUE); purple_media_set_prpl_data(session_data->media, session); g_signal_connect_swapped(G_OBJECT(session_data->media), "candidates-prepared", G_CALLBACK(google_session_ready), session); g_signal_connect_swapped(G_OBJECT(session_data->media), "codecs-changed", G_CALLBACK(google_session_ready), session); g_signal_connect(G_OBJECT(session_data->media), "state-changed", G_CALLBACK(google_session_state_changed_cb), session); g_signal_connect(G_OBJECT(session_data->media), "stream-info", G_CALLBACK(google_session_stream_info_cb), session); params = jabber_google_session_get_params(js, relay_ip, relay_udp, relay_tcp, relay_ssltcp, relay_username, relay_password, &num_params); if (purple_media_add_stream(session_data->media, "google-voice", session->remote_jid, PURPLE_MEDIA_AUDIO, TRUE, "nice", num_params, params) == FALSE || (session_data->video && purple_media_add_stream( session_data->media, "google-video", session->remote_jid, PURPLE_MEDIA_VIDEO, TRUE, "nice", num_params, params) == FALSE)) { purple_media_error(session_data->media, "Error adding stream."); purple_media_end(session_data->media, NULL, NULL); g_free(params); } else { session_data->added_streams = TRUE; } g_free(params); }
void Media::init() { #ifdef HAVE_VIDEO GError *error = NULL; if((gstreamer_init_failed = !gst_init_check(NULL, NULL, &error))) { b_log[W_ERR] << "Unable to initialize GStreamer: " << (error ? error->message : ""); if(error) g_free(error); return; } PurpleMediaManager *manager = purple_media_manager_get(); PurpleMediaElementInfo *default_video_src = (PurpleMediaElementInfo*)g_object_new(PURPLE_TYPE_MEDIA_ELEMENT_INFO, "id", "minbifdefaultvideosrc", "name", "minbif Default Video Source", "type", PURPLE_MEDIA_ELEMENT_VIDEO | PURPLE_MEDIA_ELEMENT_SRC | PURPLE_MEDIA_ELEMENT_ONE_SRC | PURPLE_MEDIA_ELEMENT_UNIQUE, "create-cb", create_default_video_src, NULL); PurpleMediaElementInfo *default_video_sink = (PurpleMediaElementInfo*)g_object_new(PURPLE_TYPE_MEDIA_ELEMENT_INFO, "id", "minbifdefaultvideosink", "name", "minbif Default Video Sink", "type", PURPLE_MEDIA_ELEMENT_VIDEO | PURPLE_MEDIA_ELEMENT_SINK | PURPLE_MEDIA_ELEMENT_ONE_SINK, "create-cb", create_default_video_sink, NULL); g_signal_connect(G_OBJECT(manager), "init-media", G_CALLBACK(media_new_cb), NULL); purple_media_manager_set_ui_caps(manager, (PurpleMediaCaps)( PURPLE_MEDIA_CAPS_VIDEO | PURPLE_MEDIA_CAPS_VIDEO_SINGLE_DIRECTION)); purple_media_manager_set_active_element(manager, default_video_sink); purple_media_manager_set_active_element(manager, default_video_src); #endif /* HAVE_VIDEO */ }
/*------------------------------------------------------------------------ * Initiate a voice/video session with a contact. * * @param account The MXit account object * @param who The username of the contact. * @param type The type of media session to initiate * @return TRUE if session was initiated */ gboolean mxit_media_initiate(PurpleAccount *account, const char *who, PurpleMediaSessionType type) { gchar* transmitter = "rawudp"; PurpleMedia* media = NULL; purple_debug_info(MXIT_PLUGIN_ID, "mxit_media_initiate: buddy '%s'\n", who); media = purple_media_manager_create_media( purple_media_manager_get(), account, "fsrtpconference", who, TRUE ); if (!media) { purple_debug_info(MXIT_PLUGIN_ID, "mxit_media_initiate: could not create media session\n"); return FALSE; } /* attach callbacks */ g_signal_connect(G_OBJECT(media), "candidates-prepared", G_CALLBACK(mxit_candidates_prepared_cb), NULL); g_signal_connect(G_OBJECT(media), "stream-info", G_CALLBACK(mxit_stream_info_cb), NULL); g_signal_connect(G_OBJECT(media), "state-changed", G_CALLBACK(mxit_state_changed_cb), NULL); /* initiate audio session */ if ((type & PURPLE_MEDIA_AUDIO) && (!purple_media_add_stream(media, "audio", who, PURPLE_MEDIA_AUDIO, TRUE, transmitter, 0, NULL))) { purple_media_end(media, NULL, NULL); return FALSE; } /* initiate video session */ if ((type & PURPLE_MEDIA_VIDEO) && (!purple_media_add_stream(media, "video", who, PURPLE_MEDIA_VIDEO, TRUE, transmitter, 0, NULL))) { purple_media_end(media, NULL, NULL); return FALSE; } return TRUE; }
struct sipe_backend_media * sipe_backend_media_new(struct sipe_core_public *sipe_public, struct sipe_media_call *call, const gchar *participant, gboolean initiator) { struct sipe_backend_media *media = g_new0(struct sipe_backend_media, 1); struct sipe_backend_private *purple_private = sipe_public->backend_private; PurpleMediaManager *manager = purple_media_manager_get(); GstElement *pipeline; media->m = purple_media_manager_create_media(manager, purple_private->account, "fsrtpconference", participant, initiator); g_signal_connect(G_OBJECT(media->m), "candidates-prepared", G_CALLBACK(on_candidates_prepared_cb), call); g_signal_connect(G_OBJECT(media->m), "codecs-changed", G_CALLBACK(on_codecs_changed_cb), call); g_signal_connect(G_OBJECT(media->m), "stream-info", G_CALLBACK(on_stream_info_cb), call); g_signal_connect(G_OBJECT(media->m), "error", G_CALLBACK(on_error_cb), call); g_signal_connect(G_OBJECT(media->m), "state-changed", G_CALLBACK(on_state_changed_cb), call); /* On error, the pipeline is no longer in PLAYING state and libpurple * will not switch it back to PLAYING, preventing any more calls until * application restart. We switch the state ourselves here to negate * effect of any error in previous call (if any). */ pipeline = purple_media_manager_get_pipeline(manager); gst_element_set_state(pipeline, GST_STATE_PLAYING); return media; }
void capture_pipeline(const gchar *label) { PurpleMediaManager *manager = purple_media_manager_get(); GstElement *pipeline = purple_media_manager_get_pipeline(manager); GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS(GST_BIN(pipeline), GST_DEBUG_GRAPH_SHOW_ALL, label); }
static gboolean plugin_load(PurplePlugin *plugin) { PurpleMediaManager *manager; PurpleMediaElementInfo *video_src, *video_sink, *audio_src, *audio_sink; /* Disable the plugin if the UI doesn't support VV */ if (purple_media_manager_get_ui_caps(purple_media_manager_get()) == PURPLE_MEDIA_CAPS_NONE) return FALSE; purple_prefs_add_none("/plugins/core/vvconfig"); purple_prefs_add_none("/plugins/core/vvconfig/audio"); purple_prefs_add_none("/plugins/core/vvconfig/audio/src"); purple_prefs_add_string("/plugins/core/vvconfig/audio/src/plugin", ""); purple_prefs_add_string("/plugins/core/vvconfig/audio/src/device", ""); purple_prefs_add_none("/plugins/core/vvconfig/audio/sink"); purple_prefs_add_string("/plugins/core/vvconfig/audio/sink/plugin", ""); purple_prefs_add_string("/plugins/core/vvconfig/audio/sink/device", ""); purple_prefs_add_none("/plugins/core/vvconfig/video"); purple_prefs_add_none("/plugins/core/vvconfig/video/src"); purple_prefs_add_string("/plugins/core/vvconfig/video/src/plugin", ""); purple_prefs_add_string("/plugins/core/vvconfig/video/src/device", ""); purple_prefs_add_none("/plugins/gtk/vvconfig"); purple_prefs_add_none("/plugins/gtk/vvconfig/video"); purple_prefs_add_none("/plugins/gtk/vvconfig/video/sink"); purple_prefs_add_string("/plugins/gtk/vvconfig/video/sink/plugin", ""); purple_prefs_add_string("/plugins/gtk/vvconfig/video/sink/device", ""); video_src = g_object_new(PURPLE_TYPE_MEDIA_ELEMENT_INFO, "id", "vvconfig-videosrc", "name", "VV Conf Plugin Video Source", "type", PURPLE_MEDIA_ELEMENT_VIDEO | PURPLE_MEDIA_ELEMENT_SRC | PURPLE_MEDIA_ELEMENT_ONE_SRC | PURPLE_MEDIA_ELEMENT_UNIQUE, "create-cb", create_video_src, NULL); video_sink = g_object_new(PURPLE_TYPE_MEDIA_ELEMENT_INFO, "id", "vvconfig-videosink", "name", "VV Conf Plugin Video Sink", "type", PURPLE_MEDIA_ELEMENT_VIDEO | PURPLE_MEDIA_ELEMENT_SINK | PURPLE_MEDIA_ELEMENT_ONE_SINK, "create-cb", create_video_sink, NULL); audio_src = g_object_new(PURPLE_TYPE_MEDIA_ELEMENT_INFO, "id", "vvconfig-audiosrc", "name", "VV Conf Plugin Audio Source", "type", PURPLE_MEDIA_ELEMENT_AUDIO | PURPLE_MEDIA_ELEMENT_SRC | PURPLE_MEDIA_ELEMENT_ONE_SRC | PURPLE_MEDIA_ELEMENT_UNIQUE, "create-cb", create_audio_src, NULL); audio_sink = g_object_new(PURPLE_TYPE_MEDIA_ELEMENT_INFO, "id", "vvconfig-audiosink", "name", "VV Conf Plugin Audio Sink", "type", PURPLE_MEDIA_ELEMENT_AUDIO | PURPLE_MEDIA_ELEMENT_SINK | PURPLE_MEDIA_ELEMENT_ONE_SINK, "create-cb", create_audio_sink, NULL); purple_debug_info("gtkmedia", "Registering media element types\n"); manager = purple_media_manager_get(); old_video_src = purple_media_manager_get_active_element(manager, PURPLE_MEDIA_ELEMENT_VIDEO | PURPLE_MEDIA_ELEMENT_SRC); old_video_sink = purple_media_manager_get_active_element(manager, PURPLE_MEDIA_ELEMENT_VIDEO | PURPLE_MEDIA_ELEMENT_SINK); old_audio_src = purple_media_manager_get_active_element(manager, PURPLE_MEDIA_ELEMENT_AUDIO | PURPLE_MEDIA_ELEMENT_SRC); old_audio_sink = purple_media_manager_get_active_element(manager, PURPLE_MEDIA_ELEMENT_AUDIO | PURPLE_MEDIA_ELEMENT_SINK); set_element_info_cond(old_video_src, video_src, "pidgindefaultvideosrc"); set_element_info_cond(old_video_sink, video_sink, "pidgindefaultvideosink"); set_element_info_cond(old_audio_src, audio_src, "pidgindefaultaudiosrc"); set_element_info_cond(old_audio_sink, audio_sink, "pidgindefaultaudiosink"); return TRUE; }