Mercurial > pidgin3 / file comparison

comparison: libpurple/media/backend-fs2.c

libpurple/media/backend-fs2.c

changeset 40890
631788774f96
parent 40783
4f197d3e42d6
child 41083
590d533cf290
equal deleted inserted replaced
40889:00c77e22fb64 40890:631788774f96
171 }; 171 };
172 172
173 G_DEFINE_TYPE_WITH_CODE(PurpleMediaBackendFs2, purple_media_backend_fs2, 173 G_DEFINE_TYPE_WITH_CODE(PurpleMediaBackendFs2, purple_media_backend_fs2,
174 G_TYPE_OBJECT, 174 G_TYPE_OBJECT,
175 G_ADD_PRIVATE(PurpleMediaBackendFs2) 175 G_ADD_PRIVATE(PurpleMediaBackendFs2)
176 G_IMPLEMENT_INTERFACE(PURPLE_TYPE_MEDIA_BACKEND, 176 G_IMPLEMENT_INTERFACE(PURPLE_MEDIA_TYPE_BACKEND,
177 purple_media_backend_iface_init)); 177 purple_media_backend_iface_init));
178 178
179 static void 179 static void
180 purple_media_backend_fs2_init(PurpleMediaBackendFs2 *self) 180 purple_media_backend_fs2_init(PurpleMediaBackendFs2 *self)
181 { 181 {
414 static void 414 static void
415 purple_media_backend_fs2_set_property(GObject *object, guint prop_id, 415 purple_media_backend_fs2_set_property(GObject *object, guint prop_id,
416 const GValue *value, GParamSpec *pspec) 416 const GValue *value, GParamSpec *pspec)
417 { 417 {
418 PurpleMediaBackendFs2Private *priv; 418 PurpleMediaBackendFs2Private *priv;
419 g_return_if_fail(PURPLE_IS_MEDIA_BACKEND_FS2(object)); 419 g_return_if_fail(PURPLE_MEDIA_IS_BACKEND_FS2(object));
420 420
421 priv = purple_media_backend_fs2_get_instance_private( 421 priv = purple_media_backend_fs2_get_instance_private(
422 PURPLE_MEDIA_BACKEND_FS2(object)); 422 PURPLE_MEDIA_BACKEND_FS2(object));
423 423
424 switch (prop_id) { 424 switch (prop_id) {
452 static void 452 static void
453 purple_media_backend_fs2_get_property(GObject *object, guint prop_id, 453 purple_media_backend_fs2_get_property(GObject *object, guint prop_id,
454 GValue *value, GParamSpec *pspec) 454 GValue *value, GParamSpec *pspec)
455 { 455 {
456 PurpleMediaBackendFs2Private *priv; 456 PurpleMediaBackendFs2Private *priv;
457 g_return_if_fail(PURPLE_IS_MEDIA_BACKEND_FS2(object)); 457 g_return_if_fail(PURPLE_MEDIA_IS_BACKEND_FS2(object));
458 458
459 priv = purple_media_backend_fs2_get_instance_private( 459 priv = purple_media_backend_fs2_get_instance_private(
460 PURPLE_MEDIA_BACKEND_FS2(object)); 460 PURPLE_MEDIA_BACKEND_FS2(object));
461 461
462 switch (prop_id) { 462 switch (prop_id) {
722 get_session(PurpleMediaBackendFs2 *self, const gchar *sess_id) 722 get_session(PurpleMediaBackendFs2 *self, const gchar *sess_id)
723 { 723 {
724 PurpleMediaBackendFs2Private *priv; 724 PurpleMediaBackendFs2Private *priv;
725 PurpleMediaBackendFs2Session *session = NULL; 725 PurpleMediaBackendFs2Session *session = NULL;
726 726
727 g_return_val_if_fail(PURPLE_IS_MEDIA_BACKEND_FS2(self), NULL); 727 g_return_val_if_fail(PURPLE_MEDIA_IS_BACKEND_FS2(self), NULL);
728 728
729 priv = purple_media_backend_fs2_get_instance_private(self); 729 priv = purple_media_backend_fs2_get_instance_private(self);
730 730
731 if (priv->sessions != NULL) 731 if (priv->sessions != NULL)
732 session = g_hash_table_lookup(priv->sessions, sess_id); 732 session = g_hash_table_lookup(priv->sessions, sess_id);
738 get_participant(PurpleMediaBackendFs2 *self, const gchar *name) 738 get_participant(PurpleMediaBackendFs2 *self, const gchar *name)
739 { 739 {
740 PurpleMediaBackendFs2Private *priv; 740 PurpleMediaBackendFs2Private *priv;
741 FsParticipant *participant = NULL; 741 FsParticipant *participant = NULL;
742 742
743 g_return_val_if_fail(PURPLE_IS_MEDIA_BACKEND_FS2(self), NULL); 743 g_return_val_if_fail(PURPLE_MEDIA_IS_BACKEND_FS2(self), NULL);
744 744
745 priv = purple_media_backend_fs2_get_instance_private(self); 745 priv = purple_media_backend_fs2_get_instance_private(self);
746 746
747 if (priv->participants != NULL) 747 if (priv->participants != NULL)
748 participant = g_hash_table_lookup(priv->participants, name); 748 participant = g_hash_table_lookup(priv->participants, name);
755 const gchar *sess_id, const gchar *name) 755 const gchar *sess_id, const gchar *name)
756 { 756 {
757 PurpleMediaBackendFs2Private *priv; 757 PurpleMediaBackendFs2Private *priv;
758 GList *streams; 758 GList *streams;
759 759
760 g_return_val_if_fail(PURPLE_IS_MEDIA_BACKEND_FS2(self), NULL); 760 g_return_val_if_fail(PURPLE_MEDIA_IS_BACKEND_FS2(self), NULL);
761 761
762 priv = purple_media_backend_fs2_get_instance_private(self); 762 priv = purple_media_backend_fs2_get_instance_private(self);
763 streams = priv->streams; 763 streams = priv->streams;
764 764
765 for (; streams; streams = g_list_next(streams)) { 765 for (; streams; streams = g_list_next(streams)) {
777 const gchar *sess_id, const gchar *name) 777 const gchar *sess_id, const gchar *name)
778 { 778 {
779 PurpleMediaBackendFs2Private *priv; 779 PurpleMediaBackendFs2Private *priv;
780 GList *streams, *ret = NULL; 780 GList *streams, *ret = NULL;
781 781
782 g_return_val_if_fail(PURPLE_IS_MEDIA_BACKEND_FS2(self), NULL); 782 g_return_val_if_fail(PURPLE_MEDIA_IS_BACKEND_FS2(self), NULL);
783 783
784 priv = purple_media_backend_fs2_get_instance_private(self); 784 priv = purple_media_backend_fs2_get_instance_private(self);
785 streams = priv->streams; 785 streams = priv->streams;
786 786
787 for (; streams; streams = g_list_next(streams)) { 787 for (; streams; streams = g_list_next(streams)) {
805 PurpleMediaBackendFs2Private *priv = 805 PurpleMediaBackendFs2Private *priv =
806 purple_media_backend_fs2_get_instance_private(self); 806 purple_media_backend_fs2_get_instance_private(self);
807 FsSession *fssession; 807 FsSession *fssession;
808 GList *values; 808 GList *values;
809 809
810 g_return_val_if_fail(PURPLE_IS_MEDIA_BACKEND_FS2(self), NULL); 810 g_return_val_if_fail(PURPLE_MEDIA_IS_BACKEND_FS2(self), NULL);
811 g_return_val_if_fail(FS_IS_STREAM(stream), NULL); 811 g_return_val_if_fail(FS_IS_STREAM(stream), NULL);
812 812
813 g_object_get(stream, "session", &fssession, NULL); 813 g_object_get(stream, "session", &fssession, NULL);
814 814
815 values = g_hash_table_get_values(priv->sessions); 815 values = g_hash_table_get_values(priv->sessions);
917 g_signal_emit(priv->media, level_id, 0, 917 g_signal_emit(priv->media, level_id, 0,
918 session->id, participant, percent); 918 session->id, participant, percent);
919 return; 919 return;
920 } 920 }
921 921
922 if (!FS_IS_CONFERENCE(src) || !PURPLE_IS_MEDIA_BACKEND(self) || 922 if (!FS_IS_CONFERENCE(src) || !PURPLE_MEDIA_IS_BACKEND(self) ||
923 priv->conference != FS_CONFERENCE(src)) 923 priv->conference != FS_CONFERENCE(src))
924 return; 924 return;
925 925
926 if (gst_structure_has_name(structure, "farstream-error")) { 926 if (gst_structure_has_name(structure, "farstream-error")) {
927 FsError error_no; 927 FsError error_no;
2092 { 2092 {
2093 PurpleMediaBackendFs2Private *priv; 2093 PurpleMediaBackendFs2Private *priv;
2094 PurpleMediaBackendFs2Stream *stream; 2094 PurpleMediaBackendFs2Stream *stream;
2095 GError *err = NULL; 2095 GError *err = NULL;
2096 2096
2097 g_return_if_fail(PURPLE_IS_MEDIA_BACKEND_FS2(self)); 2097 g_return_if_fail(PURPLE_MEDIA_IS_BACKEND_FS2(self));
2098 2098
2099 priv = purple_media_backend_fs2_get_instance_private( 2099 priv = purple_media_backend_fs2_get_instance_private(
2100 PURPLE_MEDIA_BACKEND_FS2(self)); 2100 PURPLE_MEDIA_BACKEND_FS2(self));
2101 stream = get_stream(PURPLE_MEDIA_BACKEND_FS2(self), 2101 stream = get_stream(PURPLE_MEDIA_BACKEND_FS2(self),
2102 sess_id, participant); 2102 sess_id, participant);
2137 const gchar *sess_id) 2137 const gchar *sess_id)
2138 { 2138 {
2139 PurpleMediaBackendFs2Private *priv; 2139 PurpleMediaBackendFs2Private *priv;
2140 gboolean ret = FALSE; 2140 gboolean ret = FALSE;
2141 2141
2142 g_return_val_if_fail(PURPLE_IS_MEDIA_BACKEND_FS2(self), FALSE); 2142 g_return_val_if_fail(PURPLE_MEDIA_IS_BACKEND_FS2(self), FALSE);
2143 2143
2144 priv = purple_media_backend_fs2_get_instance_private( 2144 priv = purple_media_backend_fs2_get_instance_private(
2145 PURPLE_MEDIA_BACKEND_FS2(self)); 2145 PURPLE_MEDIA_BACKEND_FS2(self));
2146 2146
2147 if (sess_id != NULL) { 2147 if (sess_id != NULL) {
2207 { 2207 {
2208 PurpleMediaBackendFs2Session *session; 2208 PurpleMediaBackendFs2Session *session;
2209 GList *fscodecs; 2209 GList *fscodecs;
2210 GList *codecs; 2210 GList *codecs;
2211 2211
2212 g_return_val_if_fail(PURPLE_IS_MEDIA_BACKEND_FS2(self), NULL); 2212 g_return_val_if_fail(PURPLE_MEDIA_IS_BACKEND_FS2(self), NULL);
2213 2213
2214 session = get_session(PURPLE_MEDIA_BACKEND_FS2(self), sess_id); 2214 session = get_session(PURPLE_MEDIA_BACKEND_FS2(self), sess_id);
2215 2215
2216 if (session == NULL) 2216 if (session == NULL)
2217 return NULL; 2217 return NULL;
2229 const gchar *sess_id, const gchar *participant) 2229 const gchar *sess_id, const gchar *participant)
2230 { 2230 {
2231 PurpleMediaBackendFs2Stream *stream; 2231 PurpleMediaBackendFs2Stream *stream;
2232 GList *candidates = NULL; 2232 GList *candidates = NULL;
2233 2233
2234 g_return_val_if_fail(PURPLE_IS_MEDIA_BACKEND_FS2(self), NULL); 2234 g_return_val_if_fail(PURPLE_MEDIA_IS_BACKEND_FS2(self), NULL);
2235 2235
2236 stream = get_stream(PURPLE_MEDIA_BACKEND_FS2(self), 2236 stream = get_stream(PURPLE_MEDIA_BACKEND_FS2(self),
2237 sess_id, participant); 2237 sess_id, participant);
2238 2238
2239 if (stream != NULL) { 2239 if (stream != NULL) {
2250 { 2250 {
2251 PurpleMediaBackendFs2Stream *stream; 2251 PurpleMediaBackendFs2Stream *stream;
2252 GList *fscodecs; 2252 GList *fscodecs;
2253 GError *err = NULL; 2253 GError *err = NULL;
2254 2254
2255 g_return_val_if_fail(PURPLE_IS_MEDIA_BACKEND_FS2(self), FALSE); 2255 g_return_val_if_fail(PURPLE_MEDIA_IS_BACKEND_FS2(self), FALSE);
2256 stream = get_stream(PURPLE_MEDIA_BACKEND_FS2(self), 2256 stream = get_stream(PURPLE_MEDIA_BACKEND_FS2(self),
2257 sess_id, participant); 2257 sess_id, participant);
2258 2258
2259 if (stream == NULL) 2259 if (stream == NULL)
2260 return FALSE; 2260 return FALSE;
2305 PurpleMediaBackendFs2Session *session; 2305 PurpleMediaBackendFs2Session *session;
2306 GstStructure *srtp; 2306 GstStructure *srtp;
2307 GError *err = NULL; 2307 GError *err = NULL;
2308 gboolean result; 2308 gboolean result;
2309 2309
2310 g_return_val_if_fail(PURPLE_IS_MEDIA_BACKEND_FS2(self), FALSE); 2310 g_return_val_if_fail(PURPLE_MEDIA_IS_BACKEND_FS2(self), FALSE);
2311 2311
2312 session = get_session(PURPLE_MEDIA_BACKEND_FS2(self), sess_id); 2312 session = get_session(PURPLE_MEDIA_BACKEND_FS2(self), sess_id);
2313 if (!session) 2313 if (!session)
2314 return FALSE; 2314 return FALSE;
2315 2315
2338 PurpleMediaBackendFs2Stream *stream; 2338 PurpleMediaBackendFs2Stream *stream;
2339 GstStructure *srtp; 2339 GstStructure *srtp;
2340 GError *err = NULL; 2340 GError *err = NULL;
2341 gboolean result; 2341 gboolean result;
2342 2342
2343 g_return_val_if_fail(PURPLE_IS_MEDIA_BACKEND_FS2(self), FALSE); 2343 g_return_val_if_fail(PURPLE_MEDIA_IS_BACKEND_FS2(self), FALSE);
2344 2344
2345 stream = get_stream(PURPLE_MEDIA_BACKEND_FS2(self), sess_id, 2345 stream = get_stream(PURPLE_MEDIA_BACKEND_FS2(self), sess_id,
2346 participant); 2346 participant);
2347 if (!stream) 2347 if (!stream)
2348 return FALSE; 2348 return FALSE;
2387 { 2387 {
2388 PurpleMediaBackendFs2Session *session; 2388 PurpleMediaBackendFs2Session *session;
2389 FsCodec *fscodec; 2389 FsCodec *fscodec;
2390 GError *err = NULL; 2390 GError *err = NULL;
2391 2391
2392 g_return_val_if_fail(PURPLE_IS_MEDIA_BACKEND_FS2(self), FALSE); 2392 g_return_val_if_fail(PURPLE_MEDIA_IS_BACKEND_FS2(self), FALSE);
2393 2393
2394 session = get_session(PURPLE_MEDIA_BACKEND_FS2(self), sess_id); 2394 session = get_session(PURPLE_MEDIA_BACKEND_FS2(self), sess_id);
2395 2395
2396 if (session == NULL) 2396 if (session == NULL)
2397 return FALSE; 2397 return FALSE;
2444 { 2444 {
2445 PurpleMediaBackendFs2Private *priv; 2445 PurpleMediaBackendFs2Private *priv;
2446 guint i; 2446 guint i;
2447 GstStructure *sdes; 2447 GstStructure *sdes;
2448 2448
2449 g_return_if_fail(PURPLE_IS_MEDIA_BACKEND_FS2(self)); 2449 g_return_if_fail(PURPLE_MEDIA_IS_BACKEND_FS2(self));
2450 2450
2451 priv = purple_media_backend_fs2_get_instance_private( 2451 priv = purple_media_backend_fs2_get_instance_private(
2452 PURPLE_MEDIA_BACKEND_FS2(self)); 2452 PURPLE_MEDIA_BACKEND_FS2(self));
2453 2453
2454 if (priv->conference == NULL && 2454 if (priv->conference == NULL &&
2488 guint16 duration) 2488 guint16 duration)
2489 { 2489 {
2490 PurpleMediaBackendFs2Session *session; 2490 PurpleMediaBackendFs2Session *session;
2491 FsDTMFEvent event; 2491 FsDTMFEvent event;
2492 2492
2493 g_return_val_if_fail(PURPLE_IS_MEDIA_BACKEND_FS2(self), FALSE); 2493 g_return_val_if_fail(PURPLE_MEDIA_IS_BACKEND_FS2(self), FALSE);
2494 2494
2495 session = get_session(PURPLE_MEDIA_BACKEND_FS2(self), sess_id); 2495 session = get_session(PURPLE_MEDIA_BACKEND_FS2(self), sess_id);
2496 if (session == NULL) 2496 if (session == NULL)
2497 return FALSE; 2497 return FALSE;
2498 2498
2577 { 2577 {
2578 #ifdef USE_VV 2578 #ifdef USE_VV
2579 PurpleMediaBackendFs2Private *priv; 2579 PurpleMediaBackendFs2Private *priv;
2580 GList *sessions; 2580 GList *sessions;
2581 2581
2582 g_return_if_fail(PURPLE_IS_MEDIA_BACKEND_FS2(self)); 2582 g_return_if_fail(PURPLE_MEDIA_IS_BACKEND_FS2(self));
2583 2583
2584 priv = purple_media_backend_fs2_get_instance_private(self); 2584 priv = purple_media_backend_fs2_get_instance_private(self);
2585 2585
2586 purple_prefs_set_int("/purple/media/audio/volume/input", level); 2586 purple_prefs_set_int("/purple/media/audio/volume/input", level);
2587 2587
2610 const gchar *sess_id, const gchar *who, double level) 2610 const gchar *sess_id, const gchar *who, double level)
2611 { 2611 {
2612 #ifdef USE_VV 2612 #ifdef USE_VV
2613 GList *streams; 2613 GList *streams;
2614 2614
2615 g_return_if_fail(PURPLE_IS_MEDIA_BACKEND_FS2(self)); 2615 g_return_if_fail(PURPLE_MEDIA_IS_BACKEND_FS2(self));
2616 2616
2617 purple_prefs_set_int("/purple/media/audio/volume/output", level); 2617 purple_prefs_set_int("/purple/media/audio/volume/output", level);
2618 2618
2619 streams = get_streams(self, sess_id, who); 2619 streams = get_streams(self, sess_id, who);
2620 2620
2636 const gchar *sess_id, const gchar *participant, 2636 const gchar *sess_id, const gchar *participant,
2637 gboolean send_rtcp_mux) 2637 gboolean send_rtcp_mux)
2638 { 2638 {
2639 PurpleMediaBackendFs2Stream *stream; 2639 PurpleMediaBackendFs2Stream *stream;
2640 2640
2641 g_return_val_if_fail(PURPLE_IS_MEDIA_BACKEND_FS2(self), FALSE); 2641 g_return_val_if_fail(PURPLE_MEDIA_IS_BACKEND_FS2(self), FALSE);
2642 stream = get_stream(PURPLE_MEDIA_BACKEND_FS2(self), 2642 stream = get_stream(PURPLE_MEDIA_BACKEND_FS2(self),
2643 sess_id, participant); 2643 sess_id, participant);
2644 2644
2645 if (stream != NULL && 2645 if (stream != NULL &&
2646 g_object_class_find_property (G_OBJECT_GET_CLASS (stream->stream), 2646 g_object_class_find_property (G_OBJECT_GET_CLASS (stream->stream),

Mercurial Repository: pidgin3

mercurial