shaka-player 4.9.34 → 4.9.36

package/lib/media/content_workarounds.js

@@ -58,6 +58,20 @@ shaka.media.ContentWorkarounds = class {
     /** @type {!Array.<{box: shaka.extern.ParsedBox, newType: number}>} */
     const boxesToModify = [];
 
+    const pushEncv = (box) => {
+      boxesToModify.push({
+        box,
+        newType: ContentWorkarounds.BOX_TYPE_ENCV_,
+      });
+    };
+
+    const pushEnca = (box) => {
+      boxesToModify.push({
+        box,
+        newType: ContentWorkarounds.BOX_TYPE_ENCA_,
+      });
+    };
+
     new shaka.util.Mp4Parser()
         .box('moov', onSimpleAncestorBox)
         .box('trak', onSimpleAncestorBox)
@@ -71,78 +85,23 @@ shaka.media.ContentWorkarounds = class {
         })
         .fullBox('encv', onEncryptionMetadataBox)
         .fullBox('enca', onEncryptionMetadataBox)
-        .fullBox('dvav', (box) => {
-          boxesToModify.push({
-            box,
-            newType: ContentWorkarounds.BOX_TYPE_ENCV_,
-          });
-        })
-        .fullBox('dva1', (box) => {
-          boxesToModify.push({
-            box,
-            newType: ContentWorkarounds.BOX_TYPE_ENCV_,
-          });
-        })
-        .fullBox('dvh1', (box) => {
-          boxesToModify.push({
-            box,
-            newType: ContentWorkarounds.BOX_TYPE_ENCV_,
-          });
-        })
-        .fullBox('dvhe', (box) => {
-          boxesToModify.push({
-            box,
-            newType: ContentWorkarounds.BOX_TYPE_ENCV_,
-          });
-        })
-        .fullBox('hev1', (box) => {
-          boxesToModify.push({
-            box,
-            newType: ContentWorkarounds.BOX_TYPE_ENCV_,
-          });
-        })
-        .fullBox('hvc1', (box) => {
-          boxesToModify.push({
-            box,
-            newType: ContentWorkarounds.BOX_TYPE_ENCV_,
-          });
-        })
-        .fullBox('avc1', (box) => {
-          boxesToModify.push({
-            box,
-            newType: ContentWorkarounds.BOX_TYPE_ENCV_,
-          });
-        })
-        .fullBox('avc3', (box) => {
-          boxesToModify.push({
-            box,
-            newType: ContentWorkarounds.BOX_TYPE_ENCV_,
-          });
-        })
-        .fullBox('ac-3', (box) => {
-          boxesToModify.push({
-            box,
-            newType: ContentWorkarounds.BOX_TYPE_ENCA_,
-          });
-        })
-        .fullBox('ec-3', (box) => {
-          boxesToModify.push({
-            box,
-            newType: ContentWorkarounds.BOX_TYPE_ENCA_,
-          });
-        })
-        .fullBox('ac-4', (box) => {
-          boxesToModify.push({
-            box,
-            newType: ContentWorkarounds.BOX_TYPE_ENCA_,
-          });
-        })
-        .fullBox('mp4a', (box) => {
-          boxesToModify.push({
-            box,
-            newType: ContentWorkarounds.BOX_TYPE_ENCA_,
-          });
-        }).parse(initSegment);
+        .fullBox('dvav', pushEncv)
+        .fullBox('dva1', pushEncv)
+        .fullBox('dvh1', pushEncv)
+        .fullBox('dvhe', pushEncv)
+        .fullBox('dvc1', pushEncv)
+        .fullBox('dvi1', pushEncv)
+        .fullBox('hev1', pushEncv)
+        .fullBox('hvc1', pushEncv)
+        .fullBox('avc1', pushEncv)
+        .fullBox('avc3', pushEncv)
+        .fullBox('ac-3', pushEnca)
+        .fullBox('ec-3', pushEnca)
+        .fullBox('ac-4', pushEnca)
+        .fullBox('Opus', pushEnca)
+        .fullBox('fLaC', pushEnca)
+        .fullBox('mp4a', pushEnca)
+        .parse(initSegment);
 
     if (isEncrypted) {
       shaka.log.debug('Init segment already indicates encryption.');
@@ -335,6 +294,53 @@ shaka.media.ContentWorkarounds = class {
       boxView.setUint32(ContentWorkarounds.BOX_SIZE_OFFSET_, newBoxSize);
     }
   }
