fix: Defer closeSegmentIndex() for old streams during ABR switches when segment fetches are ongoing

demo/config.js

@@ -515,7 +515,9 @@ shakaDemo.Config = class {
         .addBoolInput_('Infinite Live Stream Duration',
             'streaming.infiniteLiveStreamDuration')
         .addBoolInput_('Clear decodingInfo cache on unload',
-            'streaming.clearDecodingCache');
+            'streaming.clearDecodingCache')
+        .addBoolInput_('Defer old stream cleanup during ABR switches',
+            'streaming.deferOldStreamCleanupDuringSwitch');
     if (!shakaDemoMain.getNativeControlsEnabled()) {
       this.addBoolInput_('Always Stream Text', 'streaming.alwaysStreamText');
     } else {

externs/shaka/player.js

@@ -1567,7 +1567,8 @@ shaka.extern.LiveSyncConfiguration;
  *   loadTimeout: number,
  *   clearDecodingCache: boolean,
  *   dontChooseCodecs: boolean,
- *   shouldFixTimestampOffset: boolean
+ *   shouldFixTimestampOffset: boolean,
+ *   deferOldStreamCleanupDuringSwitch: boolean
  * }}
  *
  * @description
@@ -1824,6 +1825,14 @@ shaka.extern.LiveSyncConfiguration;
  *   <br>
  *   Defaults to <code>false</code> except on Tizen, WebOS whose default value
  *   is <code>true</code>.
+ * @property {boolean} deferOldStreamCleanupDuringSwitch
+ *   If true, defers cleanup of the old stream during an ABR stream switch
+ *   until it is safe to cleanup.
+ *   For example, if <code>StreamingEngine</code> is in the middle of a segment
+ *   fetch using the old stream information when a switch happens, segment
+ *   availability issues may arise if the cleanup is not deferred.
+ *   <br>
+ *   Defaults to <code>false</code>.
  * @exportDoc
  */
 shaka.extern.StreamingConfiguration;

lib/media/streaming_engine.js

@@ -73,6 +73,17 @@ shaka.media.StreamingEngine = class {
     /** @private {?shaka.extern.StreamingConfiguration} */
     this.config_ = null;
 
+    /**
+     * Retains deferred closeSegmentIndex() operations for streams which were
+     * switched away from during an ongoing fetchAndAppend_().
+     * These close operations are resumed and cleared from this map when the
+     * next onUpdate_() for a stream's content type occurs.
+     * This is because at that point, it is guaranteed no logic is actively
+     * using information for these old streams.
+     * @private {!Map.<string, !function()>}
+     */
+    this.deferredCloseSegmentIndex_ = new Map();
+
     /** @private {number} */
     this.bufferingGoalScale_ = 1;
 
@@ -174,6 +185,7 @@ shaka.media.StreamingEngine = class {
     this.playerInterface_ = null;
     this.manifest_ = null;
     this.config_ = null;
+    this.deferredCloseSegmentIndex_.clear();
   }
 
   /**
@@ -572,20 +584,34 @@ shaka.media.StreamingEngine = class {
           fullMimeType, this.manifest_.sequenceMode, stream.external);
     }
 
-    // Releases the segmentIndex of the old stream.
+    // Releases the segmentIndex of the old stream if safe to do so.
     // Do not close segment indexes we are prefetching.
     if (!this.audioPrefetchMap_.has(mediaState.stream)) {
       if (mediaState.stream.closeSegmentIndex) {
-        mediaState.stream.closeSegmentIndex();
+        if (this.config_.deferOldStreamCleanupDuringSwitch &&
+            mediaState.performingUpdate) {
+          const oldStreamTag =
+              shaka.media.StreamingEngine.logPrefix_(mediaState);
+          // The ongoing update is still using the old stream's segment
+          // reference information.
+          // If we close the old stream now, the update will not complete
+          // correctly.
+          // onUpdate_() will resume the closeSegmentIndex() operation for the
+          // old stream when the update has finished.
+          this.deferredCloseSegmentIndex_.set(
+              oldStreamTag, mediaState.stream.closeSegmentIndex);
+        } else {
+          mediaState.stream.closeSegmentIndex();
+        }
       }
     }
 
     mediaState.stream = stream;
     mediaState.segmentIterator = null;
     mediaState.adaptation = !!adaptation;
 
-    const streamTag = shaka.media.StreamingEngine.logPrefix_(mediaState);
-    shaka.log.debug('switch: switching to Stream ' + streamTag);
+    const newStreamTag = shaka.media.StreamingEngine.logPrefix_(mediaState);
+    shaka.log.debug('switch: switching to Stream ' + newStreamTag);
 
     if (clearBuffer) {
       if (mediaState.clearingBuffer) {
@@ -1168,6 +1194,15 @@ shaka.media.StreamingEngine = class {
           mediaState.clearBufferSafeMargin);
       return;
     }
+    // Handle deferred closeSegmentIndex() operations.
+    for (const [key, value] of this.deferredCloseSegmentIndex_.entries()) {
+      const streamId = /** @type {string} */ (key);
+      const closeSegmentIndex = /** @type {!function()} */ (value);
+      if (streamId.includes(mediaState.type)) {
+        closeSegmentIndex();
+      }
+      this.deferredCloseSegmentIndex_.delete(streamId);
+    }
 
     // Make sure the segment index exists. If not, create the segment index.
     if (!mediaState.stream.segmentIndex) {

lib/util/player_configuration.js

@@ -269,6 +269,7 @@ shaka.util.PlayerConfiguration = class {
       dontChooseCodecs: false,
       shouldFixTimestampOffset: shaka.util.Platform.isWebOS() ||
         shaka.util.Platform.isTizen(),
+      deferOldStreamCleanupDuringSwitch: false,
     };
 
     // WebOS, Tizen, Chromecast and Hisense have long hardware pipelines