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