← Back to branch summary

~ubuntu-branches/ubuntu/quantal/pidgin/quantal

« back to all changes in this revision

Viewing changes to libpurple/media/backend-fs2.c

  • Committer: Package Import Robot
  • Author(s): Ken VanDine
  • Date: 2012-04-04 17:02:58 UTC
  • Revision ID: package-import@ubuntu.com-20120404170258-m6yhyj8syg6m6fbc
Tags: 1:2.10.2-1ubuntu2
* debian/patches/70_farstream_rename.patch
  - updated patch from the upstream bug report
    http://developer.pidgin.im/ticket/14936

Show diffs side-by-side

added added

removed removed

Lines of Context:
libpurple/media/backend-fs2.c
1
1
/**
2
 
 * @file backend-fs2.c Farsight 2 backend for media API
 
2
 * @file backend-fs2.c Farstream backend for media API
3
3
 * @ingroup core
4
4
 */
5
5
 
36
36
 
37
37
#include <farstream/fs-conference.h>
38
38
#include <farstream/fs-element-added-notifier.h>
 
39
#include <farstream/fs-utils.h>
39
40
 
40
41
/** @copydoc _PurpleMediaBackendFs2Class */
41
42
typedef struct _PurpleMediaBackendFs2Class PurpleMediaBackendFs2Class;
112
113
        gchar *participant;
113
114
        FsStream *stream;
114
115
 
 
116
        gboolean supports_add;
 
117
 
115
118
        GstElement *src;
116
119
        GstElement *tee;
117
120
        GstElement *volume;
147
150
        FsConference *conference;
148
151
        gchar *conference_type;
149
152
 
 
153
        FsElementAddedNotifier *notifier;
 
154
 
150
155
        GHashTable *sessions;
151
156
        GHashTable *participants;
152
157
 
212
217
 
213
218
        purple_debug_info("backend-fs2", "purple_media_backend_fs2_dispose\n");
214
219
 
 
220
        if (priv->notifier) {
 
221
                g_object_unref(priv->notifier);
 
222
                priv->notifier = NULL;
 
223
        }
 
224
 
215
225
        if (priv->confbin) {
216
226
                GstElement *pipeline;
217
227
 
846
856
                        priv->conference != FS_CONFERENCE(src))
847
857
                return;
848
858
 
849
 
        if (gst_structure_has_name(msg->structure, "farsight-error")) {
 
859
        if (gst_structure_has_name(msg->structure, "farstream-error")) {
850
860
                FsError error_no;
851
861
                gst_structure_get_enum(msg->structure, "error-no",
852
862
                                FS_TYPE_ERROR, (gint*)&error_no);
859
869
                                                " packages."));
860
870
                                purple_media_end(priv->media, NULL, NULL);
861
871
                                break;
862
 
                        case FS_ERROR_NO_CODECS_LEFT:
863
 
                                purple_media_error(priv->media, _("No codecs"
864
 
                                                " left. Your codec"
865
 
                                                " preferences in"
866
 
                                                " fs-codecs.conf are too"
867
 
                                                " strict."));
868
 
                                purple_media_end(priv->media, NULL, NULL);
869
 
                                break;
870
872
                        default:
871
873
                                purple_debug_error("backend-fs2",
872
 
                                                "farsight-error: %i: %s\n",
 
874
                                                "farstream-error: %i: %s\n",
873
875
                                                error_no,
874
876
                                                gst_structure_get_string(
875
877
                                                msg->structure, "error-msg"));
878
880
 
879
881
                if (FS_ERROR_IS_FATAL(error_no)) {
880
882
                        purple_media_error(priv->media, _("A non-recoverable "
881
 
                                        "Farsight2 error has occurred."));
 
883
                                        "Farstream error has occurred."));
882
884
                        purple_media_end(priv->media, NULL, NULL);
883
885
                }
884
886
        } else if (gst_structure_has_name(msg->structure,
885
 
                        "farsight-new-local-candidate")) {
 
887
                        "farstream-new-local-candidate")) {
886
888
                const GValue *value;
887
889
                FsStream *stream;
888
890
                FsCandidate *local_candidate;
917
919
                                session->id, name, candidate);
