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