shaka-player 4.1.3 → 4.2.1

package/lib/hls/hls_parser.js

@@ -37,6 +37,7 @@ goog.require('shaka.util.OperationManager');
 goog.require('shaka.util.Pssh');
 goog.require('shaka.util.Timer');
 goog.require('shaka.util.Platform');
+goog.require('shaka.util.Uint8ArrayUtils');
 goog.require('shaka.util.XmlUtils');
 goog.requireType('shaka.hls.Segment');
 
@@ -179,10 +180,6 @@ shaka.hls.HlsParser = class {
      */
     this.groupIdToClosedCaptionsMap_ = new Map();
 
-    /** True if some of the variants in  the playlist is encrypted with AES-128.
-     * @private {boolean} */
-    this.aesEncrypted_ = false;
-
     /** @private {Map.<string, string>} */
     this.groupIdToCodecsMap_ = new Map();
 
@@ -575,7 +572,6 @@ shaka.hls.HlsParser = class {
           playlist, uri, uri, codecs, type, language, primary, name,
           channelsCount, closedCaptions, characteristics, forced, spatialAudio,
           mimeType);
-      goog.asserts.assert(streamInfo != null, 'StreamInfo is null!');
       this.uriToStreamInfosMap_.set(uri, streamInfo);
 
       // Wrap the stream from that stream info with a variant.
@@ -653,17 +649,6 @@ shaka.hls.HlsParser = class {
       this.syncStreamsWithProgramDateTime_();
     }
 
-    if (this.aesEncrypted_ && variants.length == 0) {
-      // We do not support AES-128 encryption with HLS yet. Variants is null
-      // when the playlist is encrypted with AES-128.
-      shaka.log.info('No stream is created, because we don\'t support AES-128',
-          'encryption yet');
-      throw new shaka.util.Error(
-          shaka.util.Error.Severity.CRITICAL,
-          shaka.util.Error.Category.MANIFEST,
-          shaka.util.Error.Code.HLS_AES_128_ENCRYPTION_NOT_SUPPORTED);
-    }
-
     // Find the min and max timestamp of the earliest segment in all streams.
     // Find the minimum duration of all streams as well.
     let minDuration = Infinity;
@@ -862,8 +847,6 @@ shaka.hls.HlsParser = class {
       }
       try {
         const streamInfo = await this.createStreamInfoFromMediaTag_(tag);
-        goog.asserts.assert(
-            streamInfo, 'Should always have a streamInfo for text');
         return streamInfo.stream;
       } catch (e) {
         if (this.config_.hls.ignoreTextStreamFailures) {
@@ -906,8 +889,6 @@ shaka.hls.HlsParser = class {
       }
       try {
         const streamInfo = await this.createStreamInfoFromImageTag_(tag);
-        goog.asserts.assert(
-            streamInfo, 'Should always have a streamInfo for image');
         return streamInfo.stream;
       } catch (e) {
         if (this.config_.hls.ignoreImageStreamFailures) {
@@ -959,22 +940,17 @@ shaka.hls.HlsParser = class {
       const streamInfos = await this.createStreamInfosForVariantTag_(tag,
           resolution, frameRate);
 
-      if (streamInfos) {
-        goog.asserts.assert(streamInfos.audio.length ||
-            streamInfos.video.length, 'We should have created a stream!');
-
-        return this.createVariants_(
-            streamInfos.audio,
-            streamInfos.video,
-            bandwidth,
-            width,
-            height,
-            frameRate,
-            videoRange);
-      }
-      // We do not support AES-128 encryption with HLS yet. If the streamInfos
-      // is null because of AES-128 encryption, do not create variants for that.
-      return [];
+      goog.asserts.assert(streamInfos.audio.length ||
+          streamInfos.video.length, 'We should have created a stream!');
+
+      return this.createVariants_(
+          streamInfos.audio,
+          streamInfos.video,
+          bandwidth,
+          width,
+          height,
+          frameRate,
+          videoRange);
     });
 
     const allVariants = await Promise.all(variantsPromises);
@@ -991,7 +967,7 @@ shaka.hls.HlsParser = class {
    * @param {!shaka.hls.Tag} tag
    * @param {?string} resolution
    * @param {?string} frameRate
-   * @return {!Promise.<?shaka.hls.HlsParser.StreamInfos>}
+   * @return {!Promise.<!shaka.hls.HlsParser.StreamInfos>}
    * @private
    */
   async createStreamInfosForVariantTag_(tag, resolution, frameRate) {
@@ -1061,17 +1037,10 @@ shaka.hls.HlsParser = class {
       type = ContentType.VIDEO;
     }
 
-    let streamInfo;
     if (!ignoreStream) {
-      streamInfo =
+      const streamInfo =
           await this.createStreamInfoFromVariantTag_(tag, allCodecs, type);
-    }
-    if (streamInfo) {
       res[streamInfo.stream.type] = [streamInfo];
-    } else if (streamInfo === null) {
-      // Triple-equals for undefined.
-      shaka.log.debug('streamInfo is null');
-      return null;
     }
     this.filterLegacyCodecs_(res);
     return res;
@@ -1363,7 +1332,7 @@ shaka.hls.HlsParser = class {
    * Parse EXT-X-MEDIA media tag into a Stream object.
    *
    * @param {shaka.hls.Tag} tag
-   * @return {!Promise.<?shaka.hls.HlsParser.StreamInfo>}
+   * @return {!Promise.<!shaka.hls.HlsParser.StreamInfo>}
    * @private
    */
   async createStreamInfoFromMediaTag_(tag) {
@@ -1417,9 +1386,6 @@ shaka.hls.HlsParser = class {
     } else {
       this.groupIdToStreamInfosMap_.set(groupId, [streamInfo]);
     }
-    if (streamInfo == null) {
-      return null;
-    }
 
     // TODO: This check is necessary because of the possibility of multiple
     // calls to createStreamInfoFromMediaTag_ before either has resolved.
@@ -1434,7 +1400,7 @@ shaka.hls.HlsParser = class {
    * Parse EXT-X-MEDIA media tag into a Stream object.
    *
    * @param {shaka.hls.Tag} tag
-   * @return {!Promise.<?shaka.hls.HlsParser.StreamInfo>}
+   * @return {!Promise.<!shaka.hls.HlsParser.StreamInfo>}
    * @private
    */
   async createStreamInfoFromImageTag_(tag) {
@@ -1462,9 +1428,6 @@ shaka.hls.HlsParser = class {
         verbatimImagePlaylistUri, codecs, type, language, /* primary= */ false,
         name, /* channelsCount= */ null, /* closedCaptions= */ null,
         characteristics, /* forced= */ false, /* spatialAudio= */ false);
-    if (streamInfo == null) {
-      return null;
-    }
 
     // TODO: This check is necessary because of the possibility of multiple
     // calls to createStreamInfoFromImageTag_ before either has resolved.
@@ -1505,7 +1468,7 @@ shaka.hls.HlsParser = class {
    * @param {!shaka.hls.Tag} tag
    * @param {!Array.<string>} allCodecs
    * @param {string} type
-   * @return {!Promise.<?shaka.hls.HlsParser.StreamInfo>}
+   * @return {!Promise.<!shaka.hls.HlsParser.StreamInfo>}
    * @private
    */
   async createStreamInfoFromVariantTag_(tag, allCodecs, type) {
@@ -1525,9 +1488,6 @@ shaka.hls.HlsParser = class {
         /* name= */ null, /* channelcount= */ null, closedCaptions,
         /* characteristics= */ null, /* forced= */ false,
         /* spatialAudio= */ false);
-    if (streamInfo == null) {
-      return null;
-    }
     // TODO: This check is necessary because of the possibility of multiple
     // calls to createStreamInfoFromVariantTag_ before either has resolved.
     if (this.uriToStreamInfosMap_.has(verbatimMediaPlaylistUri)) {
@@ -1551,7 +1511,7 @@ shaka.hls.HlsParser = class {
    * @param {?string} characteristics
    * @param {boolean} forced
    * @param {boolean} spatialAudio
-   * @return {!Promise.<?shaka.hls.HlsParser.StreamInfo>}
+   * @return {!Promise.<!shaka.hls.HlsParser.StreamInfo>}
    * @private
    */
   async createStreamInfo_(verbatimMediaPlaylistUri, codecs, type, language,
@@ -1591,7 +1551,7 @@ shaka.hls.HlsParser = class {
    * @param {boolean} forced
    * @param {boolean} spatialAudio
    * @param {(string|undefined)} mimeType
-   * @return {!Promise.<?shaka.hls.HlsParser.StreamInfo>}
+   * @return {!Promise.<!shaka.hls.HlsParser.StreamInfo>}
    * @private
    */
   async convertParsedPlaylistIntoStreamInfo_(playlist, verbatimMediaPlaylistUri,
@@ -1634,6 +1594,8 @@ shaka.hls.HlsParser = class {
     }
 
     let encrypted = false;
+    let aesEncrypted = false;
+
     /** @type {!Array.<shaka.extern.DrmInfo>}*/
     const drmInfos = [];
     const keyIds = new Set();
@@ -1644,34 +1606,30 @@ shaka.hls.HlsParser = class {
       if (method != 'NONE') {
         encrypted = true;
 
-        // We do not support AES-128 encryption with HLS yet. So, do not create
-        // StreamInfo for the playlist encrypted with AES-128.
-        // TODO: Remove the error message once we add support for AES-128.
         if (method == 'AES-128') {
-          shaka.log.warning('Unsupported HLS Encryption', method);
-          this.aesEncrypted_ = true;
-          return null;
-        }
-
-        const keyFormat = drmTag.getRequiredAttrValue('KEYFORMAT');
-        const drmParser =
-            shaka.hls.HlsParser.KEYFORMATS_TO_DRM_PARSERS_[keyFormat];
-
-        const drmInfo = drmParser ? drmParser(drmTag, mimeType) : null;
-        if (drmInfo) {
-          if (drmInfo.keyIds) {
-            for (const keyId of drmInfo.keyIds) {
-              keyIds.add(keyId);
+          // These keys are handled separately.
+          aesEncrypted = true;
+        } else {
+          const keyFormat = drmTag.getRequiredAttrValue('KEYFORMAT');
+          const drmParser =
+              shaka.hls.HlsParser.KEYFORMATS_TO_DRM_PARSERS_[keyFormat];
+
+          const drmInfo = drmParser ? drmParser(drmTag, mimeType) : null;
+          if (drmInfo) {
+            if (drmInfo.keyIds) {
+              for (const keyId of drmInfo.keyIds) {
+                keyIds.add(keyId);
+              }
             }
+            drmInfos.push(drmInfo);
+          } else {
+            shaka.log.warning('Unsupported HLS KEYFORMAT', keyFormat);
           }
-          drmInfos.push(drmInfo);
-        } else {
-          shaka.log.warning('Unsupported HLS KEYFORMAT', keyFormat);
         }
       }
     }
 
-    if (encrypted && !drmInfos.length) {
+    if (encrypted && !drmInfos.length && !aesEncrypted) {
       throw new shaka.util.Error(
           shaka.util.Error.Severity.CRITICAL,
           shaka.util.Error.Category.MANIFEST,
@@ -1686,20 +1644,8 @@ shaka.hls.HlsParser = class {
     /** @type {!Map.<number, number>} */
     const mediaSequenceToStartTime = new Map();
 
-    let segments;
-    try {
-      segments = this.createSegments_(verbatimMediaPlaylistUri,
-          playlist, type, mimeType, mediaSequenceToStartTime, mediaVariables,
-          codecs);
-    } catch (error) {
-      if (error.code == shaka.util.Error.Code.HLS_INTERNAL_SKIP_STREAM) {
-        shaka.log.alwaysWarn('Skipping unsupported HLS stream',
-            mimeType, verbatimMediaPlaylistUri);
-        return null;
-      }
-
-      throw error;
-    }
+    const segments = this.createSegments_(verbatimMediaPlaylistUri, playlist,
+        type, mimeType, mediaSequenceToStartTime, mediaVariables, codecs);
 
     const lastEndTime = segments[segments.length - 1].endTime;
     /** @type {!shaka.media.SegmentIndex} */
@@ -1765,6 +1711,78 @@ shaka.hls.HlsParser = class {
   }
 
 
+  /**
+   * @param {!shaka.hls.Tag} drmTag
+   * @param {!shaka.hls.Playlist} playlist
+   * @return {!shaka.extern.HlsAes128Key}
+   * @private
+   */
+  parseAES128DrmTag_(drmTag, playlist) {
+    // Check if the Web Crypto API is available.
+    if (!window.crypto || !window.crypto.subtle) {
+      shaka.log.alwaysWarn('Web Crypto API is not available to decrypt ' +
+          'AES-128. (Web Crypto only exists in secure origins like https)');
+      throw new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.MANIFEST,
+          shaka.util.Error.Code.NO_WEB_CRYPTO_API);
+    }
+
+    // HLS RFC 8216 Section 5.2:
+    // An EXT-X-KEY tag with a KEYFORMAT of "identity" that does not have an IV
+    // attribute indicates that the Media Sequence Number is to be used as the
+    // IV when decrypting a Media Segment, by putting its big-endian binary
+    // representation into a 16-octet (128-bit) buffer and padding (on the left)
+    // with zeros.
+    let firstMediaSequenceNumber = 0;
+    let iv;
+    const ivHex = drmTag.getAttributeValue('IV', '');
+    if (!ivHex) {
+      // Media Sequence Number will be used as IV.
+      firstMediaSequenceNumber = shaka.hls.Utils.getFirstTagWithNameAsNumber(
+          playlist.tags, 'EXT-X-MEDIA-SEQUENCE', 0);
+    } else {
+      // Exclude 0x at the start of string.
+      iv = shaka.util.Uint8ArrayUtils.fromHex(ivHex.substr(2));
+      if (iv.byteLength != 16) {
+        throw new shaka.util.Error(
+            shaka.util.Error.Severity.CRITICAL,
+            shaka.util.Error.Category.MANIFEST,
+            shaka.util.Error.Code.HLS_AES_128_INVALID_IV_LENGTH);
+      }
+    }
+
+    const keyUri = shaka.hls.Utils.constructAbsoluteUri(
+        playlist.absoluteUri, drmTag.getRequiredAttrValue('URI'));
+
+    const requestType = shaka.net.NetworkingEngine.RequestType.KEY;
+    const request = shaka.net.NetworkingEngine.makeRequest(
+        [keyUri], this.config_.retryParameters);
+
+    const keyInfo = {method: 'AES-128', iv, firstMediaSequenceNumber};
+
+    // Don't download the key object until the segment is parsed, to avoid a
+    // startup delay for long manifests with lots of keys.
+    keyInfo.fetchKey = async () => {
+      const keyResponse = await this.makeNetworkRequest_(request, requestType);
+
+      // keyResponse.status is undefined when URI is "data:text/plain;base64,"
+      if (!keyResponse.data || keyResponse.data.byteLength != 16) {
+        throw new shaka.util.Error(
+            shaka.util.Error.Severity.CRITICAL,
+            shaka.util.Error.Category.MANIFEST,
+            shaka.util.Error.Code.HLS_AES_128_INVALID_KEY_LENGTH);
+      }
+
+      keyInfo.cryptoKey = await window.crypto.subtle.importKey(
+          'raw', keyResponse.data, 'AES-CBC', true, ['decrypt']);
+      keyInfo.fetchKey = undefined; // No longer needed.
+    };
+
+    return keyInfo;
+  }
+
+
   /**
    * @param {!shaka.hls.Playlist} playlist
    * @private
@@ -1939,12 +1957,13 @@ shaka.hls.HlsParser = class {
    * @param {!Map.<string, string>} variables
    * @param {string} absoluteMediaPlaylistUri
    * @param {string} type
+   * @param {shaka.extern.HlsAes128Key=} hlsAes128Key
    * @return {shaka.media.SegmentReference}
    * @private
    */
   createSegmentReference_(
       initSegmentReference, previousReference, hlsSegment, startTime,
-      variables, absoluteMediaPlaylistUri, type) {
+      variables, absoluteMediaPlaylistUri, type, hlsAes128Key) {
     const tags = hlsSegment.tags;
     const absoluteSegmentUri = this.variableSubstitution_(
         hlsSegment.absoluteUri, variables);
@@ -2039,6 +2058,8 @@ shaka.hls.HlsParser = class {
           partialStatus = shaka.media.SegmentReference.Status.MISSING;
         }
 
+        // We do not set the AES-128 key information for partial segments, as we
+        // do not support AES-128 and low-latency at the same time.
         const partial = new shaka.media.SegmentReference(
             pStartTime,
             pEndTime,
@@ -2120,6 +2141,7 @@ shaka.hls.HlsParser = class {
         tileDuration,
         syncTime,
         status,
+        hlsAes128Key,
     );
   }
 
@@ -2186,6 +2208,9 @@ shaka.hls.HlsParser = class {
     /** @type {shaka.media.InitSegmentReference} */
     let initSegmentRef;
 
+    /** @type {shaka.extern.HlsAes128Key|undefined} */
+    let hlsAes128Key = undefined;
+
     // We may need to look at the media itself to determine a segment start
     // time.
     const mediaSequenceNumber = shaka.hls.Utils.getFirstTagWithNameAsNumber(
@@ -2214,6 +2239,14 @@ shaka.hls.HlsParser = class {
           (i == 0) ? firstStartTime : previousReference.endTime;
       position = mediaSequenceNumber + skippedSegments + i;
 
+      // Apply new AES-128 tags as you see them, keeping a running total.
+      for (const drmTag of item.tags) {
+        if (drmTag.name == 'EXT-X-KEY' &&
+            drmTag.getRequiredAttrValue('METHOD') == 'AES-128') {
+          hlsAes128Key = this.parseAES128DrmTag_(drmTag, playlist);
+        }
+      }
+
       mediaSequenceToStartTime.set(position, startTime);
 
       initSegmentRef = this.getInitSegmentReference_(playlist.absoluteUri,
@@ -2238,7 +2271,8 @@ shaka.hls.HlsParser = class {
           startTime,
           variables,
           playlist.absoluteUri,
-          type);
+          type,
+          hlsAes128Key);
       previousReference = reference;
 
       if (reference) {
@@ -2611,6 +2645,14 @@ shaka.hls.HlsParser = class {
           shaka.util.Error.Code.HLS_MSE_ENCRYPTED_MP2T_NOT_SUPPORTED);
     }
 
+    if (shaka.util.Platform.isMediaKeysPolyfilled()) {
+      throw new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.MANIFEST,
+          shaka.util.Error.Code
+              .HLS_MSE_ENCRYPTED_LEGACY_APPLE_MEDIA_KEYS_NOT_SUPPORTED);
+    }
+
     /*
      * Even if we're not able to construct initData through the HLS tag, adding
      * a DRMInfo will allow DRM Engine to request a media key system access

package/lib/media/drm_engine.js

@@ -1668,8 +1668,6 @@ shaka.media.DrmEngine = class {
       'com.widevine.alpha',
       'com.microsoft.playready',
       'com.microsoft.playready.recommendation',
-      'com.apple.fps.3_0',
-      'com.apple.fps.2_0',
       'com.apple.fps.1_0',
       'com.apple.fps',
       'com.adobe.primetime',

package/lib/media/segment_index.js

@@ -529,6 +529,14 @@ shaka.media.SegmentIterator = class {
     this.currentPartialPosition_ = partialSegmentIndex;
   }
 
+  /**
+   * @return {number}
+   * @export
+   */
+  currentPosition() {
+    return this.currentPosition_;
+  }
+
   /**
    * @return {shaka.media.SegmentReference}
    * @export

package/lib/media/segment_reference.js

@@ -166,12 +166,15 @@ shaka.media.SegmentReference = class {
    * @param {shaka.media.SegmentReference.Status=} status
    *  The segment status is used to indicate that a segment does not exist or is
    *  not available.
+   * @param {?shaka.extern.HlsAes128Key=} hlsAes128Key
+   *  The segment's AES-128-CBC full segment encryption key and iv.
    */
   constructor(
       startTime, endTime, uris, startByte, endByte, initSegmentReference,
       timestampOffset, appendWindowStart, appendWindowEnd,
       partialReferences = [], tilesLayout = '', tileDuration = null,
-      syncTime = null, status = shaka.media.SegmentReference.Status.AVAILABLE) {
+      syncTime = null, status = shaka.media.SegmentReference.Status.AVAILABLE,
+      hlsAes128Key = null) {
     // A preload hinted Partial Segment has the same startTime and endTime.
     goog.asserts.assert(startTime <= endTime,
         'startTime must be less than or equal to endTime');
@@ -233,6 +236,9 @@ shaka.media.SegmentReference = class {
 
     /** @type {shaka.media.SegmentReference.Status} */
     this.status = status;
+
+    /** @type {?shaka.extern.HlsAes128Key} */
+    this.hlsAes128Key = hlsAes128Key;
   }
 
   /**

package/lib/media/streaming_engine.js

@@ -1233,7 +1233,10 @@ shaka.media.StreamingEngine = class {
               stream.mimeType == 'audio/mp4';
       const isReadableStreamSupported = window.ReadableStream;
       // Enable MP4 low latency streaming with ReadableStream chunked data.
-      if (this.config_.lowLatencyMode && isReadableStreamSupported && isMP4) {
+      // Disabled when AES-128 is present, as we cannot decrypt part of a
+      // segment.
+      if (this.config_.lowLatencyMode && isReadableStreamSupported && isMP4 &&
+          !reference.hlsAes128Key) {
         let remaining = new Uint8Array(0);
         const streamDataCallback = async (data) => {
           this.destroyer_.ensureNotDestroyed();
@@ -1273,11 +1276,16 @@ shaka.media.StreamingEngine = class {
             'ReadableStream is not supported by the browser.');
         }
         const fetchSegment = this.fetch_(mediaState, reference);
-        const result = await fetchSegment;
+        let result = await fetchSegment;
         this.destroyer_.ensureNotDestroyed();
         if (this.fatalError_) {
           return;
         }
+        if (reference.hlsAes128Key) {
+          goog.asserts.assert(iter, 'mediaState.segmentIterator should exist');
+          result = await this.aes128Decrypt_(result, reference, iter);
+        }
+        this.destroyer_.ensureNotDestroyed();
 
         // If the text stream gets switched between fetch_() and append_(), the
         // new text parser is initialized, but the new init segment is not
@@ -1368,6 +1376,34 @@ shaka.media.StreamingEngine = class {
     }
   }
 
+  /**
+   * @param {!BufferSource} rawResult
+   * @param {!shaka.media.SegmentReference} reference
+   * @param {!shaka.media.SegmentIterator} iter
+   * @return {!Promise.<!BufferSource>} finalResult
+   * @private
+   */
+  async aes128Decrypt_(rawResult, reference, iter) {
+    const key = reference.hlsAes128Key;
+    if (!key.cryptoKey) {
+      goog.asserts.assert(key.fetchKey, 'If AES-128 cryptoKey was not ' +
+          'preloaded, fetchKey function should be provided');
+      await key.fetchKey();
+      goog.asserts.assert(key.cryptoKey, 'AES-128 cryptoKey should now be set');
+    }
+    let iv = key.iv;
+    if (!iv) {
+      iv = shaka.util.BufferUtils.toUint8(new ArrayBuffer(16));
+      let sequence = key.firstMediaSequenceNumber + iter.currentPosition();
+      for (let i = iv.byteLength - 1; i >= 0; i--) {
+        iv[i] = sequence & 0xff;
+        sequence >>= 8;
+      }
+    }
+    return window.crypto.subtle.decrypt(
+        {name: 'AES-CBC', iv}, key.cryptoKey, rawResult);
+  }
+
 
   /**
    * Clear per-stream error states and retry any failed streams.

package/lib/net/networking_engine.js

@@ -749,6 +749,7 @@ shaka.net.NetworkingEngine.RequestType = {
   'APP': 3,
   'TIMING': 4,
   'SERVER_CERTIFICATE': 5,
+  'KEY': 6,
 };
 
 

package/lib/player.js

@@ -1948,6 +1948,12 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     if (!this.abrManager_ || this.abrManagerFactory_ != abrFactory) {
       this.abrManagerFactory_ = abrFactory;
       this.abrManager_ = abrFactory();
+      if (typeof this.abrManager_.setMediaElement != 'function') {
+        shaka.Deprecate.deprecateFeature(5,
+            'AbrManager',
+            'Please use an AbrManager with setMediaElement function.');
+        this.abrManager_.setMediaElement = () => {};
+      }
       this.abrManager_.configure(this.config_.abr);
     }
 
@@ -1970,6 +1976,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     this.abrManager_.init((variant, clearBuffer, safeMargin) => {
       return this.switch_(variant, clearBuffer, safeMargin);
     });
+    this.abrManager_.setMediaElement(mediaElement);
 
     this.playhead_ = this.createPlayhead(has.startTime);
     this.playheadObservers_ = this.createPlayheadObserversForMSE_();
@@ -4452,6 +4459,12 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       this.stats_.setBandwidthEstimate(estimate);
     }
 
+    if (this.loadMode_ == shaka.Player.LoadMode.SRC_EQUALS) {
+      this.stats_.setResolution(
+          /* width= */ element.videoWidth || NaN,
+          /* height= */ element.videoHeight || NaN);
+    }
+
     return this.stats_.getBlob();
   }
 
@@ -5618,6 +5631,12 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       return false;
     }
 
+    if (!navigator.onLine) {
+      // Don't restrict variants if we're completely offline, or else we end up
+      // rapidly restricting all of them.
+      return false;
+    }
+
     let maxDisabledTime = this.config_.streaming.maxDisabledTime;
     if (maxDisabledTime == 0) {
       if (error.code == shaka.util.Error.Code.SEGMENT_MISSING) {
@@ -6551,7 +6570,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @define {string} A version number taken from git at compile time.
  * @export
  */
-shaka.Player.version = 'v4.1.3-uncompiled';
+shaka.Player.version = 'v4.2.1-uncompiled';
 
 // Initialize the deprecation system using the version string we just set
 // on the player.