Mercurial > pidgin.yaz

comparison libpurple/media/media.c @ 29534:fb2c0674e828

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Move media.c into libpurple/media/.
author maiku@pidgin.im
date Wed, 21 Oct 2009 20:05:52 +0000
parents
children ab1e29779722
comparison
equal deleted inserted replaced
29533:8a50c08c289d 29534:fb2c0674e828
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 /** @copydoc _PurpleMediaCandidateClass */
57 typedef struct _PurpleMediaCandidateClass PurpleMediaCandidateClass;
58 /** @copydoc _PurpleMediaCandidatePrivate */
59 typedef struct _PurpleMediaCandidatePrivate PurpleMediaCandidatePrivate;
60 /** @copydoc _PurpleMediaCodecClass */
61 typedef struct _PurpleMediaCodecClass PurpleMediaCodecClass;
62 /** @copydoc _PurpleMediaCodecPrivate */
63 typedef struct _PurpleMediaCodecPrivate PurpleMediaCodecPrivate;
64
65 /** The media class */
66 struct _PurpleMediaClass
67 {
68 GObjectClass parent_class; /**< The parent class. */
69 };
70
71 /** The media class's private data */
72 struct _PurpleMedia
73 {
74 GObject parent; /**< The parent of this object. */
75 PurpleMediaPrivate *priv; /**< The private data of this object. */
76 };
77
78 struct _PurpleMediaSession
79 {
80 gchar *id;
81 PurpleMedia *media;
82 GstElement *src;
83 GstElement *tee;
84 FsSession *session;
85
86 PurpleMediaSessionType type;
87 gboolean initiator;
88 };
89
90 struct _PurpleMediaStream
91 {
92 PurpleMediaSession *session;
93 gchar *participant;
94 FsStream *stream;
95 GstElement *src;
96 GstElement *tee;
97 GstElement *volume;
98 GstElement *level;
99
100 GList *local_candidates;
101 GList *remote_candidates;
102
103 gboolean initiator;
104 gboolean accepted;
105 gboolean candidates_prepared;
106
107 GList *active_local_candidates;
108 GList *active_remote_candidates;
109
110 guint connected_cb_id;
111 };
112 #endif
113
114 struct _PurpleMediaPrivate
115 {
116 #ifdef USE_VV
117 PurpleMediaManager *manager;
118 PurpleAccount *account;
119 FsConference *conference;
120 gboolean initiator;
121 gpointer prpl_data;
122
123 GHashTable *sessions; /* PurpleMediaSession table */
124 GHashTable *participants; /* FsParticipant table */
125
126 GList *streams; /* PurpleMediaStream table */
127
128 GstElement *confbin;
129 #else
130 gpointer dummy;
131 #endif
132 };
133
134 #ifdef USE_VV
135 #define PURPLE_MEDIA_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), PURPLE_TYPE_MEDIA, PurpleMediaPrivate))
136 #define PURPLE_MEDIA_CANDIDATE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), PURPLE_TYPE_MEDIA_CANDIDATE, PurpleMediaCandidatePrivate))
137 #define PURPLE_MEDIA_CODEC_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), PURPLE_TYPE_MEDIA_CODEC, PurpleMediaCodecPrivate))
138
139 static void purple_media_class_init (PurpleMediaClass *klass);
140 static void purple_media_init (PurpleMedia *media);
141 static void purple_media_dispose (GObject *object);
142 static void purple_media_finalize (GObject *object);
143 static void purple_media_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
144 static void purple_media_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
145
146 static void purple_media_new_local_candidate_cb(FsStream *stream,
147 FsCandidate *local_candidate, PurpleMediaSession *session);
148 static void purple_media_candidates_prepared_cb(FsStream *stream,
149 PurpleMediaSession *session);
150 static void purple_media_candidate_pair_established_cb(FsStream *stream,
151 FsCandidate *native_candidate, FsCandidate *remote_candidate,
152 PurpleMediaSession *session);
153 static gboolean media_bus_call(GstBus *bus,
154 GstMessage *msg, PurpleMedia *media);
155
156 static GObjectClass *parent_class = NULL;
157
158
159
160 enum {
161 S_ERROR,
162 CANDIDATES_PREPARED,
163 CODECS_CHANGED,
164 LEVEL,
165 NEW_CANDIDATE,
166 STATE_CHANGED,
167 STREAM_INFO,
168 LAST_SIGNAL
169 };
170 static guint purple_media_signals[LAST_SIGNAL] = {0};
171
172 enum {
173 PROP_0,
174 PROP_MANAGER,
175 PROP_ACCOUNT,
176 PROP_CONFERENCE,
177 PROP_INITIATOR,
178 PROP_PRPL_DATA,
179 };
180 #endif
181
182
183 /*
184 * PurpleMediaElementType
185 */
186
187 GType
188 purple_media_session_type_get_type()
189 {
190 static GType type = 0;
191 if (type == 0) {
192 static const GFlagsValue values[] = {
193 { PURPLE_MEDIA_NONE,
194 "PURPLE_MEDIA_NONE", "none" },
195 { PURPLE_MEDIA_RECV_AUDIO,
196 "PURPLE_MEDIA_RECV_AUDIO", "recv-audio" },
197 { PURPLE_MEDIA_SEND_AUDIO,
198 "PURPLE_MEDIA_SEND_AUDIO", "send-audio" },
199 { PURPLE_MEDIA_RECV_VIDEO,
200 "PURPLE_MEDIA_RECV_VIDEO", "recv-video" },
201 { PURPLE_MEDIA_SEND_VIDEO,
202 "PURPLE_MEDIA_SEND_VIDEO", "send-audio" },
203 { PURPLE_MEDIA_AUDIO,
204 "PURPLE_MEDIA_AUDIO", "audio" },
205 { PURPLE_MEDIA_VIDEO,
206 "PURPLE_MEDIA_VIDEO", "video" },
207 { 0, NULL, NULL }
208 };
209 type = g_flags_register_static(
210 "PurpleMediaSessionType", values);
211 }
212 return type;
213 }
214
215 GType
216 purple_media_get_type()
217 {
218 #ifdef USE_VV
219 static GType type = 0;
220
221 if (type == 0) {
222 static const GTypeInfo info = {
223 sizeof(PurpleMediaClass),
224 NULL,
225 NULL,
226 (GClassInitFunc) purple_media_class_init,
227 NULL,
228 NULL,
229 sizeof(PurpleMedia),
230 0,
231 (GInstanceInitFunc) purple_media_init,
232 NULL
233 };
234 type = g_type_register_static(G_TYPE_OBJECT, "PurpleMedia", &info, 0);
235 }
236 return type;
237 #else
238 return G_TYPE_NONE;
239 #endif
240 }
241
242 GType
243 purple_media_state_changed_get_type()
244 {
245 static GType type = 0;
246 if (type == 0) {
247 static const GEnumValue values[] = {
248 { PURPLE_MEDIA_STATE_NEW,
249 "PURPLE_MEDIA_STATE_NEW", "new" },
250 { PURPLE_MEDIA_STATE_CONNECTED,
251 "PURPLE_MEDIA_STATE_CONNECTED", "connected" },
252 { PURPLE_MEDIA_STATE_END,
253 "PURPLE_MEDIA_STATE_END", "end" },
254 { 0, NULL, NULL }
255 };
256 type = g_enum_register_static("PurpleMediaState", values);
257 }
258 return type;
259 }
260
261 GType
262 purple_media_info_type_get_type()
263 {
264 static GType type = 0;
265 if (type == 0) {
266 static const GEnumValue values[] = {
267 { PURPLE_MEDIA_INFO_HANGUP,
268 "PURPLE_MEDIA_INFO_HANGUP", "hangup" },
269 { PURPLE_MEDIA_INFO_ACCEPT,
270 "PURPLE_MEDIA_INFO_ACCEPT", "accept" },
271 { PURPLE_MEDIA_INFO_REJECT,
272 "PURPLE_MEDIA_INFO_REJECT", "reject" },
273 { PURPLE_MEDIA_INFO_MUTE,
274 "PURPLE_MEDIA_INFO_MUTE", "mute" },
275 { PURPLE_MEDIA_INFO_UNMUTE,
276 "PURPLE_MEDIA_INFO_UNMUTE", "unmute" },
277 { PURPLE_MEDIA_INFO_PAUSE,
278 "PURPLE_MEDIA_INFO_PAUSE", "pause" },
279 { PURPLE_MEDIA_INFO_UNPAUSE,
280 "PURPLE_MEDIA_INFO_UNPAUSE", "unpause" },
281 { PURPLE_MEDIA_INFO_HOLD,
282 "PURPLE_MEDIA_INFO_HOLD", "hold" },
283 { PURPLE_MEDIA_INFO_UNHOLD,
284 "PURPLE_MEDIA_INFO_HOLD", "unhold" },
285 { 0, NULL, NULL }
286 };
287 type = g_enum_register_static("PurpleMediaInfoType", values);
288 }
289 return type;
290 }
291
292 GType
293 purple_media_caps_get_type()
294 {
295 static GType type = 0;
296 if (type == 0) {
297 static const GEnumValue values[] = {
298 { PURPLE_MEDIA_CAPS_NONE,
299 "PURPLE_MEDIA_CAPS_NONE", "none" },
300 { PURPLE_MEDIA_CAPS_AUDIO,
301 "PURPLE_MEDIA_CAPS_AUDIO", "audio" },
302 { PURPLE_MEDIA_CAPS_AUDIO_SINGLE_DIRECTION,
303 "PURPLE_MEDIA_CAPS_AUDIO_SINGLE_DIRECTION",
304 "audio-single-direction" },
305 { PURPLE_MEDIA_CAPS_VIDEO,
306 "PURPLE_MEDIA_CAPS_VIDEO", "video" },
307 { PURPLE_MEDIA_CAPS_VIDEO_SINGLE_DIRECTION,
308 "PURPLE_MEDIA_CAPS_VIDEO_SINGLE_DIRECTION",
309 "video-single-direction" },
310 { PURPLE_MEDIA_CAPS_AUDIO_VIDEO,
311 "PURPLE_MEDIA_CAPS_AUDIO_VIDEO",
312 "audio-video" },
313 { PURPLE_MEDIA_CAPS_MODIFY_SESSION,
314 "PURPLE_MEDIA_CAPS_MODIFY_SESSION",
315 "modify-session" },
316 { PURPLE_MEDIA_CAPS_CHANGE_DIRECTION,
317 "PURPLE_MEDIA_CAPS_CHANGE_DIRECTION",
318 "change-direction" },
319 { 0, NULL, NULL }
320 };
321 type = g_enum_register_static("PurpleMediaCaps", values);
322 }
323 return type;
324 }
325
326 #ifdef USE_VV
327 static void
328 purple_media_class_init (PurpleMediaClass *klass)
329 {
330 GObjectClass *gobject_class = (GObjectClass*)klass;
331 parent_class = g_type_class_peek_parent(klass);
332
333 gobject_class->dispose = purple_media_dispose;
334 gobject_class->finalize = purple_media_finalize;
335 gobject_class->set_property = purple_media_set_property;
336 gobject_class->get_property = purple_media_get_property;
337
338 g_object_class_install_property(gobject_class, PROP_MANAGER,
339 g_param_spec_object("manager",
340 "Purple Media Manager",
341 "The media manager that contains this media session.",
342 PURPLE_TYPE_MEDIA_MANAGER,
343 G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
344
345 g_object_class_install_property(gobject_class, PROP_ACCOUNT,
346 g_param_spec_pointer("account",
347 "PurpleAccount",
348 "The account this media session is on.",
349 G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
350
351 g_object_class_install_property(gobject_class, PROP_CONFERENCE,
352 g_param_spec_object("conference",
353 "Farsight conference",
354 "The FsConference associated with this media.",
355 FS_TYPE_CONFERENCE,
356 G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE));
357
358 g_object_class_install_property(gobject_class, PROP_INITIATOR,
359 g_param_spec_boolean("initiator",
360 "initiator",
361 "If the local user initiated the conference.",
362 FALSE,
363 G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
364
365 g_object_class_install_property(gobject_class, PROP_PRPL_DATA,
366 g_param_spec_pointer("prpl-data",
367 "gpointer",
368 "Data the prpl plugin set on the media session.",
369 G_PARAM_READWRITE));
370
371 purple_media_signals[S_ERROR] = g_signal_new("error", G_TYPE_FROM_CLASS(klass),
372 G_SIGNAL_RUN_LAST, 0, NULL, NULL,
373 g_cclosure_marshal_VOID__STRING,
374 G_TYPE_NONE, 1, G_TYPE_STRING);
375 purple_media_signals[CANDIDATES_PREPARED] = g_signal_new("candidates-prepared", G_TYPE_FROM_CLASS(klass),
376 G_SIGNAL_RUN_LAST, 0, NULL, NULL,
377 purple_smarshal_VOID__STRING_STRING,
378 G_TYPE_NONE, 2, G_TYPE_STRING,
379 G_TYPE_STRING);
380 purple_media_signals[CODECS_CHANGED] = g_signal_new("codecs-changed", G_TYPE_FROM_CLASS(klass),
381 G_SIGNAL_RUN_LAST, 0, NULL, NULL,
382 g_cclosure_marshal_VOID__STRING,
383 G_TYPE_NONE, 1, G_TYPE_STRING);
384 purple_media_signals[LEVEL] = g_signal_new("level", G_TYPE_FROM_CLASS(klass),
385 G_SIGNAL_RUN_LAST, 0, NULL, NULL,
386 purple_smarshal_VOID__STRING_STRING_DOUBLE,
387 G_TYPE_NONE, 3, G_TYPE_STRING,
388 G_TYPE_STRING, G_TYPE_DOUBLE);
389 purple_media_signals[NEW_CANDIDATE] = g_signal_new("new-candidate", G_TYPE_FROM_CLASS(klass),
390 G_SIGNAL_RUN_LAST, 0, NULL, NULL,
391 purple_smarshal_VOID__POINTER_POINTER_OBJECT,
392 G_TYPE_NONE, 3, G_TYPE_POINTER,
393 G_TYPE_POINTER, PURPLE_TYPE_MEDIA_CANDIDATE);
394 purple_media_signals[STATE_CHANGED] = g_signal_new("state-changed", G_TYPE_FROM_CLASS(klass),
395 G_SIGNAL_RUN_LAST, 0, NULL, NULL,
396 purple_smarshal_VOID__ENUM_STRING_STRING,
397 G_TYPE_NONE, 3, PURPLE_MEDIA_TYPE_STATE,
398 G_TYPE_STRING, G_TYPE_STRING);
399 purple_media_signals[STREAM_INFO] = g_signal_new("stream-info", G_TYPE_FROM_CLASS(klass),
400 G_SIGNAL_RUN_LAST, 0, NULL, NULL,
401 purple_smarshal_VOID__ENUM_STRING_STRING_BOOLEAN,
402 G_TYPE_NONE, 4, PURPLE_MEDIA_TYPE_INFO_TYPE,
403 G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN);
404 g_type_class_add_private(klass, sizeof(PurpleMediaPrivate));
405 }
406
407
408 static void
409 purple_media_init (PurpleMedia *media)
410 {
411 media->priv = PURPLE_MEDIA_GET_PRIVATE(media);
412 memset(media->priv, 0, sizeof(*media->priv));
413 }
414
415 static void
416 purple_media_stream_free(PurpleMediaStream *stream)
417 {
418 if (stream == NULL)
419 return;
420
421 /* Remove the connected_cb timeout */
422 if (stream->connected_cb_id != 0)
423 purple_timeout_remove(stream->connected_cb_id);
424
425 g_free(stream->participant);
426
427 if (stream->local_candidates)
428 fs_candidate_list_destroy(stream->local_candidates);
429 if (stream->remote_candidates)
430 fs_candidate_list_destroy(stream->remote_candidates);
431
432 if (stream->active_local_candidates)
433 fs_candidate_list_destroy(stream->active_local_candidates);
434 if (stream->active_remote_candidates)
435 fs_candidate_list_destroy(stream->active_remote_candidates);
436
437 g_free(stream);
438 }
439
440 static void
441 purple_media_session_free(PurpleMediaSession *session)
442 {
443 if (session == NULL)
444 return;
445
446 g_free(session->id);
447 g_free(session);
448 }
449
450 static void
451 purple_media_dispose(GObject *media)
452 {
453 PurpleMediaPrivate *priv = PURPLE_MEDIA_GET_PRIVATE(media);
454 GList *iter = NULL;
455
456 purple_debug_info("media","purple_media_dispose\n");
457
458 purple_media_manager_remove_media(priv->manager, PURPLE_MEDIA(media));
459
460 if (priv->confbin) {
461 gst_element_set_locked_state(priv->confbin, TRUE);
462 gst_element_set_state(GST_ELEMENT(priv->confbin),
463 GST_STATE_NULL);
464 gst_bin_remove(GST_BIN(purple_media_manager_get_pipeline(
465 priv->manager)), priv->confbin);
466 priv->confbin = NULL;
467 priv->conference = NULL;
468 }
469
470 for (iter = priv->streams; iter; iter = g_list_next(iter)) {
471 PurpleMediaStream *stream = iter->data;
472 if (stream->stream) {
473 g_object_unref(stream->stream);
474 stream->stream = NULL;
475 }
476 }
477
478 if (priv->sessions) {
479 GList *sessions = g_hash_table_get_values(priv->sessions);
480 for (; sessions; sessions = g_list_delete_link(sessions, sessions)) {
481 PurpleMediaSession *session = sessions->data;
482 if (session->session) {
483 g_object_unref(session->session);
484 session->session = NULL;
485 }
486 }
487 }
488
489 if (priv->participants) {
490 GList *participants = g_hash_table_get_values(priv->participants);
491 for (; participants; participants = g_list_delete_link(participants, participants))
492 g_object_unref(participants->data);
493 }
494
495 if (priv->manager) {
496 GstElement *pipeline = purple_media_manager_get_pipeline(
497 priv->manager);
498 GstBus *bus = gst_pipeline_get_bus(GST_PIPELINE(pipeline));
499 g_signal_handlers_disconnect_matched(G_OBJECT(bus),
500 G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA,
501 0, 0, 0, media_bus_call, media);
502 gst_object_unref(bus);
503
504 g_object_unref(priv->manager);
505 priv->manager = NULL;
506 }
507
508 G_OBJECT_CLASS(parent_class)->dispose(media);
509 }
510
511 static void
512 purple_media_finalize(GObject *media)
513 {
514 PurpleMediaPrivate *priv = PURPLE_MEDIA_GET_PRIVATE(media);
515 purple_debug_info("media","purple_media_finalize\n");
516
517 for (; priv->streams; priv->streams = g_list_delete_link(priv->streams, priv->streams))
518 purple_media_stream_free(priv->streams->data);
519
520 if (priv->sessions) {
521 GList *sessions = g_hash_table_get_values(priv->sessions);
522 for (; sessions; sessions = g_list_delete_link(sessions, sessions)) {
523 purple_media_session_free(sessions->data);
524 }
525 g_hash_table_destroy(priv->sessions);
526 }
527
528 G_OBJECT_CLASS(parent_class)->finalize(media);
529 }
530
531 static void
532 purple_media_setup_pipeline(PurpleMedia *media)
533 {
534 GstBus *bus;
535 gchar *name;
536 GstElement *pipeline;
537
538 if (media->priv->conference == NULL || media->priv->manager == NULL)
539 return;
540
541 pipeline = purple_media_manager_get_pipeline(media->priv->manager);
542
543 name = g_strdup_printf("conf_%p",
544 media->priv->conference);
545 media->priv->confbin = gst_bin_new(name);
546 g_free(name);
547
548 bus = gst_pipeline_get_bus(GST_PIPELINE(pipeline));
549 g_signal_connect(G_OBJECT(bus), "message",
550 G_CALLBACK(media_bus_call), media);
551 gst_object_unref(bus);
552
553 gst_bin_add(GST_BIN(pipeline),
554 media->priv->confbin);
555 gst_bin_add(GST_BIN(media->priv->confbin),
556 GST_ELEMENT(media->priv->conference));
557 gst_element_set_state(GST_ELEMENT(media->priv->confbin),
558 GST_STATE_PLAYING);
559 }
560
561 static void
562 purple_media_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
563 {
564 PurpleMedia *media;
565 g_return_if_fail(PURPLE_IS_MEDIA(object));
566
567 media = PURPLE_MEDIA(object);
568
569 switch (prop_id) {
570 case PROP_MANAGER:
571 media->priv->manager = g_value_get_object(value);
572 g_object_ref(media->priv->manager);
573
574 purple_media_setup_pipeline(media);
575 break;
576 case PROP_ACCOUNT:
577 media->priv->account = g_value_get_pointer(value);
578 break;
579 case PROP_CONFERENCE: {
580 if (media->priv->conference)
581 gst_object_unref(media->priv->conference);
582 media->priv->conference = g_value_get_object(value);
583 gst_object_ref(media->priv->conference);
584
585 purple_media_setup_pipeline(media);
586 break;
587 }
588 case PROP_INITIATOR:
589 media->priv->initiator = g_value_get_boolean(value);
590 break;
591 case PROP_PRPL_DATA:
592 media->priv->prpl_data = g_value_get_pointer(value);
593 break;
594 default:
595 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
596 break;
597 }
598 }
599
600 static void
601 purple_media_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
602 {
603 PurpleMedia *media;
604 g_return_if_fail(PURPLE_IS_MEDIA(object));
605
606 media = PURPLE_MEDIA(object);
607
608 switch (prop_id) {
609 case PROP_MANAGER:
610 g_value_set_object(value, media->priv->manager);
611 break;
612 case PROP_ACCOUNT:
613 g_value_set_pointer(value, media->priv->account);
614 break;
615 case PROP_CONFERENCE:
616 g_value_set_object(value, media->priv->conference);
617 break;
618 case PROP_INITIATOR:
619 g_value_set_boolean(value, media->priv->initiator);
620 break;
621 case PROP_PRPL_DATA:
622 g_value_set_pointer(value, media->priv->prpl_data);
623 break;
624 default:
625 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
626 break;
627 }
628
629 }
630 #endif
631
632 /*
633 * PurpleMediaCandidateType
634 */
635
636 GType
637 purple_media_candidate_type_get_type()
638 {
639 static GType type = 0;
640 if (type == 0) {
641 static const GEnumValue values[] = {
642 { PURPLE_MEDIA_CANDIDATE_TYPE_HOST,
643 "PURPLE_MEDIA_CANDIDATE_TYPE_HOST",
644 "host" },
645 { PURPLE_MEDIA_CANDIDATE_TYPE_SRFLX,
646 "PURPLE_MEDIA_CANDIDATE_TYPE_SRFLX",
647 "srflx" },
648 { PURPLE_MEDIA_CANDIDATE_TYPE_PRFLX,
649 "PURPLE_MEDIA_CANDIDATE_TYPE_PRFLX",
650 "prflx" },
651 { PURPLE_MEDIA_CANDIDATE_TYPE_RELAY,
652 "PPURPLE_MEDIA_CANDIDATE_TYPE_RELAY",
653 "relay" },
654 { PURPLE_MEDIA_CANDIDATE_TYPE_MULTICAST,
655 "PURPLE_MEDIA_CANDIDATE_TYPE_MULTICAST",
656 "multicast" },
657 { 0, NULL, NULL }
658 };
659 type = g_enum_register_static("PurpleMediaCandidateType",
660 values);
661 }
662 return type;
663 }
664
665 /*
666 * PurpleMediaNetworkProtocol
667 */
668
669 GType
670 purple_media_network_protocol_get_type()
671 {
672 static GType type = 0;
673 if (type == 0) {
674 static const GEnumValue values[] = {
675 { PURPLE_MEDIA_NETWORK_PROTOCOL_UDP,
676 "PURPLE_MEDIA_NETWORK_PROTOCOL_UDP",
677 "udp" },
678 { PURPLE_MEDIA_NETWORK_PROTOCOL_TCP,
679 "PURPLE_MEDIA_NETWORK_PROTOCOL_TCP",
680 "tcp" },
681 { 0, NULL, NULL }
682 };
683 type = g_enum_register_static("PurpleMediaNetworkProtocol",
684 values);
685 }
686 return type;
687 }
688
689 /*
690 * PurpleMediaCandidate
691 */
692
693 struct _PurpleMediaCandidateClass
694 {
695 GObjectClass parent_class;
696 };
697
698 struct _PurpleMediaCandidate
699 {
700 GObject parent;
701 };
702
703 #ifdef USE_VV
704 struct _PurpleMediaCandidatePrivate
705 {
706 gchar *foundation;
707 guint component_id;
708 gchar *ip;
709 guint16 port;
710 gchar *base_ip;
711 guint16 base_port;
712 PurpleMediaNetworkProtocol proto;
713 guint32 priority;
714 PurpleMediaCandidateType type;
715 gchar *username;
716 gchar *password;
717 guint ttl;
718 };
719
720 enum {
721 PROP_CANDIDATE_0,
722 PROP_FOUNDATION,
723 PROP_COMPONENT_ID,
724 PROP_IP,
725 PROP_PORT,
726 PROP_BASE_IP,
727 PROP_BASE_PORT,
728 PROP_PROTOCOL,
729 PROP_PRIORITY,
730 PROP_TYPE,
731 PROP_USERNAME,
732 PROP_PASSWORD,
733 PROP_TTL,
734 };
735
736 static void
737 purple_media_candidate_init(PurpleMediaCandidate *info)
738 {
739 PurpleMediaCandidatePrivate *priv =
740 PURPLE_MEDIA_CANDIDATE_GET_PRIVATE(info);
741 priv->foundation = NULL;
742 priv->component_id = 0;
743 priv->ip = NULL;
744 priv->port = 0;
745 priv->base_ip = NULL;
746 priv->proto = PURPLE_MEDIA_NETWORK_PROTOCOL_UDP;
747 priv->priority = 0;
748 priv->type = PURPLE_MEDIA_CANDIDATE_TYPE_HOST;
749 priv->username = NULL;
750 priv->password = NULL;
751 priv->ttl = 0;
752 }
753
754 static void
755 purple_media_candidate_finalize(GObject *info)
756 {
757 PurpleMediaCandidatePrivate *priv =
758 PURPLE_MEDIA_CANDIDATE_GET_PRIVATE(info);
759
760 g_free(priv->foundation);
761 g_free(priv->ip);
762 g_free(priv->base_ip);
763 g_free(priv->username);
764 g_free(priv->password);
765 }
766
767 static void
768 purple_media_candidate_set_property (GObject *object, guint prop_id,
769 const GValue *value, GParamSpec *pspec)
770 {
771 PurpleMediaCandidatePrivate *priv;
772 g_return_if_fail(PURPLE_IS_MEDIA_CANDIDATE(object));
773
774 priv = PURPLE_MEDIA_CANDIDATE_GET_PRIVATE(object);
775
776 switch (prop_id) {
777 case PROP_FOUNDATION:
778 g_free(priv->foundation);
779 priv->foundation = g_value_dup_string(value);
780 break;
781 case PROP_COMPONENT_ID:
782 priv->component_id = g_value_get_uint(value);
783 break;
784 case PROP_IP:
785 g_free(priv->ip);
786 priv->ip = g_value_dup_string(value);
787 break;
788 case PROP_PORT:
789 priv->port = g_value_get_uint(value);
790 break;
791 case PROP_BASE_IP:
792 g_free(priv->base_ip);
793 priv->base_ip = g_value_dup_string(value);
794 break;
795 case PROP_BASE_PORT:
796 priv->base_port = g_value_get_uint(value);
797 break;
798 case PROP_PROTOCOL:
799 priv->proto = g_value_get_enum(value);
800 break;
801 case PROP_PRIORITY:
802 priv->priority = g_value_get_uint(value);
803 break;
804 case PROP_TYPE:
805 priv->type = g_value_get_enum(value);
806 break;
807 case PROP_USERNAME:
808 g_free(priv->username);
809 priv->username = g_value_dup_string(value);
810 break;
811 case PROP_PASSWORD:
812 g_free(priv->password);
813 priv->password = g_value_dup_string(value);
814 break;
815 case PROP_TTL:
816 priv->ttl = g_value_get_uint(value);
817 break;
818 default:
819 G_OBJECT_WARN_INVALID_PROPERTY_ID(
820 object, prop_id, pspec);
821 break;
822 }
823 }
824
825 static void
826 purple_media_candidate_get_property (GObject *object, guint prop_id,
827 GValue *value, GParamSpec *pspec)
828 {
829 PurpleMediaCandidatePrivate *priv;
830 g_return_if_fail(PURPLE_IS_MEDIA_CANDIDATE(object));
831
832 priv = PURPLE_MEDIA_CANDIDATE_GET_PRIVATE(object);
833
834 switch (prop_id) {
835 case PROP_FOUNDATION:
836 g_value_set_string(value, priv->foundation);
837 break;
838 case PROP_COMPONENT_ID:
839 g_value_set_uint(value, priv->component_id);
840 break;
841 case PROP_IP:
842 g_value_set_string(value, priv->ip);
843 break;
844 case PROP_PORT:
845 g_value_set_uint(value, priv->port);
846 break;
847 case PROP_BASE_IP:
848 g_value_set_string(value, priv->base_ip);
849 break;
850 case PROP_BASE_PORT:
851 g_value_set_uint(value, priv->base_port);
852 break;
853 case PROP_PROTOCOL:
854 g_value_set_enum(value, priv->proto);
855 break;
856 case PROP_PRIORITY:
857 g_value_set_uint(value, priv->priority);
858 break;
859 case PROP_TYPE:
860 g_value_set_enum(value, priv->type);
861 break;
862 case PROP_USERNAME:
863 g_value_set_string(value, priv->username);
864 break;
865 case PROP_PASSWORD:
866 g_value_set_string(value, priv->password);
867 break;
868 case PROP_TTL:
869 g_value_set_uint(value, priv->ttl);
870 break;
871 default:
872 G_OBJECT_WARN_INVALID_PROPERTY_ID(
873 object, prop_id, pspec);
874 break;
875 }
876 }
877
878 static void
879 purple_media_candidate_class_init(PurpleMediaCandidateClass *klass)
880 {
881 GObjectClass *gobject_class = (GObjectClass*)klass;
882
883 gobject_class->finalize = purple_media_candidate_finalize;
884 gobject_class->set_property = purple_media_candidate_set_property;
885 gobject_class->get_property = purple_media_candidate_get_property;
886
887 g_object_class_install_property(gobject_class, PROP_FOUNDATION,
888 g_param_spec_string("foundation",
889 "Foundation",
890 "The foundation of the candidate.",
891 NULL,
892 G_PARAM_READWRITE));
893
894 g_object_class_install_property(gobject_class, PROP_COMPONENT_ID,
895 g_param_spec_uint("component-id",
896 "Component ID",
897 "The component id of the candidate.",
898 0, G_MAXUINT, 0,
899 G_PARAM_READWRITE));
900
901 g_object_class_install_property(gobject_class, PROP_IP,
902 g_param_spec_string("ip",
903 "IP Address",
904 "The IP address of the candidate.",
905 NULL,
906 G_PARAM_READWRITE));
907
908 g_object_class_install_property(gobject_class, PROP_PORT,
909 g_param_spec_uint("port",
910 "Port",
911 "The port of the candidate.",
912 0, G_MAXUINT16, 0,
913 G_PARAM_READWRITE));
914
915 g_object_class_install_property(gobject_class, PROP_BASE_IP,
916 g_param_spec_string("base-ip",
917 "Base IP",
918 "The internal IP address of the candidate.",
919 NULL,
920 G_PARAM_READWRITE));
921
922 g_object_class_install_property(gobject_class, PROP_BASE_PORT,
923 g_param_spec_uint("base-port",
924 "Base Port",
925 "The internal port of the candidate.",
926 0, G_MAXUINT16, 0,
927 G_PARAM_READWRITE));
928
929 g_object_class_install_property(gobject_class, PROP_PROTOCOL,
930 g_param_spec_enum("protocol",
931 "Protocol",
932 "The protocol of the candidate.",
933 PURPLE_TYPE_MEDIA_NETWORK_PROTOCOL,
934 PURPLE_MEDIA_NETWORK_PROTOCOL_UDP,
935 G_PARAM_READWRITE));
936
937 g_object_class_install_property(gobject_class, PROP_PRIORITY,
938 g_param_spec_uint("priority",
939 "Priority",
940 "The priority of the candidate.",
941 0, G_MAXUINT32, 0,
942 G_PARAM_READWRITE));
943
944 g_object_class_install_property(gobject_class, PROP_TYPE,
945 g_param_spec_enum("type",
946 "Type",
947 "The type of the candidate.",
948 PURPLE_TYPE_MEDIA_CANDIDATE_TYPE,
949 PURPLE_MEDIA_CANDIDATE_TYPE_HOST,
950 G_PARAM_READWRITE));
951
952 g_object_class_install_property(gobject_class, PROP_USERNAME,
953 g_param_spec_string("username",
954 "Username",
955 "The username used to connect to the candidate.",
956 NULL,
957 G_PARAM_READWRITE));
958
959 g_object_class_install_property(gobject_class, PROP_PASSWORD,
960 g_param_spec_string("password",
961 "Password",
962 "The password use to connect to the candidate.",
963 NULL,
964 G_PARAM_READWRITE));
965
966 g_object_class_install_property(gobject_class, PROP_TTL,
967 g_param_spec_uint("ttl",
968 "TTL",
969 "The TTL of the candidate.",
970 0, G_MAXUINT, 0,
971 G_PARAM_READWRITE));
972
973 g_type_class_add_private(klass, sizeof(PurpleMediaCandidatePrivate));
974 }
975
976 G_DEFINE_TYPE(PurpleMediaCandidate,
977 purple_media_candidate, G_TYPE_OBJECT);
978 #else
979 GType
980 purple_media_candidate_get_type()
981 {
982 return G_TYPE_NONE;
983 }
984 #endif
985
986 PurpleMediaCandidate *
987 purple_media_candidate_new(const gchar *foundation, guint component_id,
988 PurpleMediaCandidateType type,
989 PurpleMediaNetworkProtocol proto,
990 const gchar *ip, guint port)
991 {
992 return g_object_new(PURPLE_TYPE_MEDIA_CANDIDATE,
993 "foundation", foundation,
994 "component-id", component_id,
995 "type", type,
996 "protocol", proto,
997 "ip", ip,
998 "port", port, NULL);
999 }
1000
1001 static PurpleMediaCandidate *
1002 purple_media_candidate_copy(PurpleMediaCandidate *candidate)
1003 {
1004 #ifdef USE_VV
1005 PurpleMediaCandidatePrivate *priv;
1006 PurpleMediaCandidate *new_candidate;
1007
1008 if (candidate == NULL)
1009 return NULL;
1010
1011 priv = PURPLE_MEDIA_CANDIDATE_GET_PRIVATE(candidate);
1012
1013 new_candidate = purple_media_candidate_new(priv->foundation,
1014 priv->component_id, priv->type, priv->proto,
1015 priv->ip, priv->port);
1016 g_object_set(new_candidate,
1017 "base-ip", priv->base_ip,
1018 "base-port", priv->base_port,
1019 "priority", priv->priority,
1020 "username", priv->username,
1021 "password", priv->password,
1022 "ttl", priv->ttl, NULL);
1023 return new_candidate;
1024 #else
1025 return NULL;
1026 #endif
1027 }
1028
1029 #ifdef USE_VV
1030 static FsCandidate *
1031 purple_media_candidate_to_fs(PurpleMediaCandidate *candidate)
1032 {
1033 PurpleMediaCandidatePrivate *priv;
1034 FsCandidate *fscandidate;
1035
1036 if (candidate == NULL)
1037 return NULL;
1038
1039 priv = PURPLE_MEDIA_CANDIDATE_GET_PRIVATE(candidate);
1040
1041 fscandidate = fs_candidate_new(priv->foundation,
1042 priv->component_id, priv->type,
1043 priv->proto, priv->ip, priv->port);
1044
1045 fscandidate->base_ip = g_strdup(priv->base_ip);
1046 fscandidate->base_port = priv->base_port;
1047 fscandidate->priority = priv->priority;
1048 fscandidate->username = g_strdup(priv->username);
1049 fscandidate->password = g_strdup(priv->password);
1050 fscandidate->ttl = priv->ttl;
1051 return fscandidate;
1052 }
1053
1054 static PurpleMediaCandidate *
1055 purple_media_candidate_from_fs(FsCandidate *fscandidate)
1056 {
1057 PurpleMediaCandidate *candidate;
1058
1059 if (fscandidate == NULL)
1060 return NULL;
1061
1062 candidate = purple_media_candidate_new(fscandidate->foundation,
1063 fscandidate->component_id, fscandidate->type,
1064 fscandidate->proto, fscandidate->ip, fscandidate->port);
1065 g_object_set(candidate,
1066 "base-ip", fscandidate->base_ip,
1067 "base-port", fscandidate->base_port,
1068 "priority", fscandidate->priority,
1069 "username", fscandidate->username,
1070 "password", fscandidate->password,
1071 "ttl", fscandidate->ttl, NULL);
1072 return candidate;
1073 }
1074
1075 static GList *
1076 purple_media_candidate_list_from_fs(GList *candidates)
1077 {
1078 GList *new_list = NULL;
1079
1080 for (; candidates; candidates = g_list_next(candidates)) {
1081 new_list = g_list_prepend(new_list,
1082 purple_media_candidate_from_fs(
1083 candidates->data));
1084 }
1085
1086 new_list = g_list_reverse(new_list);
1087 return new_list;
1088 }
1089
1090 static GList *
1091 purple_media_candidate_list_to_fs(GList *candidates)
1092 {
1093 GList *new_list = NULL;
1094
1095 for (; candidates; candidates = g_list_next(candidates)) {
1096 new_list = g_list_prepend(new_list,
1097 purple_media_candidate_to_fs(
1098 candidates->data));
1099 }
1100
1101 new_list = g_list_reverse(new_list);
1102 return new_list;
1103 }
1104 #endif
1105
1106 GList *
1107 purple_media_candidate_list_copy(GList *candidates)
1108 {
1109 GList *new_list = NULL;
1110
1111 for (; candidates; candidates = g_list_next(candidates)) {
1112 new_list = g_list_prepend(new_list,
1113 purple_media_candidate_copy(candidates->data));
1114 }
1115
1116 new_list = g_list_reverse(new_list);
1117 return new_list;
1118 }
1119
1120 void
1121 purple_media_candidate_list_free(GList *candidates)
1122 {
1123 for (; candidates; candidates =
1124 g_list_delete_link(candidates, candidates)) {
1125 g_object_unref(candidates->data);
1126 }
1127 }
1128
1129 gchar *
1130 purple_media_candidate_get_foundation(PurpleMediaCandidate *candidate)
1131 {
1132 gchar *foundation;
1133 g_return_val_if_fail(PURPLE_IS_MEDIA_CANDIDATE(candidate), NULL);
1134 g_object_get(candidate, "foundation", &foundation, NULL);
1135 return foundation;
1136 }
1137
1138 guint
1139 purple_media_candidate_get_component_id(PurpleMediaCandidate *candidate)
1140 {
1141 guint component_id;
1142 g_return_val_if_fail(PURPLE_IS_MEDIA_CANDIDATE(candidate), 0);
1143 g_object_get(candidate, "component-id", &component_id, NULL);
1144 return component_id;
1145 }
1146
1147 gchar *
1148 purple_media_candidate_get_ip(PurpleMediaCandidate *candidate)
1149 {
1150 gchar *ip;
1151 g_return_val_if_fail(PURPLE_IS_MEDIA_CANDIDATE(candidate), NULL);
1152 g_object_get(candidate, "ip", &ip, NULL);
1153 return ip;
1154 }
1155
1156 guint16
1157 purple_media_candidate_get_port(PurpleMediaCandidate *candidate)
1158 {
1159 guint port;
1160 g_return_val_if_fail(PURPLE_IS_MEDIA_CANDIDATE(candidate), 0);
1161 g_object_get(candidate, "port", &port, NULL);
1162 return port;
1163 }
1164
1165 gchar *
1166 purple_media_candidate_get_base_ip(PurpleMediaCandidate *candidate)
1167 {
1168 gchar *base_ip;
1169 g_return_val_if_fail(PURPLE_IS_MEDIA_CANDIDATE(candidate), NULL);
1170 g_object_get(candidate, "base-ip", &base_ip, NULL);
1171 return base_ip;
1172 }
1173
1174 guint16
1175 purple_media_candidate_get_base_port(PurpleMediaCandidate *candidate)
1176 {
1177 guint base_port;
1178 g_return_val_if_fail(PURPLE_IS_MEDIA_CANDIDATE(candidate), 0);
1179 g_object_get(candidate, "base_port", &base_port, NULL);
1180 return base_port;
1181 }
1182
1183 PurpleMediaNetworkProtocol
1184 purple_media_candidate_get_protocol(PurpleMediaCandidate *candidate)
1185 {
1186 PurpleMediaNetworkProtocol protocol;
1187 g_return_val_if_fail(PURPLE_IS_MEDIA_CANDIDATE(candidate),
1188 PURPLE_MEDIA_NETWORK_PROTOCOL_UDP);
1189 g_object_get(candidate, "protocol", &protocol, NULL);
1190 return protocol;
1191 }
1192
1193 guint32
1194 purple_media_candidate_get_priority(PurpleMediaCandidate *candidate)
1195 {
1196 guint priority;
1197 g_return_val_if_fail(PURPLE_IS_MEDIA_CANDIDATE(candidate), 0);
1198 g_object_get(candidate, "priority", &priority, NULL);
1199 return priority;
1200 }
1201
1202 PurpleMediaCandidateType
1203 purple_media_candidate_get_candidate_type(PurpleMediaCandidate *candidate)
1204 {
1205 PurpleMediaCandidateType type;
1206 g_return_val_if_fail(PURPLE_IS_MEDIA_CANDIDATE(candidate),
1207 PURPLE_MEDIA_CANDIDATE_TYPE_HOST);
1208 g_object_get(candidate, "type", &type, NULL);
1209 return type;
1210 }
1211
1212 gchar *
1213 purple_media_candidate_get_username(PurpleMediaCandidate *candidate)
1214 {
1215 gchar *username;
1216 g_return_val_if_fail(PURPLE_IS_MEDIA_CANDIDATE(candidate), NULL);
1217 g_object_get(candidate, "username", &username, NULL);
1218 return username;
1219 }
1220
1221 gchar *
1222 purple_media_candidate_get_password(PurpleMediaCandidate *candidate)
1223 {
1224 gchar *password;
1225 g_return_val_if_fail(PURPLE_IS_MEDIA_CANDIDATE(candidate), NULL);
1226 g_object_get(candidate, "password", &password, NULL);
1227 return password;
1228 }
1229
1230 guint
1231 purple_media_candidate_get_ttl(PurpleMediaCandidate *candidate)
1232 {
1233 guint ttl;
1234 g_return_val_if_fail(PURPLE_IS_MEDIA_CANDIDATE(candidate), 0);
1235 g_object_get(candidate, "ttl", &ttl, NULL);
1236 return ttl;
1237 }
1238
1239 #ifdef USE_VV
1240 static FsMediaType
1241 purple_media_to_fs_media_type(PurpleMediaSessionType type)
1242 {
1243 if (type & PURPLE_MEDIA_AUDIO)
1244 return FS_MEDIA_TYPE_AUDIO;
1245 else if (type & PURPLE_MEDIA_VIDEO)
1246 return FS_MEDIA_TYPE_VIDEO;
1247 else
1248 return 0;
1249 }
1250
1251 static FsStreamDirection
1252 purple_media_to_fs_stream_direction(PurpleMediaSessionType type)
1253 {
1254 if ((type & PURPLE_MEDIA_AUDIO) == PURPLE_MEDIA_AUDIO ||
1255 (type & PURPLE_MEDIA_VIDEO) == PURPLE_MEDIA_VIDEO)
1256 return FS_DIRECTION_BOTH;
1257 else if ((type & PURPLE_MEDIA_SEND_AUDIO) ||
1258 (type & PURPLE_MEDIA_SEND_VIDEO))
1259 return FS_DIRECTION_SEND;
1260 else if ((type & PURPLE_MEDIA_RECV_AUDIO) ||
1261 (type & PURPLE_MEDIA_RECV_VIDEO))
1262 return FS_DIRECTION_RECV;
1263 else
1264 return FS_DIRECTION_NONE;
1265 }
1266
1267 static PurpleMediaSessionType
1268 purple_media_from_fs(FsMediaType type, FsStreamDirection direction)
1269 {
1270 PurpleMediaSessionType result = PURPLE_MEDIA_NONE;
1271 if (type == FS_MEDIA_TYPE_AUDIO) {
1272 if (direction & FS_DIRECTION_SEND)
1273 result |= PURPLE_MEDIA_SEND_AUDIO;
1274 if (direction & FS_DIRECTION_RECV)
1275 result |= PURPLE_MEDIA_RECV_AUDIO;
1276 } else if (type == FS_MEDIA_TYPE_VIDEO) {
1277 if (direction & FS_DIRECTION_SEND)
1278 result |= PURPLE_MEDIA_SEND_VIDEO;
1279 if (direction & FS_DIRECTION_RECV)
1280 result |= PURPLE_MEDIA_RECV_VIDEO;
1281 }
1282 return result;
1283 }
1284 #endif
1285
1286 /*
1287 * PurpleMediaCodec
1288 */
1289
1290 struct _PurpleMediaCodecClass
1291 {
1292 GObjectClass parent_class;
1293 };
1294
1295 struct _PurpleMediaCodec
1296 {
1297 GObject parent;
1298 };
1299
1300 #ifdef USE_VV
1301 struct _PurpleMediaCodecPrivate
1302 {
1303 gint id;
1304 char *encoding_name;
1305 PurpleMediaSessionType media_type;
1306 guint clock_rate;
1307 guint channels;
1308 GList *optional_params;
1309 };
1310
1311 enum {
1312 PROP_CODEC_0,
1313 PROP_ID,
1314 PROP_ENCODING_NAME,
1315 PROP_MEDIA_TYPE,
1316 PROP_CLOCK_RATE,
1317 PROP_CHANNELS,
1318 PROP_OPTIONAL_PARAMS,
1319 };
1320
1321 static void
1322 purple_media_codec_init(PurpleMediaCodec *info)
1323 {
1324 PurpleMediaCodecPrivate *priv =
1325 PURPLE_MEDIA_CODEC_GET_PRIVATE(info);
1326 priv->encoding_name = NULL;
1327 priv->optional_params = NULL;
1328 }
1329
1330 static void
1331 purple_media_codec_finalize(GObject *info)
1332 {
1333 PurpleMediaCodecPrivate *priv =
1334 PURPLE_MEDIA_CODEC_GET_PRIVATE(info);
1335 g_free(priv->encoding_name);
1336 for (; priv->optional_params; priv->optional_params =
1337 g_list_delete_link(priv->optional_params,
1338 priv->optional_params)) {
1339 g_free(priv->optional_params->data);
1340 }
1341 }
1342
1343 static void
1344 purple_media_codec_set_property (GObject *object, guint prop_id,
1345 const GValue *value, GParamSpec *pspec)
1346 {
1347 PurpleMediaCodecPrivate *priv;
1348 g_return_if_fail(PURPLE_IS_MEDIA_CODEC(object));
1349
1350 priv = PURPLE_MEDIA_CODEC_GET_PRIVATE(object);
1351
1352 switch (prop_id) {
1353 case PROP_ID:
1354 priv->id = g_value_get_uint(value);
1355 break;
1356 case PROP_ENCODING_NAME:
1357 g_free(priv->encoding_name);
1358 priv->encoding_name = g_value_dup_string(value);
1359 break;
1360 case PROP_MEDIA_TYPE:
1361 priv->media_type = g_value_get_flags(value);
1362 break;
1363 case PROP_CLOCK_RATE:
1364 priv->clock_rate = g_value_get_uint(value);
1365 break;
1366 case PROP_CHANNELS:
1367 priv->channels = g_value_get_uint(value);
1368 break;
1369 case PROP_OPTIONAL_PARAMS:
1370 priv->optional_params = g_value_get_pointer(value);
1371 break;
1372 default:
1373 G_OBJECT_WARN_INVALID_PROPERTY_ID(
1374 object, prop_id, pspec);
1375 break;
1376 }
1377 }
1378
1379 static void
1380 purple_media_codec_get_property (GObject *object, guint prop_id,
1381 GValue *value, GParamSpec *pspec)
1382 {
1383 PurpleMediaCodecPrivate *priv;
1384 g_return_if_fail(PURPLE_IS_MEDIA_CODEC(object));
1385
1386 priv = PURPLE_MEDIA_CODEC_GET_PRIVATE(object);
1387
1388 switch (prop_id) {
1389 case PROP_ID:
1390 g_value_set_uint(value, priv->id);
1391 break;
1392 case PROP_ENCODING_NAME:
1393 g_value_set_string(value, priv->encoding_name);
1394 break;
1395 case PROP_MEDIA_TYPE:
1396 g_value_set_flags(value, priv->media_type);
1397 break;
1398 case PROP_CLOCK_RATE:
1399 g_value_set_uint(value, priv->clock_rate);
1400 break;
1401 case PROP_CHANNELS:
1402 g_value_set_uint(value, priv->channels);
1403 break;
1404 case PROP_OPTIONAL_PARAMS:
1405 g_value_set_pointer(value, priv->optional_params);
1406 break;
1407 default:
1408 G_OBJECT_WARN_INVALID_PROPERTY_ID(
1409 object, prop_id, pspec);
1410 break;
1411 }
1412 }
1413
1414 static void
1415 purple_media_codec_class_init(PurpleMediaCodecClass *klass)
1416 {
1417 GObjectClass *gobject_class = (GObjectClass*)klass;
1418
1419 gobject_class->finalize = purple_media_codec_finalize;
1420 gobject_class->set_property = purple_media_codec_set_property;
1421 gobject_class->get_property = purple_media_codec_get_property;
1422
1423 g_object_class_install_property(gobject_class, PROP_ID,
1424 g_param_spec_uint("id",
1425 "ID",
1426 "The numeric identifier of the codec.",
1427 0, G_MAXUINT, 0,
1428 G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
1429
1430 g_object_class_install_property(gobject_class, PROP_ENCODING_NAME,
1431 g_param_spec_string("encoding-name",
1432 "Encoding Name",
1433 "The name of the codec.",
1434 NULL,
1435 G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
1436
1437 g_object_class_install_property(gobject_class, PROP_MEDIA_TYPE,
1438 g_param_spec_flags("media-type",
1439 "Media Type",
1440 "Whether this is an audio of video codec.",
1441 PURPLE_TYPE_MEDIA_SESSION_TYPE,
1442 PURPLE_MEDIA_NONE,
1443 G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
1444
1445 g_object_class_install_property(gobject_class, PROP_CLOCK_RATE,
1446 g_param_spec_uint("clock-rate",
1447 "Create Callback",
1448 "The function called to create this element.",
1449 0, G_MAXUINT, 0,
1450 G_PARAM_READWRITE));
1451
1452 g_object_class_install_property(gobject_class, PROP_CHANNELS,
1453 g_param_spec_uint("channels",
1454 "Channels",
1455 "The number of channels in this codec.",
1456 0, G_MAXUINT, 0,
1457 G_PARAM_READWRITE));
1458 g_object_class_install_property(gobject_class, PROP_OPTIONAL_PARAMS,
1459 g_param_spec_pointer("optional-params",
1460 "Optional Params",
1461 "A list of optional parameters for the codec.",
1462 G_PARAM_READWRITE));
1463
1464 g_type_class_add_private(klass, sizeof(PurpleMediaCodecPrivate));
1465 }
1466
1467 G_DEFINE_TYPE(PurpleMediaCodec,
1468 purple_media_codec, G_TYPE_OBJECT);
1469 #else
1470 GType
1471 purple_media_codec_get_type()
1472 {
1473 return G_TYPE_NONE;
1474 }
1475 #endif
1476
1477 guint
1478 purple_media_codec_get_id(PurpleMediaCodec *codec)
1479 {
1480 guint id;
1481 g_return_val_if_fail(PURPLE_IS_MEDIA_CODEC(codec), 0);
1482 g_object_get(codec, "id", &id, NULL);
1483 return id;
1484 }
1485
1486 gchar *
1487 purple_media_codec_get_encoding_name(PurpleMediaCodec *codec)
1488 {
1489 gchar *name;
1490 g_return_val_if_fail(PURPLE_IS_MEDIA_CODEC(codec), NULL);
1491 g_object_get(codec, "encoding-name", &name, NULL);
1492 return name;
1493 }
1494
1495 guint
1496 purple_media_codec_get_clock_rate(PurpleMediaCodec *codec)
1497 {
1498 guint clock_rate;
1499 g_return_val_if_fail(PURPLE_IS_MEDIA_CODEC(codec), 0);
1500 g_object_get(codec, "clock-rate", &clock_rate, NULL);
1501 return clock_rate;
1502 }
1503
1504 guint
1505 purple_media_codec_get_channels(PurpleMediaCodec *codec)
1506 {
1507 guint channels;
1508 g_return_val_if_fail(PURPLE_IS_MEDIA_CODEC(codec), 0);
1509 g_object_get(codec, "channels", &channels, NULL);
1510 return channels;
1511 }
1512
1513 GList *
1514 purple_media_codec_get_optional_parameters(PurpleMediaCodec *codec)
1515 {
1516 GList *optional_params;
1517 g_return_val_if_fail(PURPLE_IS_MEDIA_CODEC(codec), NULL);
1518 g_object_get(codec, "optional-params", &optional_params, NULL);
1519 return optional_params;
1520 }
1521
1522 void
1523 purple_media_codec_add_optional_parameter(PurpleMediaCodec *codec,
1524 const gchar *name, const gchar *value)
1525 {
1526 #ifdef USE_VV
1527 PurpleMediaCodecPrivate *priv;
1528 PurpleKeyValuePair *new_param;
1529
1530 g_return_if_fail(codec != NULL);
1531 g_return_if_fail(name != NULL && value != NULL);
1532
1533 priv = PURPLE_MEDIA_CODEC_GET_PRIVATE(codec);
1534
1535 new_param = g_new0(PurpleKeyValuePair, 1);
1536 new_param->key = g_strdup(name);
1537 new_param->value = g_strdup(value);
1538 priv->optional_params = g_list_append(
1539 priv->optional_params, new_param);
1540 #endif
1541 }
1542
1543 void
1544 purple_media_codec_remove_optional_parameter(PurpleMediaCodec *codec,
1545 PurpleKeyValuePair *param)
1546 {
1547 #ifdef USE_VV
1548 PurpleMediaCodecPrivate *priv;
1549
1550 g_return_if_fail(codec != NULL && param != NULL);
1551
1552 priv = PURPLE_MEDIA_CODEC_GET_PRIVATE(codec);
1553
1554 g_free(param->key);
1555 g_free(param->value);
1556 g_free(param);
1557
1558 priv->optional_params =
1559 g_list_remove(priv->optional_params, param);
1560 #endif
1561 }
1562
1563 PurpleKeyValuePair *
1564 purple_media_codec_get_optional_parameter(PurpleMediaCodec *codec,
1565 const gchar *name, const gchar *value)
1566 {
1567 #ifdef USE_VV
1568 PurpleMediaCodecPrivate *priv;
1569 GList *iter;
1570
1571 g_return_val_if_fail(codec != NULL, NULL);
1572 g_return_val_if_fail(name != NULL, NULL);
1573
1574 priv = PURPLE_MEDIA_CODEC_GET_PRIVATE(codec);
1575
1576 for (iter = priv->optional_params; iter; iter = g_list_next(iter)) {
1577 PurpleKeyValuePair *param = iter->data;
1578 if (!g_ascii_strcasecmp(param->key, name) &&
1579 (value == NULL ||
1580 !g_ascii_strcasecmp(param->value, value)))
1581 return param;
1582 }
1583 #endif
1584
1585 return NULL;
1586 }
1587
1588 PurpleMediaCodec *
1589 purple_media_codec_new(int id, const char *encoding_name,
1590 PurpleMediaSessionType media_type, guint clock_rate)
1591 {
1592 PurpleMediaCodec *codec =
1593 g_object_new(PURPLE_TYPE_MEDIA_CODEC,
1594 "id", id,
1595 "encoding_name", encoding_name,
1596 "media_type", media_type,
1597 "clock-rate", clock_rate, NULL);
1598 return codec;
1599 }
1600
1601 static PurpleMediaCodec *
1602 purple_media_codec_copy(PurpleMediaCodec *codec)
1603 {
1604 #ifdef USE_VV
1605 PurpleMediaCodecPrivate *priv;
1606 PurpleMediaCodec *new_codec;
1607 GList *iter;
1608
1609 if (codec == NULL)
1610 return NULL;
1611
1612 priv = PURPLE_MEDIA_CODEC_GET_PRIVATE(codec);
1613
1614 new_codec = purple_media_codec_new(priv->id, priv->encoding_name,
1615 priv->media_type, priv->clock_rate);
1616 g_object_set(codec, "channels", priv->channels, NULL);
1617
1618 for (iter = priv->optional_params; iter; iter = g_list_next(iter)) {
1619 PurpleKeyValuePair *param =
1620 (PurpleKeyValuePair*)iter->data;
1621 purple_media_codec_add_optional_parameter(new_codec,
1622 param->key, param->value);
1623 }
1624
1625 return new_codec;
1626 #else
1627 return NULL;
1628 #endif
1629 }
1630
1631 #ifdef USE_VV
1632 static FsCodec *
1633 purple_media_codec_to_fs(const PurpleMediaCodec *codec)
1634 {
1635 PurpleMediaCodecPrivate *priv;
1636 FsCodec *new_codec;
1637 GList *iter;
1638
1639 if (codec == NULL)
1640 return NULL;
1641
1642 priv = PURPLE_MEDIA_CODEC_GET_PRIVATE(codec);
1643
1644 new_codec = fs_codec_new(priv->id, priv->encoding_name,
1645 purple_media_to_fs_media_type(priv->media_type),
1646 priv->clock_rate);
1647 new_codec->channels = priv->channels;
1648
1649 for (iter = priv->optional_params; iter; iter = g_list_next(iter)) {
1650 PurpleKeyValuePair *param = (PurpleKeyValuePair*)iter->data;
1651 fs_codec_add_optional_parameter(new_codec,
1652 param->key, param->value);
1653 }
1654
1655 return new_codec;
1656 }
1657
1658 static PurpleMediaCodec *
1659 purple_media_codec_from_fs(const FsCodec *codec)
1660 {
1661 PurpleMediaCodec *new_codec;
1662 GList *iter;
1663
1664 if (codec == NULL)
1665 return NULL;
1666
1667 new_codec = purple_media_codec_new(codec->id, codec->encoding_name,
1668 purple_media_from_fs(codec->media_type,
1669 FS_DIRECTION_BOTH), codec->clock_rate);
1670 g_object_set(new_codec, "channels", codec->channels, NULL);
1671
1672 for (iter = codec->optional_params; iter; iter = g_list_next(iter)) {
1673 FsCodecParameter *param = (FsCodecParameter*)iter->data;
1674 purple_media_codec_add_optional_parameter(new_codec,
1675 param->name, param->value);
1676 }
1677
1678 return new_codec;
1679 }
1680 #endif
1681
1682 gchar *
1683 purple_media_codec_to_string(const PurpleMediaCodec *codec)
1684 {
1685 #ifdef USE_VV
1686 FsCodec *fscodec = purple_media_codec_to_fs(codec);
1687 gchar *str = fs_codec_to_string(fscodec);
1688 fs_codec_destroy(fscodec);
1689 return str;
1690 #else
1691 return g_strdup("");
1692 #endif
1693 }
1694
1695 #ifdef USE_VV
1696 static GList *
1697 purple_media_codec_list_from_fs(GList *codecs)
1698 {
1699 GList *new_list = NULL;
1700
1701 for (; codecs; codecs = g_list_next(codecs)) {
1702 new_list = g_list_prepend(new_list,
1703 purple_media_codec_from_fs(
1704 codecs->data));
1705 }
1706
1707 new_list = g_list_reverse(new_list);
1708 return new_list;
1709 }
1710
1711 static GList *
1712 purple_media_codec_list_to_fs(GList *codecs)
1713 {
1714 GList *new_list = NULL;
1715
1716 for (; codecs; codecs = g_list_next(codecs)) {
1717 new_list = g_list_prepend(new_list,
1718 purple_media_codec_to_fs(
1719 codecs->data));
1720 }
1721
1722 new_list = g_list_reverse(new_list);
1723 return new_list;
1724 }
1725 #endif
1726
1727 GList *
1728 purple_media_codec_list_copy(GList *codecs)
1729 {
1730 GList *new_list = NULL;
1731
1732 for (; codecs; codecs = g_list_next(codecs)) {
1733 new_list = g_list_prepend(new_list,
1734 purple_media_codec_copy(codecs->data));
1735 }
1736
1737 new_list = g_list_reverse(new_list);
1738 return new_list;
1739 }
1740
1741 void
1742 purple_media_codec_list_free(GList *codecs)
1743 {
1744 for (; codecs; codecs =
1745 g_list_delete_link(codecs, codecs)) {
1746 g_object_unref(codecs->data);
1747 }
1748 }
1749
1750 #ifdef USE_VV
1751 static PurpleMediaSession*
1752 purple_media_get_session(PurpleMedia *media, const gchar *sess_id)
1753 {
1754 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL);
1755 return (PurpleMediaSession*) (media->priv->sessions) ?
1756 g_hash_table_lookup(media->priv->sessions, sess_id) : NULL;
1757 }
1758
1759 static FsParticipant*
1760 purple_media_get_participant(PurpleMedia *media, const gchar *name)
1761 {
1762 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL);
1763 return (FsParticipant*) (media->priv->participants) ?
1764 g_hash_table_lookup(media->priv->participants, name) : NULL;
1765 }
1766
1767 static PurpleMediaStream*
1768 purple_media_get_stream(PurpleMedia *media, const gchar *session, const gchar *participant)
1769 {
1770 GList *streams;
1771
1772 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL);
1773
1774 streams = media->priv->streams;
1775
1776 for (; streams; streams = g_list_next(streams)) {
1777 PurpleMediaStream *stream = streams->data;
1778 if (!strcmp(stream->session->id, session) &&
1779 !strcmp(stream->participant, participant))
1780 return stream;
1781 }
1782
1783 return NULL;
1784 }
1785
1786 static GList *
1787 purple_media_get_streams(PurpleMedia *media, const gchar *session,
1788 const gchar *participant)
1789 {
1790 GList *streams;
1791 GList *ret = NULL;
1792
1793 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL);
1794
1795 streams = media->priv->streams;
1796
1797 for (; streams; streams = g_list_next(streams)) {
1798 PurpleMediaStream *stream = streams->data;
1799 if ((session == NULL ||
1800 !strcmp(stream->session->id, session)) &&
1801 (participant == NULL ||
1802 !strcmp(stream->participant, participant)))
1803 ret = g_list_append(ret, stream);
1804 }
1805
1806 return ret;
1807 }
1808
1809 static void
1810 purple_media_add_session(PurpleMedia *media, PurpleMediaSession *session)
1811 {
1812 g_return_if_fail(PURPLE_IS_MEDIA(media));
1813 g_return_if_fail(session != NULL);
1814
1815 if (!media->priv->sessions) {
1816 purple_debug_info("media", "Creating hash table for sessions\n");
1817 media->priv->sessions = g_hash_table_new(g_str_hash, g_str_equal);
1818 }
1819 g_hash_table_insert(media->priv->sessions, g_strdup(session->id), session);
1820 }
1821
1822 static gboolean
1823 purple_media_remove_session(PurpleMedia *media, PurpleMediaSession *session)
1824 {
1825 g_return_val_if_fail(PURPLE_IS_MEDIA(media), FALSE);
1826 return g_hash_table_remove(media->priv->sessions, session->id);
1827 }
1828
1829 static FsParticipant *
1830 purple_media_add_participant(PurpleMedia *media, const gchar *name)
1831 {
1832 FsParticipant *participant;
1833 GError *err = NULL;
1834
1835 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL);
1836
1837 participant = purple_media_get_participant(media, name);
1838
1839 if (participant)
1840 return participant;
1841
1842 participant = fs_conference_new_participant(media->priv->conference,
1843 (gchar*)name, &err);
1844
1845 if (err) {
1846 purple_debug_error("media", "Error creating participant: %s\n",
1847 err->message);
1848 g_error_free(err);
1849 return NULL;
1850 }
1851
1852 if (!media->priv->participants) {
1853 purple_debug_info("media", "Creating hash table for participants\n");
1854 media->priv->participants = g_hash_table_new_full(g_str_hash,
1855 g_str_equal, g_free, NULL);
1856 }
1857
1858 g_hash_table_insert(media->priv->participants, g_strdup(name), participant);
1859
1860 return participant;
1861 }
1862
1863 static PurpleMediaStream *
1864 purple_media_insert_stream(PurpleMediaSession *session, const gchar *name, FsStream *stream)
1865 {
1866 PurpleMediaStream *media_stream;
1867
1868 g_return_val_if_fail(session != NULL, NULL);
1869
1870 media_stream = g_new0(PurpleMediaStream, 1);
1871 media_stream->stream = stream;
1872 media_stream->participant = g_strdup(name);
1873 media_stream->session = session;
1874
1875 session->media->priv->streams =
1876 g_list_append(session->media->priv->streams, media_stream);
1877
1878 return media_stream;
1879 }
1880
1881 static void
1882 purple_media_insert_local_candidate(PurpleMediaSession *session, const gchar *name,
1883 FsCandidate *candidate)
1884 {
1885 PurpleMediaStream *stream;
1886
1887 g_return_if_fail(session != NULL);
1888
1889 stream = purple_media_get_stream(session->media, session->id, name);
1890 stream->local_candidates = g_list_append(stream->local_candidates, candidate);
1891 }
1892 #endif
1893
1894 GList *
1895 purple_media_get_session_ids(PurpleMedia *media)
1896 {
1897 #ifdef USE_VV
1898 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL);
1899 return media->priv->sessions != NULL ?
1900 g_hash_table_get_keys(media->priv->sessions) : NULL;
1901 #else
1902 return NULL;
1903 #endif
1904 }
1905
1906 #ifdef USE_VV
1907 static void
1908 purple_media_set_src(PurpleMedia *media, const gchar *sess_id, GstElement *src)
1909 {
1910 PurpleMediaSession *session;
1911 GstPad *sinkpad;
1912 GstPad *srcpad;
1913
1914 g_return_if_fail(PURPLE_IS_MEDIA(media));
1915 g_return_if_fail(GST_IS_ELEMENT(src));
1916
1917 session = purple_media_get_session(media, sess_id);
1918
1919 if (session == NULL) {
1920 purple_debug_warning("media", "purple_media_set_src: trying"
1921 " to set src on non-existent session\n");
1922 return;
1923 }
1924
1925 if (session->src)
1926 gst_object_unref(session->src);
1927 session->src = src;
1928 gst_element_set_locked_state(session->src, TRUE);
1929
1930 session->tee = gst_element_factory_make("tee", NULL);
1931 gst_bin_add(GST_BIN(session->media->priv->confbin), session->tee);
1932
1933 /* This supposedly isn't necessary, but it silences some warnings */
1934 if (GST_ELEMENT_PARENT(session->media->priv->confbin)
1935 == GST_ELEMENT_PARENT(session->src)) {
1936 GstPad *pad = gst_element_get_static_pad(session->tee, "sink");
1937 GstPad *ghost = gst_ghost_pad_new(NULL, pad);
1938 gst_object_unref(pad);
1939 gst_pad_set_active(ghost, TRUE);
1940 gst_element_add_pad(session->media->priv->confbin, ghost);
1941 }
1942
1943 gst_element_set_state(session->tee, GST_STATE_PLAYING);
1944 gst_element_link(session->src, session->media->priv->confbin);
1945
1946 g_object_get(session->session, "sink-pad", &sinkpad, NULL);
1947 if (session->type & PURPLE_MEDIA_SEND_AUDIO) {
1948 gchar *name = g_strdup_printf("volume_%s", session->id);
1949 GstElement *level;
1950 GstElement *volume = gst_element_factory_make("volume", name);
1951 double input_volume = purple_prefs_get_int(
1952 "/purple/media/audio/volume/input")/10.0;
1953 g_free(name);
1954 name = g_strdup_printf("sendlevel_%s", session->id);
1955 level = gst_element_factory_make("level", name);
1956 g_free(name);
1957 gst_bin_add(GST_BIN(session->media->priv->confbin), volume);
1958 gst_bin_add(GST_BIN(session->media->priv->confbin), level);
1959 gst_element_set_state(level, GST_STATE_PLAYING);
1960 gst_element_set_state(volume, GST_STATE_PLAYING);
1961 gst_element_link(volume, level);
1962 gst_element_link(session->tee, volume);
1963 srcpad = gst_element_get_static_pad(level, "src");
1964 g_object_set(volume, "volume", input_volume, NULL);
1965 } else {
1966 srcpad = gst_element_get_request_pad(session->tee, "src%d");
1967 }
1968 purple_debug_info("media", "connecting pad: %s\n",
1969 gst_pad_link(srcpad, sinkpad) == GST_PAD_LINK_OK
1970 ? "success" : "failure");
1971 gst_element_set_locked_state(session->src, FALSE);
1972 gst_object_unref(session->src);
1973 }
1974 #endif
1975
1976 #ifdef USE_GSTREAMER
1977 GstElement *
1978 purple_media_get_src(PurpleMedia *media, const gchar *sess_id)
1979 {
1980 #ifdef USE_VV
1981 PurpleMediaSession *session;
1982 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL);
1983 session = purple_media_get_session(media, sess_id);
1984 return (session != NULL) ? session->src : NULL;
1985 #else
1986 return NULL;
1987 #endif
1988 }
1989 #endif /* USE_GSTREAMER */
1990
1991 #ifdef USE_VV
1992 static PurpleMediaSession *
1993 purple_media_session_from_fs_stream(PurpleMedia *media, FsStream *stream)
1994 {
1995 FsSession *fssession;
1996 GList *values;
1997
1998 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL);
1999 g_return_val_if_fail(FS_IS_STREAM(stream), NULL);
2000
2001 g_object_get(stream, "session", &fssession, NULL);
2002
2003 values = g_hash_table_get_values(media->priv->sessions);
2004
2005 for (; values; values = g_list_delete_link(values, values)) {
2006 PurpleMediaSession *session = values->data;
2007
2008 if (session->session == fssession) {
2009 g_list_free(values);
2010 g_object_unref(fssession);
2011 return session;
2012 }
2013 }
2014
2015 g_object_unref(fssession);
2016 return NULL;
2017 }
2018
2019 static gboolean
2020 media_bus_call(GstBus *bus, GstMessage *msg, PurpleMedia *media)
2021 {
2022 switch(GST_MESSAGE_TYPE(msg)) {
2023 case GST_MESSAGE_ELEMENT: {
2024 if (g_signal_has_handler_pending(media,
2025 purple_media_signals[LEVEL], 0, FALSE)
2026 && gst_structure_has_name(
2027 gst_message_get_structure(msg), "level")) {
2028 GstElement *src = GST_ELEMENT(GST_MESSAGE_SRC(msg));
2029 gchar *name;
2030 gchar *participant = NULL;
2031 PurpleMediaSession *session = NULL;
2032 gdouble rms_db;
2033 gdouble percent;
2034 const GValue *list;
2035 const GValue *value;
2036
2037 if (!PURPLE_IS_MEDIA(media) ||
2038 GST_ELEMENT_PARENT(src) !=
2039 media->priv->confbin)
2040 break;
2041
2042 name = gst_element_get_name(src);
2043 if (!strncmp(name, "sendlevel_", 10)) {
2044 session = purple_media_get_session(
2045 media, name+10);
2046 } else {
2047 GList *iter = media->priv->streams;
2048 for (; iter; iter = g_list_next(iter)) {
2049 PurpleMediaStream *stream = iter->data;
2050 if (stream->level == src) {
2051 session = stream->session;
2052 participant = stream->participant;
2053 break;
2054 }
2055 }
2056 }
2057 g_free(name);
2058 if (!session)
2059 break;
2060
2061 list = gst_structure_get_value(
2062 gst_message_get_structure(msg), "rms");
2063 value = gst_value_list_get_value(list, 0);
2064 rms_db = g_value_get_double(value);
2065 percent = pow(10, rms_db / 20) * 5;
2066 if(percent > 1.0)
2067 percent = 1.0;
2068
2069 g_signal_emit(media, purple_media_signals[LEVEL],
2070 0, session->id, participant, percent);
2071 break;
2072 }
2073 if (!FS_IS_CONFERENCE(GST_MESSAGE_SRC(msg)) ||
2074 !PURPLE_IS_MEDIA(media) ||
2075 media->priv->conference !=
2076 FS_CONFERENCE(GST_MESSAGE_SRC(msg)))
2077 break;
2078
2079 if (gst_structure_has_name(msg->structure, "farsight-error")) {
2080 FsError error_no;
2081 gst_structure_get_enum(msg->structure, "error-no",
2082 FS_TYPE_ERROR, (gint*)&error_no);
2083 switch (error_no) {
2084 case FS_ERROR_NO_CODECS:
2085 purple_media_error(media, _("No codecs found. Install some GStreamer codecs found in GStreamer plugins packages."));
2086 purple_media_end(media, NULL, NULL);
2087 break;
2088 case FS_ERROR_NO_CODECS_LEFT:
2089 purple_media_error(media, _("No codecs left. Your codec preferences in fs-codecs.conf are too strict."));
2090 purple_media_end(media, NULL, NULL);
2091 break;
2092 case FS_ERROR_UNKNOWN_CNAME:
2093 /*
2094 * Unknown CName is only a problem for the
2095 * multicast transmitter which isn't used.
2096 * It is also deprecated.
2097 */
2098 break;
2099 default:
2100 purple_debug_error("media", "farsight-error: %i: %s\n", error_no,
2101 gst_structure_get_string(msg->structure, "error-msg"));
2102 break;
2103 }
2104
2105 if (FS_ERROR_IS_FATAL(error_no)) {
2106 purple_media_error(media, _("A non-recoverable Farsight2 error has occurred."));
2107 purple_media_end(media, NULL, NULL);
2108 }
2109 } else if (gst_structure_has_name(msg->structure,
2110 "farsight-new-local-candidate")) {
2111 FsStream *stream = g_value_get_object(gst_structure_get_value(msg->structure, "stream"));
2112 FsCandidate *local_candidate = g_value_get_boxed(gst_structure_get_value(msg->structure, "candidate"));
2113 PurpleMediaSession *session = purple_media_session_from_fs_stream(media, stream);
2114 purple_media_new_local_candidate_cb(stream, local_candidate, session);
2115 } else if (gst_structure_has_name(msg->structure,
2116 "farsight-local-candidates-prepared")) {
2117 FsStream *stream = g_value_get_object(gst_structure_get_value(msg->structure, "stream"));
2118 PurpleMediaSession *session = purple_media_session_from_fs_stream(media, stream);
2119 purple_media_candidates_prepared_cb(stream, session);
2120 } else if (gst_structure_has_name(msg->structure,
2121 "farsight-new-active-candidate-pair")) {
2122 FsStream *stream = g_value_get_object(gst_structure_get_value(msg->structure, "stream"));
2123 FsCandidate *local_candidate = g_value_get_boxed(gst_structure_get_value(msg->structure, "local-candidate"));
2124 FsCandidate *remote_candidate = g_value_get_boxed(gst_structure_get_value(msg->structure, "remote-candidate"));
2125 PurpleMediaSession *session = purple_media_session_from_fs_stream(media, stream);
2126 purple_media_candidate_pair_established_cb(stream, local_candidate, remote_candidate, session);
2127 } else if (gst_structure_has_name(msg->structure,
2128 "farsight-recv-codecs-changed")) {
2129 GList *codecs = g_value_get_boxed(gst_structure_get_value(msg->structure, "codecs"));
2130 FsCodec *codec = codecs->data;
2131 purple_debug_info("media", "farsight-recv-codecs-changed: %s\n", codec->encoding_name);
2132
2133 } else if (gst_structure_has_name(msg->structure,
2134 "farsight-component-state-changed")) {
2135 FsStreamState fsstate = g_value_get_enum(gst_structure_get_value(msg->structure, "state"));
2136 guint component = g_value_get_uint(gst_structure_get_value(msg->structure, "component"));
2137 const gchar *state;
2138 switch (fsstate) {
2139 case FS_STREAM_STATE_FAILED:
2140 state = "FAILED";
2141 break;
2142 case FS_STREAM_STATE_DISCONNECTED:
2143 state = "DISCONNECTED";
2144 break;
2145 case FS_STREAM_STATE_GATHERING:
2146 state = "GATHERING";
2147 break;
2148 case FS_STREAM_STATE_CONNECTING:
2149 state = "CONNECTING";
2150 break;
2151 case FS_STREAM_STATE_CONNECTED:
2152 state = "CONNECTED";
2153 break;
2154 case FS_STREAM_STATE_READY:
2155 state = "READY";
2156 break;
2157 default:
2158 state = "UNKNOWN";
2159 break;
2160 }
2161 purple_debug_info("media", "farsight-component-state-changed: component: %u state: %s\n", component, state);
2162 } else if (gst_structure_has_name(msg->structure,
2163 "farsight-send-codec-changed")) {
2164 FsCodec *codec = g_value_get_boxed(gst_structure_get_value(msg->structure, "codec"));
2165 gchar *codec_str = fs_codec_to_string(codec);
2166 purple_debug_info("media", "farsight-send-codec-changed: codec: %s\n", codec_str);
2167 g_free(codec_str);
2168 } else if (gst_structure_has_name(msg->structure,
2169 "farsight-codecs-changed")) {
2170 GList *sessions = g_hash_table_get_values(PURPLE_MEDIA(media)->priv->sessions);
2171 FsSession *fssession = g_value_get_object(gst_structure_get_value(msg->structure, "session"));
2172 for (; sessions; sessions = g_list_delete_link(sessions, sessions)) {
2173 PurpleMediaSession *session = sessions->data;
2174 if (session->session == fssession) {
2175 gchar *session_id = g_strdup(session->id);
2176 g_signal_emit(media, purple_media_signals[CODECS_CHANGED], 0, session_id);
2177 g_free(session_id);
2178 g_list_free(sessions);
2179 break;
2180 }
2181 }
2182 }
2183 break;
2184 }
2185 case GST_MESSAGE_ERROR: {
2186 GstElement *element = GST_ELEMENT(GST_MESSAGE_SRC(msg));
2187 GstElement *lastElement = NULL;
2188 while (!GST_IS_PIPELINE(element)) {
2189 if (element == media->priv->confbin) {
2190 purple_media_error(media, _("Conference error"));
2191 purple_media_end(media, NULL, NULL);
2192 break;
2193 }
2194 lastElement = element;
2195 element = GST_ELEMENT_PARENT(element);
2196 }
2197 if (GST_IS_PIPELINE(element)) {
2198 GList *sessions = g_hash_table_get_values(media->priv->sessions);
2199 for (; sessions; sessions = g_list_delete_link(sessions, sessions)) {
2200 PurpleMediaSession *session = sessions->data;
2201
2202 if (session->src == lastElement) {
2203 if (session->type & PURPLE_MEDIA_AUDIO)
2204 purple_media_error(media, _("Error with your microphone"));
2205 else
2206 purple_media_error(media, _("Error with your webcam"));
2207 purple_media_end(media, NULL, NULL);
2208 break;
2209 }
2210 }
2211 g_list_free(sessions);
2212 }
2213 }
2214 default:
2215 break;
2216 }
2217
2218 return TRUE;
2219 }
2220 #endif
2221
2222 PurpleAccount *
2223 purple_media_get_account(PurpleMedia *media)
2224 {
2225 #ifdef USE_VV
2226 PurpleAccount *account;
2227 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL);
2228 g_object_get(G_OBJECT(media), "account", &account, NULL);
2229 return account;
2230 #else
2231 return NULL;
2232 #endif
2233 }
2234
2235 gpointer
2236 purple_media_get_prpl_data(PurpleMedia *media)
2237 {
2238 #ifdef USE_VV
2239 gpointer prpl_data;
2240 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL);
2241 g_object_get(G_OBJECT(media), "prpl-data", &prpl_data, NULL);
2242 return prpl_data;
2243 #else
2244 return NULL;
2245 #endif
2246 }
2247
2248 void
2249 purple_media_set_prpl_data(PurpleMedia *media, gpointer prpl_data)
2250 {
2251 #ifdef USE_VV
2252 g_return_if_fail(PURPLE_IS_MEDIA(media));
2253 g_object_set(G_OBJECT(media), "prpl-data", prpl_data, NULL);
2254 #endif
2255 }
2256
2257 void
2258 purple_media_error(PurpleMedia *media, const gchar *error, ...)
2259 {
2260 #ifdef USE_VV
2261 va_list args;
2262 gchar *message;
2263
2264 g_return_if_fail(PURPLE_IS_MEDIA(media));
2265
2266 va_start(args, error);
2267 message = g_strdup_vprintf(error, args);
2268 va_end(args);
2269
2270 purple_debug_error("media", "%s\n", message);
2271 g_signal_emit(media, purple_media_signals[S_ERROR], 0, message);
2272
2273 g_free(message);
2274 #endif
2275 }
2276
2277 void
2278 purple_media_end(PurpleMedia *media,
2279 const gchar *session_id, const gchar *participant)
2280 {
2281 #ifdef USE_VV
2282 g_return_if_fail(PURPLE_IS_MEDIA(media));
2283 if (session_id == NULL && participant == NULL) {
2284 g_signal_emit(media, purple_media_signals[STATE_CHANGED],
2285 0, PURPLE_MEDIA_STATE_END,
2286 NULL, NULL);
2287 g_object_unref(media);
2288 }
2289 #endif
2290 }
2291
2292 void
2293 purple_media_stream_info(PurpleMedia *media, PurpleMediaInfoType type,
2294 const gchar *session_id, const gchar *participant,
2295 gboolean local)
2296 {
2297 #ifdef USE_VV
2298 g_return_if_fail(PURPLE_IS_MEDIA(media));
2299
2300 if (type == PURPLE_MEDIA_INFO_ACCEPT) {
2301 GList *streams;
2302
2303 g_return_if_fail(PURPLE_IS_MEDIA(media));
2304
2305 streams = purple_media_get_streams(media,
2306 session_id, participant);
2307
2308 for (; streams; streams =
2309 g_list_delete_link(streams, streams)) {
2310 PurpleMediaStream *stream = streams->data;
2311 g_object_set(G_OBJECT(stream->stream), "direction",
2312 purple_media_to_fs_stream_direction(
2313 stream->session->type), NULL);
2314 stream->accepted = TRUE;
2315
2316 if (stream->remote_candidates != NULL) {
2317 GError *err = NULL;
2318 fs_stream_set_remote_candidates(stream->stream,
2319 stream->remote_candidates, &err);
2320
2321 if (err) {
2322 purple_debug_error("media", "Error adding remote"
2323 " candidates: %s\n", err->message);
2324 g_error_free(err);
2325 }
2326 }
2327 }
2328 } else if (local == TRUE && (type == PURPLE_MEDIA_INFO_MUTE ||
2329 type == PURPLE_MEDIA_INFO_UNMUTE)) {
2330 GList *sessions;
2331 gboolean active = (type == PURPLE_MEDIA_INFO_MUTE);
2332
2333 g_return_if_fail(PURPLE_IS_MEDIA(media));
2334
2335 if (session_id == NULL)
2336 sessions = g_hash_table_get_values(
2337 media->priv->sessions);
2338 else
2339 sessions = g_list_prepend(NULL,
2340 purple_media_get_session(
2341 media, session_id));
2342
2343 purple_debug_info("media", "Turning mute %s\n",
2344 active ? "on" : "off");
2345
2346 for (; sessions; sessions = g_list_delete_link(
2347 sessions, sessions)) {
2348 PurpleMediaSession *session = sessions->data;
2349 if (session->type & PURPLE_MEDIA_SEND_AUDIO) {
2350 gchar *name = g_strdup_printf("volume_%s",
2351 session->id);
2352 GstElement *volume = gst_bin_get_by_name(
2353 GST_BIN(session->media->
2354 priv->confbin), name);
2355 g_free(name);
2356 g_object_set(volume, "mute", active, NULL);
2357 }
2358 }
2359 } else if (local == TRUE && (type == PURPLE_MEDIA_INFO_PAUSE ||
2360 type == PURPLE_MEDIA_INFO_UNPAUSE)) {
2361 gboolean active = (type == PURPLE_MEDIA_INFO_PAUSE);
2362 GList *streams = purple_media_get_streams(media,
2363 session_id, participant);
2364 for (; streams; streams = g_list_delete_link(streams, streams)) {
2365 PurpleMediaStream *stream = streams->data;
2366 if (stream->session->type & PURPLE_MEDIA_SEND_VIDEO) {
2367 g_object_set(stream->stream, "direction",
2368 purple_media_to_fs_stream_direction(
2369 stream->session->type & ((active) ?
2370 ~PURPLE_MEDIA_SEND_VIDEO :
2371 PURPLE_MEDIA_VIDEO)), NULL);
2372 }
2373 }
2374 }
2375
2376 g_signal_emit(media, purple_media_signals[STREAM_INFO],
2377 0, type, session_id, participant, local);
2378
2379 if (type == PURPLE_MEDIA_INFO_HANGUP ||
2380 type == PURPLE_MEDIA_INFO_REJECT) {
2381 purple_media_end(media, session_id, participant);
2382 }
2383 #endif
2384 }
2385
2386 #ifdef USE_VV
2387 static void
2388 purple_media_new_local_candidate_cb(FsStream *stream,
2389 FsCandidate *local_candidate,
2390 PurpleMediaSession *session)
2391 {
2392 gchar *name;
2393 FsParticipant *participant;
2394 PurpleMediaCandidate *candidate;
2395
2396 g_return_if_fail(FS_IS_STREAM(stream));
2397 g_return_if_fail(session != NULL);
2398
2399 purple_debug_info("media", "got new local candidate: %s\n", local_candidate->foundation);
2400 g_object_get(stream, "participant", &participant, NULL);
2401 g_object_get(participant, "cname", &name, NULL);
2402 g_object_unref(participant);
2403
2404 purple_media_insert_local_candidate(session, name, fs_candidate_copy(local_candidate));
2405
2406 candidate = purple_media_candidate_from_fs(local_candidate);
2407 g_signal_emit(session->media, purple_media_signals[NEW_CANDIDATE],
2408 0, session->id, name, candidate);
2409 g_object_unref(candidate);
2410
2411 g_free(name);
2412 }
2413
2414 static void
2415 purple_media_candidates_prepared_cb(FsStream *stream, PurpleMediaSession *session)
2416 {
2417 gchar *name;
2418 FsParticipant *participant;
2419 PurpleMediaStream *stream_data;
2420
2421 g_return_if_fail(FS_IS_STREAM(stream));
2422 g_return_if_fail(session != NULL);
2423
2424 g_object_get(stream, "participant", &participant, NULL);
2425 g_object_get(participant, "cname", &name, NULL);
2426 g_object_unref(participant);
2427
2428 stream_data = purple_media_get_stream(session->media, session->id, name);
2429 stream_data->candidates_prepared = TRUE;
2430
2431 g_signal_emit(session->media,
2432 purple_media_signals[CANDIDATES_PREPARED],
2433 0, session->id, name);
2434
2435 g_free(name);
2436 }
2437
2438 /* callback called when a pair of transport candidates (local and remote)
2439 * has been established */
2440 static void
2441 purple_media_candidate_pair_established_cb(FsStream *fsstream,
2442 FsCandidate *native_candidate,
2443 FsCandidate *remote_candidate,
2444 PurpleMediaSession *session)
2445 {
2446 gchar *name;
2447 FsParticipant *participant;
2448 PurpleMediaStream *stream;
2449 GList *iter;
2450
2451 g_return_if_fail(FS_IS_STREAM(fsstream));
2452 g_return_if_fail(session != NULL);
2453
2454 g_object_get(fsstream, "participant", &participant, NULL);
2455 g_object_get(participant, "cname", &name, NULL);
2456 g_object_unref(participant);
2457
2458 stream = purple_media_get_stream(session->media, session->id, name);
2459
2460 iter = stream->active_local_candidates;
2461 for(; iter; iter = g_list_next(iter)) {
2462 FsCandidate *c = iter->data;
2463 if (native_candidate->component_id == c->component_id) {
2464 fs_candidate_destroy(c);
2465 stream->active_local_candidates =
2466 g_list_delete_link(iter, iter);
2467 stream->active_local_candidates = g_list_prepend(
2468 stream->active_local_candidates,
2469 fs_candidate_copy(native_candidate));
2470 break;
2471 }
2472 }
2473 if (iter == NULL)
2474 stream->active_local_candidates = g_list_prepend(
2475 stream->active_local_candidates,
2476 fs_candidate_copy(native_candidate));
2477
2478 iter = stream->active_remote_candidates;
2479 for(; iter; iter = g_list_next(iter)) {
2480 FsCandidate *c = iter->data;
2481 if (native_candidate->component_id == c->component_id) {
2482 fs_candidate_destroy(c);
2483 stream->active_remote_candidates =
2484 g_list_delete_link(iter, iter);
2485 stream->active_remote_candidates = g_list_prepend(
2486 stream->active_remote_candidates,
2487 fs_candidate_copy(remote_candidate));
2488 break;
2489 }
2490 }
2491 if (iter == NULL)
2492 stream->active_remote_candidates = g_list_prepend(
2493 stream->active_remote_candidates,
2494 fs_candidate_copy(remote_candidate));
2495
2496 purple_debug_info("media", "candidate pair established\n");
2497 }
2498
2499 static gboolean
2500 purple_media_connected_cb(PurpleMediaStream *stream)
2501 {
2502 g_return_val_if_fail(stream != NULL, FALSE);
2503
2504 stream->connected_cb_id = 0;
2505
2506 purple_media_manager_create_output_window(
2507 stream->session->media->priv->manager,
2508 stream->session->media,
2509 stream->session->id, stream->participant);
2510
2511 g_signal_emit(stream->session->media,
2512 purple_media_signals[STATE_CHANGED],
2513 0, PURPLE_MEDIA_STATE_CONNECTED,
2514 stream->session->id, stream->participant);
2515 return FALSE;
2516 }
2517
2518 static void
2519 purple_media_src_pad_added_cb(FsStream *fsstream, GstPad *srcpad,
2520 FsCodec *codec, PurpleMediaStream *stream)
2521 {
2522 PurpleMediaPrivate *priv;
2523 GstPad *sinkpad;
2524
2525 g_return_if_fail(FS_IS_STREAM(fsstream));
2526 g_return_if_fail(stream != NULL);
2527
2528 priv = stream->session->media->priv;
2529
2530 if (stream->src == NULL) {
2531 GstElement *sink = NULL;
2532
2533 if (codec->media_type == FS_MEDIA_TYPE_AUDIO) {
2534 GstElement *queue = NULL;
2535 double output_volume = purple_prefs_get_int(
2536 "/purple/media/audio/volume/output")/10.0;
2537 /*
2538 * Should this instead be:
2539 * audioconvert ! audioresample ! liveadder !
2540 * audioresample ! audioconvert ! realsink
2541 */
2542 queue = gst_element_factory_make("queue", NULL);
2543 stream->volume = gst_element_factory_make(
2544 "volume", NULL);
2545 g_object_set(stream->volume, "volume",
2546 output_volume, NULL);
2547 stream->level = gst_element_factory_make(
2548 "level", NULL);
2549 stream->src = gst_element_factory_make(
2550 "liveadder", NULL);
2551 sink = purple_media_manager_get_element(priv->manager,
2552 PURPLE_MEDIA_RECV_AUDIO,
2553 stream->session->media,
2554 stream->session->id,
2555 stream->participant);
2556 gst_bin_add(GST_BIN(priv->confbin), queue);
2557 gst_bin_add(GST_BIN(priv->confbin), stream->volume);
2558 gst_bin_add(GST_BIN(priv->confbin), stream->level);
2559 gst_bin_add(GST_BIN(priv->confbin), sink);
2560 gst_element_set_state(sink, GST_STATE_PLAYING);
2561 gst_element_set_state(stream->level, GST_STATE_PLAYING);
2562 gst_element_set_state(stream->volume, GST_STATE_PLAYING);
2563 gst_element_set_state(queue, GST_STATE_PLAYING);
2564 gst_element_link(stream->level, sink);
2565 gst_element_link(stream->volume, stream->level);
2566 gst_element_link(queue, stream->volume);
2567 sink = queue;
2568 } else if (codec->media_type == FS_MEDIA_TYPE_VIDEO) {
2569 stream->src = gst_element_factory_make(
2570 "fsfunnel", NULL);
2571 sink = gst_element_factory_make(
2572 "fakesink", NULL);
2573 g_object_set(G_OBJECT(sink), "async", FALSE, NULL);
2574 gst_bin_add(GST_BIN(priv->confbin), sink);
2575 gst_element_set_state(sink, GST_STATE_PLAYING);
2576 }
2577 stream->tee = gst_element_factory_make("tee", NULL);
2578 gst_bin_add_many(GST_BIN(priv->confbin),
2579 stream->src, stream->tee, NULL);
2580 gst_element_set_state(stream->tee, GST_STATE_PLAYING);
2581 gst_element_set_state(stream->src, GST_STATE_PLAYING);
2582 gst_element_link_many(stream->src, stream->tee, sink, NULL);
2583 }
2584
2585 sinkpad = gst_element_get_request_pad(stream->src, "sink%d");
2586 gst_pad_link(srcpad, sinkpad);
2587 gst_object_unref(sinkpad);
2588
2589 stream->connected_cb_id = purple_timeout_add(0,
2590 (GSourceFunc)purple_media_connected_cb, stream);
2591 }
2592
2593 static void
2594 purple_media_element_added_cb(FsElementAddedNotifier *self,
2595 GstBin *bin, GstElement *element, gpointer user_data)
2596 {
2597 /*
2598 * Hack to make H264 work with Gmail video.
2599 */
2600 if (!strncmp(GST_ELEMENT_NAME(element), "x264", 4)) {
2601 g_object_set(GST_OBJECT(element), "cabac", FALSE, NULL);
2602 }
2603 }
2604 #endif /* USE_VV */
2605
2606 gboolean
2607 purple_media_add_stream(PurpleMedia *media, const gchar *sess_id,
2608 const gchar *who, PurpleMediaSessionType type,
2609 gboolean initiator, const gchar *transmitter,
2610 guint num_params, GParameter *params)
2611 {
2612 #ifdef USE_VV
2613 PurpleMediaSession *session;
2614 FsParticipant *participant = NULL;
2615 PurpleMediaStream *stream = NULL;
2616 FsMediaType media_type = purple_media_to_fs_media_type(type);
2617 FsStreamDirection type_direction =
2618 purple_media_to_fs_stream_direction(type);
2619 gboolean is_nice = !strcmp(transmitter, "nice");
2620
2621 g_return_val_if_fail(PURPLE_IS_MEDIA(media), FALSE);
2622
2623 session = purple_media_get_session(media, sess_id);
2624
2625 if (!session) {
2626 GError *err = NULL;
2627 GList *codec_conf = NULL, *iter = NULL;
2628 gchar *filename = NULL;
2629 PurpleMediaSessionType session_type;
2630 GstElement *src = NULL;
2631
2632 session = g_new0(PurpleMediaSession, 1);
2633
2634 session->session = fs_conference_new_session(
2635 media->priv->conference, media_type, &err);
2636
2637 if (err != NULL) {
2638 purple_media_error(media, _("Error creating session: %s"), err->message);
2639 g_error_free(err);
2640 g_free(session);
2641 return FALSE;
2642 }
2643
2644 filename = g_build_filename(purple_user_dir(), "fs-codec.conf", NULL);
2645 codec_conf = fs_codec_list_from_keyfile(filename, &err);
2646 g_free(filename);
2647
2648 if (err != NULL) {
2649 if (err->code == 4)
2650 purple_debug_info("media", "Couldn't read "
2651 "fs-codec.conf: %s\n",
2652 err->message);
2653 else
2654 purple_debug_error("media", "Error reading "
2655 "fs-codec.conf: %s\n",
2656 err->message);
2657 g_error_free(err);
2658 }
2659
2660 /*
2661 * Add SPEEX if the configuration file doesn't exist or
2662 * there isn't a speex entry.
2663 */
2664 for (iter = codec_conf; iter; iter = g_list_next(iter)) {
2665 FsCodec *codec = iter->data;
2666 if (!g_ascii_strcasecmp(codec->encoding_name, "speex"))
2667 break;
2668 }
2669
2670 if (iter == NULL) {
2671 codec_conf = g_list_prepend(codec_conf,
2672 fs_codec_new(FS_CODEC_ID_ANY,
2673 "SPEEX", FS_MEDIA_TYPE_AUDIO, 8000));
2674 codec_conf = g_list_prepend(codec_conf,
2675 fs_codec_new(FS_CODEC_ID_ANY,
2676 "SPEEX", FS_MEDIA_TYPE_AUDIO, 16000));
2677 }
2678
2679 fs_session_set_codec_preferences(session->session, codec_conf, NULL);
2680
2681 /*
2682 * Removes a 5-7 second delay before
2683 * receiving the src-pad-added signal.
2684 * Only works for non-multicast FsRtpSessions.
2685 */
2686 if (is_nice || !strcmp(transmitter, "rawudp"))
2687 g_object_set(G_OBJECT(session->session),
2688 "no-rtcp-timeout", 0, NULL);
2689
2690 /*
2691 * Hack to make x264 work with Gmail video.
2692 */
2693 if (is_nice && !strcmp(sess_id, "google-video")) {
2694 FsElementAddedNotifier *notifier =
2695 fs_element_added_notifier_new();
2696 g_signal_connect(G_OBJECT(notifier), "element-added",
2697 G_CALLBACK(purple_media_element_added_cb),
2698 stream);
2699 fs_element_added_notifier_add(notifier,
2700 GST_BIN(media->priv->conference));
2701 }
2702
2703 fs_codec_list_destroy(codec_conf);
2704
2705 session->id = g_strdup(sess_id);
2706 session->media = media;
2707 session->type = type;
2708 session->initiator = initiator;
2709
2710 purple_media_add_session(media, session);
2711 g_signal_emit(media, purple_media_signals[STATE_CHANGED],
2712 0, PURPLE_MEDIA_STATE_NEW,
2713 session->id, NULL);
2714
2715 if (type_direction & FS_DIRECTION_SEND) {
2716 session_type = purple_media_from_fs(media_type,
2717 FS_DIRECTION_SEND);
2718 src = purple_media_manager_get_element(
2719 media->priv->manager, session_type,
2720 media, session->id, who);
2721 if (!GST_IS_ELEMENT(src)) {
2722 purple_debug_error("media",
2723 "Error creating src for session %s\n",
2724 session->id);
2725 purple_media_end(media, session->id, NULL);
2726 return FALSE;
2727 }
2728
2729 purple_media_set_src(media, session->id, src);
2730 gst_element_set_state(session->src, GST_STATE_PLAYING);
2731 purple_media_manager_create_output_window(
2732 media->priv->manager,
2733 session->media,
2734 session->id, NULL);
2735 }
2736 }
2737
2738 if (!(participant = purple_media_add_participant(media, who))) {
2739 purple_media_remove_session(media, session);
2740 g_free(session);
2741 return FALSE;
2742 } else {
2743 g_signal_emit(media, purple_media_signals[STATE_CHANGED],
2744 0, PURPLE_MEDIA_STATE_NEW,
2745 NULL, who);
2746 }
2747
2748 stream = purple_media_get_stream(media, sess_id, who);
2749
2750 if (!stream) {
2751 GError *err = NULL;
2752 FsStream *fsstream = NULL;
2753 const gchar *stun_ip = purple_network_get_stun_ip();
2754 const gchar *turn_ip = purple_network_get_turn_ip();
2755
2756 if (stun_ip || turn_ip) {
2757 guint new_num_params =
2758 (stun_ip && is_nice) && turn_ip ?
2759 num_params + 2 : num_params + 1;
2760 guint next_param_index = num_params;
2761 GParameter *param = g_new0(GParameter, new_num_params);
2762 memcpy(param, params, sizeof(GParameter) * num_params);
2763
2764 if (stun_ip) {
2765 purple_debug_info("media",
2766 "setting property stun-ip on new stream: %s\n", stun_ip);
2767
2768 param[next_param_index].name = "stun-ip";
2769 g_value_init(&param[next_param_index].value, G_TYPE_STRING);
2770 g_value_set_string(&param[next_param_index].value, stun_ip);
2771 next_param_index++;
2772 }
2773
2774 if (turn_ip && is_nice) {
2775 GValueArray *relay_info = g_value_array_new(0);
2776 GValue value;
2777 gint turn_port =
2778 purple_prefs_get_int("/purple/network/turn_port");
2779 const gchar *username =
2780 purple_prefs_get_string("/purple/network/turn_username");
2781 const gchar *password =
2782 purple_prefs_get_string("/purple/network/turn_password");
2783 GstStructure *turn_setup = gst_structure_new("relay-info",
2784 "ip", G_TYPE_STRING, turn_ip,
2785 "port", G_TYPE_UINT, turn_port,
2786 "username", G_TYPE_STRING, username,
2787 "password", G_TYPE_STRING, password,
2788 NULL);
2789
2790 if (turn_setup) {
2791 memset(&value, 0, sizeof(GValue));
2792 g_value_init(&value, GST_TYPE_STRUCTURE);
2793 gst_value_set_structure(&value, turn_setup);
2794 relay_info = g_value_array_append(relay_info, &value);
2795 gst_structure_free(turn_setup);
2796
2797 purple_debug_info("media",
2798 "setting property relay-info on new stream\n");
2799 param[next_param_index].name = "relay-info";
2800 g_value_init(&param[next_param_index].value,
2801 G_TYPE_VALUE_ARRAY);
2802 g_value_set_boxed(&param[next_param_index].value,
2803 relay_info);
2804 g_value_array_free(relay_info);
2805 } else {
2806 purple_debug_error("media", "Error relay info");
2807 g_object_unref(participant);
2808 g_hash_table_remove(media->priv->participants, who);
2809 purple_media_remove_session(media, session);
2810 g_free(session);
2811 return FALSE;
2812 }
2813 }
2814
2815 fsstream = fs_session_new_stream(session->session,
2816 participant, type_direction &
2817 FS_DIRECTION_RECV, transmitter,
2818 new_num_params, param, &err);
2819 g_free(param);
2820 } else {
2821 fsstream = fs_session_new_stream(session->session,
2822 participant, type_direction &
2823 FS_DIRECTION_RECV, transmitter,
2824 num_params, params, &err);
2825 }
2826
2827 if (fsstream == NULL) {
2828 purple_debug_error("media",
2829 "Error creating stream: %s\n",
2830 err && err->message ?
2831 err->message : "NULL");
2832 if (err)
2833 g_error_free(err);
2834 g_object_unref(participant);
2835 g_hash_table_remove(media->priv->participants, who);
2836 purple_media_remove_session(media, session);
2837 g_free(session);
2838 return FALSE;
2839 }
2840
2841 stream = purple_media_insert_stream(session, who, fsstream);
2842 stream->initiator = initiator;
2843
2844 /* callback for source pad added (new stream source ready) */
2845 g_signal_connect(G_OBJECT(fsstream),
2846 "src-pad-added", G_CALLBACK(purple_media_src_pad_added_cb), stream);
2847
2848 g_signal_emit(media, purple_media_signals[STATE_CHANGED],
2849 0, PURPLE_MEDIA_STATE_NEW,
2850 session->id, who);
2851 } else {
2852 if (purple_media_to_fs_stream_direction(stream->session->type)
2853 != type_direction) {
2854 /* change direction */
2855 g_object_set(stream->stream, "direction",
2856 type_direction, NULL);
2857 }
2858 }
2859
2860 return TRUE;
2861 #else
2862 return FALSE;
2863 #endif /* USE_VV */
2864 }
2865
2866 PurpleMediaManager *
2867 purple_media_get_manager(PurpleMedia *media)
2868 {
2869 PurpleMediaManager *ret;
2870 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL);
2871 g_object_get(media, "manager", &ret, NULL);
2872 return ret;
2873 }
2874
2875 PurpleMediaSessionType
2876 purple_media_get_session_type(PurpleMedia *media, const gchar *sess_id)
2877 {
2878 #ifdef USE_VV
2879 PurpleMediaSession *session;
2880 g_return_val_if_fail(PURPLE_IS_MEDIA(media), PURPLE_MEDIA_NONE);
2881 session = purple_media_get_session(media, sess_id);
2882 return session->type;
2883 #else
2884 return PURPLE_MEDIA_NONE;
2885 #endif
2886 }
2887 /* XXX: Should wait until codecs-ready is TRUE before using this function */
2888 GList *
2889 purple_media_get_codecs(PurpleMedia *media, const gchar *sess_id)
2890 {
2891 #ifdef USE_VV
2892 GList *fscodecs;
2893 GList *codecs;
2894 PurpleMediaSession *session;
2895
2896 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL);
2897
2898 session = purple_media_get_session(media, sess_id);
2899
2900 if (session == NULL)
2901 return NULL;
2902
2903 g_object_get(G_OBJECT(session->session),
2904 "codecs", &fscodecs, NULL);
2905 codecs = purple_media_codec_list_from_fs(fscodecs);
2906 fs_codec_list_destroy(fscodecs);
2907 return codecs;
2908 #else
2909 return NULL;
2910 #endif
2911 }
2912
2913 GList *
2914 purple_media_get_local_candidates(PurpleMedia *media, const gchar *sess_id,
2915 const gchar *participant)
2916 {
2917 #ifdef USE_VV
2918 PurpleMediaStream *stream;
2919 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL);
2920 stream = purple_media_get_stream(media, sess_id, participant);
2921 return stream ? purple_media_candidate_list_from_fs(
2922 stream->local_candidates) : NULL;
2923 #else
2924 return NULL;
2925 #endif
2926 }
2927
2928 void
2929 purple_media_add_remote_candidates(PurpleMedia *media, const gchar *sess_id,
2930 const gchar *participant,
2931 GList *remote_candidates)
2932 {
2933 #ifdef USE_VV
2934 PurpleMediaStream *stream;
2935 GError *err = NULL;
2936
2937 g_return_if_fail(PURPLE_IS_MEDIA(media));
2938 stream = purple_media_get_stream(media, sess_id, participant);
2939
2940 if (stream == NULL) {
2941 purple_debug_error("media",
2942 "purple_media_add_remote_candidates: "
2943 "couldn't find stream %s %s.\n",
2944 sess_id ? sess_id : "(null)",
2945 participant ? participant : "(null)");
2946 return;
2947 }
2948
2949 stream->remote_candidates = g_list_concat(stream->remote_candidates,
2950 purple_media_candidate_list_to_fs(remote_candidates));
2951
2952 if (stream->accepted == TRUE) {
2953 fs_stream_set_remote_candidates(stream->stream,
2954 stream->remote_candidates, &err);
2955
2956 if (err) {
2957 purple_debug_error("media", "Error adding remote"
2958 " candidates: %s\n", err->message);
2959 g_error_free(err);
2960 }
2961 }
2962 #endif
2963 }
2964
2965 #if 0
2966 /*
2967 * These two functions aren't being used and I'd rather not lock in the API
2968 * until they are needed. If they ever are.
2969 */
2970
2971 GList *
2972 purple_media_get_active_local_candidates(PurpleMedia *media,
2973 const gchar *sess_id, const gchar *participant)
2974 {
2975 #ifdef USE_VV
2976 PurpleMediaStream *stream;
2977 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL);
2978 stream = purple_media_get_stream(media, sess_id, participant);
2979 return purple_media_candidate_list_from_fs(
2980 stream->active_local_candidates);
2981 #else
2982 return NULL;
2983 #endif
2984 }
2985
2986 GList *
2987 purple_media_get_active_remote_candidates(PurpleMedia *media,
2988 const gchar *sess_id, const gchar *participant)
2989 {
2990 #ifdef USE_VV
2991 PurpleMediaStream *stream;
2992 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL);
2993 stream = purple_media_get_stream(media, sess_id, participant);
2994 return purple_media_candidate_list_from_fs(
2995 stream->active_remote_candidates);
2996 #else
2997 return NULL;
2998 #endif
2999 }
3000 #endif
3001
3002 gboolean
3003 purple_media_set_remote_codecs(PurpleMedia *media, const gchar *sess_id,
3004 const gchar *participant, GList *codecs)
3005 {
3006 #ifdef USE_VV
3007 PurpleMediaStream *stream;
3008 FsStream *fsstream;
3009 GList *fscodecs;
3010 GError *err = NULL;
3011
3012 g_return_val_if_fail(PURPLE_IS_MEDIA(media), FALSE);
3013 stream = purple_media_get_stream(media, sess_id, participant);
3014
3015 if (stream == NULL)
3016 return FALSE;
3017
3018 fsstream = stream->stream;
3019 fscodecs = purple_media_codec_list_to_fs(codecs);
3020 fs_stream_set_remote_codecs(fsstream, fscodecs, &err);
3021 fs_codec_list_destroy(fscodecs);
3022
3023 if (err) {
3024 purple_debug_error("media", "Error setting remote codecs: %s\n",
3025 err->message);
3026 g_error_free(err);
3027 return FALSE;
3028 }
3029 return TRUE;
3030 #else
3031 return FALSE;
3032 #endif
3033 }
3034
3035 gboolean
3036 purple_media_candidates_prepared(PurpleMedia *media,
3037 const gchar *session_id, const gchar *participant)
3038 {
3039 #ifdef USE_VV
3040 GList *streams;
3041 gboolean prepared = TRUE;
3042
3043 g_return_val_if_fail(PURPLE_IS_MEDIA(media), FALSE);
3044
3045 streams = purple_media_get_streams(media, session_id, participant);
3046
3047 for (; streams; streams = g_list_delete_link(streams, streams)) {
3048 PurpleMediaStream *stream = streams->data;
3049 if (stream->candidates_prepared == FALSE) {
3050 g_list_free(streams);
3051 prepared = FALSE;
3052 break;
3053 }
3054 }
3055
3056 return prepared;
3057 #else
3058 return FALSE;
3059 #endif
3060 }
3061
3062 gboolean
3063 purple_media_set_send_codec(PurpleMedia *media, const gchar *sess_id, PurpleMediaCodec *codec)
3064 {
3065 #ifdef USE_VV
3066 PurpleMediaSession *session;
3067 FsCodec *fscodec;
3068 GError *err = NULL;
3069
3070 g_return_val_if_fail(PURPLE_IS_MEDIA(media), FALSE);
3071
3072 session = purple_media_get_session(media, sess_id);
3073
3074 if (session != NULL)
3075 return FALSE;
3076
3077 fscodec = purple_media_codec_to_fs(codec);
3078 fs_session_set_send_codec(session->session, fscodec, &err);
3079 fs_codec_destroy(fscodec);
3080
3081 if (err) {
3082 purple_debug_error("media", "Error setting send codec\n");
3083 g_error_free(err);
3084 return FALSE;
3085 }
3086 return TRUE;
3087 #else
3088 return FALSE;
3089 #endif
3090 }
3091
3092 gboolean
3093 purple_media_codecs_ready(PurpleMedia *media, const gchar *sess_id)
3094 {
3095 #ifdef USE_VV
3096 gboolean ret;
3097
3098 g_return_val_if_fail(PURPLE_IS_MEDIA(media), FALSE);
3099
3100 if (sess_id != NULL) {
3101 PurpleMediaSession *session;
3102 session = purple_media_get_session(media, sess_id);
3103
3104 if (session == NULL)
3105 return FALSE;
3106 if (session->type & (PURPLE_MEDIA_SEND_AUDIO |
3107 PURPLE_MEDIA_SEND_VIDEO))
3108 g_object_get(session->session,
3109 "codecs-ready", &ret, NULL);
3110 else
3111 ret = TRUE;
3112 } else {
3113 GList *values = g_hash_table_get_values(media->priv->sessions);
3114 for (; values; values = g_list_delete_link(values, values)) {
3115 PurpleMediaSession *session = values->data;
3116 if (session->type & (PURPLE_MEDIA_SEND_AUDIO |
3117 PURPLE_MEDIA_SEND_VIDEO))
3118 g_object_get(session->session,
3119 "codecs-ready", &ret, NULL);
3120 else
3121 ret = TRUE;
3122
3123 if (ret == FALSE)
3124 break;
3125 }
3126 if (values != NULL)
3127 g_list_free(values);
3128 }
3129 return ret;
3130 #else
3131 return FALSE;
3132 #endif
3133 }
3134
3135 gboolean
3136 purple_media_is_initiator(PurpleMedia *media,
3137 const gchar *sess_id, const gchar *participant)
3138 {
3139 #ifdef USE_VV
3140 g_return_val_if_fail(PURPLE_IS_MEDIA(media), FALSE);
3141
3142 if (sess_id == NULL && participant == NULL)
3143 return media->priv->initiator;
3144 else if (sess_id != NULL && participant == NULL) {
3145 PurpleMediaSession *session =
3146 purple_media_get_session(media, sess_id);
3147 return session != NULL ? session->initiator : FALSE;
3148 } else if (sess_id != NULL && participant != NULL) {
3149 PurpleMediaStream *stream = purple_media_get_stream(
3150 media, sess_id, participant);
3151 return stream != NULL ? stream->initiator : FALSE;
3152 }
3153 #endif
3154 return FALSE;
3155 }
3156
3157 gboolean
3158 purple_media_accepted(PurpleMedia *media, const gchar *sess_id,
3159 const gchar *participant)
3160 {
3161 #ifdef USE_VV
3162 gboolean accepted = TRUE;
3163
3164 g_return_val_if_fail(PURPLE_IS_MEDIA(media), FALSE);
3165
3166 if (sess_id == NULL && participant == NULL) {
3167 GList *streams = media->priv->streams;
3168
3169 for (; streams; streams = g_list_next(streams)) {
3170 PurpleMediaStream *stream = streams->data;
3171 if (stream->accepted == FALSE) {
3172 accepted = FALSE;
3173 break;
3174 }
3175 }
3176 } else if (sess_id != NULL && participant == NULL) {
3177 GList *streams = purple_media_get_streams(
3178 media, sess_id, NULL);
3179 for (; streams; streams =
3180 g_list_delete_link(streams, streams)) {
3181 PurpleMediaStream *stream = streams->data;
3182 if (stream->accepted == FALSE) {
3183 g_list_free(streams);
3184 accepted = FALSE;
3185 break;
3186 }
3187 }
3188 } else if (sess_id != NULL && participant != NULL) {
3189 PurpleMediaStream *stream = purple_media_get_stream(
3190 media, sess_id, participant);
3191 if (stream == NULL || stream->accepted == FALSE)
3192 accepted = FALSE;
3193 }
3194
3195 return accepted;
3196 #else
3197 return FALSE;
3198 #endif
3199 }
3200
3201 void purple_media_set_input_volume(PurpleMedia *media,
3202 const gchar *session_id, double level)
3203 {
3204 #ifdef USE_VV
3205 GList *sessions;
3206
3207 g_return_if_fail(PURPLE_IS_MEDIA(media));
3208
3209 purple_prefs_set_int("/purple/media/audio/volume/input", level);
3210
3211 if (session_id == NULL)
3212 sessions = g_hash_table_get_values(media->priv->sessions);
3213 else
3214 sessions = g_list_append(NULL,
3215 purple_media_get_session(media, session_id));
3216
3217 for (; sessions; sessions = g_list_delete_link(sessions, sessions)) {
3218 PurpleMediaSession *session = sessions->data;
3219
3220 if (session->type & PURPLE_MEDIA_SEND_AUDIO) {
3221 gchar *name = g_strdup_printf("volume_%s",
3222 session->id);
3223 GstElement *volume = gst_bin_get_by_name(
3224 GST_BIN(session->media->priv->confbin),
3225 name);
3226 g_free(name);
3227 g_object_set(volume, "volume", level/10.0, NULL);
3228 }
3229 }
3230 #endif
3231 }
3232
3233 void purple_media_set_output_volume(PurpleMedia *media,
3234 const gchar *session_id, const gchar *participant,
3235 double level)
3236 {
3237 #ifdef USE_VV
3238 GList *streams;
3239
3240 g_return_if_fail(PURPLE_IS_MEDIA(media));
3241
3242 purple_prefs_set_int("/purple/media/audio/volume/output", level);
3243
3244 streams = purple_media_get_streams(media,
3245 session_id, participant);
3246
3247 for (; streams; streams = g_list_delete_link(streams, streams)) {
3248 PurpleMediaStream *stream = streams->data;
3249
3250 if (stream->session->type & PURPLE_MEDIA_RECV_AUDIO
3251 && GST_IS_ELEMENT(stream->volume)) {
3252 g_object_set(stream->volume, "volume", level/10.0, NULL);
3253 }
3254 }
3255 #endif
3256 }
3257
3258 gulong
3259 purple_media_set_output_window(PurpleMedia *media, const gchar *session_id,
3260 const gchar *participant, gulong window_id)
3261 {
3262 #ifdef USE_VV
3263 g_return_val_if_fail(PURPLE_IS_MEDIA(media), FALSE);
3264
3265 return purple_media_manager_set_output_window(media->priv->manager,
3266 media, session_id, participant, window_id);
3267 #else
3268 return 0;
3269 #endif
3270 }
3271
3272 void
3273 purple_media_remove_output_windows(PurpleMedia *media)
3274 {
3275 #ifdef USE_VV
3276 GList *iter = media->priv->streams;
3277 for (; iter; iter = g_list_next(iter)) {
3278 PurpleMediaStream *stream = iter->data;
3279 purple_media_manager_remove_output_windows(
3280 media->priv->manager, media,
3281 stream->session->id, stream->participant);
3282 }
3283
3284 iter = purple_media_get_session_ids(media);
3285 for (; iter; iter = g_list_delete_link(iter, iter)) {
3286 gchar *session_name = iter->data;
3287 purple_media_manager_remove_output_windows(
3288 media->priv->manager, media,
3289 session_name, NULL);
3290 }
3291 #endif
3292 }
3293
3294 #ifdef USE_GSTREAMER
3295 GstElement *
3296 purple_media_get_tee(PurpleMedia *media,
3297 const gchar *session_id, const gchar *participant)
3298 {
3299 #ifdef USE_VV
3300 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL);
3301
3302 if (session_id != NULL && participant == NULL) {
3303 PurpleMediaSession *session =
3304 purple_media_get_session(media, session_id);
3305 return (session != NULL) ? session->tee : NULL;
3306 } else if (session_id != NULL && participant != NULL) {
3307 PurpleMediaStream *stream =
3308 purple_media_get_stream(media,
3309 session_id, participant);
3310 return (stream != NULL) ? stream->tee : NULL;
3311 }
3312 g_return_val_if_reached(NULL);
3313 #else
3314 return NULL;
3315 #endif
3316 }
3317 #endif /* USE_GSTREAMER */
3318