Mercurial > pidgin.yaz
annotate libpurple/media/media.c @ 29591:a71400a86933
Remove unnecessary Farsight 2 headers from media.c
author | maiku@pidgin.im |
---|---|
date | Tue, 27 Oct 2009 21:48:06 +0000 |
parents | 2751016b8084 |
children | 0b54934f2742 |
rev | line source |
---|---|
29534 | 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" | |
29549
41ae97b7e97e
Start to use the media backend code in PurpleMedia and PurpleMediaManager.
maiku@pidgin.im
parents:
29545
diff
changeset
|
33 #include "media/backend-fs2.h" |
41ae97b7e97e
Start to use the media backend code in PurpleMedia and PurpleMediaManager.
maiku@pidgin.im
parents:
29545
diff
changeset
|
34 #include "media/backend-iface.h" |
29534 | 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 /** @copydoc _PurpleMediaSession */ | |
48 typedef struct _PurpleMediaSession PurpleMediaSession; | |
49 /** @copydoc _PurpleMediaStream */ | |
50 typedef struct _PurpleMediaStream PurpleMediaStream; | |
51 /** @copydoc _PurpleMediaClass */ | |
52 typedef struct _PurpleMediaClass PurpleMediaClass; | |
53 /** @copydoc _PurpleMediaPrivate */ | |
54 typedef struct _PurpleMediaPrivate PurpleMediaPrivate; | |
55 | |
56 /** The media class */ | |
57 struct _PurpleMediaClass | |
58 { | |
59 GObjectClass parent_class; /**< The parent class. */ | |
60 }; | |
61 | |
62 /** The media class's private data */ | |
63 struct _PurpleMedia | |
64 { | |
65 GObject parent; /**< The parent of this object. */ | |
66 PurpleMediaPrivate *priv; /**< The private data of this object. */ | |
67 }; | |
68 | |
69 struct _PurpleMediaSession | |
70 { | |
71 gchar *id; | |
72 PurpleMedia *media; | |
73 PurpleMediaSessionType type; | |
74 gboolean initiator; | |
75 }; | |
76 | |
77 struct _PurpleMediaStream | |
78 { | |
79 PurpleMediaSession *session; | |
80 gchar *participant; | |
81 | |
82 GList *local_candidates; | |
83 GList *remote_candidates; | |
84 | |
85 gboolean initiator; | |
86 gboolean accepted; | |
87 gboolean candidates_prepared; | |
88 | |
89 GList *active_local_candidates; | |
90 GList *active_remote_candidates; | |
91 | |
92 guint connected_cb_id; | |
93 }; | |
94 #endif | |
95 | |
96 struct _PurpleMediaPrivate | |
97 { | |
98 #ifdef USE_VV | |
99 PurpleMediaManager *manager; | |
100 PurpleAccount *account; | |
29549
41ae97b7e97e
Start to use the media backend code in PurpleMedia and PurpleMediaManager.
maiku@pidgin.im
parents:
29545
diff
changeset
|
101 PurpleMediaBackend *backend; |
29545
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29538
diff
changeset
|
102 gchar *conference_type; |
29551
e85df0170905
Decouple the media_bus_call from the backend. It will still be needed even
maiku@pidgin.im
parents:
29550
diff
changeset
|
103 gulong gst_bus_handler_id; |
29534 | 104 gboolean initiator; |
105 gpointer prpl_data; | |
106 | |
107 GHashTable *sessions; /* PurpleMediaSession table */ | |
108 | |
109 GList *streams; /* PurpleMediaStream table */ | |
110 #else | |
111 gpointer dummy; | |
112 #endif | |
113 }; | |
114 | |
115 #ifdef USE_VV | |
116 #define PURPLE_MEDIA_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), PURPLE_TYPE_MEDIA, PurpleMediaPrivate)) | |
117 | |
118 static void purple_media_class_init (PurpleMediaClass *klass); | |
119 static void purple_media_init (PurpleMedia *media); | |
120 static void purple_media_dispose (GObject *object); | |
121 static void purple_media_finalize (GObject *object); | |
122 static void purple_media_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec); | |
123 static void purple_media_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec); | |
124 | |
29554
2460e6774e08
Move handling Farsight 2's new-local-candidate signal in Fs2 media backend.
maiku@pidgin.im
parents:
29553
diff
changeset
|
125 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:
29553
diff
changeset
|
126 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:
29553
diff
changeset
|
127 PurpleMediaCandidate *candidate, PurpleMedia *media); |
29557
1fdc75c94c22
Move Farsight 2's local-candidates-prepared signal to the Fs2 media backend.
maiku@pidgin.im
parents:
29556
diff
changeset
|
128 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:
29556
diff
changeset
|
129 const gchar *sess_id, const gchar *name, PurpleMedia *media); |
29556
74e75fc3481e
Move Farsight 2's new-active-candidate-pair into the Fs2 media backend.
maiku@pidgin.im
parents:
29555
diff
changeset
|
130 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:
29555
diff
changeset
|
131 PurpleMediaBackend *backend, |
74e75fc3481e
Move Farsight 2's new-active-candidate-pair into the Fs2 media backend.
maiku@pidgin.im
parents:
29555
diff
changeset
|
132 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:
29555
diff
changeset
|
133 PurpleMediaCandidate *local_candidate, |
74e75fc3481e
Move Farsight 2's new-active-candidate-pair into the Fs2 media backend.
maiku@pidgin.im
parents:
29555
diff
changeset
|
134 PurpleMediaCandidate *remote_candidate, |
74e75fc3481e
Move Farsight 2's new-active-candidate-pair into the Fs2 media backend.
maiku@pidgin.im
parents:
29555
diff
changeset
|
135 PurpleMedia *media); |
29555
cc978a1a4bd1
Move handling Farsight 2's codecs-changed signal into the Fs2 media backend.
maiku@pidgin.im
parents:
29554
diff
changeset
|
136 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:
29554
diff
changeset
|
137 const gchar *sess_id, PurpleMedia *media); |
29534 | 138 |
139 static GObjectClass *parent_class = NULL; | |
140 | |
141 | |
142 | |
143 enum { | |
144 S_ERROR, | |
145 CANDIDATES_PREPARED, | |
146 CODECS_CHANGED, | |
147 LEVEL, | |
148 NEW_CANDIDATE, | |
149 STATE_CHANGED, | |
150 STREAM_INFO, | |
151 LAST_SIGNAL | |
152 }; | |
153 static guint purple_media_signals[LAST_SIGNAL] = {0}; | |
154 | |
155 enum { | |
156 PROP_0, | |
157 PROP_MANAGER, | |
158 PROP_ACCOUNT, | |
29545
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29538
diff
changeset
|
159 PROP_CONFERENCE_TYPE, |
29534 | 160 PROP_INITIATOR, |
161 PROP_PRPL_DATA, | |
162 }; | |
163 #endif | |
164 | |
165 | |
166 GType | |
167 purple_media_get_type() | |
168 { | |
169 #ifdef USE_VV | |
170 static GType type = 0; | |
171 | |
172 if (type == 0) { | |
173 static const GTypeInfo info = { | |
174 sizeof(PurpleMediaClass), | |
175 NULL, | |
176 NULL, | |
177 (GClassInitFunc) purple_media_class_init, | |
178 NULL, | |
179 NULL, | |
180 sizeof(PurpleMedia), | |
181 0, | |
182 (GInstanceInitFunc) purple_media_init, | |
183 NULL | |
184 }; | |
185 type = g_type_register_static(G_TYPE_OBJECT, "PurpleMedia", &info, 0); | |
186 } | |
187 return type; | |
188 #else | |
189 return G_TYPE_NONE; | |
190 #endif | |
191 } | |
192 | |
193 #ifdef USE_VV | |
194 static void | |
195 purple_media_class_init (PurpleMediaClass *klass) | |
196 { | |
197 GObjectClass *gobject_class = (GObjectClass*)klass; | |
198 parent_class = g_type_class_peek_parent(klass); | |
199 | |
200 gobject_class->dispose = purple_media_dispose; | |
201 gobject_class->finalize = purple_media_finalize; | |
202 gobject_class->set_property = purple_media_set_property; | |
203 gobject_class->get_property = purple_media_get_property; | |
204 | |
205 g_object_class_install_property(gobject_class, PROP_MANAGER, | |
206 g_param_spec_object("manager", | |
207 "Purple Media Manager", | |
208 "The media manager that contains this media session.", | |
209 PURPLE_TYPE_MEDIA_MANAGER, | |
210 G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE)); | |
211 | |
212 g_object_class_install_property(gobject_class, PROP_ACCOUNT, | |
213 g_param_spec_pointer("account", | |
214 "PurpleAccount", | |
215 "The account this media session is on.", | |
216 G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE)); | |
217 | |
29545
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29538
diff
changeset
|
218 g_object_class_install_property(gobject_class, PROP_CONFERENCE_TYPE, |
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29538
diff
changeset
|
219 g_param_spec_string("conference-type", |
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29538
diff
changeset
|
220 "Conference Type", |
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29538
diff
changeset
|
221 "The type of conference that this media object " |
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29538
diff
changeset
|
222 "has been created to provide.", |
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29538
diff
changeset
|
223 NULL, |
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29538
diff
changeset
|
224 G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE)); |
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29538
diff
changeset
|
225 |
29534 | 226 g_object_class_install_property(gobject_class, PROP_INITIATOR, |
227 g_param_spec_boolean("initiator", | |
228 "initiator", | |
229 "If the local user initiated the conference.", | |
230 FALSE, | |
231 G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE)); | |
232 | |
233 g_object_class_install_property(gobject_class, PROP_PRPL_DATA, | |
234 g_param_spec_pointer("prpl-data", | |
235 "gpointer", | |
236 "Data the prpl plugin set on the media session.", | |
237 G_PARAM_READWRITE)); | |
238 | |
239 purple_media_signals[S_ERROR] = g_signal_new("error", G_TYPE_FROM_CLASS(klass), | |
240 G_SIGNAL_RUN_LAST, 0, NULL, NULL, | |
241 g_cclosure_marshal_VOID__STRING, | |
242 G_TYPE_NONE, 1, G_TYPE_STRING); | |
243 purple_media_signals[CANDIDATES_PREPARED] = g_signal_new("candidates-prepared", G_TYPE_FROM_CLASS(klass), | |
244 G_SIGNAL_RUN_LAST, 0, NULL, NULL, | |
245 purple_smarshal_VOID__STRING_STRING, | |
246 G_TYPE_NONE, 2, G_TYPE_STRING, | |
247 G_TYPE_STRING); | |
248 purple_media_signals[CODECS_CHANGED] = g_signal_new("codecs-changed", G_TYPE_FROM_CLASS(klass), | |
249 G_SIGNAL_RUN_LAST, 0, NULL, NULL, | |
250 g_cclosure_marshal_VOID__STRING, | |
251 G_TYPE_NONE, 1, G_TYPE_STRING); | |
252 purple_media_signals[LEVEL] = g_signal_new("level", G_TYPE_FROM_CLASS(klass), | |
253 G_SIGNAL_RUN_LAST, 0, NULL, NULL, | |
254 purple_smarshal_VOID__STRING_STRING_DOUBLE, | |
255 G_TYPE_NONE, 3, G_TYPE_STRING, | |
256 G_TYPE_STRING, G_TYPE_DOUBLE); | |
257 purple_media_signals[NEW_CANDIDATE] = g_signal_new("new-candidate", G_TYPE_FROM_CLASS(klass), | |
258 G_SIGNAL_RUN_LAST, 0, NULL, NULL, | |
259 purple_smarshal_VOID__POINTER_POINTER_OBJECT, | |
260 G_TYPE_NONE, 3, G_TYPE_POINTER, | |
261 G_TYPE_POINTER, PURPLE_TYPE_MEDIA_CANDIDATE); | |
262 purple_media_signals[STATE_CHANGED] = g_signal_new("state-changed", G_TYPE_FROM_CLASS(klass), | |
263 G_SIGNAL_RUN_LAST, 0, NULL, NULL, | |
264 purple_smarshal_VOID__ENUM_STRING_STRING, | |
265 G_TYPE_NONE, 3, PURPLE_MEDIA_TYPE_STATE, | |
266 G_TYPE_STRING, G_TYPE_STRING); | |
267 purple_media_signals[STREAM_INFO] = g_signal_new("stream-info", G_TYPE_FROM_CLASS(klass), | |
268 G_SIGNAL_RUN_LAST, 0, NULL, NULL, | |
269 purple_smarshal_VOID__ENUM_STRING_STRING_BOOLEAN, | |
270 G_TYPE_NONE, 4, PURPLE_MEDIA_TYPE_INFO_TYPE, | |
271 G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN); | |
272 g_type_class_add_private(klass, sizeof(PurpleMediaPrivate)); | |
273 } | |
274 | |
275 | |
276 static void | |
277 purple_media_init (PurpleMedia *media) | |
278 { | |
279 media->priv = PURPLE_MEDIA_GET_PRIVATE(media); | |
280 memset(media->priv, 0, sizeof(*media->priv)); | |
281 } | |
282 | |
283 static void | |
284 purple_media_stream_free(PurpleMediaStream *stream) | |
285 { | |
286 if (stream == NULL) | |
287 return; | |
288 | |
289 /* Remove the connected_cb timeout */ | |
290 if (stream->connected_cb_id != 0) | |
291 purple_timeout_remove(stream->connected_cb_id); | |
292 | |
293 g_free(stream->participant); | |
294 | |
295 if (stream->local_candidates) | |
29559
cb843608e183
Store local_candidates in PurpleMedia as a GList of PurpleMediaCandidate's.
maiku@pidgin.im
parents:
29557
diff
changeset
|
296 purple_media_candidate_list_free(stream->local_candidates); |
29534 | 297 if (stream->remote_candidates) |
29560
18571ea6e44a
Store remote_candidates in PurpleMedia as a GList of PurpleMediaCandidate's.
maiku@pidgin.im
parents:
29559
diff
changeset
|
298 purple_media_candidate_list_free(stream->remote_candidates); |
29534 | 299 |
300 if (stream->active_local_candidates) | |
29561
7713312c4ab0
Store active_local_candidates in PurpleMedia as a GList of PurpleMediaCandidate's.
maiku@pidgin.im
parents:
29560
diff
changeset
|
301 purple_media_candidate_list_free( |
7713312c4ab0
Store active_local_candidates in PurpleMedia as a GList of PurpleMediaCandidate's.
maiku@pidgin.im
parents:
29560
diff
changeset
|
302 stream->active_local_candidates); |
29534 | 303 if (stream->active_remote_candidates) |
29562
1156bf88b4d3
Store active_remote_candidates in PurpleMedia as a GList of PurpleMediaCandidate's.
maiku@pidgin.im
parents:
29561
diff
changeset
|
304 purple_media_candidate_list_free( |
1156bf88b4d3
Store active_remote_candidates in PurpleMedia as a GList of PurpleMediaCandidate's.
maiku@pidgin.im
parents:
29561
diff
changeset
|
305 stream->active_remote_candidates); |
29534 | 306 |
307 g_free(stream); | |
308 } | |
309 | |
310 static void | |
311 purple_media_session_free(PurpleMediaSession *session) | |
312 { | |
313 if (session == NULL) | |
314 return; | |
315 | |
316 g_free(session->id); | |
317 g_free(session); | |
318 } | |
319 | |
320 static void | |
321 purple_media_dispose(GObject *media) | |
322 { | |
323 PurpleMediaPrivate *priv = PURPLE_MEDIA_GET_PRIVATE(media); | |
324 | |
325 purple_debug_info("media","purple_media_dispose\n"); | |
326 | |
327 purple_media_manager_remove_media(priv->manager, PURPLE_MEDIA(media)); | |
328 | |
29549
41ae97b7e97e
Start to use the media backend code in PurpleMedia and PurpleMediaManager.
maiku@pidgin.im
parents:
29545
diff
changeset
|
329 if (priv->backend) { |
41ae97b7e97e
Start to use the media backend code in PurpleMedia and PurpleMediaManager.
maiku@pidgin.im
parents:
29545
diff
changeset
|
330 g_object_unref(priv->backend); |
41ae97b7e97e
Start to use the media backend code in PurpleMedia and PurpleMediaManager.
maiku@pidgin.im
parents:
29545
diff
changeset
|
331 priv->backend = NULL; |
29534 | 332 } |
333 | |
29551
e85df0170905
Decouple the media_bus_call from the backend. It will still be needed even
maiku@pidgin.im
parents:
29550
diff
changeset
|
334 if (priv->gst_bus_handler_id != 0) { |
29534 | 335 GstElement *pipeline = purple_media_manager_get_pipeline( |
336 priv->manager); | |
337 GstBus *bus = gst_pipeline_get_bus(GST_PIPELINE(pipeline)); | |
29551
e85df0170905
Decouple the media_bus_call from the backend. It will still be needed even
maiku@pidgin.im
parents:
29550
diff
changeset
|
338 g_signal_handler_disconnect(bus, priv->gst_bus_handler_id); |
29534 | 339 gst_object_unref(bus); |
29551
e85df0170905
Decouple the media_bus_call from the backend. It will still be needed even
maiku@pidgin.im
parents:
29550
diff
changeset
|
340 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:
29550
diff
changeset
|
341 } |
29534 | 342 |
29551
e85df0170905
Decouple the media_bus_call from the backend. It will still be needed even
maiku@pidgin.im
parents:
29550
diff
changeset
|
343 if (priv->manager) { |
29534 | 344 g_object_unref(priv->manager); |
345 priv->manager = NULL; | |
346 } | |
347 | |
348 G_OBJECT_CLASS(parent_class)->dispose(media); | |
349 } | |
350 | |
351 static void | |
352 purple_media_finalize(GObject *media) | |
353 { | |
354 PurpleMediaPrivate *priv = PURPLE_MEDIA_GET_PRIVATE(media); | |
355 purple_debug_info("media","purple_media_finalize\n"); | |
356 | |
357 for (; priv->streams; priv->streams = g_list_delete_link(priv->streams, priv->streams)) | |
358 purple_media_stream_free(priv->streams->data); | |
359 | |
360 if (priv->sessions) { | |
361 GList *sessions = g_hash_table_get_values(priv->sessions); | |
362 for (; sessions; sessions = g_list_delete_link(sessions, sessions)) { | |
363 purple_media_session_free(sessions->data); | |
364 } | |
365 g_hash_table_destroy(priv->sessions); | |
366 } | |
367 | |
368 G_OBJECT_CLASS(parent_class)->finalize(media); | |
369 } | |
370 | |
371 static void | |
372 purple_media_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) | |
373 { | |
374 PurpleMedia *media; | |
375 g_return_if_fail(PURPLE_IS_MEDIA(object)); | |
376 | |
377 media = PURPLE_MEDIA(object); | |
378 | |
379 switch (prop_id) { | |
380 case PROP_MANAGER: | |
29549
41ae97b7e97e
Start to use the media backend code in PurpleMedia and PurpleMediaManager.
maiku@pidgin.im
parents:
29545
diff
changeset
|
381 media->priv->manager = g_value_dup_object(value); |
29534 | 382 break; |
383 case PROP_ACCOUNT: | |
384 media->priv->account = g_value_get_pointer(value); | |
385 break; | |
29545
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29538
diff
changeset
|
386 case PROP_CONFERENCE_TYPE: |
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29538
diff
changeset
|
387 media->priv->conference_type = |
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29538
diff
changeset
|
388 g_value_dup_string(value); |
29549
41ae97b7e97e
Start to use the media backend code in PurpleMedia and PurpleMediaManager.
maiku@pidgin.im
parents:
29545
diff
changeset
|
389 /* 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:
29545
diff
changeset
|
390 media->priv->backend = g_object_new( |
41ae97b7e97e
Start to use the media backend code in PurpleMedia and PurpleMediaManager.
maiku@pidgin.im
parents:
29545
diff
changeset
|
391 PURPLE_TYPE_MEDIA_BACKEND_FS2, |
41ae97b7e97e
Start to use the media backend code in PurpleMedia and PurpleMediaManager.
maiku@pidgin.im
parents:
29545
diff
changeset
|
392 "conference-type", |
41ae97b7e97e
Start to use the media backend code in PurpleMedia and PurpleMediaManager.
maiku@pidgin.im
parents:
29545
diff
changeset
|
393 media->priv->conference_type, |
41ae97b7e97e
Start to use the media backend code in PurpleMedia and PurpleMediaManager.
maiku@pidgin.im
parents:
29545
diff
changeset
|
394 "media", media, |
41ae97b7e97e
Start to use the media backend code in PurpleMedia and PurpleMediaManager.
maiku@pidgin.im
parents:
29545
diff
changeset
|
395 NULL); |
29554
2460e6774e08
Move handling Farsight 2's new-local-candidate signal in Fs2 media backend.
maiku@pidgin.im
parents:
29553
diff
changeset
|
396 g_signal_connect(media->priv->backend, |
29556
74e75fc3481e
Move Farsight 2's new-active-candidate-pair into the Fs2 media backend.
maiku@pidgin.im
parents:
29555
diff
changeset
|
397 "active-candidate-pair", |
74e75fc3481e
Move Farsight 2's new-active-candidate-pair into the Fs2 media backend.
maiku@pidgin.im
parents:
29555
diff
changeset
|
398 G_CALLBACK( |
74e75fc3481e
Move Farsight 2's new-active-candidate-pair into the Fs2 media backend.
maiku@pidgin.im
parents:
29555
diff
changeset
|
399 purple_media_candidate_pair_established_cb), |
74e75fc3481e
Move Farsight 2's new-active-candidate-pair into the Fs2 media backend.
maiku@pidgin.im
parents:
29555
diff
changeset
|
400 media); |
74e75fc3481e
Move Farsight 2's new-active-candidate-pair into the Fs2 media backend.
maiku@pidgin.im
parents:
29555
diff
changeset
|
401 g_signal_connect(media->priv->backend, |
29557
1fdc75c94c22
Move Farsight 2's local-candidates-prepared signal to the Fs2 media backend.
maiku@pidgin.im
parents:
29556
diff
changeset
|
402 "candidates-prepared", |
1fdc75c94c22
Move Farsight 2's local-candidates-prepared signal to the Fs2 media backend.
maiku@pidgin.im
parents:
29556
diff
changeset
|
403 G_CALLBACK( |
1fdc75c94c22
Move Farsight 2's local-candidates-prepared signal to the Fs2 media backend.
maiku@pidgin.im
parents:
29556
diff
changeset
|
404 purple_media_candidates_prepared_cb), |
1fdc75c94c22
Move Farsight 2's local-candidates-prepared signal to the Fs2 media backend.
maiku@pidgin.im
parents:
29556
diff
changeset
|
405 media); |
1fdc75c94c22
Move Farsight 2's local-candidates-prepared signal to the Fs2 media backend.
maiku@pidgin.im
parents:
29556
diff
changeset
|
406 g_signal_connect(media->priv->backend, |
29555
cc978a1a4bd1
Move handling Farsight 2's codecs-changed signal into the Fs2 media backend.
maiku@pidgin.im
parents:
29554
diff
changeset
|
407 "codecs-changed", |
cc978a1a4bd1
Move handling Farsight 2's codecs-changed signal into the Fs2 media backend.
maiku@pidgin.im
parents:
29554
diff
changeset
|
408 G_CALLBACK( |
cc978a1a4bd1
Move handling Farsight 2's codecs-changed signal into the Fs2 media backend.
maiku@pidgin.im
parents:
29554
diff
changeset
|
409 purple_media_codecs_changed_cb), |
cc978a1a4bd1
Move handling Farsight 2's codecs-changed signal into the Fs2 media backend.
maiku@pidgin.im
parents:
29554
diff
changeset
|
410 media); |
cc978a1a4bd1
Move handling Farsight 2's codecs-changed signal into the Fs2 media backend.
maiku@pidgin.im
parents:
29554
diff
changeset
|
411 g_signal_connect(media->priv->backend, |
29554
2460e6774e08
Move handling Farsight 2's new-local-candidate signal in Fs2 media backend.
maiku@pidgin.im
parents:
29553
diff
changeset
|
412 "new-candidate", |
2460e6774e08
Move handling Farsight 2's new-local-candidate signal in Fs2 media backend.
maiku@pidgin.im
parents:
29553
diff
changeset
|
413 G_CALLBACK( |
2460e6774e08
Move handling Farsight 2's new-local-candidate signal in Fs2 media backend.
maiku@pidgin.im
parents:
29553
diff
changeset
|
414 purple_media_new_local_candidate_cb), |
2460e6774e08
Move handling Farsight 2's new-local-candidate signal in Fs2 media backend.
maiku@pidgin.im
parents:
29553
diff
changeset
|
415 media); |
29545
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29538
diff
changeset
|
416 break; |
29534 | 417 case PROP_INITIATOR: |
418 media->priv->initiator = g_value_get_boolean(value); | |
419 break; | |
420 case PROP_PRPL_DATA: | |
421 media->priv->prpl_data = g_value_get_pointer(value); | |
422 break; | |
423 default: | |
424 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); | |
425 break; | |
426 } | |
427 } | |
428 | |
429 static void | |
430 purple_media_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) | |
431 { | |
432 PurpleMedia *media; | |
433 g_return_if_fail(PURPLE_IS_MEDIA(object)); | |
434 | |
435 media = PURPLE_MEDIA(object); | |
436 | |
437 switch (prop_id) { | |
438 case PROP_MANAGER: | |
439 g_value_set_object(value, media->priv->manager); | |
440 break; | |
441 case PROP_ACCOUNT: | |
442 g_value_set_pointer(value, media->priv->account); | |
443 break; | |
29545
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29538
diff
changeset
|
444 case PROP_CONFERENCE_TYPE: |
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29538
diff
changeset
|
445 g_value_set_string(value, |
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29538
diff
changeset
|
446 media->priv->conference_type); |
30e8ab2a4bc2
Add a conference-type parameter to PurpleMedia.
maiku@pidgin.im
parents:
29538
diff
changeset
|
447 break; |
29534 | 448 case PROP_INITIATOR: |
449 g_value_set_boolean(value, media->priv->initiator); | |
450 break; | |
451 case PROP_PRPL_DATA: | |
452 g_value_set_pointer(value, media->priv->prpl_data); | |
453 break; | |
454 default: | |
455 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); | |
456 break; | |
457 } | |
458 | |
459 } | |
460 | |
461 static PurpleMediaSession* | |
462 purple_media_get_session(PurpleMedia *media, const gchar *sess_id) | |
463 { | |
464 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL); | |
465 return (PurpleMediaSession*) (media->priv->sessions) ? | |
466 g_hash_table_lookup(media->priv->sessions, sess_id) : NULL; | |
467 } | |
468 | |
469 static PurpleMediaStream* | |
470 purple_media_get_stream(PurpleMedia *media, const gchar *session, const gchar *participant) | |
471 { | |
472 GList *streams; | |
473 | |
474 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL); | |
475 | |
476 streams = media->priv->streams; | |
477 | |
478 for (; streams; streams = g_list_next(streams)) { | |
479 PurpleMediaStream *stream = streams->data; | |
480 if (!strcmp(stream->session->id, session) && | |
481 !strcmp(stream->participant, participant)) | |
482 return stream; | |
483 } | |
484 | |
485 return NULL; | |
486 } | |
487 | |
488 static GList * | |
489 purple_media_get_streams(PurpleMedia *media, const gchar *session, | |
490 const gchar *participant) | |
491 { | |
492 GList *streams; | |
493 GList *ret = NULL; | |
494 | |
495 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL); | |
496 | |
497 streams = media->priv->streams; | |
498 | |
499 for (; streams; streams = g_list_next(streams)) { | |
500 PurpleMediaStream *stream = streams->data; | |
501 if ((session == NULL || | |
502 !strcmp(stream->session->id, session)) && | |
503 (participant == NULL || | |
504 !strcmp(stream->participant, participant))) | |
505 ret = g_list_append(ret, stream); | |
506 } | |
507 | |
508 return ret; | |
509 } | |
510 | |
511 static void | |
512 purple_media_add_session(PurpleMedia *media, PurpleMediaSession *session) | |
513 { | |
514 g_return_if_fail(PURPLE_IS_MEDIA(media)); | |
515 g_return_if_fail(session != NULL); | |
516 | |
517 if (!media->priv->sessions) { | |
518 purple_debug_info("media", "Creating hash table for sessions\n"); | |
519 media->priv->sessions = g_hash_table_new(g_str_hash, g_str_equal); | |
520 } | |
521 g_hash_table_insert(media->priv->sessions, g_strdup(session->id), session); | |
522 } | |
523 | |
29568 | 524 #if 0 |
29534 | 525 static gboolean |
526 purple_media_remove_session(PurpleMedia *media, PurpleMediaSession *session) | |
527 { | |
528 g_return_val_if_fail(PURPLE_IS_MEDIA(media), FALSE); | |
529 return g_hash_table_remove(media->priv->sessions, session->id); | |
530 } | |
29568 | 531 #endif |
29534 | 532 |
533 static PurpleMediaStream * | |
29580 | 534 purple_media_insert_stream(PurpleMediaSession *session, |
535 const gchar *name, gboolean initiator) | |
29534 | 536 { |
537 PurpleMediaStream *media_stream; | |
538 | |
539 g_return_val_if_fail(session != NULL, NULL); | |
540 | |
541 media_stream = g_new0(PurpleMediaStream, 1); | |
542 media_stream->participant = g_strdup(name); | |
543 media_stream->session = session; | |
29580 | 544 media_stream->initiator = initiator; |
29534 | 545 |
546 session->media->priv->streams = | |
547 g_list_append(session->media->priv->streams, media_stream); | |
548 | |
549 return media_stream; | |
550 } | |
551 | |
552 static void | |
553 purple_media_insert_local_candidate(PurpleMediaSession *session, const gchar *name, | |
29559
cb843608e183
Store local_candidates in PurpleMedia as a GList of PurpleMediaCandidate's.
maiku@pidgin.im
parents:
29557
diff
changeset
|
554 PurpleMediaCandidate *candidate) |
29534 | 555 { |
556 PurpleMediaStream *stream; | |
557 | |
558 g_return_if_fail(session != NULL); | |
559 | |
560 stream = purple_media_get_stream(session->media, session->id, name); | |
561 stream->local_candidates = g_list_append(stream->local_candidates, candidate); | |
562 } | |
563 #endif | |
564 | |
565 GList * | |
566 purple_media_get_session_ids(PurpleMedia *media) | |
567 { | |
568 #ifdef USE_VV | |
569 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL); | |
570 return media->priv->sessions != NULL ? | |
571 g_hash_table_get_keys(media->priv->sessions) : NULL; | |
572 #else | |
573 return NULL; | |
574 #endif | |
575 } | |
576 | |
577 #ifdef USE_GSTREAMER | |
578 GstElement * | |
579 purple_media_get_src(PurpleMedia *media, const gchar *sess_id) | |
580 { | |
581 #ifdef USE_VV | |
582 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL); | |
29583
eadb9e309b87
Move all src and sink creation in PurpleMedia to the Fs2 media backend.
maiku@pidgin.im
parents:
29582
diff
changeset
|
583 |
eadb9e309b87
Move all src and sink creation in PurpleMedia to the Fs2 media backend.
maiku@pidgin.im
parents:
29582
diff
changeset
|
584 if (PURPLE_IS_MEDIA_BACKEND_FS2(media->priv->backend)) |
eadb9e309b87
Move all src and sink creation in PurpleMedia to the Fs2 media backend.
maiku@pidgin.im
parents:
29582
diff
changeset
|
585 return purple_media_backend_fs2_get_src( |
eadb9e309b87
Move all src and sink creation in PurpleMedia to the Fs2 media backend.
maiku@pidgin.im
parents:
29582
diff
changeset
|
586 PURPLE_MEDIA_BACKEND_FS2( |
eadb9e309b87
Move all src and sink creation in PurpleMedia to the Fs2 media backend.
maiku@pidgin.im
parents:
29582
diff
changeset
|
587 media->priv->backend), sess_id); |
eadb9e309b87
Move all src and sink creation in PurpleMedia to the Fs2 media backend.
maiku@pidgin.im
parents:
29582
diff
changeset
|
588 |
eadb9e309b87
Move all src and sink creation in PurpleMedia to the Fs2 media backend.
maiku@pidgin.im
parents:
29582
diff
changeset
|
589 g_return_val_if_reached(NULL); |
29534 | 590 #else |
591 return NULL; | |
592 #endif | |
593 } | |
594 #endif /* USE_GSTREAMER */ | |
595 | |
596 PurpleAccount * | |
597 purple_media_get_account(PurpleMedia *media) | |
598 { | |
599 #ifdef USE_VV | |
600 PurpleAccount *account; | |
601 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL); | |
602 g_object_get(G_OBJECT(media), "account", &account, NULL); | |
603 return account; | |
604 #else | |
605 return NULL; | |
606 #endif | |
607 } | |
608 | |
609 gpointer | |
610 purple_media_get_prpl_data(PurpleMedia *media) | |
611 { | |
612 #ifdef USE_VV | |
613 gpointer prpl_data; | |
614 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL); | |
615 g_object_get(G_OBJECT(media), "prpl-data", &prpl_data, NULL); | |
616 return prpl_data; | |
617 #else | |
618 return NULL; | |
619 #endif | |
620 } | |
621 | |
622 void | |
623 purple_media_set_prpl_data(PurpleMedia *media, gpointer prpl_data) | |
624 { | |
625 #ifdef USE_VV | |
626 g_return_if_fail(PURPLE_IS_MEDIA(media)); | |
627 g_object_set(G_OBJECT(media), "prpl-data", prpl_data, NULL); | |
628 #endif | |
629 } | |
630 | |
631 void | |
632 purple_media_error(PurpleMedia *media, const gchar *error, ...) | |
633 { | |
634 #ifdef USE_VV | |
635 va_list args; | |
636 gchar *message; | |
637 | |
638 g_return_if_fail(PURPLE_IS_MEDIA(media)); | |
639 | |
640 va_start(args, error); | |
641 message = g_strdup_vprintf(error, args); | |
642 va_end(args); | |
643 | |
644 purple_debug_error("media", "%s\n", message); | |
645 g_signal_emit(media, purple_media_signals[S_ERROR], 0, message); | |
646 | |
647 g_free(message); | |
648 #endif | |
649 } | |
650 | |
651 void | |
652 purple_media_end(PurpleMedia *media, | |
653 const gchar *session_id, const gchar *participant) | |
654 { | |
655 #ifdef USE_VV | |
656 g_return_if_fail(PURPLE_IS_MEDIA(media)); | |
657 if (session_id == NULL && participant == NULL) { | |
658 g_signal_emit(media, purple_media_signals[STATE_CHANGED], | |
659 0, PURPLE_MEDIA_STATE_END, | |
660 NULL, NULL); | |
661 g_object_unref(media); | |
662 } | |
663 #endif | |
664 } | |
665 | |
666 void | |
667 purple_media_stream_info(PurpleMedia *media, PurpleMediaInfoType type, | |
668 const gchar *session_id, const gchar *participant, | |
669 gboolean local) | |
670 { | |
671 #ifdef USE_VV | |
672 g_return_if_fail(PURPLE_IS_MEDIA(media)); | |
673 | |
674 if (type == PURPLE_MEDIA_INFO_ACCEPT) { | |
675 GList *streams; | |
676 | |
677 g_return_if_fail(PURPLE_IS_MEDIA(media)); | |
678 | |
679 streams = purple_media_get_streams(media, | |
680 session_id, participant); | |
681 | |
682 for (; streams; streams = | |
683 g_list_delete_link(streams, streams)) { | |
684 PurpleMediaStream *stream = streams->data; | |
29576
a27e41f373db
Handle part of accepting a stream in the Fs2 media backend.
maiku@pidgin.im
parents:
29575
diff
changeset
|
685 |
29534 | 686 stream->accepted = TRUE; |
687 } | |
688 } | |
689 | |
690 g_signal_emit(media, purple_media_signals[STREAM_INFO], | |
691 0, type, session_id, participant, local); | |
692 | |
693 if (type == PURPLE_MEDIA_INFO_HANGUP || | |
694 type == PURPLE_MEDIA_INFO_REJECT) { | |
695 purple_media_end(media, session_id, participant); | |
696 } | |
697 #endif | |
698 } | |
699 | |
700 #ifdef USE_VV | |
701 static void | |
29554
2460e6774e08
Move handling Farsight 2's new-local-candidate signal in Fs2 media backend.
maiku@pidgin.im
parents:
29553
diff
changeset
|
702 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:
29553
diff
changeset
|
703 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:
29553
diff
changeset
|
704 PurpleMediaCandidate *candidate, PurpleMedia *media) |
29534 | 705 { |
29554
2460e6774e08
Move handling Farsight 2's new-local-candidate signal in Fs2 media backend.
maiku@pidgin.im
parents:
29553
diff
changeset
|
706 PurpleMediaSession *session = |
2460e6774e08
Move handling Farsight 2's new-local-candidate signal in Fs2 media backend.
maiku@pidgin.im
parents:
29553
diff
changeset
|
707 purple_media_get_session(media, sess_id); |
29534 | 708 |
29554
2460e6774e08
Move handling Farsight 2's new-local-candidate signal in Fs2 media backend.
maiku@pidgin.im
parents:
29553
diff
changeset
|
709 purple_media_insert_local_candidate(session, participant, |
29559
cb843608e183
Store local_candidates in PurpleMedia as a GList of PurpleMediaCandidate's.
maiku@pidgin.im
parents:
29557
diff
changeset
|
710 purple_media_candidate_copy(candidate)); |
29534 | 711 |
712 g_signal_emit(session->media, purple_media_signals[NEW_CANDIDATE], | |
29554
2460e6774e08
Move handling Farsight 2's new-local-candidate signal in Fs2 media backend.
maiku@pidgin.im
parents:
29553
diff
changeset
|
713 0, session->id, participant, candidate); |
29534 | 714 } |
715 | |
716 static void | |
29557
1fdc75c94c22
Move Farsight 2's local-candidates-prepared signal to the Fs2 media backend.
maiku@pidgin.im
parents:
29556
diff
changeset
|
717 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:
29556
diff
changeset
|
718 const gchar *sess_id, const gchar *name, PurpleMedia *media) |
29534 | 719 { |
720 PurpleMediaStream *stream_data; | |
721 | |
29557
1fdc75c94c22
Move Farsight 2's local-candidates-prepared signal to the Fs2 media backend.
maiku@pidgin.im
parents:
29556
diff
changeset
|
722 g_return_if_fail(PURPLE_IS_MEDIA(media)); |
29534 | 723 |
29557
1fdc75c94c22
Move Farsight 2's local-candidates-prepared signal to the Fs2 media backend.
maiku@pidgin.im
parents:
29556
diff
changeset
|
724 stream_data = purple_media_get_stream(media, sess_id, name); |
29534 | 725 stream_data->candidates_prepared = TRUE; |
726 | |
29557
1fdc75c94c22
Move Farsight 2's local-candidates-prepared signal to the Fs2 media backend.
maiku@pidgin.im
parents:
29556
diff
changeset
|
727 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:
29556
diff
changeset
|
728 0, sess_id, name); |
29534 | 729 } |
730 | |
731 /* callback called when a pair of transport candidates (local and remote) | |
732 * has been established */ | |
733 static void | |
29556
74e75fc3481e
Move Farsight 2's new-active-candidate-pair into the Fs2 media backend.
maiku@pidgin.im
parents:
29555
diff
changeset
|
734 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:
29555
diff
changeset
|
735 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:
29555
diff
changeset
|
736 PurpleMediaCandidate *local_candidate, |
74e75fc3481e
Move Farsight 2's new-active-candidate-pair into the Fs2 media backend.
maiku@pidgin.im
parents:
29555
diff
changeset
|
737 PurpleMediaCandidate *remote_candidate, |
74e75fc3481e
Move Farsight 2's new-active-candidate-pair into the Fs2 media backend.
maiku@pidgin.im
parents:
29555
diff
changeset
|
738 PurpleMedia *media) |
29534 | 739 { |
740 PurpleMediaStream *stream; | |
741 GList *iter; | |
29556
74e75fc3481e
Move Farsight 2's new-active-candidate-pair into the Fs2 media backend.
maiku@pidgin.im
parents:
29555
diff
changeset
|
742 guint id; |
29534 | 743 |
29556
74e75fc3481e
Move Farsight 2's new-active-candidate-pair into the Fs2 media backend.
maiku@pidgin.im
parents:
29555
diff
changeset
|
744 g_return_if_fail(PURPLE_IS_MEDIA(media)); |
29534 | 745 |
29556
74e75fc3481e
Move Farsight 2's new-active-candidate-pair into the Fs2 media backend.
maiku@pidgin.im
parents:
29555
diff
changeset
|
746 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:
29555
diff
changeset
|
747 id = purple_media_candidate_get_component_id(local_candidate); |
29534 | 748 |
749 iter = stream->active_local_candidates; | |
750 for(; iter; iter = g_list_next(iter)) { | |
29561
7713312c4ab0
Store active_local_candidates in PurpleMedia as a GList of PurpleMediaCandidate's.
maiku@pidgin.im
parents:
29560
diff
changeset
|
751 PurpleMediaCandidate *c = iter->data; |
7713312c4ab0
Store active_local_candidates in PurpleMedia as a GList of PurpleMediaCandidate's.
maiku@pidgin.im
parents:
29560
diff
changeset
|
752 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:
29560
diff
changeset
|
753 g_object_unref(c); |
29534 | 754 stream->active_local_candidates = |
755 g_list_delete_link(iter, iter); | |
756 stream->active_local_candidates = g_list_prepend( | |
757 stream->active_local_candidates, | |
29561
7713312c4ab0
Store active_local_candidates in PurpleMedia as a GList of PurpleMediaCandidate's.
maiku@pidgin.im
parents:
29560
diff
changeset
|
758 purple_media_candidate_copy( |
29556
74e75fc3481e
Move Farsight 2's new-active-candidate-pair into the Fs2 media backend.
maiku@pidgin.im
parents:
29555
diff
changeset
|
759 local_candidate)); |
29534 | 760 break; |
761 } | |
762 } | |
763 if (iter == NULL) | |
764 stream->active_local_candidates = g_list_prepend( | |
765 stream->active_local_candidates, | |
29561
7713312c4ab0
Store active_local_candidates in PurpleMedia as a GList of PurpleMediaCandidate's.
maiku@pidgin.im
parents:
29560
diff
changeset
|
766 purple_media_candidate_copy( |
29556
74e75fc3481e
Move Farsight 2's new-active-candidate-pair into the Fs2 media backend.
maiku@pidgin.im
parents:
29555
diff
changeset
|
767 local_candidate)); |
74e75fc3481e
Move Farsight 2's new-active-candidate-pair into the Fs2 media backend.
maiku@pidgin.im
parents:
29555
diff
changeset
|
768 |
74e75fc3481e
Move Farsight 2's new-active-candidate-pair into the Fs2 media backend.
maiku@pidgin.im
parents:
29555
diff
changeset
|
769 id = purple_media_candidate_get_component_id(local_candidate); |
29534 | 770 |
771 iter = stream->active_remote_candidates; | |
772 for(; iter; iter = g_list_next(iter)) { | |
29562
1156bf88b4d3
Store active_remote_candidates in PurpleMedia as a GList of PurpleMediaCandidate's.
maiku@pidgin.im
parents:
29561
diff
changeset
|
773 PurpleMediaCandidate *c = iter->data; |
1156bf88b4d3
Store active_remote_candidates in PurpleMedia as a GList of PurpleMediaCandidate's.
maiku@pidgin.im
parents:
29561
diff
changeset
|
774 if (id == purple_media_candidate_get_component_id(c)) { |
1156bf88b4d3
Store active_remote_candidates in PurpleMedia as a GList of PurpleMediaCandidate's.
maiku@pidgin.im
parents:
29561
diff
changeset
|
775 g_object_unref(c); |
29534 | 776 stream->active_remote_candidates = |
777 g_list_delete_link(iter, iter); | |
778 stream->active_remote_candidates = g_list_prepend( | |
779 stream->active_remote_candidates, | |
29562
1156bf88b4d3
Store active_remote_candidates in PurpleMedia as a GList of PurpleMediaCandidate's.
maiku@pidgin.im
parents:
29561
diff
changeset
|
780 purple_media_candidate_copy( |
29556
74e75fc3481e
Move Farsight 2's new-active-candidate-pair into the Fs2 media backend.
maiku@pidgin.im
parents:
29555
diff
changeset
|
781 remote_candidate)); |
29534 | 782 break; |
783 } | |
784 } | |
785 if (iter == NULL) | |
786 stream->active_remote_candidates = g_list_prepend( | |
787 stream->active_remote_candidates, | |
29562
1156bf88b4d3
Store active_remote_candidates in PurpleMedia as a GList of PurpleMediaCandidate's.
maiku@pidgin.im
parents:
29561
diff
changeset
|
788 purple_media_candidate_copy( |
29556
74e75fc3481e
Move Farsight 2's new-active-candidate-pair into the Fs2 media backend.
maiku@pidgin.im
parents:
29555
diff
changeset
|
789 remote_candidate)); |
29534 | 790 |
791 purple_debug_info("media", "candidate pair established\n"); | |
792 } | |
793 | |
29555
cc978a1a4bd1
Move handling Farsight 2's codecs-changed signal into the Fs2 media backend.
maiku@pidgin.im
parents:
29554
diff
changeset
|
794 static void |
cc978a1a4bd1
Move handling Farsight 2's codecs-changed signal into the Fs2 media backend.
maiku@pidgin.im
parents:
29554
diff
changeset
|
795 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:
29554
diff
changeset
|
796 const gchar *sess_id, PurpleMedia *media) |
cc978a1a4bd1
Move handling Farsight 2's codecs-changed signal into the Fs2 media backend.
maiku@pidgin.im
parents:
29554
diff
changeset
|
797 { |
cc978a1a4bd1
Move handling Farsight 2's codecs-changed signal into the Fs2 media backend.
maiku@pidgin.im
parents:
29554
diff
changeset
|
798 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:
29554
diff
changeset
|
799 } |
29534 | 800 #endif /* USE_VV */ |
801 | |
802 gboolean | |
803 purple_media_add_stream(PurpleMedia *media, const gchar *sess_id, | |
804 const gchar *who, PurpleMediaSessionType type, | |
805 gboolean initiator, const gchar *transmitter, | |
806 guint num_params, GParameter *params) | |
807 { | |
808 #ifdef USE_VV | |
809 PurpleMediaSession *session; | |
810 PurpleMediaStream *stream = NULL; | |
811 | |
812 g_return_val_if_fail(PURPLE_IS_MEDIA(media), FALSE); | |
813 | |
29549
41ae97b7e97e
Start to use the media backend code in PurpleMedia and PurpleMediaManager.
maiku@pidgin.im
parents:
29545
diff
changeset
|
814 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:
29545
diff
changeset
|
815 sess_id, who, type, initiator, transmitter, |
41ae97b7e97e
Start to use the media backend code in PurpleMedia and PurpleMediaManager.
maiku@pidgin.im
parents:
29545
diff
changeset
|
816 num_params, params)) { |
41ae97b7e97e
Start to use the media backend code in PurpleMedia and PurpleMediaManager.
maiku@pidgin.im
parents:
29545
diff
changeset
|
817 purple_debug_error("media", "Error adding stream.\n"); |
41ae97b7e97e
Start to use the media backend code in PurpleMedia and PurpleMediaManager.
maiku@pidgin.im
parents:
29545
diff
changeset
|
818 return FALSE; |
41ae97b7e97e
Start to use the media backend code in PurpleMedia and PurpleMediaManager.
maiku@pidgin.im
parents:
29545
diff
changeset
|
819 } |
41ae97b7e97e
Start to use the media backend code in PurpleMedia and PurpleMediaManager.
maiku@pidgin.im
parents:
29545
diff
changeset
|
820 |
29534 | 821 session = purple_media_get_session(media, sess_id); |
822 | |
823 if (!session) { | |
824 session = g_new0(PurpleMediaSession, 1); | |
825 session->id = g_strdup(sess_id); | |
826 session->media = media; | |
827 session->type = type; | |
828 session->initiator = initiator; | |
829 | |
830 purple_media_add_session(media, session); | |
831 g_signal_emit(media, purple_media_signals[STATE_CHANGED], | |
832 0, PURPLE_MEDIA_STATE_NEW, | |
833 session->id, NULL); | |
834 } | |
835 | |
29579
f65689100cfe
Move odd direction changing functionality to the Fs2 media backend.
maiku@pidgin.im
parents:
29578
diff
changeset
|
836 if (purple_media_get_stream(media, sess_id, who) == NULL) { |
29580 | 837 stream = purple_media_insert_stream(session, who, initiator); |
29534 | 838 |
839 g_signal_emit(media, purple_media_signals[STATE_CHANGED], | |
840 0, PURPLE_MEDIA_STATE_NEW, | |
841 session->id, who); | |
842 } | |
843 | |
844 return TRUE; | |
845 #else | |
846 return FALSE; | |
847 #endif /* USE_VV */ | |
848 } | |
849 | |
850 PurpleMediaManager * | |
851 purple_media_get_manager(PurpleMedia *media) | |
852 { | |
853 PurpleMediaManager *ret; | |
854 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL); | |
855 g_object_get(media, "manager", &ret, NULL); | |
856 return ret; | |
857 } | |
858 | |
859 PurpleMediaSessionType | |
860 purple_media_get_session_type(PurpleMedia *media, const gchar *sess_id) | |
861 { | |
862 #ifdef USE_VV | |
863 PurpleMediaSession *session; | |
864 g_return_val_if_fail(PURPLE_IS_MEDIA(media), PURPLE_MEDIA_NONE); | |
865 session = purple_media_get_session(media, sess_id); | |
866 return session->type; | |
867 #else | |
868 return PURPLE_MEDIA_NONE; | |
869 #endif | |
870 } | |
871 /* XXX: Should wait until codecs-ready is TRUE before using this function */ | |
872 GList * | |
873 purple_media_get_codecs(PurpleMedia *media, const gchar *sess_id) | |
874 { | |
875 #ifdef USE_VV | |
876 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL); | |
877 | |
29569
9c1810122f21
Transfer get_codecs functionality to the Fs2 media backend.
maiku@pidgin.im
parents:
29568
diff
changeset
|
878 return purple_media_backend_get_codecs(media->priv->backend, sess_id); |
29534 | 879 #else |
880 return NULL; | |
881 #endif | |
882 } | |
883 | |
884 GList * | |
885 purple_media_get_local_candidates(PurpleMedia *media, const gchar *sess_id, | |
886 const gchar *participant) | |
887 { | |
888 #ifdef USE_VV | |
889 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL); | |
29571
f0966e90ec44
Move get_local_candidates functionality over to the Fs2 media backend.
maiku@pidgin.im
parents:
29569
diff
changeset
|
890 |
f0966e90ec44
Move get_local_candidates functionality over to the Fs2 media backend.
maiku@pidgin.im
parents:
29569
diff
changeset
|
891 return purple_media_backend_get_local_candidates(media->priv->backend, |
f0966e90ec44
Move get_local_candidates functionality over to the Fs2 media backend.
maiku@pidgin.im
parents:
29569
diff
changeset
|
892 sess_id, participant); |
29534 | 893 #else |
894 return NULL; | |
895 #endif | |
896 } | |
897 | |
898 void | |
899 purple_media_add_remote_candidates(PurpleMedia *media, const gchar *sess_id, | |
900 const gchar *participant, | |
901 GList *remote_candidates) | |
902 { | |
903 #ifdef USE_VV | |
904 PurpleMediaStream *stream; | |
905 | |
906 g_return_if_fail(PURPLE_IS_MEDIA(media)); | |
907 stream = purple_media_get_stream(media, sess_id, participant); | |
908 | |
909 if (stream == NULL) { | |
910 purple_debug_error("media", | |
911 "purple_media_add_remote_candidates: " | |
912 "couldn't find stream %s %s.\n", | |
913 sess_id ? sess_id : "(null)", | |
914 participant ? participant : "(null)"); | |
915 return; | |
916 } | |
917 | |
918 stream->remote_candidates = g_list_concat(stream->remote_candidates, | |
29560
18571ea6e44a
Store remote_candidates in PurpleMedia as a GList of PurpleMediaCandidate's.
maiku@pidgin.im
parents:
29559
diff
changeset
|
919 purple_media_candidate_list_copy(remote_candidates)); |
29534 | 920 |
29576
a27e41f373db
Handle part of accepting a stream in the Fs2 media backend.
maiku@pidgin.im
parents:
29575
diff
changeset
|
921 purple_media_backend_add_remote_candidates(media->priv->backend, |
a27e41f373db
Handle part of accepting a stream in the Fs2 media backend.
maiku@pidgin.im
parents:
29575
diff
changeset
|
922 sess_id, participant, remote_candidates); |
29534 | 923 #endif |
924 } | |
925 | |
926 #if 0 | |
927 /* | |
928 * These two functions aren't being used and I'd rather not lock in the API | |
929 * until they are needed. If they ever are. | |
930 */ | |
931 | |
932 GList * | |
933 purple_media_get_active_local_candidates(PurpleMedia *media, | |
934 const gchar *sess_id, const gchar *participant) | |
935 { | |
936 #ifdef USE_VV | |
937 PurpleMediaStream *stream; | |
938 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL); | |
939 stream = purple_media_get_stream(media, sess_id, participant); | |
29561
7713312c4ab0
Store active_local_candidates in PurpleMedia as a GList of PurpleMediaCandidate's.
maiku@pidgin.im
parents:
29560
diff
changeset
|
940 return purple_media_candidate_list_copy( |
29534 | 941 stream->active_local_candidates); |
942 #else | |
943 return NULL; | |
944 #endif | |
945 } | |
946 | |
947 GList * | |
948 purple_media_get_active_remote_candidates(PurpleMedia *media, | |
949 const gchar *sess_id, const gchar *participant) | |
950 { | |
951 #ifdef USE_VV | |
952 PurpleMediaStream *stream; | |
953 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL); | |
954 stream = purple_media_get_stream(media, sess_id, participant); | |
29562
1156bf88b4d3
Store active_remote_candidates in PurpleMedia as a GList of PurpleMediaCandidate's.
maiku@pidgin.im
parents:
29561
diff
changeset
|
955 return purple_media_candidate_list_copy( |
29534 | 956 stream->active_remote_candidates); |
957 #else | |
958 return NULL; | |
959 #endif | |
960 } | |
961 #endif | |
962 | |
963 gboolean | |
964 purple_media_set_remote_codecs(PurpleMedia *media, const gchar *sess_id, | |
965 const gchar *participant, GList *codecs) | |
966 { | |
967 #ifdef USE_VV | |
968 g_return_val_if_fail(PURPLE_IS_MEDIA(media), FALSE); | |
969 | |
29573
a39696686dd6
Move set_remote_codecs functionality to the Fs2 media backend.
maiku@pidgin.im
parents:
29571
diff
changeset
|
970 return purple_media_backend_set_remote_codecs(media->priv->backend, |
a39696686dd6
Move set_remote_codecs functionality to the Fs2 media backend.
maiku@pidgin.im
parents:
29571
diff
changeset
|
971 sess_id, participant, codecs); |
29534 | 972 #else |
973 return FALSE; | |
974 #endif | |
975 } | |
976 | |
977 gboolean | |
978 purple_media_candidates_prepared(PurpleMedia *media, | |
979 const gchar *session_id, const gchar *participant) | |
980 { | |
981 #ifdef USE_VV | |
982 GList *streams; | |
983 gboolean prepared = TRUE; | |
984 | |
985 g_return_val_if_fail(PURPLE_IS_MEDIA(media), FALSE); | |
986 | |
987 streams = purple_media_get_streams(media, session_id, participant); | |
988 | |
989 for (; streams; streams = g_list_delete_link(streams, streams)) { | |
990 PurpleMediaStream *stream = streams->data; | |
991 if (stream->candidates_prepared == FALSE) { | |
992 g_list_free(streams); | |
993 prepared = FALSE; | |
994 break; | |
995 } | |
996 } | |
997 | |
998 return prepared; | |
999 #else | |
1000 return FALSE; | |
1001 #endif | |
1002 } | |
1003 | |
1004 gboolean | |
1005 purple_media_set_send_codec(PurpleMedia *media, const gchar *sess_id, PurpleMediaCodec *codec) | |
1006 { | |
1007 #ifdef USE_VV | |
1008 g_return_val_if_fail(PURPLE_IS_MEDIA(media), FALSE); | |
1009 | |
29575
ec5ed142f551
Move set_remote_codec functionality to the Fs2 media backend.
maiku@pidgin.im
parents:
29573
diff
changeset
|
1010 return purple_media_backend_set_send_codec( |
ec5ed142f551
Move set_remote_codec functionality to the Fs2 media backend.
maiku@pidgin.im
parents:
29573
diff
changeset
|
1011 media->priv->backend, sess_id, codec); |
29534 | 1012 #else |
1013 return FALSE; | |
1014 #endif | |
1015 } | |
1016 | |
1017 gboolean | |
1018 purple_media_codecs_ready(PurpleMedia *media, const gchar *sess_id) | |
1019 { | |
1020 #ifdef USE_VV | |
1021 g_return_val_if_fail(PURPLE_IS_MEDIA(media), FALSE); | |
1022 | |
29581
f351e87b7af0
Add codecs_ready to the media backend interface.
maiku@pidgin.im
parents:
29580
diff
changeset
|
1023 return purple_media_backend_codecs_ready( |
f351e87b7af0
Add codecs_ready to the media backend interface.
maiku@pidgin.im
parents:
29580
diff
changeset
|
1024 media->priv->backend, sess_id); |
29534 | 1025 #else |
1026 return FALSE; | |
1027 #endif | |
1028 } | |
1029 | |
1030 gboolean | |
1031 purple_media_is_initiator(PurpleMedia *media, | |
1032 const gchar *sess_id, const gchar *participant) | |
1033 { | |
1034 #ifdef USE_VV | |
1035 g_return_val_if_fail(PURPLE_IS_MEDIA(media), FALSE); | |
1036 | |
1037 if (sess_id == NULL && participant == NULL) | |
1038 return media->priv->initiator; | |
1039 else if (sess_id != NULL && participant == NULL) { | |
1040 PurpleMediaSession *session = | |
1041 purple_media_get_session(media, sess_id); | |
1042 return session != NULL ? session->initiator : FALSE; | |
1043 } else if (sess_id != NULL && participant != NULL) { | |
1044 PurpleMediaStream *stream = purple_media_get_stream( | |
1045 media, sess_id, participant); | |
1046 return stream != NULL ? stream->initiator : FALSE; | |
1047 } | |
1048 #endif | |
1049 return FALSE; | |
1050 } | |
1051 | |
1052 gboolean | |
1053 purple_media_accepted(PurpleMedia *media, const gchar *sess_id, | |
1054 const gchar *participant) | |
1055 { | |
1056 #ifdef USE_VV | |
1057 gboolean accepted = TRUE; | |
1058 | |
1059 g_return_val_if_fail(PURPLE_IS_MEDIA(media), FALSE); | |
1060 | |
1061 if (sess_id == NULL && participant == NULL) { | |
1062 GList *streams = media->priv->streams; | |
1063 | |
1064 for (; streams; streams = g_list_next(streams)) { | |
1065 PurpleMediaStream *stream = streams->data; | |
1066 if (stream->accepted == FALSE) { | |
1067 accepted = FALSE; | |
1068 break; | |
1069 } | |
1070 } | |
1071 } else if (sess_id != NULL && participant == NULL) { | |
1072 GList *streams = purple_media_get_streams( | |
1073 media, sess_id, NULL); | |
1074 for (; streams; streams = | |
1075 g_list_delete_link(streams, streams)) { | |
1076 PurpleMediaStream *stream = streams->data; | |
1077 if (stream->accepted == FALSE) { | |
1078 g_list_free(streams); | |
1079 accepted = FALSE; | |
1080 break; | |
1081 } | |
1082 } | |
1083 } else if (sess_id != NULL && participant != NULL) { | |
1084 PurpleMediaStream *stream = purple_media_get_stream( | |
1085 media, sess_id, participant); | |
1086 if (stream == NULL || stream->accepted == FALSE) | |
1087 accepted = FALSE; | |
1088 } | |
1089 | |
1090 return accepted; | |
1091 #else | |
1092 return FALSE; | |
1093 #endif | |
1094 } | |
1095 | |
1096 void purple_media_set_input_volume(PurpleMedia *media, | |
1097 const gchar *session_id, double level) | |
1098 { | |
1099 #ifdef USE_VV | |
1100 g_return_if_fail(PURPLE_IS_MEDIA(media)); | |
29585
95f918df7f09
Move volume setting functionality to the Fs2 media backend.
maiku@pidgin.im
parents:
29584
diff
changeset
|
1101 g_return_if_fail(PURPLE_IS_MEDIA_BACKEND_FS2(media->priv->backend)); |
29534 | 1102 |
29585
95f918df7f09
Move volume setting functionality to the Fs2 media backend.
maiku@pidgin.im
parents:
29584
diff
changeset
|
1103 purple_media_backend_fs2_set_input_volume( |
95f918df7f09
Move volume setting functionality to the Fs2 media backend.
maiku@pidgin.im
parents:
29584
diff
changeset
|
1104 PURPLE_MEDIA_BACKEND_FS2( |
95f918df7f09
Move volume setting functionality to the Fs2 media backend.
maiku@pidgin.im
parents:
29584
diff
changeset
|
1105 media->priv->backend), |
95f918df7f09
Move volume setting functionality to the Fs2 media backend.
maiku@pidgin.im
parents:
29584
diff
changeset
|
1106 session_id, level); |
29534 | 1107 #endif |
1108 } | |
1109 | |
1110 void purple_media_set_output_volume(PurpleMedia *media, | |
1111 const gchar *session_id, const gchar *participant, | |
1112 double level) | |
1113 { | |
1114 #ifdef USE_VV | |
1115 g_return_if_fail(PURPLE_IS_MEDIA(media)); | |
29585
95f918df7f09
Move volume setting functionality to the Fs2 media backend.
maiku@pidgin.im
parents:
29584
diff
changeset
|
1116 g_return_if_fail(PURPLE_IS_MEDIA_BACKEND_FS2(media->priv->backend)); |
29534 | 1117 |
29585
95f918df7f09
Move volume setting functionality to the Fs2 media backend.
maiku@pidgin.im
parents:
29584
diff
changeset
|
1118 purple_media_backend_fs2_set_output_volume( |
95f918df7f09
Move volume setting functionality to the Fs2 media backend.
maiku@pidgin.im
parents:
29584
diff
changeset
|
1119 PURPLE_MEDIA_BACKEND_FS2( |
95f918df7f09
Move volume setting functionality to the Fs2 media backend.
maiku@pidgin.im
parents:
29584
diff
changeset
|
1120 media->priv->backend), |
95f918df7f09
Move volume setting functionality to the Fs2 media backend.
maiku@pidgin.im
parents:
29584
diff
changeset
|
1121 session_id, participant, level); |
29534 | 1122 #endif |
1123 } | |
1124 | |
1125 gulong | |
1126 purple_media_set_output_window(PurpleMedia *media, const gchar *session_id, | |
1127 const gchar *participant, gulong window_id) | |
1128 { | |
1129 #ifdef USE_VV | |
1130 g_return_val_if_fail(PURPLE_IS_MEDIA(media), FALSE); | |
1131 | |
1132 return purple_media_manager_set_output_window(media->priv->manager, | |
1133 media, session_id, participant, window_id); | |
1134 #else | |
1135 return 0; | |
1136 #endif | |
1137 } | |
1138 | |
1139 void | |
1140 purple_media_remove_output_windows(PurpleMedia *media) | |
1141 { | |
1142 #ifdef USE_VV | |
1143 GList *iter = media->priv->streams; | |
1144 for (; iter; iter = g_list_next(iter)) { | |
1145 PurpleMediaStream *stream = iter->data; | |
1146 purple_media_manager_remove_output_windows( | |
1147 media->priv->manager, media, | |
1148 stream->session->id, stream->participant); | |
1149 } | |
1150 | |
1151 iter = purple_media_get_session_ids(media); | |
1152 for (; iter; iter = g_list_delete_link(iter, iter)) { | |
1153 gchar *session_name = iter->data; | |
1154 purple_media_manager_remove_output_windows( | |
1155 media->priv->manager, media, | |
1156 session_name, NULL); | |
1157 } | |
1158 #endif | |
1159 } | |
1160 | |
1161 #ifdef USE_GSTREAMER | |
1162 GstElement * | |
1163 purple_media_get_tee(PurpleMedia *media, | |
1164 const gchar *session_id, const gchar *participant) | |
1165 { | |
1166 #ifdef USE_VV | |
1167 g_return_val_if_fail(PURPLE_IS_MEDIA(media), NULL); | |
1168 | |
29583
eadb9e309b87
Move all src and sink creation in PurpleMedia to the Fs2 media backend.
maiku@pidgin.im
parents:
29582
diff
changeset
|
1169 if (PURPLE_IS_MEDIA_BACKEND_FS2(media->priv->backend)) |
eadb9e309b87
Move all src and sink creation in PurpleMedia to the Fs2 media backend.
maiku@pidgin.im
parents:
29582
diff
changeset
|
1170 return purple_media_backend_fs2_get_tee( |
eadb9e309b87
Move all src and sink creation in PurpleMedia to the Fs2 media backend.
maiku@pidgin.im
parents:
29582
diff
changeset
|
1171 PURPLE_MEDIA_BACKEND_FS2( |
eadb9e309b87
Move all src and sink creation in PurpleMedia to the Fs2 media backend.
maiku@pidgin.im
parents:
29582
diff
changeset
|
1172 media->priv->backend), |
29534 | 1173 session_id, participant); |
1174 g_return_val_if_reached(NULL); | |
1175 #else | |
1176 return NULL; | |
1177 #endif | |
1178 } | |
1179 #endif /* USE_GSTREAMER */ | |
1180 |