shaka-player 4.5.0 → 4.6.0

package/lib/media/streaming_engine.js

@@ -1054,6 +1054,14 @@ shaka.media.StreamingEngine = class {
       this.playerInterface_.mediaSourceEngine.clearSelectedClosedCaptionId();
     }
 
+    if (!this.playerInterface_.mediaSourceEngine.isStreamingAllowed() &&
+        mediaState.type != ContentType.TEXT) {
+      // It is not allowed to add segments yet, so we schedule an update to
+      // check again later. So any prediction we make now could be terribly
+      // invalid soon.
+      return this.config_.updateIntervalSeconds / 2;
+    }
+
     const logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
 
     // Compute how far we've buffered ahead of the playhead.
@@ -1163,6 +1171,12 @@ shaka.media.StreamingEngine = class {
     }
 
     if (mediaState.segmentPrefetch && mediaState.segmentIterator) {
+      const initSegmentReference = reference.initSegmentReference;
+      if (initSegmentReference && (!mediaState.lastSegmentReference ||
+          !shaka.media.InitSegmentReference.equal(
+              initSegmentReference, mediaState.lastInitSegmentReference))) {
+        mediaState.segmentPrefetch.prefetchInitSegment(initSegmentReference);
+      }
       mediaState.segmentPrefetch.prefetchSegments(reference);
     }
 
@@ -1373,6 +1387,11 @@ shaka.media.StreamingEngine = class {
             await this.append_(
                 mediaState, presentationTime, stream, reference, dataToAppend,
                 /* isChunkedData= */ true);
+
+            if (mediaState.segmentPrefetch && mediaState.segmentIterator) {
+              mediaState.segmentPrefetch.prefetchSegments(
+                  reference, /* skipFirst= */ true);
+            }
           }
         };
 
@@ -1403,6 +1422,11 @@ shaka.media.StreamingEngine = class {
           await this.append_(
               mediaState, presentationTime, stream, reference, result);
         }