918
920
                g_object_unref(candidate);
919
921
        } else if (gst_structure_has_name(msg->structure,
920
 
                        "farsight-local-candidates-prepared")) {
 
922
                        "farstream-local-candidates-prepared")) {
921
923
                const GValue *value;
922
924
                FsStream *stream;
923
925
                FsParticipant *participant;
935
937
                g_signal_emit_by_name(self, "candidates-prepared",
936
938
                                session->id, name);
937
939
        } else if (gst_structure_has_name(msg->structure,
938
 
                        "farsight-new-active-candidate-pair")) {
 
940
                        "farstream-new-active-candidate-pair")) {
939
941
                const GValue *value;
940
942
                FsStream *stream;
941
943
                FsCandidate *local_candidate;
969
971
                g_object_unref(lcandidate);
970
972
                g_object_unref(rcandidate);
971
973
        } else if (gst_structure_has_name(msg->structure,
972
 
                        "farsight-recv-codecs-changed")) {
 
974
                        "farstream-recv-codecs-changed")) {
973
975
                const GValue *value;
974
976
                GList *codecs;
975
977
                FsCodec *codec;
979
981
                codec = codecs->data;
980
982
 
981
983
                purple_debug_info("backend-fs2",
982
 
                                "farsight-recv-codecs-changed: %s\n",
 
984
                                "farstream-recv-codecs-changed: %s\n",
983
985
                                codec->encoding_name);
984
986
        } else if (gst_structure_has_name(msg->structure,
985
 
                        "farsight-component-state-changed")) {
 
987
                        "farstream-component-state-changed")) {
986
988
                const GValue *value;
987
989
                FsStreamState fsstate;
988
990
                guint component;
1018
1020
                }
1019
1021
 
1020
1022
                purple_debug_info("backend-fs2",
1021
 
                                "farsight-component-state-changed: "
 
1023
                                "farstream-component-state-changed: "
1022
1024
                                "component: %u state: %s\n",
1023
1025
                                component, state);
1024
1026
        } else if (gst_structure_has_name(msg->structure,
1025
 
                        "farsight-send-codec-changed")) {
 
1027
                        "farstream-send-codec-changed")) {
1026
1028
                const GValue *value;
1027
1029
                FsCodec *codec;
1028
1030
                gchar *codec_str;
1032
1034
                codec_str = fs_codec_to_string(codec);
1033
1035
 
1034
1036
                purple_debug_info("backend-fs2",
1035
 
                                "farsight-send-codec-changed: codec: %s\n",
 
1037
                                "farstream-send-codec-changed: codec: %s\n",
1036
1038
                                codec_str);
1037
1039
 
1038
1040
                g_free(codec_str);
1039
1041
        } else if (gst_structure_has_name(msg->structure,
1040
 
                        "farsight-codecs-changed")) {
 
1042
                        "farstream-codecs-changed")) {
1041
1043
                const GValue *value;
1042
1044
                FsSession *fssession;
1043
1045
                GList *sessions;
1213
1215
                                purple_media_is_initiator(media, sid, name))
1214
1216
                        return;
1215
1217
 
1216
 
                fs_stream_add_remote_candidates(stream->stream,
1217
 
                                stream->remote_candidates, &err);
 
1218
                if (stream->supports_add)
 
1219
                  fs_stream_add_remote_candidates(stream->stream,
 
1220
                                stream->remote_candidates, &err);
 
1221
                else
 
1222
                  fs_stream_force_remote_candidates(stream->stream,
 
1223
                                stream->remote_candidates, &err);
1218
1224
 
1219
1225
                if (err == NULL)
1220
1226
                        return;
1294
1300
        GstElement *pipeline;
1295
1301
        GstBus *bus;
1296
1302
        gchar *name;
 
1303
        GKeyFile *default_props;
1297
1304
 
1298
1305
        priv->conference = FS_CONFERENCE(
1299
1306
                        gst_element_factory_make(priv->conference_type, NULL));
1336
1343
                return FALSE;
