Use insertable streams to drop all media when in lite mode. (#2178)

(Rather than moving streams to inactive in SDP.)

JitsiConference.js

@@ -28,6 +28,7 @@ import { E2EEncryption } from './modules/e2ee/E2EEncryption';
 import E2ePing from './modules/e2eping/e2eping';
 import Jvb121EventGenerator from './modules/event/Jvb121EventGenerator';
 import FeatureFlags from './modules/flags/FeatureFlags';
+import { LiteModeContext } from './modules/litemode/LiteModeContext';
 import ReceiveVideoController from './modules/qualitycontrol/ReceiveVideoController';
 import SendVideoController from './modules/qualitycontrol/SendVideoController';
 import RecordingManager from './modules/recording/RecordingManager';
@@ -282,6 +283,12 @@ export default function JitsiConference(options) {
         this._e2eEncryption = new E2EEncryption(this);
     }
 
+    if (FeatureFlags.isRunInLiteModeEnabled()) {
+        logger.info('Lite mode enabled');
+
+        this._liteModeContext = new LiteModeContext(this);
+    }
+
     /**
      * Flag set to <tt>true</tt> when Jicofo sends a presence message indicating that the max audio sender limit has
      * been reached for the call. Once this is set, unmuting audio will be disabled from the client until it gets reset
@@ -2246,7 +2253,7 @@ JitsiConference.prototype._acceptJvbIncomingCall = function(jingleSession, jingl
             this._signalingLayer,
             {
                 ...this.options.config,
-                enableInsertableStreams: this.isE2EEEnabled()
+                enableInsertableStreams: this.isE2EEEnabled() || FeatureFlags.isRunInLiteModeEnabled()
             });
     } catch (error) {
         GlobalOnErrorHandler.callErrorHandler(error);
@@ -3005,7 +3012,7 @@ JitsiConference.prototype._acceptP2PIncomingCall = function(jingleSession, jingl
         this._signalingLayer,
         {
             ...this.options.config,
-            enableInsertableStreams: this.isE2EEEnabled()
+            enableInsertableStreams: this.isE2EEEnabled() || FeatureFlags.isRunInLiteModeEnabled()
         });
 
     logger.info('Starting CallStats for P2P connection...');
@@ -3373,7 +3380,7 @@ JitsiConference.prototype._startP2PSession = function(remoteJid) {
         this._signalingLayer,
         {
             ...this.options.config,
-            enableInsertableStreams: this.isE2EEEnabled()
+            enableInsertableStreams: this.isE2EEEnabled() || FeatureFlags.isRunInLiteModeEnabled()
         });
 
     logger.info('Starting CallStats for P2P connection...');

modules/RTC/TraceablePeerConnection.js

@@ -2525,10 +2525,6 @@ TraceablePeerConnection.prototype.setRemoteDescription = function(description) {
 
             remoteDescription = this.interop.toUnifiedPlan(remoteDescription, currentDescription);
             this.trace('setRemoteDescription::postTransform (Unified)', dumpSDP(remoteDescription));
-
-            if (FeatureFlags.isRunInLiteModeEnabled()) {
-                remoteDescription = this._mungeInactive(remoteDescription);
-            }
         }
         if (this.isSimulcastOn()) {
             remoteDescription = this.tpcUtils.insertUnifiedPlanSimulcastReceive(remoteDescription);

modules/flags/FeatureFlags.js

@@ -28,13 +28,13 @@ class FeatureFlags {
 
     /**
      * Checks if the run in lite mode is enabled.
-     * This will cause any media to be received and not decoded. (Directions are inactive and no ssrc and ssrc-groups
-     * are added to the remote description). This can be used for various test scenarios.
+     * This will cause any media to be received and not decoded. (Insertable streams are used to discard
+     * all media before it is decoded). This can be used for various test scenarios.
      *
      * @returns {boolean}
      */
     isRunInLiteModeEnabled() {
-        return this._runInLiteMode;
+        return this._runInLiteMode && browser.supportsInsertableStreams();
     }
 
     /**

modules/litemode/LiteModeContext.js

@@ -0,0 +1,65 @@
+/* global TransformStream */
+import { getLogger } from '@jitsi/logger';
+
+import RTCEvents from '../../service/RTC/RTCEvents';
+import FeatureFlags from '../flags/FeatureFlags';
+
+// Flag to set on receivers to avoid setting up the lite mode
+// more than once.
+const kJitsiLiteMode = Symbol('kJitsiLiteMode');
+
+const logger = getLogger(__filename);
+
+/**
+ * This module implements a discard-all insertable stream.  Use to reduce decoder CPU load for testing.
+ */
+export class LiteModeContext {
+    /**
+     * A constructor.
+     * @param {JitsiConference} conference - The conference instance for which lite mode is to be enabled.
+     */
+    constructor(conference) {
+        this.enabled = FeatureFlags.isRunInLiteModeEnabled();
+        if (!this.enabled) {
+            return;
+        }
+
+        conference.rtc.on(
+            RTCEvents.REMOTE_TRACK_ADDED,
+            (track, tpc) => this._setupLiteModeForTrack(tpc, track));
+    }
+
+    /**
+     * Setup Lite Mode for a track.
+     *
+     * @private
+     */
+    _setupLiteModeForTrack(tpc, track) {
+        if (!this.enabled) {
+            return;
+        }
+
+        const receiver = tpc.findReceiverForTrack(track.track);
+
+        if (!receiver) {
+            logger.warn(`Could not set up lite mode for ${track}: receiver not found in: ${tpc}`);
+
+            return;
+        }
+
+        if (receiver[kJitsiLiteMode]) {
+            return;
+        }
+        receiver[kJitsiLiteMode] = true;
+
+        const receiverStreams = receiver.createEncodedStreams();
+
+        const transformStream = new TransformStream({
+            transform: () => {
+                // Don't call controller.enqueue(encodedFrame), and so drop everything
+            }
+        });
+
+        receiverStreams.readable.pipeThrough(transformStream).pipeTo(receiverStreams.writable);
+    }
+}