+
+  /**
+   * Transform the init segment into a new init segment buffer that indicates
+   * EC-3 as audio codec instead of AC-3. Even though any EC-3 decoder should
+   * be able to decode AC-3 streams, there are platforms that do not accept
+   * AC-3 as codec.
+   *
+   * Should only be called for MP4 init segments, and only on platforms that
+   * need this workaround. Returns a new buffer containing the modified init
+   * segment.
+   *
+   * @param {!BufferSource} initSegmentBuffer
+   * @return {!Uint8Array}
+   */
+  static fakeEC3(initSegmentBuffer) {
+    const ContentWorkarounds = shaka.media.ContentWorkarounds;
+    const initSegment = shaka.util.BufferUtils.toUint8(initSegmentBuffer);
+    const ancestorBoxes = [];
+
+    const onSimpleAncestorBox = (box) => {
+      ancestorBoxes.push({start: box.start, size: box.size});
+      shaka.util.Mp4Parser.children(box);
+    };
+
+    new shaka.util.Mp4Parser()
+        .box('moov', onSimpleAncestorBox)
+        .box('trak', onSimpleAncestorBox)
+        .box('mdia', onSimpleAncestorBox)
+        .box('minf', onSimpleAncestorBox)
+        .box('stbl', onSimpleAncestorBox)
+        .box('stsd', (box) => {
+          ancestorBoxes.push({start: box.start, size: box.size});
+          const stsdBoxView = shaka.util.BufferUtils.toDataView(
+              initSegment, box.start);
+          // "size - 3" is because we immediately read a uint32.
+          for (let i = 0; i < box.size -3; i++) {
+            const codecTag = stsdBoxView.getUint32(i);
+            if (codecTag == ContentWorkarounds.BOX_TYPE_AC_3_) {
+              stsdBoxView.setUint32(i, ContentWorkarounds.BOX_TYPE_EC_3_);
+            } else if (codecTag == ContentWorkarounds.BOX_TYPE_DAC3_) {
+              stsdBoxView.setUint32(i, ContentWorkarounds.BOX_TYPE_DEC3_);
+            }
+          }
+        }).parse(initSegment);
+
+    return initSegment;
+  }
 };
 
 /**
@@ -470,3 +476,35 @@ shaka.media.ContentWorkarounds.BOX_TYPE_ENCV_ = 0x656e6376;
  * @private
  */
 shaka.media.ContentWorkarounds.BOX_TYPE_ENCA_ = 0x656e6361;
+
+/**
+ * Box type for "ac-3".
+ *
+ * @const {number}
+ * @private
+ */
+shaka.media.ContentWorkarounds.BOX_TYPE_AC_3_ = 0x61632d33;
+
+/**
+ * Box type for "dac3".
+ *
+ * @const {number}
+ * @private
+ */
+shaka.media.ContentWorkarounds.BOX_TYPE_DAC3_ = 0x64616333;
+
+/**
+ * Box type for "ec-3".
+ *
+ * @const {number}
+ * @private
+ */
+shaka.media.ContentWorkarounds.BOX_TYPE_EC_3_ = 0x65632d33;
+
+/**
+ * Box type for "dec3".
+ *
+ * @const {number}
+ * @private
+ */
+shaka.media.ContentWorkarounds.BOX_TYPE_DEC3_ = 0x64656333;

package/lib/media/drm_engine.js

