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