shaka-player 4.1.1 → 4.2.0

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');
 
@@ -740,8 +741,14 @@ shaka.hls.HlsParser = class {
     for (const stream of streamsToNotify) {
       this.segmentsToNotifyByStream_.push(stream.segmentIndex.references);
     }
+
     this.notifySegments_();
 
+    // This is the first point where we have a meaningful presentation start
+    // time, and we need to tell PresentationTimeline that so that it can
+    // maintain consistency from here on.
+    this.presentationTimeline_.lockStartTime();
+
     // This asserts that the live edge is being calculated from segment times.
     // For VOD and event streams, this check should still pass.
     goog.asserts.assert(
@@ -1638,34 +1645,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);
+          // These keys are handled separately.
           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);
+        } 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 && !this.aesEncrypted_) {
       throw new shaka.util.Error(
           shaka.util.Error.Severity.CRITICAL,
           shaka.util.Error.Category.MANIFEST,
@@ -1682,9 +1685,8 @@ shaka.hls.HlsParser = class {
 
     let segments;
     try {
-      segments = this.createSegments_(verbatimMediaPlaylistUri,
-          playlist, type, mimeType, mediaSequenceToStartTime, mediaVariables,
-          codecs);
+      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',
@@ -1759,6 +1761,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
@@ -1859,8 +1933,6 @@ shaka.hls.HlsParser = class {
       /* presentationStartTime= */ null, /* delay= */ 0);
       this.presentationTimeline_.setStatic(true);
     }
-
-    this.notifySegments_();
   }
 
   /**
@@ -1935,12 +2007,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);
@@ -2035,6 +2108,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,
@@ -2116,6 +2191,7 @@ shaka.hls.HlsParser = class {
         tileDuration,
         syncTime,
         status,
+        hlsAes128Key,
     );
   }
 
@@ -2182,6 +2258,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(
@@ -2210,6 +2289,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,
@@ -2234,7 +2321,8 @@ shaka.hls.HlsParser = class {
           startTime,
           variables,
           playlist.absoluteUri,
-          type);
+          type,
+          hlsAes128Key);
       previousReference = reference;
 
       if (reference) {
@@ -2607,6 +2695,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

@@ -1548,7 +1548,7 @@ shaka.media.DrmEngine = class {
       if (shaka.media.DrmEngine.isPlayReadyKeySystem(
           this.currentDrmInfo_.keySystem) &&
           keyId.byteLength == 16 &&
-          shaka.util.Platform.isEdge()) {
+          (shaka.util.Platform.isEdge() || shaka.util.Platform.isPS4())) {
         // Read out some fields in little-endian:
         const dataView = shaka.util.BufferUtils.toDataView(keyId);
         const part0 = dataView.getUint32(0, /* LE= */ true);
@@ -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/media_source_engine.js

@@ -10,6 +10,7 @@ goog.require('goog.asserts');
 goog.require('shaka.log');
 goog.require('shaka.media.ContentWorkarounds');
 goog.require('shaka.media.IClosedCaptionParser');
+goog.require('shaka.media.SegmentReference');
 goog.require('shaka.media.TimeRangesUtils');
 goog.require('shaka.media.Transmuxer');
 goog.require('shaka.text.TextEngine');
@@ -466,13 +467,13 @@ shaka.media.MediaSourceEngine = class {
    */
   getBufferedInfo() {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
-    const TimeRangeUtils = shaka.media.TimeRangesUtils;
+    const TimeRangesUtils = shaka.media.TimeRangesUtils;
 
     const info = {
-      total: TimeRangeUtils.getBufferedInfo(this.video_.buffered),
-      audio: TimeRangeUtils.getBufferedInfo(
+      total: TimeRangesUtils.getBufferedInfo(this.video_.buffered),
+      audio: TimeRangesUtils.getBufferedInfo(
           this.getBuffered_(ContentType.AUDIO)),
-      video: TimeRangeUtils.getBufferedInfo(
+      video: TimeRangesUtils.getBufferedInfo(
           this.getBuffered_(ContentType.VIDEO)),
       text: [],
     };
@@ -516,15 +517,14 @@ shaka.media.MediaSourceEngine = class {
    *
    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
    * @param {!BufferSource} data
-   * @param {?number} startTime relative to the start of the presentation
-   * @param {?number} endTime relative to the start of the presentation
+   * @param {?shaka.media.SegmentReference} reference The segment reference
+   *   we are appending, or null for init segments
    * @param {?boolean} hasClosedCaptions True if the buffer contains CEA closed
-   * captions
+   *   captions
    * @param {boolean=} seeked True if we just seeked
    * @return {!Promise}
    */
-  async appendBuffer(
-      contentType, data, startTime, endTime, hasClosedCaptions, seeked) {
+  async appendBuffer(contentType, data, reference, hasClosedCaptions, seeked) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
     if (contentType == ContentType.TEXT) {
@@ -533,7 +533,10 @@ shaka.media.MediaSourceEngine = class {
         const offset = await this.textSequenceModeOffset_;
         this.textEngine_.setTimestampOffset(offset);
       }
-      await this.textEngine_.appendBuffer(data, startTime, endTime);
+      await this.textEngine_.appendBuffer(
+          data,
+          reference ? reference.startTime : null,
+          reference ? reference.endTime : null);
       return;
     }
 
@@ -549,7 +552,10 @@ shaka.media.MediaSourceEngine = class {
       if (transmuxedData.metadata) {
         const timestampOffset =
             this.sourceBuffers_[contentType].timestampOffset;
-        this.onMetadata_(transmuxedData.metadata, timestampOffset, endTime);
+        this.onMetadata_(
+            transmuxedData.metadata,
+            timestampOffset,
+            reference ? reference.endTime : null);
       }
       // This doesn't work for native TS support (ex. Edge/Chromecast),
       // since no transmuxing is needed for native TS.
@@ -559,7 +565,10 @@ shaka.media.MediaSourceEngine = class {
         const closedCaptions = this.textEngine_
             .convertMuxjsCaptionsToShakaCaptions(transmuxedData.captions);
         this.textEngine_.storeAndAppendClosedCaptions(
-            closedCaptions, startTime, endTime, videoOffset);
+            closedCaptions,
+            reference ? reference.startTime : null,
+            reference ? reference.endTime : null,
+            videoOffset);
       }
 
       data = transmuxedData.data;
@@ -569,7 +578,7 @@ shaka.media.MediaSourceEngine = class {
       }
       // If it is the init segment for closed captions, initialize the closed
       // caption parser.
-      if (startTime == null && endTime == null) {
+      if (!reference) {
         this.captionParser_.init(data);
       } else {
         const closedCaptions = this.captionParser_.parseFrom(data);
@@ -577,18 +586,21 @@ shaka.media.MediaSourceEngine = class {
           const videoOffset =
             this.sourceBuffers_[ContentType.VIDEO].timestampOffset;
           this.textEngine_.storeAndAppendClosedCaptions(
-              closedCaptions, startTime, endTime, videoOffset);
+              closedCaptions,
+              reference.startTime,
+              reference.endTime,
+              videoOffset);
         }
       }
     }
 
-    data = this.workAroundBrokenPlatforms_(data, startTime, contentType);
+    data = this.workAroundBrokenPlatforms_(
+        data, reference ? reference.startTime : null, contentType);
 
     const sourceBuffer = this.sourceBuffers_[contentType];
     const SEQUENCE = shaka.media.MediaSourceEngine.SourceBufferMode_.SEQUENCE;
 
-    if (this.sequenceMode_ && sourceBuffer.mode != SEQUENCE &&
-        startTime != null) {
+    if (this.sequenceMode_ && sourceBuffer.mode != SEQUENCE && reference) {
       // This is the first media segment to be appended to a SourceBuffer in
       // sequence mode.  We set the mode late so that we can trick MediaSource
       // into extracting a timestamp for us to align text segments in sequence
@@ -623,7 +635,7 @@ shaka.media.MediaSourceEngine = class {
         // segments.
         const mediaStartTime = shaka.media.TimeRangesUtils.bufferStart(
             this.getBuffered_(contentType));
-        const textOffset = (startTime || 0) - (mediaStartTime || 0);
+        const textOffset = (reference.startTime || 0) - (mediaStartTime || 0);
         this.textSequenceModeOffset_.resolve(textOffset);
 
         // Finally, clear the buffer.
@@ -636,22 +648,43 @@ shaka.media.MediaSourceEngine = class {
       sourceBuffer.mode = SEQUENCE;
     }
 
-    if (startTime != null && this.sequenceMode_ &&
-        contentType != ContentType.TEXT) {
+    if (reference && this.sequenceMode_ && contentType != ContentType.TEXT) {
       // In sequence mode, for non-text streams, if we just cleared the buffer
       // and are performing an unbuffered seek, we need to set a new
       // timestampOffset on the sourceBuffer.
       if (seeked) {
-        const timestampOffset = /** @type {number} */ (startTime);
+        const timestampOffset = reference.startTime;
         this.enqueueOperation_(
             contentType,
             () => this.setTimestampOffset_(contentType, timestampOffset));
       }
     }
 
-    await this.enqueueOperation_(
-        contentType,
-        () => this.append_(contentType, data));
+    let bufferedBefore = null;
+
+    await this.enqueueOperation_(contentType, () => {
+      if (goog.DEBUG && reference) {
+        bufferedBefore = this.getBuffered_(contentType);
+      }
+      this.append_(contentType, data);
+    });
+
+    if (goog.DEBUG && reference) {
+      const bufferedAfter = this.getBuffered_(contentType);
+      const newBuffered = shaka.media.TimeRangesUtils.computeAddedRange(
+          bufferedBefore, bufferedAfter);
+      if (newBuffered) {
+        const segmentDuration = reference.endTime - reference.startTime;
+        if (Math.abs(newBuffered.start - reference.startTime) >
+            segmentDuration / 2) {
+          shaka.log.error('Possible encoding problem detected!',
+              'Unexpected buffered range for reference', reference,
+              'from URIs', reference.getUris(),
+              'should be', {start: reference.startTime, end: reference.endTime},
+              'but got', newBuffered);
+        }
+      }
+    }
   }
 
   /**

package/lib/media/presentation_timeline.js

@@ -93,6 +93,9 @@ shaka.media.PresentationTimeline = class {
      * @private {number}
      */
     this.availabilityTimeOffset_ = 0;
+
+    /** @private {boolean} */
+    this.startTimeLocked_ = false;
   }
 
 
@@ -229,7 +232,8 @@ shaka.media.PresentationTimeline = class {
     this.maxSegmentEndTime_ =
         Math.max(this.maxSegmentEndTime_, lastReferenceEndTime);
 
-    if (this.presentationStartTime_ != null && this.autoCorrectDrift_) {
+    if (this.presentationStartTime_ != null && this.autoCorrectDrift_ &&
+        !this.startTimeLocked_) {
       // Since we have explicit segment end times, calculate a presentation
       // start based on them.  This start time accounts for drift.
       // Date.now() is in milliseconds, from which we compute "now" in seconds.
@@ -243,6 +247,25 @@ shaka.media.PresentationTimeline = class {
   }
 
 
+  /**
+   * Lock the presentation timeline's start time.  After this is called, no
+   * further adjustments to presentationStartTime_ will be permitted.
+   *
+   * This should be called after all Periods have been parsed, and all calls to
+   * notifySegments() from the initial manifest parse have been made.
+   *
+   * Without this, we can get assertion failures in SegmentIndex for certain
+   * DAI content.  If DAI adds ad segments to the manifest faster than
+   * real-time, adjustments to presentationStartTime_ can cause availability
+   * windows to jump around on updates.
+   *
+   * @export
+   */
+  lockStartTime() {
+    this.startTimeLocked_ = true;
+  }
+
+
   /**
    * Gives PresentationTimeline a Stream's minimum segment start time.
    *

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.
@@ -1555,8 +1591,8 @@ shaka.media.StreamingEngine = class {
             const hasClosedCaptions = mediaState.stream.closedCaptions &&
                 mediaState.stream.closedCaptions.size > 0;
             await this.playerInterface_.mediaSourceEngine.appendBuffer(
-                mediaState.type, initSegment, /* startTime= */ null,
-                /* endTime= */ null, hasClosedCaptions);
+                mediaState.type, initSegment, /* reference= */ null,
+                hasClosedCaptions);
           } catch (error) {
             mediaState.lastInitSegmentReference = null;
             throw error;
@@ -1609,8 +1645,7 @@ shaka.media.StreamingEngine = class {
     await this.playerInterface_.mediaSourceEngine.appendBuffer(
         mediaState.type,
         segment,
-        reference.startTime,
-        reference.endTime,
+        reference,
         hasClosedCaptions,
         seeked);
     this.destroyer_.ensureNotDestroyed();
@@ -1791,6 +1826,7 @@ shaka.media.StreamingEngine = class {
    *
    * @return {!Promise.<BufferSource>}
    * @private
+   * @suppress {strictMissingProperties}
    */
   async fetch_(mediaState, reference, streamDataCallback) {
     const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;

package/lib/media/time_ranges_utils.js

@@ -155,4 +155,50 @@ shaka.media.TimeRangesUtils = class {
     }
     return ret;
   }
+
+  /**
+   * This operation can be potentially EXPENSIVE and should only be done in
+   * debug builds for debugging purposes.
+   *
+   * @param {TimeRanges} oldRanges
+   * @param {TimeRanges} newRanges
+   * @return {?shaka.extern.BufferedRange} The last added range,
+   *   chronologically by presentation time.
+   */
+  static computeAddedRange(oldRanges, newRanges) {
+    const TimeRangesUtils = shaka.media.TimeRangesUtils;
+
+    if (!oldRanges || !oldRanges.length) {
+      return null;
+    }
+    if (!newRanges || !newRanges.length) {
+      return TimeRangesUtils.getBufferedInfo(newRanges).pop();
+    }
+
+    const newRangesReversed =
+        TimeRangesUtils.getBufferedInfo(newRanges).reverse();
+    const oldRangesReversed =
+        TimeRangesUtils.getBufferedInfo(oldRanges).reverse();
+    for (const newRange of newRangesReversed) {
+      let foundOverlap = false;
+
+      for (const oldRange of oldRangesReversed) {
+        if (oldRange.end >= newRange.start && oldRange.end <= newRange.end) {
+          foundOverlap = true;
+
+          // If the new range goes beyond the corresponding old one, the
+          // difference is newly-added.
+          if (newRange.end > oldRange.end) {
+            return {start: oldRange.end, end: newRange.end};
+          }
+        }
+      }
+
+      if (!foundOverlap) {
+        return newRange;
+      }
+    }
+
+    return null;
+  }
 };