@@ -1004,7 +1004,17 @@ shaka.media.DrmEngine = class {
 
     // If we have configured preferredKeySystems, choose a preferred keySystem
     // if available.
-    for (const preferredKeySystem of this.config_.preferredKeySystems) {
+    let preferredKeySystems = this.config_.preferredKeySystems;
+    if (!preferredKeySystems.length) {
+      // If there is no preference set and we only have one license server, we
+      // use this as preference. This is used to override manifests on those
+      // that have the embedded license and the browser supports multiple DRMs.
+      const servers = shaka.util.MapUtils.asMap(this.config_.servers);
+      if (servers.size == 1) {
+        preferredKeySystems = Array.from(servers.keys());
+      }
+    }
+    for (const preferredKeySystem of preferredKeySystems) {
       for (const variant of variants) {
         const decodingInfo = variant.decodingInfos.find((decodingInfo) => {
           return decodingInfo.supported &&
@@ -1028,8 +1038,15 @@ shaka.media.DrmEngine = class {
           if (!decodingInfo.supported || !decodingInfo.keySystemAccess) {
             continue;
           }
-          const drmInfos =
-              drmInfosByKeySystem.get(decodingInfo.keySystemAccess.keySystem);
+          const originalKeySystem = decodingInfo.keySystemAccess.keySystem;
+          if (preferredKeySystems.includes(originalKeySystem)) {
+            continue;
+          }
+          let drmInfos = drmInfosByKeySystem.get(originalKeySystem);
+          if (!drmInfos && this.config_.keySystemsMapping[originalKeySystem]) {
+            drmInfos = drmInfosByKeySystem.get(
+                this.config_.keySystemsMapping[originalKeySystem]);
+          }
           for (const info of drmInfos) {
             if (!!info.licenseServerUri == shouldHaveLicenseServer) {
               return decodingInfo.keySystemAccess;
@@ -1800,7 +1817,18 @@ shaka.media.DrmEngine = class {
      */
     const processMediaKeySystemAccess = async (keySystem, access) => {
       try {
-        await access.createMediaKeys();
+        // Workaround: Our automated test lab runs Windows browsers under a
+        // headless service.  In this environment, Firefox's ClearKey CDM seems
+        // to crash when we create the CDM here.
+        if (goog.DEBUG &&  // not a production build
+            shaka.util.Platform.isWindows() &&  // on Windows
+            shaka.util.Platform.isFirefox()) {  // with Firefox
+          // Reject this, since it crashes our tests.
+          throw new Error('Suppressing Firefox Windows ClearKey in testing!');
+        } else {
+          // Otherwise, create the CDM.
+          await access.createMediaKeys();
+        }
       } catch (error) {
         // In some cases, we can get a successful access object but fail to
         // create a MediaKeys instance.  When this happens, don't update the
@@ -1947,17 +1975,47 @@ shaka.media.DrmEngine = class {
       support.set(keySystem, null);
     }
 
+    const checkKeySystem = (keySystem) => {
+      // Our Polyfill will reject anything apart com.apple.fps key systems.
+      // It seems the Safari modern EME API will allow to request a
+      // MediaKeySystemAccess for the ClearKey CDM, create and update a key
+      // session but playback will never start
+      // Safari bug: https://bugs.webkit.org/show_bug.cgi?id=231006
+      if (shaka.util.DrmUtils.isClearKeySystem(keySystem) &&
+          shaka.util.Platform.isSafari()) {
+        return false;
+      }
+      // FairPlay is a proprietary DRM from Apple and will never work on
+      // Windows.
+      if (shaka.util.DrmUtils.isFairPlayKeySystem(keySystem) &&
+          shaka.util.Platform.isWindows()) {
+        return false;
+      }
+      // PlayReady is a proprietary DRM from Microsoft and will never work on
+      // Apple platforms
+      if (shaka.util.DrmUtils.isPlayReadyKeySystem(keySystem) &&
+          (shaka.util.Platform.isMac() || shaka.util.Platform.isApple())) {
+        return false;
+      }
+      // Mozilla has no intention of supporting PlayReady according to
+      // comments posted on Bugzilla.
+      if (shaka.util.DrmUtils.isPlayReadyKeySystem(keySystem) &&
+          shaka.util.Platform.isFirefox()) {
+        return false;
+      }
+      // We are sure that WisePlay is not supported on Windows or macOS.
+      if (shaka.util.DrmUtils.isWisePlayKeySystem(keySystem) &&
+          (shaka.util.Platform.isWindows() || shaka.util.Platform.isMac())) {
+        return false;
+      }
+      return true;
+    };
+
     // Test each key system and encryption scheme.
     const tests = [];
     for (const encryptionScheme of testEncryptionSchemes) {
       for (const keySystem of testKeySystems) {
-        // Our Polyfill will reject anything apart com.apple.fps key systems.
-        // It seems the Safari modern EME API will allow to request a
-        // MediaKeySystemAccess for the ClearKey CDM, create and update a key
-        // session but playback will never start
-        // Safari bug: https://bugs.webkit.org/show_bug.cgi?id=231006
-        if (keySystem === 'org.w3.clearkey' &&
-            shaka.util.Platform.isSafari()) {
+        if (!checkKeySystem(keySystem)) {
           continue;
         }
         tests.push(testSystemEme(keySystem, encryptionScheme, '', ''));
@@ -1967,6 +2025,9 @@ shaka.media.DrmEngine = class {
 
     for (const keySystem of testKeySystems) {
       for (const robustness of (testRobustness[keySystem] || [])) {
+        if (!checkKeySystem(keySystem)) {
+          continue;
+        }
         tests.push(testSystemEme(keySystem, null, robustness, ''));
         tests.push(testSystemEme(keySystem, null, '', robustness));
         tests.push(testSystemMcap(keySystem, null, robustness, ''));

package/lib/media/gap_jumping_controller.js

@@ -53,6 +53,9 @@ shaka.media.GapJumpingController = class {
     /** @private {shaka.util.EventManager} */
     this.eventManager_ = new shaka.util.EventManager();
 
+    /** @private {boolean} */
+    this.started_ = false;
+
     /** @private {boolean} */
     this.seekingEventReceived_ = false;
 
@@ -90,7 +93,7 @@ shaka.media.GapJumpingController = class {
      */
     this.gapJumpTimer_ = new shaka.util.Timer(() => {
       this.onPollGapJump_();
-    }).tickEvery(this.config_.gapJumpTimerTime);
+    });
   }
 
 
@@ -134,16 +137,22 @@ shaka.media.GapJumpingController = class {
    * @param {number} startTime
    */
   onStarted(startTime) {
+    this.started_ = true;
     if (this.video_.seeking && !this.seekingEventReceived_) {
       this.seekingEventReceived_ = true;
       this.startTime_ = startTime;
     }
+    if (this.gapJumpTimer_) {
+      this.gapJumpTimer_.tickEvery(this.config_.gapJumpTimerTime);
+    }
+    this.onPollGapJump_();
   }
 
   /** Called when a seek has started. */
   onSeeking() {
     this.seekingEventReceived_ = true;
     this.hadSegmentAppended_ = false;
+    this.onPollGapJump_();
   }
 
 
@@ -167,6 +176,10 @@ shaka.media.GapJumpingController = class {
     if (this.video_.readyState == 0) {
       return;
     }
+    // Don't gap jump before playback started
+    if (!this.started_) {
+      return;
+    }
     // Do not gap jump if seeking has begun, but the seeking event has not
     // yet fired for this particular seek.
     if (this.video_.seeking) {

package/lib/media/media_source_engine.js

@@ -543,6 +543,11 @@ shaka.media.MediaSourceEngine = class {
             stream, contentType),
         'Type negotiation should happen before MediaSourceEngine.init!');
 
+    if (contentType == ContentType.AUDIO && codecs) {
+      codecs = shaka.util.StreamUtils.getCorrectAudioCodecs(
+          codecs, stream.mimeType);
+    }
+
     let mimeType = shaka.util.MimeUtils.getFullType(
         stream.mimeType, codecs);
     if (contentType == ContentType.TEXT) {
@@ -1157,7 +1162,7 @@ shaka.media.MediaSourceEngine = class {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     if (contentType == ContentType.TEXT) {
       await this.textEngine_.remove(startTime, endTime);
-    } else {
+    } else if (endTime > startTime) {
       await this.enqueueOperation_(
           contentType,
           () => this.remove_(contentType, startTime, endTime),
@@ -1309,20 +1314,24 @@ shaka.media.MediaSourceEngine = class {
             null));
       }
     }
-    operations.push(this.enqueueOperation_(
-        contentType,
-        () => this.setAppendWindow_(
-            contentType, appendWindowStart, appendWindowEnd),
-        null));
-    if (this.needSplitMuxedContent_) {
+    if (appendWindowStart != 0 || appendWindowEnd != Infinity) {
       operations.push(this.enqueueOperation_(
-          ContentType.AUDIO,
+          contentType,
           () => this.setAppendWindow_(
-              ContentType.AUDIO, appendWindowStart, appendWindowEnd),
+              contentType, appendWindowStart, appendWindowEnd),
           null));
+      if (this.needSplitMuxedContent_) {
+        operations.push(this.enqueueOperation_(
+            ContentType.AUDIO,
+            () => this.setAppendWindow_(
+                ContentType.AUDIO, appendWindowStart, appendWindowEnd),
+            null));
+      }
     }
 
-    await Promise.all(operations);
+    if (operations.length) {
+      await Promise.all(operations);
+    }
   }
 
   /**
@@ -1841,6 +1850,14 @@ shaka.media.MediaSourceEngine = class {
       segment = shaka.media.ContentWorkarounds.fakeEncryption(segment, uri);
     }
 
+    if (isInitSegment &&
+        Platform.requiresEC3InitSegments() &&
+        shaka.util.MimeUtils.getContainerType(
+            this.sourceBufferTypes_[contentType]) == 'mp4') {
+      shaka.log.debug('Forcing fake EC-3 information in init segment.');
+      segment = shaka.media.ContentWorkarounds.fakeEC3(segment);
+    }
+
     return segment;
   }
 
@@ -2169,7 +2186,8 @@ shaka.media.MediaSourceEngine = class {
     const newMimeType = realInfo.mimeType;
 
     let muxedContentCheck = true;
-    if (transmuxerMuxed) {
+    if (transmuxerMuxed &&
+        ContentType.AUDIO in this.sourceBufferTypes_) {
       const muxedRealInfo =
           this.getRealInfo_(ContentType.AUDIO, mimeType, codecs);
       const muxedCurrentCodec = MimeUtils.getNormalizedCodec(

package/lib/media/region_timeline.js

@@ -102,13 +102,14 @@ shaka.media.RegionTimeline = class extends shaka.util.FakeEventTarget {
    * @private
    */
   findSimilarRegion_(region) {
+    const isDiffNegligible = (a, b) => Math.abs(a - b) < 0.1;
     for (const existing of this.regions_) {
       // The same scheme ID and time range means that it is similar-enough to
       // be the same region.
       const isSimilar = existing.schemeIdUri == region.schemeIdUri &&
-                        existing.id == region.id &&
-                        existing.startTime == region.startTime &&
-                        existing.endTime == region.endTime;
+          existing.id == region.id &&
+          isDiffNegligible(existing.startTime, region.startTime) &&
+          isDiffNegligible(existing.endTime, region.endTime);
 
       if (isSimilar) {
         return existing;

package/lib/media/segment_utils.js

@@ -47,11 +47,12 @@ shaka.media.SegmentUtils = class {
 
   /**
    * @param {!BufferSource} data
-   * @param {boolean=} disableAudio
-   * @param {boolean=} disableVideo
+   * @param {boolean} disableAudio
+   * @param {boolean} disableVideo
+   * @param {boolean} disableText
    * @return {?shaka.media.SegmentUtils.BasicInfo}
    */
-  static getBasicInfoFromTs(data, disableAudio = false, disableVideo = false) {
+  static getBasicInfoFromTs(data, disableAudio, disableVideo, disableText) {
     const uint8ArrayData = shaka.util.BufferUtils.toUint8(data);
     const tsParser = new shaka.util.TsParser().parse(uint8ArrayData);
     const tsCodecs = tsParser.getCodecs();
@@ -63,24 +64,34 @@ shaka.media.SegmentUtils = class {
       switch (tsCodecs.audio) {
         case 'aac':
         case 'aac-loas':
-          codecs.push('mp4a.40.2');
-          hasAudio = true;
+          if (tsParser.getAudioData().length) {
+            codecs.push('mp4a.40.2');
+            hasAudio = true;
+          }
           break;
         case 'mp3':
-          codecs.push('mp4a.40.34');
-          hasAudio = true;
+          if (tsParser.getAudioData().length) {
+            codecs.push('mp4a.40.34');
+            hasAudio = true;
+          }
           break;
         case 'ac3':
-          codecs.push('ac-3');
-          hasAudio = true;
+          if (tsParser.getAudioData().length) {
+            codecs.push('ac-3');
+            hasAudio = true;
+          }
           break;
         case 'ec3':
-          codecs.push('ec-3');
-          hasAudio = true;
+          if (tsParser.getAudioData().length) {
+            codecs.push('ec-3');
+            hasAudio = true;
+          }
           break;
         case 'opus':
-          codecs.push('opus');
-          hasAudio = true;
+          if (tsParser.getAudioData().length) {
+            codecs.push('opus');
+            hasAudio = true;
+          }
           break;
       }
     }
@@ -113,7 +124,7 @@ shaka.media.SegmentUtils = class {
     }
     const onlyAudio = hasAudio && !hasVideo;
     const closedCaptions = new Map();
-    if (hasVideo) {
+    if (hasVideo && !disableText) {
       const captionParser = new shaka.media.ClosedCaptionParser('video/mp2t');
       captionParser.parseFrom(data);
       for (const stream of captionParser.getStreams()) {
@@ -139,9 +150,10 @@ shaka.media.SegmentUtils = class {
   /**
    * @param {?BufferSource} initData
    * @param {!BufferSource} data
+   * @param {boolean} disableText
    * @return {?shaka.media.SegmentUtils.BasicInfo}
    */
-  static getBasicInfoFromMp4(initData, data) {
+  static getBasicInfoFromMp4(initData, data, disableText) {
     const Mp4Parser = shaka.util.Mp4Parser;
     const SegmentUtils = shaka.media.SegmentUtils;
 
@@ -382,7 +394,7 @@ shaka.media.SegmentUtils = class {
     }
     const onlyAudio = hasAudio && !hasVideo;
     const closedCaptions = new Map();
-    if (hasVideo) {
+    if (hasVideo && !disableText) {
       const captionParser = new shaka.media.ClosedCaptionParser('video/mp4');
       if (initData) {
         captionParser.init(initData);

package/lib/media/streaming_engine.js

@@ -1314,12 +1314,17 @@ shaka.media.StreamingEngine = class {
       this.playerInterface_.mediaSourceEngine.clearSelectedClosedCaptionId();
     }
 
+    // Update updateIntervalSeconds according to our current playbackrate,
+    // and always considering a minimum of 1.
+    const updateIntervalSeconds = this.config_.updateIntervalSeconds /
+        Math.max(1, Math.abs(this.playerInterface_.getPlaybackRate()));
+
     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;
+      return updateIntervalSeconds / 2;
     }
 
     const logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
@@ -1393,9 +1398,8 @@ shaka.media.StreamingEngine = class {
       shaka.log.v2(logPrefix, 'buffering goal met');
 
       // Do not try to predict the next update.  Just poll according to
-      // configuration (seconds). The playback rate can change at any time, so
-      // any prediction we make now could be terribly invalid soon.
-      return this.config_.updateIntervalSeconds / 2;
+      // configuration (seconds).
+      return updateIntervalSeconds / 2;
     }
 
     // Lack of segment iterator is the best indicator stream has changed.
@@ -1407,7 +1411,7 @@ shaka.media.StreamingEngine = class {
       // In any case just try again... if the manifest is incomplete or is not
       // being updated then we'll idle forever; otherwise, we'll end up getting
       // a SegmentReference eventually.
-      return this.config_.updateIntervalSeconds;
+      return updateIntervalSeconds;
     }
     // Get media state adaptation and reset this value. By guarding it during
     // actual stream change we ensure it won't be cleaned by accident on regular
@@ -1446,7 +1450,7 @@ shaka.media.StreamingEngine = class {
       // For example, let video buffering catch up to audio buffering before
       // fetching another audio segment.
       shaka.log.v2(logPrefix, 'waiting for other streams to buffer');
-      return this.config_.updateIntervalSeconds;
+      return updateIntervalSeconds;
     }
 
     if (mediaState.segmentPrefetch && mediaState.segmentIterator &&
@@ -1509,7 +1513,18 @@ shaka.media.StreamingEngine = class {
       // Something is buffered from the same Stream.  Use the current position
       // in the segment index.  This is updated via next() after each segment is
       // appended.
-      return mediaState.segmentIterator.current();
+      let ref = mediaState.segmentIterator.current();
+      if (ref && mediaState.lastSegmentReference) {
+        // In HLS sometimes the segment iterator adds or removes segments very
+        // quickly, so we have to be sure that we do not add the last segment
+        // again, tolerating a difference of 1ms.
+        const isDiffNegligible = (a, b) => Math.abs(a - b) < 0.001;
+        const lastStartTime = mediaState.lastSegmentReference.startTime;
+        if (isDiffNegligible(lastStartTime, ref.startTime)) {
+          ref = mediaState.segmentIterator.next().value;
+        }
+      }
+      return ref;
     } else if (mediaState.lastSegmentReference || bufferEnd) {
       // Something is buffered from another Stream.
       const time = mediaState.lastSegmentReference ?
@@ -2485,7 +2500,7 @@ shaka.media.StreamingEngine = class {
     const segmentIndex = mediaState.stream.segmentIndex;
     if (segmentIndex instanceof shaka.media.MetaSegmentIndex) {
       segmentIndex.evict(
-          this.manifest_.presentationTimeline.getSeekRangeStart());
+          this.manifest_.presentationTimeline.getSegmentAvailabilityStart());
     }
 
     const logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
@@ -2512,15 +2527,26 @@ shaka.media.StreamingEngine = class {
     }
     const bufferedBehind = presentationTime - startTime;
 
-    const overflow = bufferedBehind - bufferBehind;
+    const evictionGoal = this.config_.evictionGoal;
+
+    const seekRangeStart =
+        this.manifest_.presentationTimeline.getSeekRangeStart();
+    const seekRangeEnd =
+        this.manifest_.presentationTimeline.getSeekRangeEnd();
+
+    let overflow = bufferedBehind - bufferBehind;
+    if (seekRangeEnd - seekRangeStart > evictionGoal) {
+      overflow = Math.max(bufferedBehind - bufferBehind,
+          seekRangeStart - evictionGoal - startTime);
+    }
     // See: https://github.com/shaka-project/shaka-player/issues/6240
-    if (overflow <= this.config_.evictionGoal) {
+    if (overflow <= evictionGoal) {
       shaka.log.v2(logPrefix,
           'buffer behind okay:',
           'presentationTime=' + presentationTime,
           'bufferedBehind=' + bufferedBehind,
           'bufferBehind=' + bufferBehind,
-          'evictionGoal=' + this.config_.evictionGoal,
+          'evictionGoal=' + evictionGoal,
           'underflow=' + Math.abs(overflow));
       return;
     }
@@ -2530,7 +2556,7 @@ shaka.media.StreamingEngine = class {
         'presentationTime=' + presentationTime,
         'bufferedBehind=' + bufferedBehind,
         'bufferBehind=' + bufferBehind,
-        'evictionGoal=' + this.config_.evictionGoal,
+        'evictionGoal=' + evictionGoal,
         'overflow=' + overflow);
 
     await this.playerInterface_.mediaSourceEngine.remove(mediaState.type,