1337
1344
        }
1338
1345
 
 
1346
        default_props = fs_utils_get_default_element_properties(GST_ELEMENT(priv->conference));
 
1347
        if (default_props != NULL) {
 
1348
                priv->notifier = fs_element_added_notifier_new();
 
1349
                fs_element_added_notifier_add(priv->notifier,
 
1350
                                              GST_BIN(priv->confbin));
 
1351
                fs_element_added_notifier_set_properties_from_keyfile(priv->notifier, default_props);
 
1352
        }
 
1353
 
1339
1354
        g_signal_connect(G_OBJECT(bus), "message",
1340
1355
                        G_CALLBACK(gst_bus_cb), self);
1341
1356
        gst_object_unref(bus);
1552
1567
         * receiving the src-pad-added signal.
1553
1568
         * Only works for non-multicast FsRtpSessions.
1554
1569
         */
1555
 
        if (is_nice || !strcmp(transmitter, "rawudp"))
 
1570
        if (!!strcmp(transmitter, "multicast"))
1556
1571
                g_object_set(G_OBJECT(session->session),
1557
1572
                                "no-rtcp-timeout", 0, NULL);
1558
1573
 
1615
1630
                return FALSE;
1616
1631
        }
1617
1632
 
 
1633
        if (g_object_class_find_property(G_OBJECT_GET_CLASS(participant),
 
1634
                                         "cname")) {
 
1635
          g_object_set(participant, "cname", name, NULL);
 
1636
        }
 
1637
 
 
1638
 
1618
1639
        if (!priv->participants) {
1619
1640
                purple_debug_info("backend-fs2",
1620
1641
                                "Creating hash table for participants\n");
1779
1800
                }
1780
1801
        }
1781
1802
 
 
1803
 
 
1804
        session = get_session(self, sess_id);
 
1805
 
 
1806
        if (session == NULL) {
 
1807
                purple_debug_error("backend-fs2",
 
1808
                                "Couldn't find session to create stream.\n");
 
1809
                return FALSE;
 
1810
        }
 
1811
 
 
1812
        participant = get_participant(self, who);
 
1813
 
 
1814
        if (participant == NULL) {
 
1815
                purple_debug_error("backend-fs2", "Couldn't find "
 
1816
                                "participant to create stream.\n");
 
1817
                return FALSE;
 
1818
        }
 
1819
 
 
1820
        fsstream = fs_session_new_stream(session->session, participant,
 
1821
                        initiator == TRUE ? type_direction :
 
1822
                        (type_direction & FS_DIRECTION_RECV), &err);
 
1823
 
 
1824
        if (fsstream == NULL) {
 
1825
                if (err) {
 
1826
                        purple_debug_error("backend-fs2",
 
1827
                                        "Error creating stream: %s\n",
 
1828
                                        err && err->message ?
 
1829
                                        err->message : "NULL");
 
1830
                        g_error_free(err);
 
1831
                } else
 
1832
                        purple_debug_error("backend-fs2",
 
1833
                                        "Error creating stream\n");
 
1834
                return FALSE;
 
1835
        }
 
1836
 
1782
1837
        memcpy(_params, params, sizeof(GParameter) * num_params);
1783
1838
 
1784
1839
        /* set the controlling mode parameter */
1833
1888
                _num_params++;
1834
1889
        }
1835
1890
 
1836
 
        session = get_session(self, sess_id);
1837
 
 
1838
 
        if (session == NULL) {
1839
 
                purple_debug_error("backend-fs2",
1840
 
                                "Couldn't find session to create stream.\n");
1841
 
                return FALSE;
1842
 
        }
1843
 
 
1844
 
        participant = get_participant(self, who);
1845
 
 
1846
 
        if (participant == NULL) {
1847
 
                purple_debug_error("backend-fs2", "Couldn't find "
1848
 
                                "participant to create stream.\n");
1849
 
                return FALSE;
1850
 
        }
1851
 
 
1852
 
        fsstream = fs_session_new_stream(session->session, participant,
1853
 
                        initiator == TRUE ? type_direction :
1854
 
                        (type_direction & FS_DIRECTION_RECV),  &err);
 