+
+        if (mediaState.segmentPrefetch && mediaState.segmentIterator) {
+          mediaState.segmentPrefetch.prefetchSegments(
+              reference, /* skipFirst= */ true);
+        }
       } else {
         if (this.config_.lowLatencyMode && !isReadableStreamSupported) {
           shaka.log.warning('Low latency streaming mode is enabled, but ' +
@@ -1499,11 +1523,11 @@ shaka.media.StreamingEngine = class {
   /**
    * @param {!BufferSource} rawResult
    * @param {shaka.extern.aes128Key} aes128Key
-   * @param {!shaka.media.SegmentIterator} iter
+   * @param {number} position
    * @return {!Promise.<!BufferSource>} finalResult
    * @private
    */
-  async aes128Decrypt_(rawResult, aes128Key, iter) {
+  async aes128Decrypt_(rawResult, aes128Key, position) {
     const key = aes128Key;
     if (!key.cryptoKey) {
       goog.asserts.assert(key.fetchKey, 'If AES-128 cryptoKey was not ' +
@@ -1514,7 +1538,7 @@ shaka.media.StreamingEngine = class {
     let iv = key.iv;
     if (!iv) {
       iv = shaka.util.BufferUtils.toUint8(new ArrayBuffer(16));
-      let sequence = key.firstMediaSequenceNumber + iter.currentPosition();
+      let sequence = key.firstMediaSequenceNumber + position;
       for (let i = iv.byteLength - 1; i >= 0; i--) {
         iv[i] = sequence & 0xff;
         sequence >>= 8;
@@ -1764,8 +1788,7 @@ shaka.media.StreamingEngine = class {
         shaka.log.v1(logPrefix, 'fetching init segment');
 
         const fetchInit =
-            this.fetch_(mediaState, reference.initSegmentReference,
-            /* streamDataCallback= */ undefined, /* isInit= */ true);
+            this.fetch_(mediaState, reference.initSegmentReference);
         const append = async () => {
           try {
             const initSegment = await fetchInit;
@@ -2169,13 +2192,12 @@ shaka.media.StreamingEngine = class {
    * @param {(!shaka.media.InitSegmentReference|!shaka.media.SegmentReference)}
    *   reference
    * @param {?function(BufferSource):!Promise=} streamDataCallback
-   * @param {boolean=} isInit
    *
    * @return {!Promise.<BufferSource>}
    * @private
    * @suppress {strictMissingProperties}
    */
-  async fetch_(mediaState, reference, streamDataCallback, isInit) {
+  async fetch_(mediaState, reference, streamDataCallback) {
     if (reference instanceof shaka.media.InitSegmentReference) {
       const segmentData = reference.getSegmentData();
       if (segmentData) {
@@ -2183,17 +2205,18 @@ shaka.media.StreamingEngine = class {
       }
     }
     let op = null;
-    if (
-      mediaState.segmentPrefetch &&
-      reference instanceof shaka.media.SegmentReference
-    ) {
+    if (mediaState.segmentPrefetch) {
       op = mediaState.segmentPrefetch.getPrefetchedSegment(
           reference, streamDataCallback);
     }
     if (!op) {
       op = this.dispatchFetch_(
-          reference, mediaState.stream, streamDataCallback, isInit,
-      );
+          reference, mediaState.stream, streamDataCallback);
+    }
+
+    let position = 0;
+    if (mediaState.segmentIterator) {
+      position = mediaState.segmentIterator.currentPosition();
     }
 
     mediaState.operation = op;
@@ -2201,9 +2224,7 @@ shaka.media.StreamingEngine = class {
     mediaState.operation = null;
     let result = response.data;
     if (reference.aes128Key) {
-      const iter = mediaState.segmentIterator;
-      goog.asserts.assert(iter, 'mediaState.segmentIterator should exist');
-      result = await this.aes128Decrypt_(result, reference.aes128Key, iter);
+      result = await this.aes128Decrypt_(result, reference.aes128Key, position);
     }
     return result;
   }
@@ -2215,18 +2236,17 @@ shaka.media.StreamingEngine = class {
    * @param {(!shaka.media.InitSegmentReference|!shaka.media.SegmentReference)}
    *   reference
    * @param {?function(BufferSource):!Promise=} streamDataCallback
-   * @param {boolean=} isInit
    *
    * @return {!shaka.net.NetworkingEngine.PendingRequest}
    * @private
    */
-  dispatchFetch_(reference, stream, streamDataCallback, isInit) {
+  dispatchFetch_(reference, stream, streamDataCallback) {
     const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
-    const type = isInit ?
-        shaka.net.NetworkingEngine.AdvancedRequestType.INIT_SEGMENT :
-        shaka.net.NetworkingEngine.AdvancedRequestType.MEDIA_SEGMENT;
     const segment = reference instanceof shaka.media.SegmentReference ?
         reference : undefined;
+    const type = segment ?
+        shaka.net.NetworkingEngine.AdvancedRequestType.MEDIA_SEGMENT :
+        shaka.net.NetworkingEngine.AdvancedRequestType.INIT_SEGMENT;
     const request = shaka.util.Networking.createSegmentRequest(
         reference.getUris(),
         reference.startByte,

package/lib/mss/mss_parser.js

@@ -213,6 +213,22 @@ shaka.mss.MssParser = class {
     // No-op
   }
 
+  /**
+   * @override
+   * @exportInterface
+   */
+  onInitialVariantChosen(variant) {
+    // No-op
+  }
+
+  /**
+   * @override
+   * @exportInterface
+   */
+  banLocation(uri) {
+    // No-op
+  }
+
   /**
    * Makes a network request for the manifest and parses the resulting data.
    *
@@ -529,6 +545,7 @@ shaka.mss.MssParser = class {
       spatialAudio: false,
       closedCaptions: null,
       hdr: undefined,
+      videoLayout: undefined,
       tilesLayout: undefined,
       matchedStreams: [],
       mssPrivateData: {
@@ -538,6 +555,7 @@ shaka.mss.MssParser = class {
       },
       accessibilityPurpose: null,
       external: false,
+      fastSwitching: false,
     };
 
     // This is specifically for text tracks.
@@ -1077,7 +1095,5 @@ shaka.mss.MssParser.Context;
  */
 shaka.mss.MssParser.TimeRange;
 
-shaka.media.ManifestParser.registerParserByExtension(
-    'ism', () => new shaka.mss.MssParser());
 shaka.media.ManifestParser.registerParserByMime(
     'application/vnd.ms-sstr+xml', () => new shaka.mss.MssParser());

package/lib/net/networking_engine.js

@@ -46,18 +46,21 @@ goog.require('shaka.util.Timer');
  */
 shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
   /**
-   * @param {function(number, number)=} onProgressUpdated Called when a progress
-   *   event is triggered. Passed the duration, in milliseconds, that the
-   *   request took, and the number of bytes transferred.
+   * @param {function(number, number, boolean)=} onProgressUpdated Called when
+   *   a progress event is triggered. Passed the duration, in milliseconds,
+   *   that the request took, the number of bytes transferred, and the boolean
+   *   of whether the switching is allowed.
    * @param {shaka.net.NetworkingEngine.OnHeadersReceived=} onHeadersReceived
    *   Called when the headers are received for a download.
    * @param {shaka.net.NetworkingEngine.OnDownloadFailed=} onDownloadFailed
    *   Called when a download fails, for any reason.
    * @param {shaka.net.NetworkingEngine.OnRequest=} onRequest
    *   Called when a request is made
+   * @param {shaka.net.NetworkingEngine.OnRetry=} onRetry
+   *   Called when a request retry is made
    */
   constructor(onProgressUpdated, onHeadersReceived, onDownloadFailed,
-      onRequest) {
+      onRequest, onRetry) {
     super();
 
     /** @private {boolean} */
@@ -72,7 +75,7 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
     /** @private {!Set.<shaka.extern.ResponseFilter>} */
     this.responseFilters_ = new Set();
 
-    /** @private {?function(number, number)} */
+    /** @private {?function(number, number, boolean)} */
     this.onProgressUpdated_ = onProgressUpdated || null;
 
     /** @private {?shaka.net.NetworkingEngine.OnHeadersReceived} */
@@ -84,6 +87,9 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
     /** @private {?shaka.net.NetworkingEngine.OnRequest} */
     this.onRequest_ = onRequest || null;
 
+    /** @private {?shaka.net.NetworkingEngine.OnRetry} */
+    this.onRetry_ = onRetry || null;
+
     /** @private {boolean} */
     this.forceHTTPS_ = false;
   }
@@ -295,7 +301,8 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
     // Apply the registered filters to the request.
     const requestFilterOperation = this.filterRequest_(type, request, context);
     const requestOperation = requestFilterOperation.chain(
-        () => this.makeRequestWithRetry_(type, request, numBytesRemainingObj));
+        () => this.makeRequestWithRetry_(type, request, context,
+            numBytesRemainingObj));
     const responseFilterOperation = requestOperation.chain(
         (responseAndGotProgress) =>
           this.filterResponse_(type, responseAndGotProgress, context));
@@ -322,7 +329,9 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
           !response.fromCache &&
           request.method != 'HEAD' &&
           type == shaka.net.NetworkingEngine.RequestType.SEGMENT) {
-        this.onProgressUpdated_(response.timeMs, response.data.byteLength);
+        const allowSwitch = this.allowSwitch_(context);
+        this.onProgressUpdated_(
+            response.timeMs, response.data.byteLength, allowSwitch);
       }
       return response;
     }, (e) => {
@@ -399,18 +408,19 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
   /**
    * @param {shaka.net.NetworkingEngine.RequestType} type
    * @param {shaka.extern.Request} request
+   * @param {(shaka.extern.RequestContext|undefined)} context
    * @param {shaka.net.NetworkingEngine.NumBytesRemainingClass}
    *            numBytesRemainingObj
    * @return {!shaka.extern.IAbortableOperation.<
    *            shaka.net.NetworkingEngine.ResponseAndGotProgress>}
    * @private
    */
-  makeRequestWithRetry_(type, request, numBytesRemainingObj) {
+  makeRequestWithRetry_(type, request, context, numBytesRemainingObj) {
     const backoff = new shaka.net.Backoff(
         request.retryParameters, /* autoReset= */ false);
     const index = 0;
     return this.send_(
-        type, request, backoff, index, /* lastError= */ null,
+        type, request, context, backoff, index, /* lastError= */ null,
         numBytesRemainingObj);
   }
 
@@ -419,6 +429,7 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
    *
    * @param {shaka.net.NetworkingEngine.RequestType} type
    * @param {shaka.extern.Request} request
+   * @param {(shaka.extern.RequestContext|undefined)} context
    * @param {!shaka.net.Backoff} backoff
    * @param {number} index
    * @param {?shaka.util.Error} lastError
@@ -428,11 +439,18 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
    *               shaka.net.NetworkingEngine.ResponseAndGotProgress>}
    * @private
    */
-  send_(type, request, backoff, index, lastError, numBytesRemainingObj) {
+  send_(type, request, context, backoff, index, lastError,
+      numBytesRemainingObj) {
     if (this.forceHTTPS_) {
       request.uris[index] = request.uris[index].replace('http://', 'https://');
     }
 
+    if (index > 0 && this.onRetry_) {
+      const newUri = request.uris[index];
+      const oldUri = request.uris[index - 1];
+      this.onRetry_(type, context, newUri, oldUri);
+    }
+
     const uri = new goog.Uri(request.uris[index]);
     let scheme = uri.getScheme();
     // Whether it got a progress event.
@@ -501,7 +519,8 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
           stallTimer.tickAfter(stallTimeoutMs / 1000);
         }
         if (this.onProgressUpdated_ && type == segment) {
-          this.onProgressUpdated_(time, bytes);
+          const allowSwitch = this.allowSwitch_(context);
+          this.onProgressUpdated_(time, bytes, allowSwitch);
           gotProgress = true;
           numBytesRemainingObj.setBytes(numBytesRemaining);
         }
@@ -610,7 +629,8 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
           // Move to the next URI.
           index = (index + 1) % request.uris.length;
           return this.send_(
-              type, request, backoff, index, error, numBytesRemainingObj);
+              type, request, context, backoff, index, error,
+              numBytesRemainingObj);
         }
       }
 
@@ -670,6 +690,24 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
     });
   }
 
+  /**
+   * @param {(shaka.extern.RequestContext|undefined)} context
+   * @return {boolean}
+   * @private
+   */
+  allowSwitch_(context) {
+    if (context) {
+      const segment = context.segment;
+      const stream = context.stream;
+      if (segment && stream && stream.fastSwitching) {
+        if (segment.isPartial() && !segment.isLastPartial()) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
   /**
    * This is here only for testability.  We can't mock location in our tests on
    * all browsers, so instead we mock this.
@@ -770,6 +808,7 @@ shaka.net.NetworkingEngine.RequestType = {
   'SERVER_CERTIFICATE': 5,
   'KEY': 6,
   'ADS': 7,
+  'CONTENT_STEERING': 8,
 };
 
 /**
@@ -887,3 +926,18 @@ shaka.net.NetworkingEngine.OnDownloadFailed;
  * @export
  */
 shaka.net.NetworkingEngine.OnRequest;
+
+
+/**
+ * @typedef {function(
+ *    !shaka.net.NetworkingEngine.RequestType,
+ *    (shaka.extern.RequestContext|undefined),
+ *    string,
+ *    string)}
+ *
+ * @description
+ * A callback function called on every request retry. The first string is the
+ * new URI and the second string is the old URI.
+ * @export
+ */
+shaka.net.NetworkingEngine.OnRetry;

package/lib/net/networking_utils.js

@@ -0,0 +1,95 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.net.NetworkingUtils');
+
+goog.require('goog.Uri');
+goog.require('shaka.net.NetworkingEngine');
+
+
+/**
+ * @summary Networking utility functions.
+ */
+shaka.net.NetworkingUtils = class {
+  /**
+   * @param {string} uri
+   * @param {!shaka.net.NetworkingEngine} netEngine
+   * @param {shaka.extern.RetryParameters} retryParams
+   * @return {!Promise.<string>}
+   */
+  static async getMimeType(uri, netEngine, retryParams) {
+    const extension = shaka.net.NetworkingUtils.getExtension_(uri);
+    let mimeType =
+        shaka.net.NetworkingUtils.EXTENSIONS_TO_MIME_TYPES_[extension];
+    if (mimeType) {
+      return mimeType;
+    }
+    const type = shaka.net.NetworkingEngine.RequestType.MANIFEST;
+
+    const request = shaka.net.NetworkingEngine.makeRequest([uri], retryParams);
+    request.method = 'HEAD';
+
+    const response = await netEngine.request(type, request).promise;
+
+    // https://bit.ly/2K9s9kf says this header should always be available,
+    // but just to be safe:
+    mimeType = response.headers['content-type'];
+    return mimeType ? mimeType.toLowerCase().split(';').shift() : '';
+  }
+
+
+  /**
+   * @param {string} uri
+   * @return {string}
+   * @private
+   */
+  static getExtension_(uri) {
+    const uriObj = new goog.Uri(uri);
+    const uriPieces = uriObj.getPath().split('/');
+    const uriFilename = uriPieces.pop();
+    const filenamePieces = uriFilename.split('.');
+
+    // Only one piece means there is no extension.
+    if (filenamePieces.length == 1) {
+      return '';
+    }
+
+    return filenamePieces.pop().toLowerCase();
+  }
+};
+
+/**
+ * @const {!Object.<string, string>}
+ * @private
+ */
+shaka.net.NetworkingUtils.EXTENSIONS_TO_MIME_TYPES_ = {
+  'mp4': 'video/mp4',
+  'm4v': 'video/mp4',
+  'm4a': 'audio/mp4',
+  'webm': 'video/webm',
+  'weba': 'audio/webm',
+  'mkv': 'video/webm', // Chromium browsers supports it.
+  'ts': 'video/mp2t',
+  'ogv': 'video/ogg',
+  'ogg': 'audio/ogg',
+  'mpg': 'video/mpeg',
+  'mpeg': 'video/mpeg',
+  'm3u8': 'application/x-mpegurl',
+  'mpd': 'application/dash+xml',
+  'ism': 'application/vnd.ms-sstr+xml',
+  'mp3': 'audio/mpeg',
+  'aac': 'audio/aac',
+  'flac': 'audio/flac',
+  'wav': 'audio/wav',
+  'sbv': 'text/x-subviewer',
+  'srt': 'text/srt',
+  'vtt': 'text/vtt',
+  'webvtt': 'text/vtt',
+  'ttml': 'application/ttml+xml',
+  'lrc': 'application/x-subtitle-lrc',
+  'ssa': 'text/x-ssa',
+  'ass': 'text/x-ssa',
+};

package/lib/offline/indexeddb/v1_storage_cell.js

@@ -158,6 +158,7 @@ shaka.offline.indexeddb.V1StorageCell = class
       frameRate: old.frameRate,
       pixelAspectRatio: undefined,
       hdr: undefined,
+      videoLayout: undefined,
       kind: old.kind,
       language: old.language,
       originalLanguage: old.language || null,
@@ -179,6 +180,7 @@ shaka.offline.indexeddb.V1StorageCell = class
       closedCaptions: null,
       tilesLayout: undefined,
       external: false,
+      fastSwitching: false,
     };
   }
 

package/lib/offline/indexeddb/v2_storage_cell.js

@@ -107,6 +107,7 @@ shaka.offline.indexeddb.V2StorageCell = class
       frameRate: old.frameRate,
       pixelAspectRatio: old.pixelAspectRatio,
       hdr: undefined,
+      videoLayout: undefined,
       kind: old.kind,
       language: old.language,
       originalLanguage: old.language || null,
@@ -128,6 +129,7 @@ shaka.offline.indexeddb.V2StorageCell = class
       closedCaptions: null,
       tilesLayout: undefined,
       external: false,
+      fastSwitching: false,
     };
   }
 

package/lib/offline/manifest_converter.js

@@ -190,6 +190,7 @@ shaka.offline.ManifestConverter = class {
       frameRate: streamDB.frameRate,
       pixelAspectRatio: streamDB.pixelAspectRatio,
       hdr: streamDB.hdr,
+      videoLayout: streamDB.videoLayout,
       kind: streamDB.kind,
       encrypted: streamDB.encrypted,
       drmInfos: [],
@@ -210,6 +211,7 @@ shaka.offline.ManifestConverter = class {
       tilesLayout: streamDB.tilesLayout,
       accessibilityPurpose: null,
       external: streamDB.external,
+      fastSwitching: streamDB.fastSwitching,
     };
 
     return stream;

package/lib/offline/offline_manifest_parser.js

@@ -112,6 +112,16 @@ shaka.offline.OfflineManifestParser = class {
       await muxer.destroy();
     }
   }
+
+  /** @override */
+  onInitialVariantChosen(variant) {
+    // No-op
+  }
+
+  /** @override */
+  banLocation(uri) {
+    // No-op
+  }
 };
 
 

package/lib/offline/storage.js

@@ -12,6 +12,7 @@ goog.require('shaka.log');
 goog.require('shaka.media.DrmEngine');
 goog.require('shaka.media.ManifestParser');
 goog.require('shaka.net.NetworkingEngine');
+goog.require('shaka.net.NetworkingUtils');
 goog.require('shaka.offline.DownloadInfo');
 goog.require('shaka.offline.DownloadManager');
 goog.require('shaka.offline.OfflineUri');
@@ -271,10 +272,13 @@ shaka.offline.Storage = class {
       goog.asserts.assert(
           this.networkingEngine_, 'Should not call |store| after |destroy|');
 
-      const factory = await shaka.media.ManifestParser.getFactory(
+      if (!mimeType) {
+        mimeType = await shaka.net.NetworkingUtils.getMimeType(
+            uri, this.networkingEngine_, config.manifest.retryParameters);
+      }
+
+      const factory = shaka.media.ManifestParser.getFactory(
           uri,
-          this.networkingEngine_,
-          config.manifest.retryParameters,
           mimeType || null);
 
       return factory();
@@ -656,20 +660,19 @@ shaka.offline.Storage = class {
     // Filter the manifest based on what we know MediaCapabilities will be able
     // to play later (no point storing something we can't play).
     await shaka.util.StreamUtils.filterManifestByMediaCapabilities(
-        manifest, config.offline.usePersistentLicense);
+        drmEngine, manifest, config.offline.usePersistentLicense);
 
     // Gather all tracks.
     const allTracks = [];
 
     // Choose the codec that has the lowest average bandwidth.
-    const preferredAudioChannelCount = config.preferredAudioChannelCount;
     const preferredDecodingAttributes = config.preferredDecodingAttributes;
     const preferredVideoCodecs = config.preferredVideoCodecs;
     const preferredAudioCodecs = config.preferredAudioCodecs;
 
     shaka.util.StreamUtils.chooseCodecsAndFilterManifest(
         manifest, preferredVideoCodecs, preferredAudioCodecs,
-        preferredAudioChannelCount, preferredDecodingAttributes);
+        preferredDecodingAttributes);
 
     for (const variant of manifest.variants) {
       goog.asserts.assert(
@@ -1230,7 +1233,6 @@ shaka.offline.Storage = class {
     drmEngine.configure(config.drm);
     await drmEngine.initForStorage(
         manifest.variants, config.offline.usePersistentLicense);
-    await drmEngine.setServerCertificate();
     await drmEngine.createOrLoad();
 
     return drmEngine;
@@ -1309,6 +1311,7 @@ shaka.offline.Storage = class {
       frameRate: stream.frameRate,
       pixelAspectRatio: stream.pixelAspectRatio,
       hdr: stream.hdr,
+      videoLayout: stream.videoLayout,
       kind: stream.kind,
       language: stream.language,
       originalLanguage: stream.originalLanguage,
@@ -1327,6 +1330,7 @@ shaka.offline.Storage = class {
       closedCaptions: stream.closedCaptions,
       tilesLayout: stream.tilesLayout,
       external: stream.external,
+      fastSwitching: stream.fastSwitching,
     };
 
     const startTime =