Mercurial > pidgin
annotate libpurple/media/media.c @ 29151:30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
author | maiku@pidgin.im |
---|---|
date | Fri, 23 Oct 2009 00:01:54 +0000 |
parents | e18c1d347e37 |
children | 41ae97b7e97e |
rev | line source |
---|---|
29140 | 1 /** |
2 * @file media.c Media API | |
3 * @ingroup core | |
4 */ | |
5 | |
6 /* purple | |
7 * | |
8 * Purple is the legal property of its developers, whose names are too numerous | |
9 * to list here. Please refer to the COPYRIGHT file distributed with this | |
10 * source distribution. | |
11 * | |
12 * This program is free software; you can redistribute it and/or modify | |
13 * it under the terms of the GNU General Public License as published by | |
14 * the Free Software Foundation; either version 2 of the License, or | |
15 * (at your option) any later version. | |
16 * | |
17 * This program is distributed in the hope that it will be useful, | |
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
20 * GNU General Public License for more details. | |
21 * | |
22 * You should have received a copy of the GNU General Public License | |
23 * along with this program; if not, write to the Free Software | |
24 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA | |
25 */ | |
26 | |
27 #include <string.h> | |
28 | |
29 #include "internal.h" | |
30 | |
31 #include "account.h" | |
32 #include "media.h" | |
33 #include "mediamanager.h" | |
34 #include "network.h" | |
35 | |
36 #include "debug.h" | |
37 | |
38 #ifdef USE_GSTREAMER | |
39 #include "marshallers.h" | |
40 #include "media-gst.h" | |
41 #endif | |
42 | |
43 #ifdef USE_VV | |
44 | |
45 #include <gst/farsight/fs-conference-iface.h> | |
46 #include <gst/farsight/fs-element-added-notifier.h> | |
47 | |
48 /** @copydoc _PurpleMediaSession */ | |
49 typedef struct _PurpleMediaSession PurpleMediaSession; | |
50 /** @copydoc _PurpleMediaStream */ | |
51 typedef struct _PurpleMediaStream PurpleMediaStream; | |
52 /** @copydoc _PurpleMediaClass */ | |
53 typedef struct _PurpleMediaClass PurpleMediaClass; | |
54 /** @copydoc _PurpleMediaPrivate */ | |
55 typedef struct _PurpleMediaPrivate PurpleMediaPrivate; | |
56 | |
57 /** The media class */ | |
58 struct _PurpleMediaClass | |
59 { | |
60 GObjectClass parent_class; /**< The parent class. */ | |
61 }; | |
62 | |
63 /** The media class's private data */ | |
64 struct _PurpleMedia | |
65 { | |
66 GObject parent; /**< The parent of this object. */ | |
67 PurpleMediaPrivate *priv; /**< The private data of this object. */ | |
68 }; | |
69 | |
70 struct _PurpleMediaSession | |
71 { | |
72 gchar *id; | |
73 PurpleMedia *media; | |
74 GstElement *src; | |
75 GstElement *tee; | |
76 FsSession *session; | |
77 | |
78 PurpleMediaSessionType type; | |
79 gboolean initiator; | |
80 }; | |
81 | |
82 struct _PurpleMediaStream | |
83 { | |
84 PurpleMediaSession *session; | |
85 gchar *participant; | |
86 FsStream *stream; | |
87 GstElement *src; | |
88 GstElement *tee; | |
89 GstElement *volume; | |
90 GstElement *level; | |
91 | |
92 GList *local_candidates; | |
93 GList *remote_candidates; | |
94 | |
95 gboolean initiator; | |
96 gboolean accepted; | |
97 gboolean candidates_prepared; | |
98 | |
99 GList *active_local_candidates; | |
100 GList *active_remote_candidates; | |
101 | |
102 guint connected_cb_id; | |
103 }; | |
104 #endif | |
105 | |
106 struct _PurpleMediaPrivate | |
107 { | |
108 #ifdef USE_VV | |
109 PurpleMediaManager *manager; | |
110 PurpleAccount *account; | |
111 FsConference *conference; | |
29151
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29144
diff
changeset
|
112 gchar *conference_type; |
29140 | 113 gboolean initiator; |
114 gpointer prpl_data; | |
115 | |
116 GHashTable *sessions; /* PurpleMediaSession table */ | |
117 GHashTable *participants; /* FsParticipant table */ | |
118 | |
119 GList *streams; /* PurpleMediaStream table */ | |
120 | |
121 GstElement *confbin; | |
122 #else | |
123 gpointer dummy; | |
124 #endif | |
125 }; | |
126 | |
127 #ifdef USE_VV | |
128 #define PURPLE_MEDIA_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), PURPLE_TYPE_MEDIA, PurpleMediaPrivate)) | |
129 | |
130 static void purple_media_class_init (PurpleMediaClass *klass); | |
131 static void purple_media_init (PurpleMedia *media); | |
132 static void purple_media_dispose (GObject *object); | |
133 static void purple_media_finalize (GObject *object); | |
134 static void purple_media_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec); | |
135 static void purple_media_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec); | |
136 | |
137 static void purple_media_new_local_candidate_cb(FsStream *stream, | |
138 FsCandidate *local_candidate, PurpleMediaSession *session); | |
139 static void purple_media_candidates_prepared_cb(FsStream *stream, | |
140 PurpleMediaSession *session); | |
141 static void purple_media_candidate_pair_established_cb(FsStream *stream, | |
142 FsCandidate *native_candidate, FsCandidate *remote_candidate, | |
143 PurpleMediaSession *session); | |
144 static gboolean media_bus_call(GstBus *bus, | |
145 GstMessage *msg, PurpleMedia *media); | |
146 | |
147 static GObjectClass *parent_class = NULL; | |
148 | |
149 | |
150 | |
151 enum { | |
152 S_ERROR, | |
153 CANDIDATES_PREPARED, | |
154 CODECS_CHANGED, | |
155 LEVEL, | |
156 NEW_CANDIDATE, | |
157 STATE_CHANGED, | |
158 STREAM_INFO, | |
159 LAST_SIGNAL | |
160 }; | |
161 static guint purple_media_signals[LAST_SIGNAL] = {0}; | |
162 | |
163 enum { | |
164 PROP_0, | |
165 PROP_MANAGER, | |
166 PROP_ACCOUNT, | |
167 PROP_CONFERENCE, | |
29151
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29144
diff
changeset
|
168 PROP_CONFERENCE_TYPE, |
29140 | 169 PROP_INITIATOR, |
170 PROP_PRPL_DATA, | |
171 }; | |
172 #endif | |
173 | |
174 | |
175 GType | |
176 purple_media_get_type() | |
177 { | |
178 #ifdef USE_VV | |
179 static GType type = 0; | |
180 | |
181 if (type == 0) { | |
182 static const GTypeInfo info = { | |
183 sizeof(PurpleMediaClass), | |
184 NULL, | |
185 NULL, | |
186 (GClassInitFunc) purple_media_class_init, | |
187 NULL, | |
188 NULL, | |
189 sizeof(PurpleMedia), | |
190 0, | |
191 (GInstanceInitFunc) purple_media_init, | |
192 NULL | |
193 }; | |
194 type = g_type_register_static(G_TYPE_OBJECT, "PurpleMedia", &info, 0); | |
195 } | |
196 return type; | |
197 #else | |
198 return G_TYPE_NONE; | |
199 #endif | |
200 } | |
201 | |
202 #ifdef USE_VV | |
203 static void | |
204 purple_media_class_init (PurpleMediaClass *klass) | |
205 { | |
206 GObjectClass *gobject_class = (GObjectClass*)klass; | |
207 parent_class = g_type_class_peek_parent(klass); | |
208 | |
209 gobject_class->dispose = purple_media_dispose; | |
210 gobject_class->finalize = purple_media_finalize; | |
211 gobject_class->set_property = purple_media_set_property; | |
212 gobject_class->get_property = purple_media_get_property; | |
213 | |
214 g_object_class_install_property(gobject_class, PROP_MANAGER, | |
215 g_param_spec_object("manager", | |
216 "Purple Media Manager", | |
217 "The media manager that contains this media session.", | |
218 PURPLE_TYPE_MEDIA_MANAGER, | |
219 G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE)); | |
220 | |
221 g_object_class_install_property(gobject_class, PROP_ACCOUNT, | |
222 g_param_spec_pointer("account", | |
223 "PurpleAccount", | |
224 "The account this media session is on.", | |
225 G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE)); | |
226 | |
227 g_object_class_install_property(gobject_class, PROP_CONFERENCE, | |
228 g_param_spec_object("conference", | |
229 "Farsight conference", | |
230 "The FsConference associated with this media.", | |
231 FS_TYPE_CONFERENCE, | |
232 G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE)); | |
233 | |
29151
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29144
diff
changeset
|
234 g_object_class_install_property(gobject_class, PROP_CONFERENCE_TYPE, |
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29144
diff
changeset
|
235 g_param_spec_string("conference-type", |
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29144
diff
changeset
|
236 "Conference Type", |
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29144
diff
changeset
|
237 "The type of conference that this media object " |
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29144
diff
changeset
|
238 "has been created to provide.", |
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29144
diff
changeset
|
239 NULL, |
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29144
diff
changeset
|
240 G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE)); |
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29144
diff
changeset
|
241 |
29140 | 242 g_object_class_install_property(gobject_class, PROP_INITIATOR, |
243 g_param_spec_boolean("initiator", | |
244 "initiator", | |
245 "If the local user initiated the conference.", | |
246 FALSE, | |
247 G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE)); | |
248 | |
249 g_object_class_install_property(gobject_class, PROP_PRPL_DATA, | |
250 g_param_spec_pointer("prpl-data", | |
251 "gpointer", | |
252 "Data the prpl plugin set on the media session.", | |
253 G_PARAM_READWRITE)); | |
254 | |
255 purple_media_signals[S_ERROR] = g_signal_new("error", G_TYPE_FROM_CLASS(klass), | |
256 G_SIGNAL_RUN_LAST, 0, NULL, NULL, | |
257 g_cclosure_marshal_VOID__STRING, | |
258 G_TYPE_NONE, 1, G_TYPE_STRING); | |
259 purple_media_signals[CANDIDATES_PREPARED] = g_signal_new("candidates-prepared", G_TYPE_FROM_CLASS(klass), | |
260 G_SIGNAL_RUN_LAST, 0, NULL, NULL, | |
261 purple_smarshal_VOID__STRING_STRING, | |
262 G_TYPE_NONE, 2, G_TYPE_STRING, | |
263 G_TYPE_STRING); | |
264 purple_media_signals[CODECS_CHANGED] = g_signal_new("codecs-changed", G_TYPE_FROM_CLASS(klass), | |
265 G_SIGNAL_RUN_LAST, 0, NULL, NULL, | |
266 g_cclosure_marshal_VOID__STRING, | |
267 G_TYPE_NONE, 1, G_TYPE_STRING); | |
268 purple_media_signals[LEVEL] = g_signal_new("level", G_TYPE_FROM_CLASS(klass), | |
269 G_SIGNAL_RUN_LAST, 0, NULL, NULL, | |
270 purple_smarshal_VOID__STRING_STRING_DOUBLE, | |
271 G_TYPE_NONE, 3, G_TYPE_STRING, | |
272 G_TYPE_STRING, G_TYPE_DOUBLE); | |
273 purple_media_signals[NEW_CANDIDATE] = g_signal_new("new-candidate", G_TYPE_FROM_CLASS(klass), | |
274 G_SIGNAL_RUN_LAST, 0, NULL, NULL, | |
275 purple_smarshal_VOID__POINTER_POINTER_OBJECT, | |
276 G_TYPE_NONE, 3, G_TYPE_POINTER, | |
277 G_TYPE_POINTER, PURPLE_TYPE_MEDIA_CANDIDATE); | |
278 purple_media_signals[STATE_CHANGED] = g_signal_new("state-changed", G_TYPE_FROM_CLASS(klass), | |
279 G_SIGNAL_RUN_LAST, 0, NULL, NULL, | |
280 purple_smarshal_VOID__ENUM_STRING_STRING, | |
281 G_TYPE_NONE, 3, PURPLE_MEDIA_TYPE_STATE, | |
282 G_TYPE_STRING, G_TYPE_STRING); | |
283 purple_media_signals[STREAM_INFO] = g_signal_new("stream-info", G_TYPE_FROM_CLASS(klass), | |
284 G_SIGNAL_RUN_LAST, 0, NULL, NULL, | |
285 purple_smarshal_VOID__ENUM_STRING_STRING_BOOLEAN, | |
286 G_TYPE_NONE, 4, PURPLE_MEDIA_TYPE_INFO_TYPE, | |
287 G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN); | |
288 g_type_class_add_private(klass, sizeof(PurpleMediaPrivate)); | |
289 } | |
290 | |
291 | |
292 static void | |
293 purple_media_init (PurpleMedia *media) | |
294 { | |
295 media->priv = PURPLE_MEDIA_GET_PRIVATE(media); | |
296 memset(media->priv, 0, sizeof(*media->priv)); | |
297 } | |
298 | |
299 static void | |
300 purple_media_stream_free(PurpleMediaStream *stream) | |
301 { | |
302 if (stream == NULL) | |
303 return; | |
304 | |
305 /* Remove the connected_cb timeout */ | |
306 if (stream->connected_cb_id != 0) | |
307 purple_timeout_remove(stream->connected_cb_id); | |
308 | |
309 g_free(stream->participant); | |
310 | |
311 if (stream->local_candidates) | |
312 fs_candidate_list_destroy(stream->local_candidates); | |
313 if (stream->remote_candidates) | |
314 fs_candidate_list_destroy(stream->remote_candidates); | |
315 | |
316 if (stream->active_local_candidates) | |
317 fs_candidate_list_destroy(stream->active_local_candidates); | |
318 if (stream->active_remote_candidates) | |
319 fs_candidate_list_destroy(stream->active_remote_candidates); | |
320 | |
321 g_free(stream); | |
322 } | |
323 | |
324 static void | |
325 purple_media_session_free(PurpleMediaSession *session) | |
326 { | |
327 if (session == NULL) | |
328 return; | |
329 | |
330 g_free(session->id); | |
331 g_free(session); | |
332 } | |
333 | |
334 static void | |
335 purple_media_dispose(GObject *media) | |
336 { | |
337 PurpleMediaPrivate *priv = PURPLE_MEDIA_GET_PRIVATE(media); | |
338 GList *iter = NULL; | |
339 | |
340 purple_debug_info("media","purple_media_dispose\n"); | |
341 | |
342 purple_media_manager_remove_media(priv->manager, PURPLE_MEDIA(media)); | |
343 | |
344 if (priv->confbin) { | |
345 gst_element_set_locked_state(priv->confbin, TRUE); | |
346 gst_element_set_state(GST_ELEMENT(priv->confbin), | |
347 GST_STATE_NULL); | |
348 gst_bin_remove(GST_BIN(purple_media_manager_get_pipeline( | |
349 priv->manager)), priv->confbin); | |
350 priv->confbin = NULL; | |
351 priv->conference = NULL; | |
352 } | |
353 | |
354 for (iter = priv->streams; iter; iter = g_list_next(iter)) { | |
355 PurpleMediaStream *stream = iter->data; | |
356 if (stream->stream) { | |
357 g_object_unref(stream->stream); | |
358 stream->stream = NULL; | |
359 } | |
360 } | |
361 | |
362 if (priv->sessions) { | |
363 GList *sessions = g_hash_table_get_values(priv->sessions); | |
364 for (; sessions; sessions = g_list_delete_link(sessions, sessions)) { | |
365 PurpleMediaSession *session = sessions->data; | |
366 if (session->session) { | |
367 g_object_unref(session->session); | |
368 session->session = NULL; | |
369 } | |
370 } | |
371 } | |
372 | |
373 if (priv->participants) { | |
374 GList *participants = g_hash_table_get_values(priv->participants); | |
375 for (; participants; participants = g_list_delete_link(participants, participants)) | |
376 g_object_unref(participants->data); | |
377 } | |
378 | |
379 if (priv->manager) { | |
380 GstElement *pipeline = purple_media_manager_get_pipeline( | |
381 priv->manager); | |
382 GstBus *bus = gst_pipeline_get_bus(GST_PIPELINE(pipeline)); | |
383 g_signal_handlers_disconnect_matched(G_OBJECT(bus), | |
384 G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, | |
385 0, 0, 0, media_bus_call, media); | |
386 gst_object_unref(bus); | |
387 | |
388 g_object_unref(priv->manager); | |
389 priv->manager = NULL; | |
390 } | |
391 | |
392 G_OBJECT_CLASS(parent_class)->dispose(media); | |
393 } | |
394 | |
395 static void | |
396 purple_media_finalize(GObject *media) | |
397 { | |
398 PurpleMediaPrivate *priv = PURPLE_MEDIA_GET_PRIVATE(media); | |
399 purple_debug_info("media","purple_media_finalize\n"); | |
400 | |
401 for (; priv->streams; priv->streams = g_list_delete_link(priv->streams, priv->streams)) | |
402 purple_media_stream_free(priv->streams->data); | |
403 | |
404 if (priv->sessions) { | |
405 GList *sessions = g_hash_table_get_values(priv->sessions); | |
406 for (; sessions; sessions = g_list_delete_link(sessions, sessions)) { | |
407 purple_media_session_free(sessions->data); | |
408 } | |
409 g_hash_table_destroy(priv->sessions); | |
410 } | |
411 | |
412 G_OBJECT_CLASS(parent_class)->finalize(media); | |
413 } | |
414 | |
415 static void | |
416 purple_media_setup_pipeline(PurpleMedia *media) | |
417 { | |
418 GstBus *bus; | |
419 gchar *name; | |
420 GstElement *pipeline; | |
421 | |
422 if (media->priv->conference == NULL || media->priv->manager == NULL) | |
423 return; | |
424 | |
425 pipeline = purple_media_manager_get_pipeline(media->priv->manager); | |
426 | |
427 name = g_strdup_printf("conf_%p", | |
428 media->priv->conference); | |
429 media->priv->confbin = gst_bin_new(name); | |
430 g_free(name); | |
431 | |
432 bus = gst_pipeline_get_bus(GST_PIPELINE(pipeline)); | |
433 g_signal_connect(G_OBJECT(bus), "message", | |
434 G_CALLBACK(media_bus_call), media); | |
435 gst_object_unref(bus); | |
436 | |
437 gst_bin_add(GST_BIN(pipeline), | |
438 media->priv->confbin); | |
439 gst_bin_add(GST_BIN(media->priv->confbin), | |
440 GST_ELEMENT(media->priv->conference)); | |
441 gst_element_set_state(GST_ELEMENT(media->priv->confbin), | |
442 GST_STATE_PLAYING); | |
443 } | |
444 | |
445 static void | |
446 purple_media_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) | |
447 { | |
448 PurpleMedia *media; | |
449 g_return_if_fail(PURPLE_IS_MEDIA(object)); | |
450 | |
451 media = PURPLE_MEDIA(object); | |
452 | |
453 switch (prop_id) { | |
454 case PROP_MANAGER: | |
455 media->priv->manager = g_value_get_object(value); | |
456 g_object_ref(media->priv->manager); | |
457 | |
458 purple_media_setup_pipeline(media); | |
459 break; | |
460 case PROP_ACCOUNT: | |
461 media->priv->account = g_value_get_pointer(value); | |
462 break; | |
463 case PROP_CONFERENCE: { | |
464 if (media->priv->conference) | |
465 gst_object_unref(media->priv->conference); | |
466 media->priv->conference = g_value_get_object(value); | |
467 gst_object_ref(media->priv->conference); | |
468 | |
469 purple_media_setup_pipeline(media); | |
470 break; | |
471 } | |
29151
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29144
diff
changeset
|
472 case PROP_CONFERENCE_TYPE: |
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29144
diff
changeset
|
473 media->priv->conference_type = |
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29144
diff
changeset
|
474 g_value_dup_string(value); |
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29144
diff
changeset
|
475 break; |
29140 | 476 case PROP_INITIATOR: |
477 media->priv->initiator = g_value_get_boolean(value); | |
478 break; | |
479 case PROP_PRPL_DATA: | |
480 media->priv->prpl_data = g_value_get_pointer(value); | |
481 break; | |
482 default: | |
483 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); | |
484 break; | |
485 } | |
486 } | |
487 | |
488 static void | |
489 purple_media_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) | |
490 { | |
491 PurpleMedia *media; | |
492 g_return_if_fail(PURPLE_IS_MEDIA(object)); | |
493 | |
494 media = PURPLE_MEDIA(object); | |
495 | |
496 switch (prop_id) { | |
497 case PROP_MANAGER: | |
498 g_value_set_object(value, media->priv->manager); | |
499 break; | |
500 case PROP_ACCOUNT: | |
501 g_value_set_pointer(value, media->priv->account); | |
502 break; | |
503 case PROP_CONFERENCE: | |
504 g_value_set_object(value, media->priv->conference); | |
505 break; | |
29151
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29144
diff
changeset
|
506 case PROP_CONFERENCE_TYPE: |
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29144
diff
changeset
|
507 g_value_set_string(value, |
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29144
diff
changeset
|
508 media->priv->conference_type); |
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29144
diff
changeset
|
509 break; |
29140 | 510 case PROP_INITIATOR: |
511 g_value_set_boolean(value, media->priv->initiator); | |
512 break; | |
513 case PROP_PRPL_DATA: | |
514 g_value_set_pointer(value, media->priv->prpl_data); | |
515 break; | |
516 default: | |
517 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); | |
518 break; | |
519 } | |
520 | |
521 } | |
522 | |
29142
f585e10f156b
Split out PurpleMediaCandidate into its own file.
maiku@pidgin.im
parents:
29141
diff
changeset
|
523 static FsCandidate * |
f585e10f156b
Split out PurpleMediaCandidate into its own file.
maiku@pidgin.im
parents:
29141
diff
changeset
|
524 purple_media_candidate_to_fs(PurpleMediaCandidate *candidate) |
29140 | 525 { |
29142
f585e10f156b
Split out PurpleMediaCandidate into its own file.
maiku@pidgin.im
parents:
29141
diff
changeset
|
526 FsCandidate *fscandidate; |
29140 | 527 gchar *foundation; |
528 guint component_id; | |
529 gchar *ip; | |
29142
f585e10f156b
Split out PurpleMediaCandidate into its own file.
maiku@pidgin.im
parents:
29141
diff
changeset
|
530 guint port; |
29140 | 531 gchar *base_ip; |
29142
f585e10f156b
Split out PurpleMediaCandidate into its own file.
maiku@pidgin.im
parents:
29141
diff
changeset
|
532 guint base_port; |
29140 | 533 PurpleMediaNetworkProtocol proto; |
534 guint32 priority; | |
535 PurpleMediaCandidateType type; | |
536 gchar *username; | |
537 gchar *password; | |
538 guint ttl; | |
539 | |
540 if (candidate == NULL) | |
541 return NULL; | |
542 | |
29142
f585e10f156b
Split out PurpleMediaCandidate into its own file.
maiku@pidgin.im
parents:
29141
diff
changeset
|
543 g_object_get(G_OBJECT(candidate), |
f585e10f156b
Split out PurpleMediaCandidate into its own file.
maiku@pidgin.im
parents:
29141
diff
changeset
|
544 "foundation", &foundation, |
f585e10f156b
Split out PurpleMediaCandidate into its own file.
maiku@pidgin.im
parents:
29141
diff
changeset
|
545 "component-id", &component_id, |
f585e10f156b
Split out PurpleMediaCandidate into its own file.
maiku@pidgin.im
parents:
29141
diff
changeset
|
546 "ip", &ip, |
f585e10f156b
Split out PurpleMediaCandidate into its own file.
maiku@pidgin.im
parents:
29141
diff
changeset
|
547 "port", &port, |
f585e10f156b
Split out PurpleMediaCandidate into its own file.
maiku@pidgin.im
parents:
29141
diff
changeset
|
548 "base-ip", &base_ip, |
f585e10f156b
Split out PurpleMediaCandidate into its own file.
maiku@pidgin.im
parents:
29141
diff
changeset
|
549 "base-port", &base_port, |
f585e10f156b
Split out PurpleMediaCandidate into its own file.
maiku@pidgin.im
parents:
29141
diff
changeset
|
550 "protocol", &proto, |
f585e10f156b
Split out PurpleMediaCandidate into its own file.
maiku@pidgin.im
parents:
29141
diff
changeset
|
551 "priority", &priority, |
f585e10f156b
Split out PurpleMediaCandidate into its own file.
maiku@pidgin.im
parents:
29141
diff
changeset
|
552 "type", &type, |
f585e10f156b
Split out PurpleMediaCandidate into its own file.
maiku@pidgin.im
parents:
29141
diff
changeset
|
553 "username", &username, |
f585e10f156b
Split out PurpleMediaCandidate into its own file.
maiku@pidgin.im
parents:
29141
diff
changeset
|
554 "password", &password, |
f585e10f156b
Split out PurpleMediaCandidate into its own file.
maiku@pidgin.im
parents:
29141
diff
changeset
|
555 "ttl", &ttl, |
f585e10f156b
Split out PurpleMediaCandidate into its own file.
maiku@pidgin.im
parents:
29141
diff
changeset
|
556 NULL); |
29140 | 557 |
29142
f585e10f156b
Split out PurpleMediaCandidate into its own file.
maiku@pidgin.im
parents:
29141
diff
changeset
|
558 fscandidate = fs_candidate_new(foundation, |
f585e10f156b
Split out PurpleMediaCandidate into its own file.
maiku@pidgin.im
parents:
29141
diff
changeset
|
559 component_id, type, |
f585e10f156b
Split out PurpleMediaCandidate into its own file.
maiku@pidgin.im
parents:
29141
diff
changeset
|
560 proto, ip, port); |
29140 | 561 |
29142
f585e10f156b
Split out PurpleMediaCandidate into its own file.
maiku@pidgin.im
parents:
29141
diff
changeset
|
562 fscandidate->base_ip = base_ip; |
f585e10f156b
Split out PurpleMediaCandidate into its own file.
maiku@pidgin.im
parents:
29141
diff
changeset
|
563 fscandidate->base_port = base_port; |
f585e10f156b
Split out PurpleMediaCandidate into its own file.
maiku@pidgin.im
parents:
29141
diff
changeset
|
564 fscandidate->priority = priority; |
f585e10f156b
Split out PurpleMediaCandidate into its own file.
maiku@pidgin.im
parents:
29141
diff
changeset
|
565 fscandidate->username = username; |
f585e10f156b
Split out PurpleMediaCandidate into its own file.
maiku@pidgin.im
parents:
29141
diff
changeset
|
566 fscandidate->password = password; |
f585e10f156b
Split out PurpleMediaCandidate into its own file.
maiku@pidgin.im
parents:
29141
diff
changeset
|
567 fscandidate->ttl = ttl; |
29140 | 568 |
29142
f585e10f156b
Split out PurpleMediaCandidate into its own file.
maiku@pidgin.im
parents:
29141
diff
changeset
|
569 g_free(foundation); |
f585e10f156b
Split out PurpleMediaCandidate into its own file.
maiku@pidgin.im
parents:
29141
diff
changeset
|
570 g_free(ip); |
29140 | 571 return fscandidate; |
572 } | |
573 | |
574 static PurpleMediaCandidate * | |
575 purple_media_candidate_from_fs(FsCandidate *fscandidate) | |
576 { | |
577 PurpleMediaCandidate *candidate; | |
578 | |
579 if (fscandidate == NULL) | |
580 return NULL; | |
581 | |
582 candidate = purple_media_candidate_new(fscandidate->foundation, | |
583 fscandidate->component_id, fscandidate->type, | |
584 fscandidate->proto, fscandidate->ip, fscandidate->port); | |
585 g_object_set(candidate, | |
586 "base-ip", fscandidate->base_ip, | |
587 "base-port", fscandidate->base_port, | |
588 "priority", fscandidate->priority, | |
589 "username", fscandidate->username, | |
590 "password", fscandidate->password, | |
591 "ttl", fscandidate->ttl, NULL); | |
592 return candidate; | |
593 } | |
594 | |
595 static GList * | |
596 purple_media_candidate_list_from_fs(GList *candidates) | |
597 { | |
598 GList *new_list = NULL; | |
599 | |
600 for (; candidates; candidates = g_list_next(candidates)) { | |
601 new_list = g_list_prepend(new_list, | |
602 purple_media_candidate_from_fs( | |
603 candidates->data)); | |
604 } | |
605 | |
606 new_list = g_list_reverse(new_list); | |
607 return new_list; | |
608 } | |
609 | |
610 static GList * | |
611 purple_media_candidate_list_to_fs(GList *candidates) | |
612 { | |
613 GList *new_list = NULL; | |
614 | |
615 for (; candidates; candidates = g_list_next(candidates)) { | |
616 new_list = g_list_prepend(new_list, | |
617 purple_media_candidate_to_fs( | |
618 candidates->data)); | |
619 } | |
620 | |
621 new_list = g_list_reverse(new_list); | |
622 return new_list; | |
623 } | |
624 | |
625 static FsMediaType | |
626 purple_media_to_fs_media_type(PurpleMediaSessionType type) | |
627 { | |
628 if (type & PURPLE_MEDIA_AUDIO) | |
629 return FS_MEDIA_TYPE_AUDIO; | |
630 else if (type & PURPLE_MEDIA_VIDEO) | |
631 return FS_MEDIA_TYPE_VIDEO; | |
632 else | |
633 return 0; | |
634 } | |
635 | |
636 static FsStreamDirection | |
637 purple_media_to_fs_stream_direction(PurpleMediaSessionType type) | |
638 { | |
639 if ((type & PURPLE_MEDIA_AUDIO) == PURPLE_MEDIA_AUDIO || | |
640 (type & PURPLE_MEDIA_VIDEO) == PURPLE_MEDIA_VIDEO) | |
641 return FS_DIRECTION_BOTH; | |
642 else if ((type & PURPLE_MEDIA_SEND_AUDIO) || | |
643 (type & PURPLE_MEDIA_SEND_VIDEO)) | |
644 return FS_DIRECTION_SEND; | |
645 else if ((type & PURPLE_MEDIA_RECV_AUDIO) || | |
646 (type & PURPLE_MEDIA_RECV_VIDEO)) | |
647 return FS_DIRECTION_RECV; | |
648 else | |
649 return FS_DIRECTION_NONE; | |
650 } | |
651 | |
652 static PurpleMediaSessionType | |
653 purple_media_from_fs(FsMediaType type, FsStreamDirection direction) | |
654 { | |
655 PurpleMediaSessionType result = PURPLE_MEDIA_NONE; | |
656 if (type == FS_MEDIA_TYPE_AUDIO) { | |
657 if (direction & FS_DIRECTION_SEND) | |
658 result |= PURPLE_MEDIA_SEND_AUDIO; | |
659 if (direction & FS_DIRECTION_RECV) | |
660 result |= PURPLE_MEDIA_RECV_AUDIO; | |
661 } else if (type == FS_MEDIA_TYPE_VIDEO) { | |
662 if (direction & FS_DIRECTION_SEND) | |
663 result |= PURPLE_MEDIA_SEND_VIDEO; | |
664 if (direction & FS_DIRECTION_RECV) | |
665 result |= PURPLE_MEDIA_RECV_VIDEO; | |
666 } | |
667 return result; | |
668 } | |
669 | |
29144
e18c1d347e37
Break PurpleMediaCodec out into its own file.
maiku@pidgin.im
parents:
29142
diff
changeset
|
670 static FsCodec * |
e18c1d347e37
Break PurpleMediaCodec out into its own file.
maiku@pidgin.im
parents:
29142
diff
changeset
|
671 purple_media_codec_to_fs(const PurpleMediaCodec *codec) |
29140 | 672 { |
29144
e18c1d347e37
Break PurpleMediaCodec out into its own file.
maiku@pidgin.im
parents:
29142
diff
changeset
|
673 FsCodec *new_codec; |
29140 | 674 gint id; |
675 char *encoding_name; | |
676 PurpleMediaSessionType media_type; | |
677 guint clock_rate; | |
678 guint channels; | |
679 GList *iter; | |
680 | |
681 if (codec == NULL) | |
682 return NULL; | |
683 | |
29144
e18c1d347e37
Break PurpleMediaCodec out into its own file.
maiku@pidgin.im
parents:
29142
diff
changeset
|
684 g_object_get(G_OBJECT(codec), |
e18c1d347e37
Break PurpleMediaCodec out into its own file.
maiku@pidgin.im
parents:
29142
diff
changeset
|
685 "id", &id, |
e18c1d347e37
Break PurpleMediaCodec out into its own file.
maiku@pidgin.im
parents:
29142
diff
changeset
|
686 "encoding-name", &encoding_name, |
e18c1d347e37
Break PurpleMediaCodec out into its own file.
maiku@pidgin.im
parents:
29142
diff
changeset
|
687 "media-type", &media_type, |
e18c1d347e37
Break PurpleMediaCodec out into its own file.
maiku@pidgin.im
parents:
29142
diff
changeset
|
688 "clock-rate", &clock_rate, |
e18c1d347e37
Break PurpleMediaCodec out into its own file.
maiku@pidgin.im
parents:
29142
diff
changeset
|
689 "channels", &channels, |
e18c1d347e37
Break PurpleMediaCodec out into its own file.
maiku@pidgin.im
parents:
29142
diff
changeset
|
690 "optional-params", &iter, |
e18c1d347e37
Break PurpleMediaCodec out into its own file.
maiku@pidgin.im
parents:
29142
diff
changeset
|
691 NULL); |
29140 | 692 |
29144
e18c1d347e37
Break PurpleMediaCodec out into its own file.
maiku@pidgin.im
parents:
29142
diff
changeset
|
693 new_codec = fs_codec_new(id, encoding_name, |
e18c1d347e37
Break PurpleMediaCodec out into its own file.
maiku@pidgin.im
parents:
29142
diff
changeset
|
694 purple_media_to_fs_media_type(media_type), |
e18c1d347e37
Break PurpleMediaCodec out into its own file.
maiku@pidgin.im
parents:
29142
diff
changeset
|
695 clock_rate); |
e18c1d347e37
Break PurpleMediaCodec out into its own file.
maiku@pidgin.im
parents:
29142
diff
changeset
|
696 new_codec->channels = channels; |
29140 | 697 |
29144
e18c1d347e37
Break PurpleMediaCodec out into its own file.
maiku@pidgin.im
parents:
29142
diff
changeset
|
698 for (; iter; iter = g_list_next(iter)) { |
29140 | 699 PurpleKeyValuePair *param = (PurpleKeyValuePair*)iter->data; |
700 fs_codec_add_optional_parameter(new_codec, | |
701 param->key, param->value); | |
702 } | |
703 | |
29144
e18c1d347e37
Break PurpleMediaCodec out into its own file.
maiku@pidgin.im
parents:
29142
diff
changeset
|
704 g_free(encoding_name); |
29140 | 705 return new_codec; |
706 } | |
707 | |
708 static PurpleMediaCodec * | |
709 purple_media_codec_from_fs(const FsCodec *codec) | |
710 { | |
711 PurpleMediaCodec *new_codec; | |
712 GList *iter; | |
713 | |
714 if (codec == NULL) | |
715 return NULL; | |
716 | |
717 new_codec = purple_media_codec_new(codec->id, codec->encoding_name, | |
718 purple_media_from_fs(codec->media_type, | |
719 FS_DIRECTION_BOTH), codec->clock_rate); | |
720 g_object_set(new_codec, "channels", codec->channels, NULL); | |
721 | |
722 for (iter = codec->optional_params; iter; iter = g_list_next(iter)) { | |
723 FsCodecParameter *param = (FsCodecParameter*)iter->data; | |
724 purple_media_codec_add_optional_parameter(new_codec, | |
725 param->name, param->value); | |
726 } | |
727 | |
728 return new_codec; | |
729 } | |
730 | |
731 static GList * | |
732 purple_media_codec_list_from_fs(GList *codecs) | |
733 { | |
734 GList *new_list = NULL; | |
735 | |
736 for (; codecs; codecs = g_list_next(codecs)) { | |
737 new_list = g_list_prepend(new_list, | |
738 purple_media_codec_from_fs( | |
739 codecs->data)); | |
740 } | |
741 | |
742 new_list = g_list_reverse(new_list); | |
743 return new_list; | |
744 } | |
745 | |
746 static GList * | |
747 purple_media_codec_list_to_fs(GList *codecs) | |
748 { | |
749 GList *new_list = NULL; | |
750 | |
751 for (; codecs; codecs = g_list_next(codecs)) { | |
752 new_list = g_list_prepend(new_list, | |
753 purple_media_codec_to_fs( | |
754 codecs->data)); | |
755 } | |
756 | |
757 new_list = g_list_reverse(new_list); | |
758 return new_list; | |
759 } | |
760 | |
761 static PurpleMediaSession* | |
762 purple_media_get_session(PurpleMedia *media, const gchar *sess_id) | |
763 { | |
764 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL); | |
765 return (PurpleMediaSession*) (media->priv->sessions) ? | |
766 g_hash_table_lookup(media->priv->sessions, sess_id) : NULL; | |
767 } | |
768 | |
769 static FsParticipant* | |
770 purple_media_get_participant(PurpleMedia *media, const gchar *name) | |
771 { | |
772 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL); | |
773 return (FsParticipant*) (media->priv->participants) ? | |
774 g_hash_table_lookup(media->priv->participants, name) : NULL; | |
775 } | |
776 | |
777 static PurpleMediaStream* | |
778 purple_media_get_stream(PurpleMedia *media, const gchar *session, const gchar *participant) | |
779 { | |
780 GList *streams; | |
781 | |
782 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL); | |
783 | |
784 streams = media->priv->streams; | |
785 | |
786 for (; streams; streams = g_list_next(streams)) { | |
787 PurpleMediaStream *stream = streams->data; | |
788 if (!strcmp(stream->session->id, session) && | |
789 !strcmp(stream->participant, participant)) | |
790 return stream; | |
791 } | |
792 | |
793 return NULL; | |
794 } | |
795 | |
796 static GList * | |
797 purple_media_get_streams(PurpleMedia *media, const gchar *session, | |
798 const gchar *participant) | |
799 { | |
800 GList *streams; | |
801 GList *ret = NULL; | |
802 | |
803 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL); | |
804 | |
805 streams = media->priv->streams; | |
806 | |
807 for (; streams; streams = g_list_next(streams)) { | |
808 PurpleMediaStream *stream = streams->data; | |
809 if ((session == NULL || | |
810 !strcmp(stream->session->id, session)) && | |
811 (participant == NULL || | |
812 !strcmp(stream->participant, participant))) | |
813 ret = g_list_append(ret, stream); | |
814 } | |
815 | |
816 return ret; | |
817 } | |
818 | |
819 static void | |
820 purple_media_add_session(PurpleMedia *media, PurpleMediaSession *session) | |
821 { | |
822 g_return_if_fail(PURPLE_IS_MEDIA(media)); | |
823 g_return_if_fail(session != NULL); | |
824 | |
825 if (!media->priv->sessions) { | |
826 purple_debug_info("media", "Creating hash table for sessions\n"); | |
827 media->priv->sessions = g_hash_table_new(g_str_hash, g_str_equal); | |
828 } | |
829 g_hash_table_insert(media->priv->sessions, g_strdup(session->id), session); | |
830 } | |
831 | |
832 static gboolean | |
833 purple_media_remove_session(PurpleMedia *media, PurpleMediaSession *session) | |
834 { | |
835 g_return_val_if_fail(PURPLE_IS_MEDIA(media), FALSE); | |
836 return g_hash_table_remove(media->priv->sessions, session->id); | |
837 } | |
838 | |
839 static FsParticipant * | |
840 purple_media_add_participant(PurpleMedia *media, const gchar *name) | |
841 { | |
842 FsParticipant *participant; | |
843 GError *err = NULL; | |
844 | |
845 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL); | |
846 | |
847 participant = purple_media_get_participant(media, name); | |
848 | |
849 if (participant) | |
850 return participant; | |
851 | |
852 participant = fs_conference_new_participant(media->priv->conference, | |
853 (gchar*)name, &err); | |
854 | |
855 if (err) { | |
856 purple_debug_error("media", "Error creating participant: %s\n", | |
857 err->message); | |
858 g_error_free(err); | |
859 return NULL; | |
860 } | |
861 | |
862 if (!media->priv->participants) { | |
863 purple_debug_info("media", "Creating hash table for participants\n"); | |
864 media->priv->participants = g_hash_table_new_full(g_str_hash, | |
865 g_str_equal, g_free, NULL); | |
866 } | |
867 | |
868 g_hash_table_insert(media->priv->participants, g_strdup(name), participant); | |
869 | |
870 return participant; | |
871 } | |
872 | |
873 static PurpleMediaStream * | |
874 purple_media_insert_stream(PurpleMediaSession *session, const gchar *name, FsStream *stream) | |
875 { | |
876 PurpleMediaStream *media_stream; | |
877 | |
878 g_return_val_if_fail(session != NULL, NULL); | |
879 | |
880 media_stream = g_new0(PurpleMediaStream, 1); | |
881 media_stream->stream = stream; | |
882 media_stream->participant = g_strdup(name); | |
883 media_stream->session = session; | |
884 | |
885 session->media->priv->streams = | |
886 g_list_append(session->media->priv->streams, media_stream); | |
887 | |
888 return media_stream; | |
889 } | |
890 | |
891 static void | |
892 purple_media_insert_local_candidate(PurpleMediaSession *session, const gchar *name, | |
893 FsCandidate *candidate) | |
894 { | |
895 PurpleMediaStream *stream; | |
896 | |
897 g_return_if_fail(session != NULL); | |
898 | |
899 stream = purple_media_get_stream(session->media, session->id, name); | |
900 stream->local_candidates = g_list_append(stream->local_candidates, candidate); | |
901 } | |
902 #endif | |
903 | |
904 GList * | |
905 purple_media_get_session_ids(PurpleMedia *media) | |
906 { | |
907 #ifdef USE_VV | |
908 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL); | |
909 return media->priv->sessions != NULL ? | |
910 g_hash_table_get_keys(media->priv->sessions) : NULL; | |
911 #else | |
912 return NULL; | |
913 #endif | |
914 } | |
915 | |
916 #ifdef USE_VV | |
917 static void | |
918 purple_media_set_src(PurpleMedia *media, const gchar *sess_id, GstElement *src) | |
919 { | |
920 PurpleMediaSession *session; | |
921 GstPad *sinkpad; | |
922 GstPad *srcpad; | |
923 | |
924 g_return_if_fail(PURPLE_IS_MEDIA(media)); | |
925 g_return_if_fail(GST_IS_ELEMENT(src)); | |
926 | |
927 session = purple_media_get_session(media, sess_id); | |
928 | |
929 if (session == NULL) { | |
930 purple_debug_warning("media", "purple_media_set_src: trying" | |
931 " to set src on non-existent session\n"); | |
932 return; | |
933 } | |
934 | |
935 if (session->src) | |
936 gst_object_unref(session->src); | |
937 session->src = src; | |
938 gst_element_set_locked_state(session->src, TRUE); | |
939 | |
940 session->tee = gst_element_factory_make("tee", NULL); | |
941 gst_bin_add(GST_BIN(session->media->priv->confbin), session->tee); | |
942 | |
943 /* This supposedly isn't necessary, but it silences some warnings */ | |
944 if (GST_ELEMENT_PARENT(session->media->priv->confbin) | |
945 == GST_ELEMENT_PARENT(session->src)) { | |
946 GstPad *pad = gst_element_get_static_pad(session->tee, "sink"); | |
947 GstPad *ghost = gst_ghost_pad_new(NULL, pad); | |
948 gst_object_unref(pad); | |
949 gst_pad_set_active(ghost, TRUE); | |
950 gst_element_add_pad(session->media->priv->confbin, ghost); | |
951 } | |
952 | |
953 gst_element_set_state(session->tee, GST_STATE_PLAYING); | |
954 gst_element_link(session->src, session->media->priv->confbin); | |
955 | |
956 g_object_get(session->session, "sink-pad", &sinkpad, NULL); | |
957 if (session->type & PURPLE_MEDIA_SEND_AUDIO) { | |
958 gchar *name = g_strdup_printf("volume_%s", session->id); | |
959 GstElement *level; | |
960 GstElement *volume = gst_element_factory_make("volume", name); | |
961 double input_volume = purple_prefs_get_int( | |
962 "/purple/media/audio/volume/input")/10.0; | |
963 g_free(name); | |
964 name = g_strdup_printf("sendlevel_%s", session->id); | |
965 level = gst_element_factory_make("level", name); | |
966 g_free(name); | |
967 gst_bin_add(GST_BIN(session->media->priv->confbin), volume); | |
968 gst_bin_add(GST_BIN(session->media->priv->confbin), level); | |
969 gst_element_set_state(level, GST_STATE_PLAYING); | |
970 gst_element_set_state(volume, GST_STATE_PLAYING); | |
971 gst_element_link(volume, level); | |
972 gst_element_link(session->tee, volume); | |
973 srcpad = gst_element_get_static_pad(level, "src"); | |
974 g_object_set(volume, "volume", input_volume, NULL); | |
975 } else { | |
976 srcpad = gst_element_get_request_pad(session->tee, "src%d"); | |
977 } | |
978 purple_debug_info("media", "connecting pad: %s\n", | |
979 gst_pad_link(srcpad, sinkpad) == GST_PAD_LINK_OK | |
980 ? "success" : "failure"); | |
981 gst_element_set_locked_state(session->src, FALSE); | |
982 gst_object_unref(session->src); | |
983 } | |
984 #endif | |
985 | |
986 #ifdef USE_GSTREAMER | |
987 GstElement * | |
988 purple_media_get_src(PurpleMedia *media, const gchar *sess_id) | |
989 { | |
990 #ifdef USE_VV | |
991 PurpleMediaSession *session; | |
992 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL); | |
993 session = purple_media_get_session(media, sess_id); | |
994 return (session != NULL) ? session->src : NULL; | |
995 #else | |
996 return NULL; | |
997 #endif | |
998 } | |
999 #endif /* USE_GSTREAMER */ | |
1000 | |
1001 #ifdef USE_VV | |
1002 static PurpleMediaSession * | |
1003 purple_media_session_from_fs_stream(PurpleMedia *media, FsStream *stream) | |
1004 { | |
1005 FsSession *fssession; | |
1006 GList *values; | |
1007 | |
1008 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL); | |
1009 g_return_val_if_fail(FS_IS_STREAM(stream), NULL); | |
1010 | |
1011 g_object_get(stream, "session", &fssession, NULL); | |
1012 | |
1013 values = g_hash_table_get_values(media->priv->sessions); | |
1014 | |
1015 for (; values; values = g_list_delete_link(values, values)) { | |
1016 PurpleMediaSession *session = values->data; | |
1017 | |
1018 if (session->session == fssession) { | |
1019 g_list_free(values); | |
1020 g_object_unref(fssession); | |
1021 return session; | |
1022 } | |
1023 } | |
1024 | |
1025 g_object_unref(fssession); | |
1026 return NULL; | |
1027 } | |
1028 | |
1029 static gboolean | |
1030 media_bus_call(GstBus *bus, GstMessage *msg, PurpleMedia *media) | |
1031 { | |
1032 switch(GST_MESSAGE_TYPE(msg)) { | |
1033 case GST_MESSAGE_ELEMENT: { | |
1034 if (g_signal_has_handler_pending(media, | |
1035 purple_media_signals[LEVEL], 0, FALSE) | |
1036 && gst_structure_has_name( | |
1037 gst_message_get_structure(msg), "level")) { | |
1038 GstElement *src = GST_ELEMENT(GST_MESSAGE_SRC(msg)); | |
1039 gchar *name; | |
1040 gchar *participant = NULL; | |
1041 PurpleMediaSession *session = NULL; | |
1042 gdouble rms_db; | |
1043 gdouble percent; | |
1044 const GValue *list; | |
1045 const GValue *value; | |
1046 | |
1047 if (!PURPLE_IS_MEDIA(media) || | |
1048 GST_ELEMENT_PARENT(src) != | |
1049 media->priv->confbin) | |
1050 break; | |
1051 | |
1052 name = gst_element_get_name(src); | |
1053 if (!strncmp(name, "sendlevel_", 10)) { | |
1054 session = purple_media_get_session( | |
1055 media, name+10); | |
1056 } else { | |
1057 GList *iter = media->priv->streams; | |
1058 for (; iter; iter = g_list_next(iter)) { | |
1059 PurpleMediaStream *stream = iter->data; | |
1060 if (stream->level == src) { | |
1061 session = stream->session; | |
1062 participant = stream->participant; | |
1063 break; | |
1064 } | |
1065 } | |
1066 } | |
1067 g_free(name); | |
1068 if (!session) | |
1069 break; | |
1070 | |
1071 list = gst_structure_get_value( | |
1072 gst_message_get_structure(msg), "rms"); | |
1073 value = gst_value_list_get_value(list, 0); | |
1074 rms_db = g_value_get_double(value); | |
1075 percent = pow(10, rms_db / 20) * 5; | |
1076 if(percent > 1.0) | |
1077 percent = 1.0; | |
1078 | |
1079 g_signal_emit(media, purple_media_signals[LEVEL], | |
1080 0, session->id, participant, percent); | |
1081 break; | |
1082 } | |
1083 if (!FS_IS_CONFERENCE(GST_MESSAGE_SRC(msg)) || | |
1084 !PURPLE_IS_MEDIA(media) || | |
1085 media->priv->conference != | |
1086 FS_CONFERENCE(GST_MESSAGE_SRC(msg))) | |
1087 break; | |
1088 | |
1089 if (gst_structure_has_name(msg->structure, "farsight-error")) { | |
1090 FsError error_no; | |
1091 gst_structure_get_enum(msg->structure, "error-no", | |
1092 FS_TYPE_ERROR, (gint*)&error_no); | |
1093 switch (error_no) { | |
1094 case FS_ERROR_NO_CODECS: | |
1095 purple_media_error(media, _("No codecs found. Install some GStreamer codecs found in GStreamer plugins packages.")); | |
1096 purple_media_end(media, NULL, NULL); | |
1097 break; | |
1098 case FS_ERROR_NO_CODECS_LEFT: | |
1099 purple_media_error(media, _("No codecs left. Your codec preferences in fs-codecs.conf are too strict.")); | |
1100 purple_media_end(media, NULL, NULL); | |
1101 break; | |
1102 case FS_ERROR_UNKNOWN_CNAME: | |
1103 /* | |
1104 * Unknown CName is only a problem for the | |
1105 * multicast transmitter which isn't used. | |
1106 * It is also deprecated. | |
1107 */ | |
1108 break; | |
1109 default: | |
1110 purple_debug_error("media", "farsight-error: %i: %s\n", error_no, | |
1111 gst_structure_get_string(msg->structure, "error-msg")); | |
1112 break; | |
1113 } | |
1114 | |
1115 if (FS_ERROR_IS_FATAL(error_no)) { | |
1116 purple_media_error(media, _("A non-recoverable Farsight2 error has occurred.")); | |
1117 purple_media_end(media, NULL, NULL); | |
1118 } | |
1119 } else if (gst_structure_has_name(msg->structure, | |
1120 "farsight-new-local-candidate")) { | |
1121 FsStream *stream = g_value_get_object(gst_structure_get_value(msg->structure, "stream")); | |
1122 FsCandidate *local_candidate = g_value_get_boxed(gst_structure_get_value(msg->structure, "candidate")); | |
1123 PurpleMediaSession *session = purple_media_session_from_fs_stream(media, stream); | |
1124 purple_media_new_local_candidate_cb(stream, local_candidate, session); | |
1125 } else if (gst_structure_has_name(msg->structure, | |
1126 "farsight-local-candidates-prepared")) { | |
1127 FsStream *stream = g_value_get_object(gst_structure_get_value(msg->structure, "stream")); | |
1128 PurpleMediaSession *session = purple_media_session_from_fs_stream(media, stream); | |
1129 purple_media_candidates_prepared_cb(stream, session); | |
1130 } else if (gst_structure_has_name(msg->structure, | |
1131 "farsight-new-active-candidate-pair")) { | |
1132 FsStream *stream = g_value_get_object(gst_structure_get_value(msg->structure, "stream")); | |
1133 FsCandidate *local_candidate = g_value_get_boxed(gst_structure_get_value(msg->structure, "local-candidate")); | |
1134 FsCandidate *remote_candidate = g_value_get_boxed(gst_structure_get_value(msg->structure, "remote-candidate")); | |
1135 PurpleMediaSession *session = purple_media_session_from_fs_stream(media, stream); | |
1136 purple_media_candidate_pair_established_cb(stream, local_candidate, remote_candidate, session); | |
1137 } else if (gst_structure_has_name(msg->structure, | |
1138 "farsight-recv-codecs-changed")) { | |
1139 GList *codecs = g_value_get_boxed(gst_structure_get_value(msg->structure, "codecs")); | |
1140 FsCodec *codec = codecs->data; | |
1141 purple_debug_info("media", "farsight-recv-codecs-changed: %s\n", codec->encoding_name); | |
1142 | |
1143 } else if (gst_structure_has_name(msg->structure, | |
1144 "farsight-component-state-changed")) { | |
1145 FsStreamState fsstate = g_value_get_enum(gst_structure_get_value(msg->structure, "state")); | |
1146 guint component = g_value_get_uint(gst_structure_get_value(msg->structure, "component")); | |
1147 const gchar *state; | |
1148 switch (fsstate) { | |
1149 case FS_STREAM_STATE_FAILED: | |
1150 state = "FAILED"; | |
1151 break; | |
1152 case FS_STREAM_STATE_DISCONNECTED: | |
1153 state = "DISCONNECTED"; | |
1154 break; | |
1155 case FS_STREAM_STATE_GATHERING: | |
1156 state = "GATHERING"; | |
1157 break; | |
1158 case FS_STREAM_STATE_CONNECTING: | |
1159 state = "CONNECTING"; | |
1160 break; | |
1161 case FS_STREAM_STATE_CONNECTED: | |
1162 state = "CONNECTED"; | |
1163 break; | |
1164 case FS_STREAM_STATE_READY: | |
1165 state = "READY"; | |
1166 break; | |
1167 default: | |
1168 state = "UNKNOWN"; | |
1169 break; | |
1170 } | |
1171 purple_debug_info("media", "farsight-component-state-changed: component: %u state: %s\n", component, state); | |
1172 } else if (gst_structure_has_name(msg->structure, | |
1173 "farsight-send-codec-changed")) { | |
1174 FsCodec *codec = g_value_get_boxed(gst_structure_get_value(msg->structure, "codec")); | |
1175 gchar *codec_str = fs_codec_to_string(codec); | |
1176 purple_debug_info("media", "farsight-send-codec-changed: codec: %s\n", codec_str); | |
1177 g_free(codec_str); | |
1178 } else if (gst_structure_has_name(msg->structure, | |
1179 "farsight-codecs-changed")) { | |
1180 GList *sessions = g_hash_table_get_values(PURPLE_MEDIA(media)->priv->sessions); | |
1181 FsSession *fssession = g_value_get_object(gst_structure_get_value(msg->structure, "session")); | |
1182 for (; sessions; sessions = g_list_delete_link(sessions, sessions)) { | |
1183 PurpleMediaSession *session = sessions->data; | |
1184 if (session->session == fssession) { | |
1185 gchar *session_id = g_strdup(session->id); | |
1186 g_signal_emit(media, purple_media_signals[CODECS_CHANGED], 0, session_id); | |
1187 g_free(session_id); | |
1188 g_list_free(sessions); | |
1189 break; | |
1190 } | |
1191 } | |
1192 } | |
1193 break; | |
1194 } | |
1195 case GST_MESSAGE_ERROR: { | |
1196 GstElement *element = GST_ELEMENT(GST_MESSAGE_SRC(msg)); | |
1197 GstElement *lastElement = NULL; | |
1198 while (!GST_IS_PIPELINE(element)) { | |
1199 if (element == media->priv->confbin) { | |
1200 purple_media_error(media, _("Conference error")); | |
1201 purple_media_end(media, NULL, NULL); | |
1202 break; | |
1203 } | |
1204 lastElement = element; | |
1205 element = GST_ELEMENT_PARENT(element); | |
1206 } | |
1207 if (GST_IS_PIPELINE(element)) { | |
1208 GList *sessions = g_hash_table_get_values(media->priv->sessions); | |
1209 for (; sessions; sessions = g_list_delete_link(sessions, sessions)) { | |
1210 PurpleMediaSession *session = sessions->data; | |
1211 | |
1212 if (session->src == lastElement) { | |
1213 if (session->type & PURPLE_MEDIA_AUDIO) | |
1214 purple_media_error(media, _("Error with your microphone")); | |
1215 else | |
1216 purple_media_error(media, _("Error with your webcam")); | |
1217 purple_media_end(media, NULL, NULL); | |
1218 break; | |
1219 } | |
1220 } | |
1221 g_list_free(sessions); | |
1222 } | |
1223 } | |
1224 default: | |
1225 break; | |
1226 } | |
1227 | |
1228 return TRUE; | |
1229 } | |
1230 #endif | |
1231 | |
1232 PurpleAccount * | |
1233 purple_media_get_account(PurpleMedia *media) | |
1234 { | |
1235 #ifdef USE_VV | |
1236 PurpleAccount *account; | |
1237 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL); | |
1238 g_object_get(G_OBJECT(media), "account", &account, NULL); | |
1239 return account; | |
1240 #else | |
1241 return NULL; | |
1242 #endif | |
1243 } | |
1244 | |
1245 gpointer | |
1246 purple_media_get_prpl_data(PurpleMedia *media) | |
1247 { | |
1248 #ifdef USE_VV | |
1249 gpointer prpl_data; | |
1250 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL); | |
1251 g_object_get(G_OBJECT(media), "prpl-data", &prpl_data, NULL); | |
1252 return prpl_data; | |
1253 #else | |
1254 return NULL; | |
1255 #endif | |
1256 } | |
1257 | |
1258 void | |
1259 purple_media_set_prpl_data(PurpleMedia *media, gpointer prpl_data) | |
1260 { | |
1261 #ifdef USE_VV | |
1262 g_return_if_fail(PURPLE_IS_MEDIA(media)); | |
1263 g_object_set(G_OBJECT(media), "prpl-data", prpl_data, NULL); | |
1264 #endif | |
1265 } | |
1266 | |
1267 void | |
1268 purple_media_error(PurpleMedia *media, const gchar *error, ...) | |
1269 { | |
1270 #ifdef USE_VV | |
1271 va_list args; | |
1272 gchar *message; | |
1273 | |
1274 g_return_if_fail(PURPLE_IS_MEDIA(media)); | |
1275 | |
1276 va_start(args, error); | |
1277 message = g_strdup_vprintf(error, args); | |
1278 va_end(args); | |
1279 | |
1280 purple_debug_error("media", "%s\n", message); | |
1281 g_signal_emit(media, purple_media_signals[S_ERROR], 0, message); | |
1282 | |
1283 g_free(message); | |
1284 #endif | |
1285 } | |
1286 | |
1287 void | |
1288 purple_media_end(PurpleMedia *media, | |
1289 const gchar *session_id, const gchar *participant) | |
1290 { | |
1291 #ifdef USE_VV | |
1292 g_return_if_fail(PURPLE_IS_MEDIA(media)); | |
1293 if (session_id == NULL && participant == NULL) { | |
1294 g_signal_emit(media, purple_media_signals[STATE_CHANGED], | |
1295 0, PURPLE_MEDIA_STATE_END, | |
1296 NULL, NULL); | |
1297 g_object_unref(media); | |
1298 } | |
1299 #endif | |
1300 } | |
1301 | |
1302 void | |
1303 purple_media_stream_info(PurpleMedia *media, PurpleMediaInfoType type, | |
1304 const gchar *session_id, const gchar *participant, | |
1305 gboolean local) | |
1306 { | |
1307 #ifdef USE_VV | |
1308 g_return_if_fail(PURPLE_IS_MEDIA(media)); | |
1309 | |
1310 if (type == PURPLE_MEDIA_INFO_ACCEPT) { | |
1311 GList *streams; | |
1312 | |
1313 g_return_if_fail(PURPLE_IS_MEDIA(media)); | |
1314 | |
1315 streams = purple_media_get_streams(media, | |
1316 session_id, participant); | |
1317 | |
1318 for (; streams; streams = | |
1319 g_list_delete_link(streams, streams)) { | |
1320 PurpleMediaStream *stream = streams->data; | |
1321 g_object_set(G_OBJECT(stream->stream), "direction", | |
1322 purple_media_to_fs_stream_direction( | |
1323 stream->session->type), NULL); | |
1324 stream->accepted = TRUE; | |
1325 | |
1326 if (stream->remote_candidates != NULL) { | |
1327 GError *err = NULL; | |
1328 fs_stream_set_remote_candidates(stream->stream, | |
1329 stream->remote_candidates, &err); | |
1330 | |
1331 if (err) { | |
1332 purple_debug_error("media", "Error adding remote" | |
1333 " candidates: %s\n", err->message); | |
1334 g_error_free(err); | |
1335 } | |
1336 } | |
1337 } | |
1338 } else if (local == TRUE && (type == PURPLE_MEDIA_INFO_MUTE || | |
1339 type == PURPLE_MEDIA_INFO_UNMUTE)) { | |
1340 GList *sessions; | |
1341 gboolean active = (type == PURPLE_MEDIA_INFO_MUTE); | |
1342 | |
1343 g_return_if_fail(PURPLE_IS_MEDIA(media)); | |
1344 | |
1345 if (session_id == NULL) | |
1346 sessions = g_hash_table_get_values( | |
1347 media->priv->sessions); | |
1348 else | |
1349 sessions = g_list_prepend(NULL, | |
1350 purple_media_get_session( | |
1351 media, session_id)); | |
1352 | |
1353 purple_debug_info("media", "Turning mute %s\n", | |
1354 active ? "on" : "off"); | |
1355 | |
1356 for (; sessions; sessions = g_list_delete_link( | |
1357 sessions, sessions)) { | |
1358 PurpleMediaSession *session = sessions->data; | |
1359 if (session->type & PURPLE_MEDIA_SEND_AUDIO) { | |
1360 gchar *name = g_strdup_printf("volume_%s", | |
1361 session->id); | |
1362 GstElement *volume = gst_bin_get_by_name( | |
1363 GST_BIN(session->media-> | |
1364 priv->confbin), name); | |
1365 g_free(name); | |
1366 g_object_set(volume, "mute", active, NULL); | |
1367 } | |
1368 } | |
1369 } else if (local == TRUE && (type == PURPLE_MEDIA_INFO_PAUSE || | |
1370 type == PURPLE_MEDIA_INFO_UNPAUSE)) { | |
1371 gboolean active = (type == PURPLE_MEDIA_INFO_PAUSE); | |
1372 GList *streams = purple_media_get_streams(media, | |
1373 session_id, participant); | |
1374 for (; streams; streams = g_list_delete_link(streams, streams)) { | |
1375 PurpleMediaStream *stream = streams->data; | |
1376 if (stream->session->type & PURPLE_MEDIA_SEND_VIDEO) { | |
1377 g_object_set(stream->stream, "direction", | |
1378 purple_media_to_fs_stream_direction( | |
1379 stream->session->type & ((active) ? | |
1380 ~PURPLE_MEDIA_SEND_VIDEO : | |
1381 PURPLE_MEDIA_VIDEO)), NULL); | |
1382 } | |
1383 } | |
1384 } | |
1385 | |
1386 g_signal_emit(media, purple_media_signals[STREAM_INFO], | |
1387 0, type, session_id, participant, local); | |
1388 | |
1389 if (type == PURPLE_MEDIA_INFO_HANGUP || | |
1390 type == PURPLE_MEDIA_INFO_REJECT) { | |
1391 purple_media_end(media, session_id, participant); | |
1392 } | |
1393 #endif | |
1394 } | |
1395 | |
1396 #ifdef USE_VV | |
1397 static void | |
1398 purple_media_new_local_candidate_cb(FsStream *stream, | |
1399 FsCandidate *local_candidate, | |
1400 PurpleMediaSession *session) | |
1401 { | |
1402 gchar *name; | |
1403 FsParticipant *participant; | |
1404 PurpleMediaCandidate *candidate; | |
1405 | |
1406 g_return_if_fail(FS_IS_STREAM(stream)); | |
1407 g_return_if_fail(session != NULL); | |
1408 | |
1409 purple_debug_info("media", "got new local candidate: %s\n", local_candidate->foundation); | |
1410 g_object_get(stream, "participant", &participant, NULL); | |
1411 g_object_get(participant, "cname", &name, NULL); | |
1412 g_object_unref(participant); | |
1413 | |
1414 purple_media_insert_local_candidate(session, name, fs_candidate_copy(local_candidate)); | |
1415 | |
1416 candidate = purple_media_candidate_from_fs(local_candidate); | |
1417 g_signal_emit(session->media, purple_media_signals[NEW_CANDIDATE], | |
1418 0, session->id, name, candidate); | |
1419 g_object_unref(candidate); | |
1420 | |
1421 g_free(name); | |
1422 } | |
1423 | |
1424 static void | |
1425 purple_media_candidates_prepared_cb(FsStream *stream, PurpleMediaSession *session) | |
1426 { | |
1427 gchar *name; | |
1428 FsParticipant *participant; | |
1429 PurpleMediaStream *stream_data; | |
1430 | |
1431 g_return_if_fail(FS_IS_STREAM(stream)); | |
1432 g_return_if_fail(session != NULL); | |
1433 | |
1434 g_object_get(stream, "participant", &participant, NULL); | |
1435 g_object_get(participant, "cname", &name, NULL); | |
1436 g_object_unref(participant); | |
1437 | |
1438 stream_data = purple_media_get_stream(session->media, session->id, name); | |
1439 stream_data->candidates_prepared = TRUE; | |
1440 | |
1441 g_signal_emit(session->media, | |
1442 purple_media_signals[CANDIDATES_PREPARED], | |
1443 0, session->id, name); | |
1444 | |
1445 g_free(name); | |
1446 } | |
1447 | |
1448 /* callback called when a pair of transport candidates (local and remote) | |
1449 * has been established */ | |
1450 static void | |
1451 purple_media_candidate_pair_established_cb(FsStream *fsstream, | |
1452 FsCandidate *native_candidate, | |
1453 FsCandidate *remote_candidate, | |
1454 PurpleMediaSession *session) | |
1455 { | |
1456 gchar *name; | |
1457 FsParticipant *participant; | |
1458 PurpleMediaStream *stream; | |
1459 GList *iter; | |
1460 | |
1461 g_return_if_fail(FS_IS_STREAM(fsstream)); | |
1462 g_return_if_fail(session != NULL); | |
1463 | |
1464 g_object_get(fsstream, "participant", &participant, NULL); | |
1465 g_object_get(participant, "cname", &name, NULL); | |
1466 g_object_unref(participant); | |
1467 | |
1468 stream = purple_media_get_stream(session->media, session->id, name); | |
1469 | |
1470 iter = stream->active_local_candidates; | |
1471 for(; iter; iter = g_list_next(iter)) { | |
1472 FsCandidate *c = iter->data; | |
1473 if (native_candidate->component_id == c->component_id) { | |
1474 fs_candidate_destroy(c); | |
1475 stream->active_local_candidates = | |
1476 g_list_delete_link(iter, iter); | |
1477 stream->active_local_candidates = g_list_prepend( | |
1478 stream->active_local_candidates, | |
1479 fs_candidate_copy(native_candidate)); | |
1480 break; | |
1481 } | |
1482 } | |
1483 if (iter == NULL) | |
1484 stream->active_local_candidates = g_list_prepend( | |
1485 stream->active_local_candidates, | |
1486 fs_candidate_copy(native_candidate)); | |
1487 | |
1488 iter = stream->active_remote_candidates; | |
1489 for(; iter; iter = g_list_next(iter)) { | |
1490 FsCandidate *c = iter->data; | |
1491 if (native_candidate->component_id == c->component_id) { | |
1492 fs_candidate_destroy(c); | |
1493 stream->active_remote_candidates = | |
1494 g_list_delete_link(iter, iter); | |
1495 stream->active_remote_candidates = g_list_prepend( | |
1496 stream->active_remote_candidates, | |
1497 fs_candidate_copy(remote_candidate)); | |
1498 break; | |
1499 } | |
1500 } | |
1501 if (iter == NULL) | |
1502 stream->active_remote_candidates = g_list_prepend( | |
1503 stream->active_remote_candidates, | |
1504 fs_candidate_copy(remote_candidate)); | |
1505 | |
1506 purple_debug_info("media", "candidate pair established\n"); | |
1507 } | |
1508 | |
1509 static gboolean | |
1510 purple_media_connected_cb(PurpleMediaStream *stream) | |
1511 { | |
1512 g_return_val_if_fail(stream != NULL, FALSE); | |
1513 | |
1514 stream->connected_cb_id = 0; | |
1515 | |
1516 purple_media_manager_create_output_window( | |
1517 stream->session->media->priv->manager, | |
1518 stream->session->media, | |
1519 stream->session->id, stream->participant); | |
1520 | |
1521 g_signal_emit(stream->session->media, | |
1522 purple_media_signals[STATE_CHANGED], | |
1523 0, PURPLE_MEDIA_STATE_CONNECTED, | |
1524 stream->session->id, stream->participant); | |
1525 return FALSE; | |
1526 } | |
1527 | |
1528 static void | |
1529 purple_media_src_pad_added_cb(FsStream *fsstream, GstPad *srcpad, | |
1530 FsCodec *codec, PurpleMediaStream *stream) | |
1531 { | |
1532 PurpleMediaPrivate *priv; | |
1533 GstPad *sinkpad; | |
1534 | |
1535 g_return_if_fail(FS_IS_STREAM(fsstream)); | |
1536 g_return_if_fail(stream != NULL); | |
1537 | |
1538 priv = stream->session->media->priv; | |
1539 | |
1540 if (stream->src == NULL) { | |
1541 GstElement *sink = NULL; | |
1542 | |
1543 if (codec->media_type == FS_MEDIA_TYPE_AUDIO) { | |
1544 GstElement *queue = NULL; | |
1545 double output_volume = purple_prefs_get_int( | |
1546 "/purple/media/audio/volume/output")/10.0; | |
1547 /* | |
1548 * Should this instead be: | |
1549 * audioconvert ! audioresample ! liveadder ! | |
1550 * audioresample ! audioconvert ! realsink | |
1551 */ | |
1552 queue = gst_element_factory_make("queue", NULL); | |
1553 stream->volume = gst_element_factory_make( | |
1554 "volume", NULL); | |
1555 g_object_set(stream->volume, "volume", | |
1556 output_volume, NULL); | |
1557 stream->level = gst_element_factory_make( | |
1558 "level", NULL); | |
1559 stream->src = gst_element_factory_make( | |
1560 "liveadder", NULL); | |
1561 sink = purple_media_manager_get_element(priv->manager, | |
1562 PURPLE_MEDIA_RECV_AUDIO, | |
1563 stream->session->media, | |
1564 stream->session->id, | |
1565 stream->participant); | |
1566 gst_bin_add(GST_BIN(priv->confbin), queue); | |
1567 gst_bin_add(GST_BIN(priv->confbin), stream->volume); | |
1568 gst_bin_add(GST_BIN(priv->confbin), stream->level); | |
1569 gst_bin_add(GST_BIN(priv->confbin), sink); | |
1570 gst_element_set_state(sink, GST_STATE_PLAYING); | |
1571 gst_element_set_state(stream->level, GST_STATE_PLAYING); | |
1572 gst_element_set_state(stream->volume, GST_STATE_PLAYING); | |
1573 gst_element_set_state(queue, GST_STATE_PLAYING); | |
1574 gst_element_link(stream->level, sink); | |
1575 gst_element_link(stream->volume, stream->level); | |
1576 gst_element_link(queue, stream->volume); | |
1577 sink = queue; | |
1578 } else if (codec->media_type == FS_MEDIA_TYPE_VIDEO) { | |
1579 stream->src = gst_element_factory_make( | |
1580 "fsfunnel", NULL); | |
1581 sink = gst_element_factory_make( | |
1582 "fakesink", NULL); | |
1583 g_object_set(G_OBJECT(sink), "async", FALSE, NULL); | |
1584 gst_bin_add(GST_BIN(priv->confbin), sink); | |
1585 gst_element_set_state(sink, GST_STATE_PLAYING); | |
1586 } | |
1587 stream->tee = gst_element_factory_make("tee", NULL); | |
1588 gst_bin_add_many(GST_BIN(priv->confbin), | |
1589 stream->src, stream->tee, NULL); | |
1590 gst_element_set_state(stream->tee, GST_STATE_PLAYING); | |
1591 gst_element_set_state(stream->src, GST_STATE_PLAYING); | |
1592 gst_element_link_many(stream->src, stream->tee, sink, NULL); | |
1593 } | |
1594 | |
1595 sinkpad = gst_element_get_request_pad(stream->src, "sink%d"); | |
1596 gst_pad_link(srcpad, sinkpad); | |
1597 gst_object_unref(sinkpad); | |
1598 | |
1599 stream->connected_cb_id = purple_timeout_add(0, | |
1600 (GSourceFunc)purple_media_connected_cb, stream); | |
1601 } | |
1602 | |
1603 static void | |
1604 purple_media_element_added_cb(FsElementAddedNotifier *self, | |
1605 GstBin *bin, GstElement *element, gpointer user_data) | |
1606 { | |
1607 /* | |
1608 * Hack to make H264 work with Gmail video. | |
1609 */ | |
1610 if (!strncmp(GST_ELEMENT_NAME(element), "x264", 4)) { | |
1611 g_object_set(GST_OBJECT(element), "cabac", FALSE, NULL); | |
1612 } | |
1613 } | |
1614 #endif /* USE_VV */ | |
1615 | |
1616 gboolean | |
1617 purple_media_add_stream(PurpleMedia *media, const gchar *sess_id, | |
1618 const gchar *who, PurpleMediaSessionType type, | |
1619 gboolean initiator, const gchar *transmitter, | |
1620 guint num_params, GParameter *params) | |
1621 { | |
1622 #ifdef USE_VV | |
1623 PurpleMediaSession *session; | |
1624 FsParticipant *participant = NULL; | |
1625 PurpleMediaStream *stream = NULL; | |
1626 FsMediaType media_type = purple_media_to_fs_media_type(type); | |
1627 FsStreamDirection type_direction = | |
1628 purple_media_to_fs_stream_direction(type); | |
1629 gboolean is_nice = !strcmp(transmitter, "nice"); | |
1630 | |
1631 g_return_val_if_fail(PURPLE_IS_MEDIA(media), FALSE); | |
1632 | |
1633 session = purple_media_get_session(media, sess_id); | |
1634 | |
1635 if (!session) { | |
1636 GError *err = NULL; | |
1637 GList *codec_conf = NULL, *iter = NULL; | |
1638 gchar *filename = NULL; | |
1639 PurpleMediaSessionType session_type; | |
1640 GstElement *src = NULL; | |
1641 | |
1642 session = g_new0(PurpleMediaSession, 1); | |
1643 | |
1644 session->session = fs_conference_new_session( | |
1645 media->priv->conference, media_type, &err); | |
1646 | |
1647 if (err != NULL) { | |
1648 purple_media_error(media, _("Error creating session: %s"), err->message); | |
1649 g_error_free(err); | |
1650 g_free(session); | |
1651 return FALSE; | |
1652 } | |
1653 | |
1654 filename = g_build_filename(purple_user_dir(), "fs-codec.conf", NULL); | |
1655 codec_conf = fs_codec_list_from_keyfile(filename, &err); | |
1656 g_free(filename); | |
1657 | |
1658 if (err != NULL) { | |
1659 if (err->code == 4) | |
1660 purple_debug_info("media", "Couldn't read " | |
1661 "fs-codec.conf: %s\n", | |
1662 err->message); | |
1663 else | |
1664 purple_debug_error("media", "Error reading " | |
1665 "fs-codec.conf: %s\n", | |
1666 err->message); | |
1667 g_error_free(err); | |
1668 } | |
1669 | |
1670 /* | |
1671 * Add SPEEX if the configuration file doesn't exist or | |
1672 * there isn't a speex entry. | |
1673 */ | |
1674 for (iter = codec_conf; iter; iter = g_list_next(iter)) { | |
1675 FsCodec *codec = iter->data; | |
1676 if (!g_ascii_strcasecmp(codec->encoding_name, "speex")) | |
1677 break; | |
1678 } | |
1679 | |
1680 if (iter == NULL) { | |
1681 codec_conf = g_list_prepend(codec_conf, | |
1682 fs_codec_new(FS_CODEC_ID_ANY, | |
1683 "SPEEX", FS_MEDIA_TYPE_AUDIO, 8000)); | |
1684 codec_conf = g_list_prepend(codec_conf, | |
1685 fs_codec_new(FS_CODEC_ID_ANY, | |
1686 "SPEEX", FS_MEDIA_TYPE_AUDIO, 16000)); | |
1687 } | |
1688 | |
1689 fs_session_set_codec_preferences(session->session, codec_conf, NULL); | |
1690 | |
1691 /* | |
1692 * Removes a 5-7 second delay before | |
1693 * receiving the src-pad-added signal. | |
1694 * Only works for non-multicast FsRtpSessions. | |
1695 */ | |
1696 if (is_nice || !strcmp(transmitter, "rawudp")) | |
1697 g_object_set(G_OBJECT(session->session), | |
1698 "no-rtcp-timeout", 0, NULL); | |
1699 | |
1700 /* | |
1701 * Hack to make x264 work with Gmail video. | |
1702 */ | |
1703 if (is_nice && !strcmp(sess_id, "google-video")) { | |
1704 FsElementAddedNotifier *notifier = | |
1705 fs_element_added_notifier_new(); | |
1706 g_signal_connect(G_OBJECT(notifier), "element-added", | |
1707 G_CALLBACK(purple_media_element_added_cb), | |
1708 stream); | |
1709 fs_element_added_notifier_add(notifier, | |
1710 GST_BIN(media->priv->conference)); | |
1711 } | |
1712 | |
1713 fs_codec_list_destroy(codec_conf); | |
1714 | |
1715 session->id = g_strdup(sess_id); | |
1716 session->media = media; | |
1717 session->type = type; | |
1718 session->initiator = initiator; | |
1719 | |
1720 purple_media_add_session(media, session); | |
1721 g_signal_emit(media, purple_media_signals[STATE_CHANGED], | |
1722 0, PURPLE_MEDIA_STATE_NEW, | |
1723 session->id, NULL); | |
1724 | |
1725 if (type_direction & FS_DIRECTION_SEND) { | |
1726 session_type = purple_media_from_fs(media_type, | |
1727 FS_DIRECTION_SEND); | |
1728 src = purple_media_manager_get_element( | |
1729 media->priv->manager, session_type, | |
1730 media, session->id, who); | |
1731 if (!GST_IS_ELEMENT(src)) { | |
1732 purple_debug_error("media", | |
1733 "Error creating src for session %s\n", | |
1734 session->id); | |
1735 purple_media_end(media, session->id, NULL); | |
1736 return FALSE; | |
1737 } | |
1738 | |
1739 purple_media_set_src(media, session->id, src); | |
1740 gst_element_set_state(session->src, GST_STATE_PLAYING); | |
1741 purple_media_manager_create_output_window( | |
1742 media->priv->manager, | |
1743 session->media, | |
1744 session->id, NULL); | |
1745 } | |
1746 } | |
1747 | |
1748 if (!(participant = purple_media_add_participant(media, who))) { | |
1749 purple_media_remove_session(media, session); | |
1750 g_free(session); | |
1751 return FALSE; | |
1752 } else { | |
1753 g_signal_emit(media, purple_media_signals[STATE_CHANGED], | |
1754 0, PURPLE_MEDIA_STATE_NEW, | |
1755 NULL, who); | |
1756 } | |
1757 | |
1758 stream = purple_media_get_stream(media, sess_id, who); | |
1759 | |
1760 if (!stream) { | |
1761 GError *err = NULL; | |
1762 FsStream *fsstream = NULL; | |
1763 const gchar *stun_ip = purple_network_get_stun_ip(); | |
1764 const gchar *turn_ip = purple_network_get_turn_ip(); | |
1765 | |
1766 if (stun_ip || turn_ip) { | |
1767 guint new_num_params = | |
1768 (stun_ip && is_nice) && turn_ip ? | |
1769 num_params + 2 : num_params + 1; | |
1770 guint next_param_index = num_params; | |
1771 GParameter *param = g_new0(GParameter, new_num_params); | |
1772 memcpy(param, params, sizeof(GParameter) * num_params); | |
1773 | |
1774 if (stun_ip) { | |
1775 purple_debug_info("media", | |
1776 "setting property stun-ip on new stream: %s\n", stun_ip); | |
1777 | |
1778 param[next_param_index].name = "stun-ip"; | |
1779 g_value_init(¶m[next_param_index].value, G_TYPE_STRING); | |
1780 g_value_set_string(¶m[next_param_index].value, stun_ip); | |
1781 next_param_index++; | |
1782 } | |
1783 | |
1784 if (turn_ip && is_nice) { | |
1785 GValueArray *relay_info = g_value_array_new(0); | |
1786 GValue value; | |
1787 gint turn_port = | |
1788 purple_prefs_get_int("/purple/network/turn_port"); | |
1789 const gchar *username = | |
1790 purple_prefs_get_string("/purple/network/turn_username"); | |
1791 const gchar *password = | |
1792 purple_prefs_get_string("/purple/network/turn_password"); | |
1793 GstStructure *turn_setup = gst_structure_new("relay-info", | |
1794 "ip", G_TYPE_STRING, turn_ip, | |
1795 "port", G_TYPE_UINT, turn_port, | |
1796 "username", G_TYPE_STRING, username, | |
1797 "password", G_TYPE_STRING, password, | |
1798 NULL); | |
1799 | |
1800 if (turn_setup) { | |
1801 memset(&value, 0, sizeof(GValue)); | |
1802 g_value_init(&value, GST_TYPE_STRUCTURE); | |
1803 gst_value_set_structure(&value, turn_setup); | |
1804 relay_info = g_value_array_append(relay_info, &value); | |
1805 gst_structure_free(turn_setup); | |
1806 | |
1807 purple_debug_info("media", | |
1808 "setting property relay-info on new stream\n"); | |
1809 param[next_param_index].name = "relay-info"; | |
1810 g_value_init(¶m[next_param_index].value, | |
1811 G_TYPE_VALUE_ARRAY); | |
1812 g_value_set_boxed(¶m[next_param_index].value, | |
1813 relay_info); | |
1814 g_value_array_free(relay_info); | |
1815 } else { | |
1816 purple_debug_error("media", "Error relay info"); | |
1817 g_object_unref(participant); | |
1818 g_hash_table_remove(media->priv->participants, who); | |
1819 purple_media_remove_session(media, session); | |
1820 g_free(session); | |
1821 return FALSE; | |
1822 } | |
1823 } | |
1824 | |
1825 fsstream = fs_session_new_stream(session->session, | |
1826 participant, type_direction & | |
1827 FS_DIRECTION_RECV, transmitter, | |
1828 new_num_params, param, &err); | |
1829 g_free(param); | |
1830 } else { | |
1831 fsstream = fs_session_new_stream(session->session, | |
1832 participant, type_direction & | |
1833 FS_DIRECTION_RECV, transmitter, | |
1834 num_params, params, &err); | |
1835 } | |
1836 | |
1837 if (fsstream == NULL) { | |
1838 purple_debug_error("media", | |
1839 "Error creating stream: %s\n", | |
1840 err && err->message ? | |
1841 err->message : "NULL"); | |
1842 if (err) | |
1843 g_error_free(err); | |
1844 g_object_unref(participant); | |
1845 g_hash_table_remove(media->priv->participants, who); | |
1846 purple_media_remove_session(media, session); | |
1847 g_free(session); | |
1848 return FALSE; | |
1849 } | |
1850 | |
1851 stream = purple_media_insert_stream(session, who, fsstream); | |
1852 stream->initiator = initiator; | |
1853 | |
1854 /* callback for source pad added (new stream source ready) */ | |
1855 g_signal_connect(G_OBJECT(fsstream), | |
1856 "src-pad-added", G_CALLBACK(purple_media_src_pad_added_cb), stream); | |
1857 | |
1858 g_signal_emit(media, purple_media_signals[STATE_CHANGED], | |
1859 0, PURPLE_MEDIA_STATE_NEW, | |
1860 session->id, who); | |
1861 } else { | |
1862 if (purple_media_to_fs_stream_direction(stream->session->type) | |
1863 != type_direction) { | |
1864 /* change direction */ | |
1865 g_object_set(stream->stream, "direction", | |
1866 type_direction, NULL); | |
1867 } | |
1868 } | |
1869 | |
1870 return TRUE; | |
1871 #else | |
1872 return FALSE; | |
1873 #endif /* USE_VV */ | |
1874 } | |
1875 | |
1876 PurpleMediaManager * | |
1877 purple_media_get_manager(PurpleMedia *media) | |
1878 { | |
1879 PurpleMediaManager *ret; | |
1880 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL); | |
1881 g_object_get(media, "manager", &ret, NULL); | |
1882 return ret; | |
1883 } | |
1884 | |
1885 PurpleMediaSessionType | |
1886 purple_media_get_session_type(PurpleMedia *media, const gchar *sess_id) | |
1887 { | |
1888 #ifdef USE_VV | |
1889 PurpleMediaSession *session; | |
1890 g_return_val_if_fail(PURPLE_IS_MEDIA(media), PURPLE_MEDIA_NONE); | |
1891 session = purple_media_get_session(media, sess_id); | |
1892 return session->type; | |
1893 #else | |
1894 return PURPLE_MEDIA_NONE; | |
1895 #endif | |
1896 } | |
1897 /* XXX: Should wait until codecs-ready is TRUE before using this function */ | |
1898 GList * | |
1899 purple_media_get_codecs(PurpleMedia *media, const gchar *sess_id) | |
1900 { | |
1901 #ifdef USE_VV | |
1902 GList *fscodecs; | |
1903 GList *codecs; | |
1904 PurpleMediaSession *session; | |
1905 | |
1906 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL); | |
1907 | |
1908 session = purple_media_get_session(media, sess_id); | |
1909 | |
1910 if (session == NULL) | |
1911 return NULL; | |
1912 | |
1913 g_object_get(G_OBJECT(session->session), | |
1914 "codecs", &fscodecs, NULL); | |
1915 codecs = purple_media_codec_list_from_fs(fscodecs); | |
1916 fs_codec_list_destroy(fscodecs); | |
1917 return codecs; | |
1918 #else | |
1919 return NULL; | |
1920 #endif | |
1921 } | |
1922 | |
1923 GList * | |
1924 purple_media_get_local_candidates(PurpleMedia *media, const gchar *sess_id, | |
1925 const gchar *participant) | |
1926 { | |
1927 #ifdef USE_VV | |
1928 PurpleMediaStream *stream; | |
1929 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL); | |
1930 stream = purple_media_get_stream(media, sess_id, participant); | |
1931 return stream ? purple_media_candidate_list_from_fs( | |
1932 stream->local_candidates) : NULL; | |
1933 #else | |
1934 return NULL; | |
1935 #endif | |
1936 } | |
1937 | |
1938 void | |
1939 purple_media_add_remote_candidates(PurpleMedia *media, const gchar *sess_id, | |
1940 const gchar *participant, | |
1941 GList *remote_candidates) | |
1942 { | |
1943 #ifdef USE_VV | |
1944 PurpleMediaStream *stream; | |
1945 GError *err = NULL; | |
1946 | |
1947 g_return_if_fail(PURPLE_IS_MEDIA(media)); | |
1948 stream = purple_media_get_stream(media, sess_id, participant); | |
1949 | |
1950 if (stream == NULL) { | |
1951 purple_debug_error("media", | |
1952 "purple_media_add_remote_candidates: " | |
1953 "couldn't find stream %s %s.\n", | |
1954 sess_id ? sess_id : "(null)", | |
1955 participant ? participant : "(null)"); | |
1956 return; | |
1957 } | |
1958 | |
1959 stream->remote_candidates = g_list_concat(stream->remote_candidates, | |
1960 purple_media_candidate_list_to_fs(remote_candidates)); | |
1961 | |
1962 if (stream->accepted == TRUE) { | |
1963 fs_stream_set_remote_candidates(stream->stream, | |
1964 stream->remote_candidates, &err); | |
1965 | |
1966 if (err) { | |
1967 purple_debug_error("media", "Error adding remote" | |
1968 " candidates: %s\n", err->message); | |
1969 g_error_free(err); | |
1970 } | |
1971 } | |
1972 #endif | |
1973 } | |
1974 | |
1975 #if 0 | |
1976 /* | |
1977 * These two functions aren't being used and I'd rather not lock in the API | |
1978 * until they are needed. If they ever are. | |
1979 */ | |
1980 | |
1981 GList * | |
1982 purple_media_get_active_local_candidates(PurpleMedia *media, | |
1983 const gchar *sess_id, const gchar *participant) | |
1984 { | |
1985 #ifdef USE_VV | |
1986 PurpleMediaStream *stream; | |
1987 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL); | |
1988 stream = purple_media_get_stream(media, sess_id, participant); | |
1989 return purple_media_candidate_list_from_fs( | |
1990 stream->active_local_candidates); | |
1991 #else | |
1992 return NULL; | |
1993 #endif | |
1994 } | |
1995 | |
1996 GList * | |
1997 purple_media_get_active_remote_candidates(PurpleMedia *media, | |
1998 const gchar *sess_id, const gchar *participant) | |
1999 { | |
2000 #ifdef USE_VV | |
2001 PurpleMediaStream *stream; | |
2002 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL); | |
2003 stream = purple_media_get_stream(media, sess_id, participant); | |
2004 return purple_media_candidate_list_from_fs( | |
2005 stream->active_remote_candidates); | |
2006 #else | |
2007 return NULL; | |
2008 #endif | |
2009 } | |
2010 #endif | |
2011 | |
2012 gboolean | |
2013 purple_media_set_remote_codecs(PurpleMedia *media, const gchar *sess_id, | |
2014 const gchar *participant, GList *codecs) | |
2015 { | |
2016 #ifdef USE_VV | |
2017 PurpleMediaStream *stream; | |
2018 FsStream *fsstream; | |
2019 GList *fscodecs; | |
2020 GError *err = NULL; | |
2021 | |
2022 g_return_val_if_fail(PURPLE_IS_MEDIA(media), FALSE); | |
2023 stream = purple_media_get_stream(media, sess_id, participant); | |
2024 | |
2025 if (stream == NULL) | |
2026 return FALSE; | |
2027 | |
2028 fsstream = stream->stream; | |
2029 fscodecs = purple_media_codec_list_to_fs(codecs); | |
2030 fs_stream_set_remote_codecs(fsstream, fscodecs, &err); | |
2031 fs_codec_list_destroy(fscodecs); | |
2032 | |
2033 if (err) { | |
2034 purple_debug_error("media", "Error setting remote codecs: %s\n", | |
2035 err->message); | |
2036 g_error_free(err); | |
2037 return FALSE; | |
2038 } | |
2039 return TRUE; | |
2040 #else | |
2041 return FALSE; | |
2042 #endif | |
2043 } | |
2044 | |
2045 gboolean | |
2046 purple_media_candidates_prepared(PurpleMedia *media, | |
2047 const gchar *session_id, const gchar *participant) | |
2048 { | |
2049 #ifdef USE_VV | |
2050 GList *streams; | |
2051 gboolean prepared = TRUE; | |
2052 | |
2053 g_return_val_if_fail(PURPLE_IS_MEDIA(media), FALSE); | |
2054 | |
2055 streams = purple_media_get_streams(media, session_id, participant); | |
2056 | |
2057 for (; streams; streams = g_list_delete_link(streams, streams)) { | |
2058 PurpleMediaStream *stream = streams->data; | |
2059 if (stream->candidates_prepared == FALSE) { | |
2060 g_list_free(streams); | |
2061 prepared = FALSE; | |
2062 break; | |
2063 } | |
2064 } | |
2065 | |
2066 return prepared; | |
2067 #else | |
2068 return FALSE; | |
2069 #endif | |
2070 } | |
2071 | |
2072 gboolean | |
2073 purple_media_set_send_codec(PurpleMedia *media, const gchar *sess_id, PurpleMediaCodec *codec) | |
2074 { | |
2075 #ifdef USE_VV | |
2076 PurpleMediaSession *session; | |
2077 FsCodec *fscodec; | |
2078 GError *err = NULL; | |
2079 | |
2080 g_return_val_if_fail(PURPLE_IS_MEDIA(media), FALSE); | |
2081 | |
2082 session = purple_media_get_session(media, sess_id); | |
2083 | |
2084 if (session != NULL) | |
2085 return FALSE; | |
2086 | |
2087 fscodec = purple_media_codec_to_fs(codec); | |
2088 fs_session_set_send_codec(session->session, fscodec, &err); | |
2089 fs_codec_destroy(fscodec); | |
2090 | |
2091 if (err) { | |
2092 purple_debug_error("media", "Error setting send codec\n"); | |
2093 g_error_free(err); | |
2094 return FALSE; | |
2095 } | |
2096 return TRUE; | |
2097 #else | |
2098 return FALSE; | |
2099 #endif | |
2100 } | |
2101 | |
2102 gboolean | |
2103 purple_media_codecs_ready(PurpleMedia *media, const gchar *sess_id) | |
2104 { | |
2105 #ifdef USE_VV | |
2106 gboolean ret; | |
2107 | |
2108 g_return_val_if_fail(PURPLE_IS_MEDIA(media), FALSE); | |
2109 | |
2110 if (sess_id != NULL) { | |
2111 PurpleMediaSession *session; | |
2112 session = purple_media_get_session(media, sess_id); | |
2113 | |
2114 if (session == NULL) | |
2115 return FALSE; | |
2116 if (session->type & (PURPLE_MEDIA_SEND_AUDIO | | |
2117 PURPLE_MEDIA_SEND_VIDEO)) | |
2118 g_object_get(session->session, | |
2119 "codecs-ready", &ret, NULL); | |
2120 else | |
2121 ret = TRUE; | |
2122 } else { | |
2123 GList *values = g_hash_table_get_values(media->priv->sessions); | |
2124 for (; values; values = g_list_delete_link(values, values)) { | |
2125 PurpleMediaSession *session = values->data; | |
2126 if (session->type & (PURPLE_MEDIA_SEND_AUDIO | | |
2127 PURPLE_MEDIA_SEND_VIDEO)) | |
2128 g_object_get(session->session, | |
2129 "codecs-ready", &ret, NULL); | |
2130 else | |
2131 ret = TRUE; | |
2132 | |
2133 if (ret == FALSE) | |
2134 break; | |
2135 } | |
2136 if (values != NULL) | |
2137 g_list_free(values); | |
2138 } | |
2139 return ret; | |
2140 #else | |
2141 return FALSE; | |
2142 #endif | |
2143 } | |
2144 | |
2145 gboolean | |
2146 purple_media_is_initiator(PurpleMedia *media, | |
2147 const gchar *sess_id, const gchar *participant) | |
2148 { | |
2149 #ifdef USE_VV | |
2150 g_return_val_if_fail(PURPLE_IS_MEDIA(media), FALSE); | |
2151 | |
2152 if (sess_id == NULL && participant == NULL) | |
2153 return media->priv->initiator; | |
2154 else if (sess_id != NULL && participant == NULL) { | |
2155 PurpleMediaSession *session = | |
2156 purple_media_get_session(media, sess_id); | |
2157 return session != NULL ? session->initiator : FALSE; | |
2158 } else if (sess_id != NULL && participant != NULL) { | |
2159 PurpleMediaStream *stream = purple_media_get_stream( | |
2160 media, sess_id, participant); | |
2161 return stream != NULL ? stream->initiator : FALSE; | |
2162 } | |
2163 #endif | |
2164 return FALSE; | |
2165 } | |
2166 | |
2167 gboolean | |
2168 purple_media_accepted(PurpleMedia *media, const gchar *sess_id, | |
2169 const gchar *participant) | |
2170 { | |
2171 #ifdef USE_VV | |
2172 gboolean accepted = TRUE; | |
2173 | |
2174 g_return_val_if_fail(PURPLE_IS_MEDIA(media), FALSE); | |
2175 | |
2176 if (sess_id == NULL && participant == NULL) { | |
2177 GList *streams = media->priv->streams; | |
2178 | |
2179 for (; streams; streams = g_list_next(streams)) { | |
2180 PurpleMediaStream *stream = streams->data; | |
2181 if (stream->accepted == FALSE) { | |
2182 accepted = FALSE; | |
2183 break; | |
2184 } | |
2185 } | |
2186 } else if (sess_id != NULL && participant == NULL) { | |
2187 GList *streams = purple_media_get_streams( | |
2188 media, sess_id, NULL); | |
2189 for (; streams; streams = | |
2190 g_list_delete_link(streams, streams)) { | |
2191 PurpleMediaStream *stream = streams->data; | |
2192 if (stream->accepted == FALSE) { | |
2193 g_list_free(streams); | |
2194 accepted = FALSE; | |
2195 break; | |
2196 } | |
2197 } | |
2198 } else if (sess_id != NULL && participant != NULL) { | |
2199 PurpleMediaStream *stream = purple_media_get_stream( | |
2200 media, sess_id, participant); | |
2201 if (stream == NULL || stream->accepted == FALSE) | |
2202 accepted = FALSE; | |
2203 } | |
2204 | |
2205 return accepted; | |
2206 #else | |
2207 return FALSE; | |
2208 #endif | |
2209 } | |
2210 | |
2211 void purple_media_set_input_volume(PurpleMedia *media, | |
2212 const gchar *session_id, double level) | |
2213 { | |
2214 #ifdef USE_VV | |
2215 GList *sessions; | |
2216 | |
2217 g_return_if_fail(PURPLE_IS_MEDIA(media)); | |
2218 | |
2219 purple_prefs_set_int("/purple/media/audio/volume/input", level); | |
2220 | |
2221 if (session_id == NULL) | |
2222 sessions = g_hash_table_get_values(media->priv->sessions); | |
2223 else | |
2224 sessions = g_list_append(NULL, | |
2225 purple_media_get_session(media, session_id)); | |
2226 | |
2227 for (; sessions; sessions = g_list_delete_link(sessions, sessions)) { | |
2228 PurpleMediaSession *session = sessions->data; | |
2229 | |
2230 if (session->type & PURPLE_MEDIA_SEND_AUDIO) { | |
2231 gchar *name = g_strdup_printf("volume_%s", | |
2232 session->id); | |
2233 GstElement *volume = gst_bin_get_by_name( | |
2234 GST_BIN(session->media->priv->confbin), | |
2235 name); | |
2236 g_free(name); | |
2237 g_object_set(volume, "volume", level/10.0, NULL); | |
2238 } | |
2239 } | |
2240 #endif | |
2241 } | |
2242 | |
2243 void purple_media_set_output_volume(PurpleMedia *media, | |
2244 const gchar *session_id, const gchar *participant, | |
2245 double level) | |
2246 { | |
2247 #ifdef USE_VV | |
2248 GList *streams; | |
2249 | |
2250 g_return_if_fail(PURPLE_IS_MEDIA(media)); | |
2251 | |
2252 purple_prefs_set_int("/purple/media/audio/volume/output", level); | |
2253 | |
2254 streams = purple_media_get_streams(media, | |
2255 session_id, participant); | |
2256 | |
2257 for (; streams; streams = g_list_delete_link(streams, streams)) { | |
2258 PurpleMediaStream *stream = streams->data; | |
2259 | |
2260 if (stream->session->type & PURPLE_MEDIA_RECV_AUDIO | |
2261 && GST_IS_ELEMENT(stream->volume)) { | |
2262 g_object_set(stream->volume, "volume", level/10.0, NULL); | |
2263 } | |
2264 } | |
2265 #endif | |
2266 } | |
2267 | |
2268 gulong | |
2269 purple_media_set_output_window(PurpleMedia *media, const gchar *session_id, | |
2270 const gchar *participant, gulong window_id) | |
2271 { | |
2272 #ifdef USE_VV | |
2273 g_return_val_if_fail(PURPLE_IS_MEDIA(media), FALSE); | |
2274 | |
2275 return purple_media_manager_set_output_window(media->priv->manager, | |
2276 media, session_id, participant, window_id); | |
2277 #else | |
2278 return 0; | |
2279 #endif | |
2280 } | |
2281 | |
2282 void | |
2283 purple_media_remove_output_windows(PurpleMedia *media) | |
2284 { | |
2285 #ifdef USE_VV | |
2286 GList *iter = media->priv->streams; | |
2287 for (; iter; iter = g_list_next(iter)) { | |
2288 PurpleMediaStream *stream = iter->data; | |
2289 purple_media_manager_remove_output_windows( | |
2290 media->priv->manager, media, | |
2291 stream->session->id, stream->participant); | |
2292 } | |
2293 | |
2294 iter = purple_media_get_session_ids(media); | |
2295 for (; iter; iter = g_list_delete_link(iter, iter)) { | |
2296 gchar *session_name = iter->data; | |
2297 purple_media_manager_remove_output_windows( | |
2298 media->priv->manager, media, | |
2299 session_name, NULL); | |
2300 } | |
2301 #endif | |
2302 } | |
2303 | |
2304 #ifdef USE_GSTREAMER | |
2305 GstElement * | |
2306 purple_media_get_tee(PurpleMedia *media, | |
2307 const gchar *session_id, const gchar *participant) | |
2308 { | |
2309 #ifdef USE_VV | |
2310 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL); | |
2311 | |
2312 if (session_id != NULL && participant == NULL) { | |
2313 PurpleMediaSession *session = | |
2314 purple_media_get_session(media, session_id); | |
2315 return (session != NULL) ? session->tee : NULL; | |
2316 } else if (session_id != NULL && participant != NULL) { | |
2317 PurpleMediaStream *stream = | |
2318 purple_media_get_stream(media, | |
2319 session_id, participant); | |
2320 return (stream != NULL) ? stream->tee : NULL; | |
2321 } | |
2322 g_return_val_if_reached(NULL); | |
2323 #else | |
2324 return NULL; | |
2325 #endif | |
2326 } | |
2327 #endif /* USE_GSTREAMER */ | |
2328 |