shaka-player 4.12.4 → 4.12.6

package/lib/media/media_source_engine.js

@@ -333,6 +333,11 @@ shaka.media.MediaSourceEngine = class {
     for (const ref of stream.segmentIndex) {
       const mimeType = ref.mimeType || stream.mimeType || '';
       let codecs = ref.codecs || stream.codecs || '';
+      // Optimization for the case where the codecs and mimetype of the stream
+      // match the reference.
+      if (mimeType == stream.mimeType && codecs == stream.codecs) {
+        continue;
+      }
       // Don't check the same combination of mimetype + codecs twice.
       const combo = mimeType + ':' + codecs;
       if (seenCombos.has(combo)) {
@@ -466,12 +471,12 @@ shaka.media.MediaSourceEngine = class {
       cleanup.push(this.textEngine_.destroy());
     }
 
+    await Promise.all(cleanup);
+
     for (const contentType in this.transmuxers_) {
-      cleanup.push(this.transmuxers_[contentType].destroy());
+      this.transmuxers_[contentType].destroy();
     }
 
-
-    await Promise.all(cleanup);
     if (this.eventManager_) {
       this.eventManager_.release();
       this.eventManager_ = null;
@@ -551,6 +556,13 @@ shaka.media.MediaSourceEngine = class {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
     await this.mediaSourceOpen_;
+    if (this.ended() || this.closed()) {
+      shaka.log.alwaysError('Expected MediaSource to be open during init(); ' +
+          'reopening the media source.');
+      this.mediaSourceOpen_ = new shaka.util.PublicPromise();
+      this.mediaSource_ = this.createMediaSource(this.mediaSourceOpen_);
+      await this.mediaSourceOpen_;
+    }
 
     this.sequenceMode_ = sequenceMode;
     this.manifestType_ = manifestType;
@@ -692,7 +704,8 @@ shaka.media.MediaSourceEngine = class {
    * @return {boolean}
    */
   isStreamingAllowed() {
-    return this.streamingAllowed_ && !this.usingRemotePlayback_;
+    return this.streamingAllowed_ && !this.usingRemotePlayback_ &&
+        !this.reloadingMediaSource_;
   }
 
   /**
@@ -723,6 +736,17 @@ shaka.media.MediaSourceEngine = class {
     return this.mediaSource_ ? this.mediaSource_.readyState == 'ended' : true;
   }
 
+  /**
+   * @return {boolean} True if the MediaSource is in an "closed" state, or if
+   *   the object has been destroyed.
+   */
+  closed() {
+    if (this.reloadingMediaSource_) {
+      return false;
+    }
+    return this.mediaSource_ ? this.mediaSource_.readyState == 'closed' : true;
+  }
+
   /**
    * Gets the first timestamp in buffer for the given content type.
    *
@@ -1209,7 +1233,16 @@ shaka.media.MediaSourceEngine = class {
             this.audioCompensation_.resolve(compensation);
           }
         }
-        const calculatedTimestampOffset = reference.startTime - timestamp;
+        let realTimestamp = timestamp;
+        const RAW_FORMATS = shaka.util.MimeUtils.RAW_FORMATS;
+        // For formats without containers and using segments mode, we need to
+        // adjust TimestampOffset relative to 0 because segments do not have
+        // any timestamp information.
+        if (!this.sequenceMode_ &&
+            RAW_FORMATS.includes(this.sourceBufferTypes_[contentType])) {
+          realTimestamp = 0;
+        }
+        const calculatedTimestampOffset = reference.startTime - realTimestamp;
         const timestampOffsetDifference =
             Math.abs(timestampOffset - calculatedTimestampOffset);
         if ((timestampOffsetDifference >= 0.001 || seeked || adaptation) &&
@@ -1566,6 +1599,13 @@ shaka.media.MediaSourceEngine = class {
       return;
     }
 
+    // Avoid changing timestampOffset when the difference is less than 100 ms
+    // from the end of the current buffer.
+    const bufferEnd = this.bufferEnd(contentType);
+    if (bufferEnd && Math.abs(bufferEnd - timestampOffset) < 0.1) {
+      return;
+    }
+
     // Queue an abort() to help MSE splice together overlapping segments.
     // We set appendWindowEnd when we change periods in DASH content, and the
     // period transition may result in overlap.
@@ -1607,7 +1647,7 @@ shaka.media.MediaSourceEngine = class {
       // don't call it again. Also do not call if readyState is
       // 'closed' (not attached to video element) since it is not a
       // valid operation.
-      if (this.ended() || this.mediaSource_.readyState === 'closed') {
+      if (this.ended() || this.closed()) {
         return;
       }
       // Tizen won't let us pass undefined, but it will let us omit the
@@ -1859,11 +1899,13 @@ shaka.media.MediaSourceEngine = class {
 
     /** @type {!Array.<!shaka.util.PublicPromise>} */
     const allWaiters = [];
+    /** @type {!Array.<!shaka.util.ManifestParserUtils.ContentType>} */
+    const contentTypes = Object.keys(this.sourceBuffers_);
 
     // Enqueue a 'wait' operation onto each queue.
     // This operation signals its readiness when it starts.
     // When all wait operations are ready, the real operation takes place.
-    for (const contentType in this.sourceBuffers_) {
+    for (const contentType of contentTypes) {
       const ready = new shaka.util.PublicPromise();
       const operation = {
         start: () => ready.resolve(),
@@ -1893,7 +1935,7 @@ shaka.media.MediaSourceEngine = class {
       // assert at the end of destroy passes.  In compiled mode, the queues
       // are wiped in destroy.
       if (goog.DEBUG) {
-        for (const contentType in this.sourceBuffers_) {
+        for (const contentType of contentTypes) {
           if (this.queues_[contentType].length) {
             goog.asserts.assert(
                 this.queues_[contentType].length == 1,
@@ -1910,7 +1952,7 @@ shaka.media.MediaSourceEngine = class {
 
     if (goog.DEBUG) {
       // If we did it correctly, nothing is updating.
-      for (const contentType in this.sourceBuffers_) {
+      for (const contentType of contentTypes) {
         goog.asserts.assert(
             this.sourceBuffers_[contentType].updating == false,
             'SourceBuffers should not be updating after a blocking op!');
@@ -1930,7 +1972,7 @@ shaka.media.MediaSourceEngine = class {
           null);
     } finally {
       // Unblock the queues.
-      for (const contentType in this.sourceBuffers_) {
+      for (const contentType of contentTypes) {
         this.popFromQueue_(contentType);
       }
     }
@@ -1942,6 +1984,7 @@ shaka.media.MediaSourceEngine = class {
    * @private
    */
   popFromQueue_(contentType) {
+    goog.asserts.assert(this.queues_[contentType], 'Queue should exist');
     // Remove the in-progress operation, which is now complete.
     this.queues_[contentType].shift();
     this.startOperation_(contentType);
@@ -2099,48 +2142,6 @@ shaka.media.MediaSourceEngine = class {
         null);
   }
 
-  /**
-   * Returns the source buffer parameters
-   * @param {shaka.util.ManifestParserUtils.ContentType} contentType
-   * @return {?shaka.media.MediaSourceEngine.SourceBufferParams}
-   * @private
-   */
-  getSourceBufferParams_(contentType) {
-    if (!this.sourceBuffers_[contentType]) {
-      return null;
-    }
-    return {
-      timestampOffset: this.sourceBuffers_[contentType].timestampOffset,
-      appendWindowStart: this.sourceBuffers_[contentType].appendWindowStart,
-      appendWindowEnd: this.sourceBuffers_[contentType].appendWindowEnd,
-    };
-  }
-
-  /**
-   * Restore source buffer parameters
-   * @param {shaka.util.ManifestParserUtils.ContentType} contentType
-   * @param {?shaka.media.MediaSourceEngine.SourceBufferParams} params
-   * @private
-   */
-  restoreSourceBufferParams_(contentType, params) {
-    if (!params) {
-      return;
-    }
-
-    if (!this.sourceBuffers_[contentType]) {
-      shaka.log.warning('Attempted to restore a non-existent source buffer');
-      return;
-    }
-
-    this.sourceBuffers_[contentType].timestampOffset =
-      params.timestampOffset;
-    // `end` needs to be set before `start`
-    this.sourceBuffers_[contentType].appendWindowEnd =
-      params.appendWindowEnd;
-    this.sourceBuffers_[contentType].appendWindowStart =
-      params.appendWindowStart;
-  }
-
   /**
    * Resets the MediaSource and re-adds source buffers due to codec mismatch
    *
@@ -2149,7 +2150,6 @@ shaka.media.MediaSourceEngine = class {
    * @private
    */
   async reset_(streamsByType) {
-    const Functional = shaka.util.Functional;
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     this.reloadingMediaSource_ = true;
     this.needSplitMuxedContent_ = false;
@@ -2171,36 +2171,19 @@ shaka.media.MediaSourceEngine = class {
     try {
       this.eventManager_.removeAll();
 
-      const cleanup = [];
       for (const contentType in this.transmuxers_) {
-        cleanup.push(this.transmuxers_[contentType].destroy());
-      }
-      for (const contentType in this.queues_) {
-        // Make a local copy of the queue and the first item.
-        const q = this.queues_[contentType];
-        const inProgress = q[0];
-
-        // Drop everything else out of the original queue.
-        this.queues_[contentType] = q.slice(0, 1);
-
-        // We will wait for this item to complete/fail.
-        if (inProgress) {
-          cleanup.push(inProgress.p.catch(Functional.noop));
-        }
-
-        // The rest will be rejected silently if possible.
-        for (const item of q.slice(1)) {
-          item.p.reject(shaka.util.Destroyer.destroyedError());
-        }
+        this.transmuxers_[contentType].destroy();
       }
       for (const contentType in this.sourceBuffers_) {
         const sourceBuffer = this.sourceBuffers_[contentType];
         try {
           this.mediaSource_.removeSourceBuffer(sourceBuffer);
-        } catch (e) {}
+        } catch (e) {
+          shaka.log.debug('Exception on removeSourceBuffer', e);
+        }
       }
-      await Promise.all(cleanup);
       this.transmuxers_ = {};
+      this.sourceBuffers_ = {};
 
       const previousDuration = this.mediaSource_.duration;
       this.mediaSourceOpen_ = new shaka.util.PublicPromise();
@@ -2231,23 +2214,17 @@ shaka.media.MediaSourceEngine = class {
           onSourceBufferAdded);
 
       for (const contentType of streamsByType.keys()) {
-        const previousParams = this.getSourceBufferParams_(contentType);
         const stream = streamsByType.get(contentType);
         // eslint-disable-next-line no-await-in-loop
         await this.initSourceBuffer_(contentType, stream, stream.codecs);
-        if (this.needSplitMuxedContent_) {
-          this.queues_[ContentType.AUDIO] = [];
-          this.queues_[ContentType.VIDEO] = [];
-        } else {
-          this.queues_[contentType] = [];
-        }
-
-        this.restoreSourceBufferParams_(contentType, previousParams);
       }
       const audio = streamsByType.get(ContentType.AUDIO);
       if (audio && audio.isAudioMuxedInVideo) {
         this.needSplitMuxedContent_ = true;
       }
+      if (this.needSplitMuxedContent_ && !this.queues_[ContentType.AUDIO]) {
+        this.queues_[ContentType.AUDIO] = [];
+      }
 
       // Fake a seek to catchup the playhead.
       this.video_.currentTime = currentTime;
@@ -2286,32 +2263,32 @@ shaka.media.MediaSourceEngine = class {
   }
 
   /**
-   * Codec switch if necessary, this will not resolve until the codec
-   * switch is over.
    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
    * @param {string} mimeType
    * @param {string} codecs
-   * @param {!Map.<shaka.util.ManifestParserUtils.ContentType,
-   *               shaka.extern.Stream>} streamsByType
-   * @return {!Promise.<boolean>} true if there was a codec switch,
-   *                              false otherwise.
+   * @return {{transmuxer: ?shaka.extern.Transmuxer,
+   *          transmuxerMuxed: boolean, basicType: string, codec: string,
+   *          mimeType: string}}
    * @private
    */
-  async codecSwitchIfNecessary_(contentType, mimeType, codecs, streamsByType) {
+  getRealInfo_(contentType, mimeType, codecs) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
-    if (contentType == ContentType.TEXT) {
-      return false;
-    }
     const MimeUtils = shaka.util.MimeUtils;
-    const currentCodec = MimeUtils.getNormalizedCodec(
-        MimeUtils.getCodecs(this.sourceBufferTypes_[contentType]));
-    const currentBasicType = MimeUtils.getBasicType(
-        this.sourceBufferTypes_[contentType]);
-
     /** @type {?shaka.extern.Transmuxer} */
     let transmuxer;
     let transmuxerMuxed = false;
-    let newMimeType = shaka.util.MimeUtils.getFullType(mimeType, codecs);
+    const audioCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
+        ContentType.AUDIO, (codecs || '').split(','));
+    const videoCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
+        ContentType.VIDEO, (codecs || '').split(','));
+    let codec = videoCodec;
+    if (contentType == ContentType.AUDIO) {
+      codec = audioCodec;
+    }
+    if (!codec) {
+      codec = codecs;
+    }
+    let newMimeType = shaka.util.MimeUtils.getFullType(mimeType, codec);
     let needTransmux = this.config_.forceTransmux;
     if (!shaka.media.Capabilities.isTypeSupported(newMimeType) ||
         (!this.sequenceMode_ &&
@@ -2321,36 +2298,79 @@ shaka.media.MediaSourceEngine = class {
     const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
     if (needTransmux) {
       const newMimeTypeWithAllCodecs =
-          shaka.util.MimeUtils.getFullTypeWithAllCodecs(mimeType, codecs);
+          shaka.util.MimeUtils.getFullTypeWithAllCodecs(mimeType, codec);
       const transmuxerPlugin =
           TransmuxerEngine.findTransmuxer(newMimeTypeWithAllCodecs);
       if (transmuxerPlugin) {
         transmuxer = transmuxerPlugin();
-        const audioCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
-            ContentType.AUDIO, (codecs || '').split(','));
-        const videoCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
-            ContentType.VIDEO, (codecs || '').split(','));
         if (audioCodec && videoCodec) {
           transmuxerMuxed = true;
-          let codec = videoCodec;
-          if (contentType == ContentType.AUDIO) {
-            codec = audioCodec;
-          }
-          newMimeType = transmuxer.convertCodecs(contentType,
-              shaka.util.MimeUtils.getFullTypeWithAllCodecs(mimeType, codec));
-        } else {
-          newMimeType =
-              transmuxer.convertCodecs(contentType, newMimeTypeWithAllCodecs);
         }
+        newMimeType =
+            transmuxer.convertCodecs(contentType, newMimeTypeWithAllCodecs);
       }
     }
 
     const newCodec = MimeUtils.getNormalizedCodec(
         MimeUtils.getCodecs(newMimeType));
     const newBasicType = MimeUtils.getBasicType(newMimeType);
+    return {
+      transmuxer,
+      transmuxerMuxed,
+      basicType: newBasicType,
+      codec: newCodec,
+      mimeType: newMimeType,
+    };
+  }
+
+  /**
+   * Codec switch if necessary, this will not resolve until the codec
+   * switch is over.
+   * @param {shaka.util.ManifestParserUtils.ContentType} contentType
+   * @param {string} mimeType
+   * @param {string} codecs
+   * @param {!Map.<shaka.util.ManifestParserUtils.ContentType,
+   *               shaka.extern.Stream>} streamsByType
+   * @return {!Promise.<boolean>} true if there was a codec switch,
+   *                              false otherwise.
+   * @private
+   */
+  async codecSwitchIfNecessary_(contentType, mimeType, codecs, streamsByType) {
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
+    if (contentType == ContentType.TEXT) {
+      return false;
+    }
+    const MimeUtils = shaka.util.MimeUtils;
+    const currentCodec = MimeUtils.getNormalizedCodec(
+        MimeUtils.getCodecs(this.sourceBufferTypes_[contentType]));
+    const currentBasicType = MimeUtils.getBasicType(
+        this.sourceBufferTypes_[contentType]);
+
+    const realInfo = this.getRealInfo_(contentType, mimeType, codecs);
+    const transmuxer = realInfo.transmuxer;
+    const transmuxerMuxed = realInfo.transmuxerMuxed;
+    const newBasicType = realInfo.basicType;
+    const newCodec = realInfo.codec;
+    const newMimeType = realInfo.mimeType;
+
+    let muxedContentCheck = true;
+    if (transmuxerMuxed) {
+      const muxedRealInfo =
+          this.getRealInfo_(ContentType.AUDIO, mimeType, codecs);
+      const muxedCurrentCodec = MimeUtils.getNormalizedCodec(
+          MimeUtils.getCodecs(this.sourceBufferTypes_[ContentType.AUDIO]));
+      const muxedCurrentBasicType = MimeUtils.getBasicType(
+          this.sourceBufferTypes_[ContentType.AUDIO]);
+      muxedContentCheck = muxedCurrentCodec == muxedRealInfo.codec &&
+        muxedCurrentBasicType == muxedRealInfo.basicType;
+      if (muxedRealInfo.transmuxer) {
+        muxedRealInfo.transmuxer.destroy();
+      }
+    }
 
     // Current/new codecs base and basic type match then no need to switch
-    if (currentCodec === newCodec && currentBasicType === newBasicType) {
+    if (currentCodec === newCodec && currentBasicType === newBasicType &&
+        muxedContentCheck) {
       if (this.transmuxers_[contentType] && !transmuxer) {
         this.transmuxers_[contentType].destroy();
         delete this.transmuxers_[contentType];
@@ -2393,13 +2413,12 @@ shaka.media.MediaSourceEngine = class {
    * Returns true if it's necessary codec switch to load the new stream.
    *
    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
-   * @param {shaka.extern.Stream} stream
    * @param {string} refMimeType
    * @param {string} refCodecs
    * @return {boolean}
    * @private
    */
-  isCodecSwitchNecessary_(contentType, stream, refMimeType, refCodecs) {
+  isCodecSwitchNecessary_(contentType, refMimeType, refCodecs) {
     if (contentType == shaka.util.ManifestParserUtils.ContentType.TEXT) {
       return false;
     }
@@ -2443,13 +2462,12 @@ shaka.media.MediaSourceEngine = class {
    * new stream.
    *
    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
-   * @param {shaka.extern.Stream} stream
    * @param {string} mimeType
    * @param {string} codecs
    * @return {boolean}
    */
-  isResetMediaSourceNecessary(contentType, stream, mimeType, codecs) {
-    if (!this.isCodecSwitchNecessary_(contentType, stream, mimeType, codecs)) {
+  isResetMediaSourceNecessary(contentType, mimeType, codecs) {
+    if (!this.isCodecSwitchNecessary_(contentType, mimeType, codecs)) {
       return false;
     }
 
@@ -2540,12 +2558,3 @@ shaka.media.MediaSourceEngine.SourceBufferMode_ = {
  *   Called when an embedded 'emsg' box should trigger a manifest update.
  */
 shaka.media.MediaSourceEngine.PlayerInterface;
-
-/**
- * @typedef {{
- *   timestampOffset: number,
- *   appendWindowStart: number,
- *   appendWindowEnd: number
- * }}
- */
-shaka.media.MediaSourceEngine.SourceBufferParams;

package/lib/media/segment_utils.js

@@ -48,9 +48,11 @@ shaka.media.SegmentUtils = class {
 
   /**
    * @param {!BufferSource} data
+   * @param {boolean=} disableAudio
+   * @param {boolean=} disableVideo
    * @return {?shaka.media.SegmentUtils.BasicInfo}
    */
-  static getBasicInfoFromTs(data) {
+  static getBasicInfoFromTs(data, disableAudio = false, disableVideo = false) {
     const uint8ArrayData = shaka.util.BufferUtils.toUint8(data);
     const tsParser = new shaka.util.TsParser().parse(uint8ArrayData);
     const tsCodecs = tsParser.getCodecs();
@@ -58,50 +60,54 @@ shaka.media.SegmentUtils = class {
     const codecs = [];
     let hasAudio = false;
     let hasVideo = false;
-    switch (tsCodecs.audio) {
-      case 'aac':
-      case 'aac-loas':
-        codecs.push('mp4a.40.2');
-        hasAudio = true;
-        break;
-      case 'mp3':
-        codecs.push('mp4a.40.34');
-        hasAudio = true;
-        break;
-      case 'ac3':
-        codecs.push('ac-3');
-        hasAudio = true;
-        break;
-      case 'ec3':
-        codecs.push('ec-3');
-        hasAudio = true;
-        break;
-      case 'opus':
-        codecs.push('opus');
-        hasAudio = true;
-        break;
+    if (!disableAudio) {
+      switch (tsCodecs.audio) {
+        case 'aac':
+        case 'aac-loas':
+          codecs.push('mp4a.40.2');
+          hasAudio = true;
+          break;
+        case 'mp3':
+          codecs.push('mp4a.40.34');
+          hasAudio = true;
+          break;
+        case 'ac3':
+          codecs.push('ac-3');
+          hasAudio = true;
+          break;
+        case 'ec3':
+          codecs.push('ec-3');
+          hasAudio = true;
+          break;
+        case 'opus':
+          codecs.push('opus');
+          hasAudio = true;
+          break;
+      }
     }
-    switch (tsCodecs.video) {
-      case 'avc':
-        if (videoInfo.codec) {
-          codecs.push(videoInfo.codec);
-        } else {
-          codecs.push('avc1.42E01E');
-        }
-        hasVideo = true;
-        break;
-      case 'hvc':
-        if (videoInfo.codec) {
-          codecs.push(videoInfo.codec);
-        } else {
-          codecs.push('hvc1.1.6.L93.90');
-        }
-        hasVideo = true;
-        break;
-      case 'av1':
-        codecs.push('av01.0.01M.08');
-        hasVideo = true;
-        break;
+    if (!disableVideo) {
+      switch (tsCodecs.video) {
+        case 'avc':
+          if (videoInfo.codec) {
+            codecs.push(videoInfo.codec);
+          } else {
+            codecs.push('avc1.42E01E');
+          }
+          hasVideo = true;
+          break;
+        case 'hvc':
+          if (videoInfo.codec) {
+            codecs.push(videoInfo.codec);
+          } else {
+            codecs.push('hvc1.1.6.L93.90');
+          }
+          hasVideo = true;
+          break;
+        case 'av1':
+          codecs.push('av01.0.01M.08');
+          hasVideo = true;
+          break;
+      }
     }
     if (!codecs.length) {
       return null;

package/lib/media/streaming_engine.js

@@ -2011,7 +2011,7 @@ shaka.media.StreamingEngine = class {
       const isResetMediaSourceNecessary =
           mediaState.lastCodecs && mediaState.lastMimeType &&
           this.playerInterface_.mediaSourceEngine.isResetMediaSourceNecessary(
-              mediaState.type, mediaState.stream, mimeType, fullCodecs);
+              mediaState.type, mimeType, fullCodecs);
       if (isResetMediaSourceNecessary) {
         let otherState = null;
         if (mediaState.type === ContentType.VIDEO) {
@@ -2025,6 +2025,10 @@ shaka.media.StreamingEngine = class {
           // Then clear our cache of the last init segment, since MSE will be
           // reloaded and no init segment will be there post-reload.
           otherState.lastInitSegmentReference = null;
+          // Clear cache of append window start and end, since they will need
+          // to be reapplied post-reload by streaming engine.
+          otherState.lastAppendWindowStart = null;
+          otherState.lastAppendWindowEnd = null;
           // Now force the existing buffer to be cleared.  It is not necessary
           // to perform the MSE clear operation, but this has the side-effect
           // that our state for that stream will then match MSE's post-reload
@@ -2729,6 +2733,8 @@ shaka.media.StreamingEngine = class {
     const audioMediaState = this.mediaStates_.get(ContentType.AUDIO);
     if (audioMediaState) {
       audioMediaState.lastInitSegmentReference = null;
+      audioMediaState.lastAppendWindowStart = null;
+      audioMediaState.lastAppendWindowEnd = null;
       if (clearBuffer) {
         this.forceClearBuffer_(audioMediaState);
       }
@@ -2740,6 +2746,8 @@ shaka.media.StreamingEngine = class {
     const videoMediaState = this.mediaStates_.get(ContentType.VIDEO);
     if (videoMediaState) {
       videoMediaState.lastInitSegmentReference = null;
+      videoMediaState.lastAppendWindowStart = null;
+      videoMediaState.lastAppendWindowEnd = null;
       if (clearBuffer) {
         this.forceClearBuffer_(videoMediaState);
       }

package/lib/offline/download_info.js

@@ -7,6 +7,7 @@
 goog.provide('shaka.offline.DownloadInfo');
 
 goog.require('shaka.util.Networking');
+goog.require('shaka.util.Uint8ArrayUtils');
 goog.requireType('shaka.media.InitSegmentReference');
 goog.requireType('shaka.media.SegmentReference');
 
@@ -43,6 +44,10 @@ shaka.offline.DownloadInfo = class {
    * @return {string}
    */
   static idForSegmentRef(ref) {
+    const segmentData = ref.getSegmentData();
+    if (segmentData) {
+      return shaka.util.Uint8ArrayUtils.toBase64(segmentData);
+    }
     // Escape the URIs using encodeURI, to make sure that a weirdly formed URI
     // cannot cause two unrelated refs to be considered equivalent.
     const removeSprites = (uri) => {