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