feat: JSON encoded sources. (#1695)

* feat: Support plain endpoint ID.

Support the ID of the owner of sources being encoded directly instead of
using the full JID.

* feat: Support JSON-encoded sources.

* feat: Advertise support for JSON-encoded sources.

modules/xmpp/JingleSessionPC.js

@@ -47,6 +47,16 @@ const DEFAULT_MAX_STATS = 300;
  */
 const ICE_CAND_GATHERING_TIMEOUT = 150;
 
+/**
+ * Reads the endpoint ID given a string which represents either the endpoint's full JID, or the endpoint ID itself.
+ * @param {String} jidOrEndpointId A string which is either the full JID of a participant, or the ID of an
+ * endpoint/participant.
+ * @returns The endpoint ID associated with 'jidOrEndpointId'.
+ */
+function getEndpointId(jidOrEndpointId) {
+    return Strophe.getResourceFromJid(jidOrEndpointId) || jidOrEndpointId;
+}
+
 /**
  * @typedef {Object} JingleSessionPCOptions
  * @property {Object} abTesting - A/B testing related options (ask George).
@@ -886,7 +896,7 @@ export default class JingleSessionPC extends JingleSession {
                             } else {
                                 this.signalingLayer.setSSRCOwner(
                                     ssrc,
-                                    Strophe.getResourceFromJid(owner));
+                                    getEndpointId(owner));
                             }
                         }
                     });

modules/xmpp/strophe.jingle.js

@@ -1,4 +1,4 @@
-/* global $, __filename */
+/* global $, $build, __filename */
 
 import { getLogger } from 'jitsi-meet-logger';
 import { $iq, Strophe } from 'strophe.js';
@@ -22,6 +22,174 @@ const logger = getLogger(__filename);
 // function call chains.
 /* eslint-disable newline-per-chained-call */
 
+/**
+ * Reads a JSON-encoded message (from a "json-message" element) and extracts source descriptions. Adds the extracted
+ * source descriptions to the given Jingle IQ in the standard Jingle format.
+ *
+ * Encoding sources in this compact JSON format instead of standard Jingle was introduced in order to reduce the
+ * network traffic and load on the XMPP server. The format is described in Jicofo [TODO: insert link].
+ *
+ * @param {*} iq the IQ to which source descriptions will be added.
+ * @param {*} jsonMessageXml The XML node for the "json-message" element.
+ * @returns nothing.
+ */
+function expandSourcesFromJson(iq, jsonMessageXml) {
+
+    let json;
+
+    try {
+        json = JSON.parse(jsonMessageXml.textContent);
+    } catch (error) {
+        logger.error(`json-message XML contained invalid JSON, ignoring: ${jsonMessageXml.textContent}`);
+
+        return;
+    }
+
+    if (!json || !json.sources) {
+        // It might be a message of a different type, no need to log.
+        return;
+    }
+
+    // This is where we'll add "source" and "ssrc-group" elements. Create them elements if they don't exist.
+    const videoRtpDescription = getOrCreateRtpDescription(iq, 'video');
+    const audioRtpDescription = getOrCreateRtpDescription(iq, 'audio');
+
+    for (const owner in json.sources) {
+        if (json.sources.hasOwnProperty(owner)) {
+
+            const ownerSources = json.sources[owner];
+
+            // The video sources, video ssrc-groups, audio sources and audio ssrc-groups are encoded in that order in
+            // the elements of the array.
+            const videoSources = ownerSources && ownerSources.length > 0 && ownerSources[0];
+            const videoSsrcGroups = ownerSources && ownerSources.length > 1 && ownerSources[1];
+            const audioSources = ownerSources && ownerSources.length > 2 && ownerSources[2];
+            const audioSsrcGroups = ownerSources && ownerSources.length > 3 && ownerSources[3];
+
+            if (videoSources && videoSources.length > 0) {
+                for (let i = 0; i < videoSources.length; i++) {
+                    videoRtpDescription.appendChild(createSourceExtension(owner, videoSources[i]));
+                }
+            }
+            if (videoSsrcGroups && videoSsrcGroups.length > 0) {
+                for (let i = 0; i < videoSsrcGroups.length; i++) {
+                    videoRtpDescription.appendChild(createSsrcGroupExtension(videoSsrcGroups[i]));
+                }
+            }
+            if (audioSources && audioSources.length > 0) {
+                for (let i = 0; i < audioSources.length; i++) {
+                    audioRtpDescription.appendChild(createSourceExtension(owner, audioSources[i]));
+                }
+            }
+            if (audioSsrcGroups && audioSsrcGroups.length > 0) {
+                for (let i = 0; i < audioSsrcGroups.length; i++) {
+                    audioRtpDescription.appendChild(createSsrcGroupExtension(audioSsrcGroups[i]));
+                }
+            }
+        }
+    }
+}
+
+/**
+ * Creates a "source" XML element for the source described in compact JSON format in [sourceCompactJson].
+ * @param {*} owner the endpoint ID of the owner of the source.
+ * @param {*} sourceCompactJson the compact JSON representation of the source.
+ * @returns the created "source" XML element.
+ */
+function createSourceExtension(owner, sourceCompactJson) {
+    const node = $build('source', {
+        xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0',
+        ssrc: sourceCompactJson.s
+    });
+
+    if (sourceCompactJson.m) {
+        node.c('parameter', {
+            name: 'msid',
+            value: sourceCompactJson.m
+        }).up();
+    }
+    node.c('ssrc-info', {
+        xmlns: 'http://jitsi.org/jitmeet',
+        owner
+    }).up();
+
+    return node.node;
+}
+
+/**
+ * Creates an "ssrc-group" XML element for the SSRC group described in compact JSON format in [ssrcGroupCompactJson].
+ * @param {*} ssrcGroupCompactJson the compact JSON representation of the SSRC group.
+ * @returns the created "ssrc-group" element.
+ */
+function createSsrcGroupExtension(ssrcGroupCompactJson) {
+    const node = $build('ssrc-group', {
+        xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0',
+        semantics: getSemantics(ssrcGroupCompactJson[0])
+    });
+
+    for (let i = 1; i < ssrcGroupCompactJson.length; i++) {
+        node.c('source', {
+            xmlns: 'urn:xmpp:jingle:apps:rtp:ssma:0',
+            ssrc: ssrcGroupCompactJson[i]
+        }).up();
+    }
+
+    return node.node;
+}
+
+/**
+ * Convert the short string representing SSRC group semantics in compact JSON format to the standard representation
+ * (i.e. convert "f" to "FID" and "s" to "SIM").
+ * @param {*} str the compact JSON format representation of an SSRC group's semantics.
+ * @returns the SSRC group semantics corresponding to [str].
+ */
+function getSemantics(str) {
+    if (str === 'f') {
+        return 'FID';
+    } else if (str === 's') {
+        return 'SIM';
+    }
+
+    return null;
+}
+
+/**
+ * Finds in a Jingle IQ the RTP description element with the given media type. If one does not exists, create it (as
+ *  well as the required  "content" parent element) and adds it to the IQ.
+ * @param {*} iq
+ * @param {*} mediaType The media type, "audio" or "video".
+ * @returns the RTP description element with the given media type.
+ */
+function getOrCreateRtpDescription(iq, mediaType) {
+    const jingle = $(iq).find('jingle')[0];
+    let content = $(jingle).find(`content[name="${mediaType}"]`);
+    let description;
+
+    if (content.length) {
+        content = content[0];
+    } else {
+        // I'm not suree if "creator" and "senders" are required.
+        content = $build('content', {
+            name: mediaType
+        }).node;
+        jingle.appendChild(content);
+    }
+
+    description = $(content).find('description');
+
+    if (description.length) {
+        description = description[0];
+    } else {
+        description = $build('description', {
+            xmlns: 'urn:xmpp:jingle:apps:rtp:1',
+            media: mediaType
+        }).node;
+        content.appendChild(description);
+    }
+
+    return description;
+}
+
 /**
  *
  */
@@ -132,6 +300,18 @@ export default class JingleConnectionPlugin extends ConnectionPlugin {
 
         // see http://xmpp.org/extensions/xep-0166.html#concepts-session
 
+        const jsonMessages = $(iq).find('jingle>json-message');
+
+        if (jsonMessages && jsonMessages.length > 0) {
+            logger.info(`Found a JSON-encoded element in ${action}, translating to standard Jingle.`);
+            for (let i = 0; i < jsonMessages.length; i++) {
+                expandSourcesFromJson(iq, jsonMessages[i]);
+            }
+
+            // TODO: is there a way to remove the json-message elements once we've extracted the information?
+            // removeChild doesn't seem to work.
+        }
+
         switch (action) {
         case 'session-initiate': {
             logger.log('(TIME) received session-initiate:\t', now);

modules/xmpp/xmpp.js

@@ -206,6 +206,7 @@ export default class XMPP extends Listenable {
         this.caps.addFeature('urn:xmpp:jingle:transports:dtls-sctp:1');
         this.caps.addFeature('urn:xmpp:jingle:apps:rtp:audio');
         this.caps.addFeature('urn:xmpp:jingle:apps:rtp:video');
+        this.caps.addFeature('http://jitsi.org/json-encoded-sources');
 
         // Disable RTX on Firefox 83 and older versions because of
         // https://bugzilla.mozilla.org/show_bug.cgi?id=1668028