1891
 
 
1892
        if(!fs_stream_set_transmitter(fsstream, transmitter,
 
1893
                                      _params, _num_params, &err)) {
 
1894
             purple_debug_error("backend-fs2", "Could not set transmitter %s: %s.\n", transmitter, err->message);
 
1895
             g_clear_error(&err);
 
1896
             g_free(_params);
 
1897
             return FALSE;
 
1898
        }
1855
1899
        g_free(_params);
1856
1900
 
1857
 
        if (fsstream == NULL) {
1858
 
                if (err) {
1859
 
                        purple_debug_error("backend-fs2",
1860
 
                                        "Error creating stream: %s\n",
1861
 
                                        err && err->message ?
1862
 
                                        err->message : "NULL");
1863
 
                        g_error_free(err);
1864
 
                } else
1865
 
                        purple_debug_error("backend-fs2",
1866
 
                                        "Error creating stream\n");
1867
 
                return FALSE;
1868
 
        }
1869
1901
 
1870
1902
        stream = g_new0(PurpleMediaBackendFs2Stream, 1);
1871
1903
        stream->participant = g_strdup(who);
1872
1904
        stream->session = session;
1873
1905
        stream->stream = fsstream;
 
1906
        stream->supports_add = !strcmp(transmitter, "nice");
1874
1907
 
1875
1908
        priv->streams = g_list_append(priv->streams, stream);
1876
1909
 
1983
2016
        if (purple_media_is_initiator(priv->media, sess_id, participant) ||
1984
2017
                        purple_media_accepted(
1985
2018
                        priv->media, sess_id, participant)) {
1986
 
                fs_stream_add_remote_candidates(stream->stream,
 
2019
                if (stream->supports_add)
 
2020
                     fs_stream_add_remote_candidates(stream->stream,
 
2021
                                stream->remote_candidates, &err);
 
2022
                else
 
2023
                     fs_stream_force_remote_candidates(stream->stream,
1987
2024
                                stream->remote_candidates, &err);
1988
2025
 
1989
2026
                if (err) {
2008
2045
        if (sess_id != NULL) {
2009
2046
                PurpleMediaBackendFs2Session *session = get_session(
2010
2047
                                PURPLE_MEDIA_BACKEND_FS2(self), sess_id);
 
2048
                GList *codecs = NULL;
2011
2049
 
2012
2050
                if (session == NULL)
2013
2051
                        return FALSE;
2015
2053
                if (session->type & (PURPLE_MEDIA_SEND_AUDIO |
2016
2054
                                PURPLE_MEDIA_SEND_VIDEO))
2017
2055
                        g_object_get(session->session,
2018
 
                                        "codecs-ready", &ret, NULL);
 
2056
                                        "codecs", &codecs, NULL);
2019
2057
                else
2020
2058
                        ret = TRUE;
 
2059
                if (codecs) {
 
2060
                        fs_codec_list_destroy (codecs);
 
2061
                        ret = TRUE;
 
2062
                }
2021
2063
        } else {
2022
2064
                GList *values = g_hash_table_get_values(priv->sessions);
2023
2065
 
2024
2066
                for (; values; values = g_list_delete_link(values, values)) {
2025
2067
                        PurpleMediaBackendFs2Session *session = values->data;
 
2068
                        GList *codecs = NULL;
 
2069
 
2026
2070
                        if (session->type & (PURPLE_MEDIA_SEND_AUDIO |
2027
2071
                                        PURPLE_MEDIA_SEND_VIDEO))
2028
2072
                                g_object_get(session->session,
2029
 
                                                "codecs-ready", &ret, NULL);
 
2073
                                                "codecs", &codecs, NULL);
2030
2074
                        else
2031
2075
                                ret = TRUE;
2032
2076
 
 
2077
                        if (codecs) {
 
2078
                                fs_codec_list_destroy (codecs);
 
2079
                                ret = TRUE;
 
2080
                        }
2033
2081
                        if (ret == FALSE)
2034
2082
                                break;
2035
2083
                }