shaka-player 4.7.12 → 4.8.0

package/lib/media/streaming_engine.js

@@ -27,6 +27,7 @@ goog.require('shaka.util.Error');
 goog.require('shaka.util.FakeEvent');
 goog.require('shaka.util.IDestroyable');
 goog.require('shaka.util.Id3Utils');
+goog.require('shaka.util.LanguageUtils');
 goog.require('shaka.util.ManifestParserUtils');
 goog.require('shaka.util.MimeUtils');
 goog.require('shaka.util.Mp4BoxParsers');
@@ -122,6 +123,17 @@ shaka.media.StreamingEngine = class {
 
     /** @private {number} */
     this.lastMediaSourceReset_ = Date.now() / 1000;
+
+    /**
+     * @private {!Map<shaka.extern.Stream, !shaka.media.SegmentPrefetch>}
+     */
+    this.audioPrefetchMap_ = new Map();
+
+    /** @private {!shaka.extern.SpatialVideoInfo} */
+    this.spatialVideoInfo_ = {
+      projection: null,
+      hfov: null,
+    };
   }
 
   /** @override */
@@ -140,10 +152,14 @@ shaka.media.StreamingEngine = class {
       this.cancelUpdate_(state);
       aborts.push(this.abortOperations_(state));
     }
+    for (const prefetch of this.audioPrefetchMap_.values()) {
+      prefetch.clearAll();
+    }
 
     await Promise.all(aborts);
 
     this.mediaStates_.clear();
+    this.audioPrefetchMap_.clear();
 
     this.playerInterface_ = null;
     this.manifest_ = null;
@@ -180,6 +196,40 @@ shaka.media.StreamingEngine = class {
     this.failureCallbackBackoff_ =
         new shaka.net.Backoff(failureRetryParams, autoReset);
 
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
+
+    // disable audio segment prefetch if this is now set
+    if (config.disableAudioPrefetch) {
+      const state = this.mediaStates_.get(ContentType.AUDIO);
+      if (state && state.segmentPrefetch) {
+        state.segmentPrefetch.clearAll();
+        state.segmentPrefetch = null;
+      }
+
+      for (const stream of this.audioPrefetchMap_.keys()) {
+        const prefetch = this.audioPrefetchMap_.get(stream);
+        prefetch.clearAll();
+        this.audioPrefetchMap_.delete(stream);
+      }
+    }
+    // disable text segment prefetch if this is now set
+    if (config.disableTextPrefetch) {
+      const state = this.mediaStates_.get(ContentType.TEXT);
+      if (state && state.segmentPrefetch) {
+        state.segmentPrefetch.clearAll();
+        state.segmentPrefetch = null;
+      }
+    }
+
+    // disable video segment prefetch if this is now set
+    if (config.disableVideoPrefetch) {
+      const state = this.mediaStates_.get(ContentType.VIDEO);
+      if (state && state.segmentPrefetch) {
+        state.segmentPrefetch.clearAll();
+        state.segmentPrefetch = null;
+      }
+    }
+
     // Allow configuring the segment prefetch in middle of the playback.
     for (const type of this.mediaStates_.keys()) {
       const state = this.mediaStates_.get(type);
@@ -194,6 +244,10 @@ shaka.media.StreamingEngine = class {
         state.segmentPrefetch = this.createSegmentPrefetch_(state.stream);
       }
     }
+
+    if (!config.disableAudioPrefetch) {
+      this.updatePrefetchMapForAudio_();
+    }
   }
 
 
@@ -205,14 +259,17 @@ shaka.media.StreamingEngine = class {
    * chosen by a prior call to switchTextStream().  Once the Promise resolves,
    * switch*() may be called freely.
    *
+   * @param {!Map.<number, shaka.media.SegmentPrefetch>=} segmentPrefetchById
+   *   If provided, segments prefetched for these streams will be used as needed
+   *   during playback.
    * @return {!Promise}
    */
-  async start() {
+  async start(segmentPrefetchById) {
     goog.asserts.assert(this.config_,
         'StreamingEngine configure() must be called before init()!');
 
     // Setup the initial set of Streams and then begin each update cycle.
-    await this.initStreams_();
+    await this.initStreams_(segmentPrefetchById || (new Map()));
     this.destroyer_.ensureNotDestroyed();
 
     shaka.log.debug('init: completed initial Stream setup');
@@ -472,7 +529,9 @@ shaka.media.StreamingEngine = class {
       return;
     }
 
-    if (mediaState.segmentPrefetch) {
+    if (this.audioPrefetchMap_.has(stream)) {
+      mediaState.segmentPrefetch = this.audioPrefetchMap_.get(stream);
+    } else if (mediaState.segmentPrefetch) {
       mediaState.segmentPrefetch.switchStream(stream);
     }
 
@@ -487,8 +546,11 @@ shaka.media.StreamingEngine = class {
     }
 
     // Releases the segmentIndex of the old stream.
-    if (mediaState.stream.closeSegmentIndex) {
-      mediaState.stream.closeSegmentIndex();
+    // Do not close segment indexes we are prefetching.
+    if (!this.audioPrefetchMap_.has(mediaState.stream)) {
+      if (mediaState.stream.closeSegmentIndex) {
+        mediaState.stream.closeSegmentIndex();
+      }
     }
 
     mediaState.stream = stream;
@@ -789,10 +851,11 @@ shaka.media.StreamingEngine = class {
    * Initializes the initial streams and media states.  This will schedule
    * updates for the given types.
    *
+   * @param {!Map.<number, shaka.media.SegmentPrefetch>} segmentPrefetchById
    * @return {!Promise}
    * @private
    */
-  async initStreams_() {
+  async initStreams_(segmentPrefetchById) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
     goog.asserts.assert(this.config_,
@@ -845,6 +908,15 @@ shaka.media.StreamingEngine = class {
       const stream = streamsByType.get(type);
       if (!this.mediaStates_.has(type)) {
         const mediaState = this.createMediaState_(stream);
+        if (segmentPrefetchById.has(stream.id)) {
+          const segmentPrefetch = segmentPrefetchById.get(stream.id);
+          segmentPrefetch.replaceFetchDispatcher(
+              (reference, stream, streamDataCallback) => {
+                return this.dispatchFetch_(
+                    reference, stream, streamDataCallback);
+              });
+          mediaState.segmentPrefetch = segmentPrefetch;
+        }
         this.mediaStates_.set(type, mediaState);
         this.scheduleUpdate_(mediaState, 0);
       }
@@ -881,7 +953,6 @@ shaka.media.StreamingEngine = class {
       // The playhead might be seeking on startup, if a start time is set, so
       // start "seeked" as true.
       seeked: true,
-      needsResync: false,
       recovering: false,
       hasError: false,
       operation: null,
@@ -896,12 +967,37 @@ shaka.media.StreamingEngine = class {
    * @private
    */
   createSegmentPrefetch_(stream) {
-    if (
-      stream.type !== shaka.util.ManifestParserUtils.ContentType.VIDEO &&
-      stream.type !== shaka.util.ManifestParserUtils.ContentType.AUDIO
-    ) {
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
+    if (stream.type === ContentType.VIDEO &&
+        this.config_.disableVideoPrefetch) {
+      return null;
+    }
+    if (stream.type === ContentType.AUDIO &&
+        this.config_.disableAudioPrefetch) {
       return null;
     }
+    const MimeUtils = shaka.util.MimeUtils;
+    const CEA608_MIME = MimeUtils.CEA608_CLOSED_CAPTION_MIMETYPE;
+    const CEA708_MIME = MimeUtils.CEA708_CLOSED_CAPTION_MIMETYPE;
+    if (stream.type === ContentType.TEXT &&
+        (stream.mimeType == CEA608_MIME || stream.mimeType == CEA708_MIME)) {
+      return null;
+    }
+    if (stream.type === ContentType.TEXT &&
+        this.config_.disableTextPrefetch) {
+      return null;
+    }
+    if (this.audioPrefetchMap_.has(stream)) {
+      return this.audioPrefetchMap_.get(stream);
+    }
+    const type = /** @type {!shaka.util.ManifestParserUtils.ContentType} */
+        (stream.type);
+    const mediaState = this.mediaStates_.get(type);
+    const currentSegmentPrefetch = mediaState && mediaState.segmentPrefetch;
+    if (currentSegmentPrefetch &&
+      stream === currentSegmentPrefetch.getStream()) {
+      return currentSegmentPrefetch;
+    }
     if (this.config_.segmentPrefetchLimit > 0) {
       return new shaka.media.SegmentPrefetch(
           this.config_.segmentPrefetchLimit,
@@ -914,6 +1010,75 @@ shaka.media.StreamingEngine = class {
     return null;
   }
 
+  /**
+   * Populates the prefetch map depending on the configuration
+   * @private
+   */
+  updatePrefetchMapForAudio_() {
+    const prefetchLimit = this.config_.segmentPrefetchLimit;
+    const prefetchLanguages = this.config_.prefetchAudioLanguages;
+    const LanguageUtils = shaka.util.LanguageUtils;
+
+    for (const variant of this.manifest_.variants) {
+      if (!variant.audio) {
+        continue;
+      }
+
+      if (this.audioPrefetchMap_.has(variant.audio)) {
+        // if we already have a segment prefetch,
+        // update it's prefetch limit and if the new limit isn't positive,
+        // remove the segment prefetch from our prefetch map.
+        const prefetch = this.audioPrefetchMap_.get(variant.audio);
+        prefetch.resetLimit(prefetchLimit);
+        if (!(prefetchLimit > 0) ||
+            !prefetchLanguages.some(
+                (lang) => LanguageUtils.areLanguageCompatible(
+                    variant.audio.language, lang))
+        ) {
+          const type = /** @type {!shaka.util.ManifestParserUtils.ContentType}*/
+            (variant.audio.type);
+          const mediaState = this.mediaStates_.get(type);
+          const currentSegmentPrefetch = mediaState &&
+              mediaState.segmentPrefetch;
+          // if this prefetch isn't the current one, we want to clear it
+          if (prefetch !== currentSegmentPrefetch) {
+            prefetch.clearAll();
+          }
+          this.audioPrefetchMap_.delete(variant.audio);
+        }
+        continue;
+      }
+
+      // don't try to create a new segment prefetch if the limit isn't positive.
+      if (prefetchLimit <= 0) {
+        continue;
+      }
+
+      // only create a segment prefetch if its language is configured
+      // to be prefetched
+      if (!prefetchLanguages.some(
+          (lang) => LanguageUtils.areLanguageCompatible(
+              variant.audio.language, lang))) {
+        continue;
+      }
+
+      // use the helper to create a segment prefetch to ensure that existing
+      // objects are reused.
+      const segmentPrefetch = this.createSegmentPrefetch_(variant.audio);
+
+      // if a segment prefetch wasn't created, skip the rest
+      if (!segmentPrefetch) {
+        continue;
+      }
+
+      if (!variant.audio.segmentIndex) {
+        variant.audio.createSegmentIndex();
+      }
+
+      this.audioPrefetchMap_.set(variant.audio, segmentPrefetch);
+    }
+  }
+
   /**
    * Sets the MediaSource's duration.
    */
@@ -922,9 +1087,13 @@ shaka.media.StreamingEngine = class {
     if (duration < Infinity) {
       this.playerInterface_.mediaSourceEngine.setDuration(duration);
     } else {
+      // To set the media source live duration as Infinity
+      // If infiniteLiveStreamDuration as true
+      const duration =
+      this.config_.infiniteLiveStreamDuration ? Infinity : Math.pow(2, 32);
       // Not all platforms support infinite durations, so set a finite duration
       // so we can append segments and so the user agent can seek.
-      this.playerInterface_.mediaSourceEngine.setDuration(Math.pow(2, 32));
+      this.playerInterface_.mediaSourceEngine.setDuration(duration);
     }
   }
 
@@ -1072,6 +1241,15 @@ shaka.media.StreamingEngine = class {
     // Compute how far we've buffered ahead of the playhead.
     const presentationTime = this.playerInterface_.getPresentationTime();
 
+    if (mediaState.type === ContentType.AUDIO) {
+      // evict all prefetched segments that are before the presentationTime
+      for (const stream of this.audioPrefetchMap_.keys()) {
+        const prefetch = this.audioPrefetchMap_.get(stream);
+        prefetch.evict(presentationTime, /* clearInitSegments= */ true);
+        prefetch.prefetchSegmentsByTime(presentationTime);
+      }
+    }
+
     // Get the next timestamp we need.
     const timeNeeded = this.getTimeNeeded_(mediaState, presentationTime);
     shaka.log.v2(logPrefix, 'timeNeeded=' + timeNeeded);
@@ -1175,14 +1353,10 @@ shaka.media.StreamingEngine = class {
       return this.config_.updateIntervalSeconds;
     }
 
-    if (mediaState.segmentPrefetch && mediaState.segmentIterator) {
-      const initSegmentReference = reference.initSegmentReference;
-      if (initSegmentReference && (!mediaState.lastSegmentReference ||
-          !shaka.media.InitSegmentReference.equal(
-              initSegmentReference, mediaState.lastInitSegmentReference))) {
-        mediaState.segmentPrefetch.prefetchInitSegment(initSegmentReference);
-      }
-      mediaState.segmentPrefetch.prefetchSegments(reference);
+    if (mediaState.segmentPrefetch && mediaState.segmentIterator &&
+        !this.audioPrefetchMap_.has(mediaState.stream)) {
+      mediaState.segmentPrefetch.evict(presentationTime);
+      mediaState.segmentPrefetch.prefetchSegmentsByTime(reference.startTime);
     }
 
     const p = this.fetchAndAppend_(mediaState, presentationTime, reference);
@@ -1248,11 +1422,6 @@ shaka.media.StreamingEngine = class {
       shaka.log.v1(
           logPrefix, 'looking up segment from new stream endTime:', time);
 
-      // Using a new iterator means we need to resync the stream in sequence
-      // mode.  The buffered range might not align perfectly with the last
-      // segment end time, so we may end up repeating a segment.  Resyncing
-      // makes this safe to do.
-      mediaState.needsResync = true;
       mediaState.segmentIterator =
           mediaState.stream.segmentIndex.getIteratorForTime(time);
       const ref = mediaState.segmentIterator &&
@@ -1396,8 +1565,8 @@ shaka.media.StreamingEngine = class {
                   /* isChunkedData= */ true);
 
               if (mediaState.segmentPrefetch && mediaState.segmentIterator) {
-                mediaState.segmentPrefetch.prefetchSegments(
-                    reference, /* skipFirst= */ true);
+                mediaState.segmentPrefetch.prefetchSegmentsByTime(
+                    reference.startTime, /* skipFirst= */ true);
               }
             }
           } catch (error) {
@@ -1437,8 +1606,8 @@ shaka.media.StreamingEngine = class {
         }
 
         if (mediaState.segmentPrefetch && mediaState.segmentIterator) {
-          mediaState.segmentPrefetch.prefetchSegments(
-              reference, /* skipFirst= */ true);
+          mediaState.segmentPrefetch.prefetchSegmentsByTime(
+              reference.startTime, /* skipFirst= */ true);
         }
       } else {
         if (this.config_.lowLatencyMode && !isReadableStreamSupported) {
@@ -1534,18 +1703,18 @@ shaka.media.StreamingEngine = class {
 
   /**
    * @param {!BufferSource} rawResult
-   * @param {shaka.extern.aes128Key} aes128Key
+   * @param {shaka.extern.aesKey} aesKey
    * @param {number} position
    * @return {!Promise.<!BufferSource>} finalResult
    * @private
    */
-  async aes128Decrypt_(rawResult, aes128Key, position) {
-    const key = aes128Key;
+  async aesDecrypt_(rawResult, aesKey, position) {
+    const key = aesKey;
     if (!key.cryptoKey) {
-      goog.asserts.assert(key.fetchKey, 'If AES-128 cryptoKey was not ' +
+      goog.asserts.assert(key.fetchKey, 'If AES cryptoKey was not ' +
           'preloaded, fetchKey function should be provided');
       await key.fetchKey();
-      goog.asserts.assert(key.cryptoKey, 'AES-128 cryptoKey should now be set');
+      goog.asserts.assert(key.cryptoKey, 'AES cryptoKey should now be set');
     }
     let iv = key.iv;
     if (!iv) {
@@ -1556,8 +1725,22 @@ shaka.media.StreamingEngine = class {
         sequence >>= 8;
       }
     }
-    return window.crypto.subtle.decrypt(
-        {name: 'AES-CBC', iv}, key.cryptoKey, rawResult);
+    let algorithm;
+    if (aesKey.blockCipherMode == 'CBC') {
+      algorithm = {
+        name: 'AES-CBC',
+        iv,
+      };
+    } else {
+      algorithm = {
+        name: 'AES-CTR',
+        counter: iv,
+        // NIST SP800-38A standard suggests that the counter should occupy half
+        // of the counter block
+        length: 64,
+      };
+    }
+    return window.crypto.subtle.decrypt(algorithm, key.cryptoKey, rawResult);
   }
 
 
@@ -1730,7 +1913,7 @@ shaka.media.StreamingEngine = class {
       const isResetMediaSourceNecessary =
           mediaState.lastCodecs && mediaState.lastMimeType &&
           this.playerInterface_.mediaSourceEngine.isResetMediaSourceNecessary(
-              mediaState.type, mediaState.stream);
+              mediaState.type, mediaState.stream, mimeType, codecs);
       if (isResetMediaSourceNecessary) {
         let otherState = null;
         if (mediaState.type === ContentType.VIDEO) {
@@ -1739,9 +1922,16 @@ shaka.media.StreamingEngine = class {
           otherState = this.mediaStates_.get(ContentType.VIDEO);
         }
         if (otherState) {
+          // First, abort all operations in progress on the other stream.
+          await this.abortOperations_(otherState).catch(() => {});
+          // 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;
+          // 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
+          // state.
           this.forceClearBuffer_(otherState);
-          this.abortOperations_(otherState).catch(() => {});
         }
       }
 
@@ -1772,19 +1962,6 @@ shaka.media.StreamingEngine = class {
               appendWindowEnd, ignoreTimestampOffset,
               reference.mimeType || mediaState.stream.mimeType,
               reference.codecs || mediaState.stream.codecs, streamsByType);
-          if (isResetMediaSourceNecessary) {
-            let otherState = null;
-            if (mediaState.type === ContentType.VIDEO) {
-              otherState = this.mediaStates_.get(ContentType.AUDIO);
-            } else if (mediaState.type === ContentType.AUDIO) {
-              otherState = this.mediaStates_.get(ContentType.VIDEO);
-            }
-            if (otherState) {
-              otherState.waitingToClearBuffer = false;
-              otherState.performingUpdate = false;
-              this.forceClearBuffer_(otherState);
-            }
-          }
         } catch (error) {
           mediaState.lastAppendWindowStart = null;
           mediaState.lastAppendWindowEnd = null;
@@ -1817,8 +1994,15 @@ shaka.media.StreamingEngine = class {
             let lastTimescale = null;
             const timescaleMap = new Map();
 
+            /** @type {!shaka.extern.SpatialVideoInfo} */
+            const spatialVideoInfo = {
+              projection: null,
+              hfov: null,
+            };
+
             const parser = new shaka.util.Mp4Parser();
             const Mp4Parser = shaka.util.Mp4Parser;
+            const Mp4BoxParsers = shaka.util.Mp4BoxParsers;
             parser.box('moov', Mp4Parser.children)
                 .box('trak', Mp4Parser.children)
                 .box('mdia', Mp4Parser.children)
@@ -1826,13 +2010,12 @@ shaka.media.StreamingEngine = class {
                   goog.asserts.assert(
                       box.version != null,
                       'MDHD is a full box and should have a valid version.');
-                  const parsedMDHDBox = shaka.util.Mp4BoxParsers.parseMDHD(
+                  const parsedMDHDBox = Mp4BoxParsers.parseMDHD(
                       box.reader, box.version);
                   lastTimescale = parsedMDHDBox.timescale;
                 })
                 .box('hdlr', (box) => {
-                  const parsedHDLR = shaka.util.Mp4BoxParsers.parseHDLR(
-                      box.reader);
+                  const parsedHDLR = Mp4BoxParsers.parseHDLR(box.reader);
                   switch (parsedHDLR.handlerType) {
                     case 'soun':
                       timescaleMap.set(ContentType.AUDIO, lastTimescale);
@@ -1843,8 +2026,32 @@ shaka.media.StreamingEngine = class {
                   }
                   lastTimescale = null;
                 })
+                .box('minf', Mp4Parser.children)
+                .box('stbl', Mp4Parser.children)
+                .fullBox('stsd', Mp4Parser.sampleDescription)
+                .box('encv', Mp4Parser.visualSampleEntry)
+                .box('avc1', Mp4Parser.visualSampleEntry)
+                .box('avc3', Mp4Parser.visualSampleEntry)
+                .box('hev1', Mp4Parser.visualSampleEntry)
+                .box('hvc1', Mp4Parser.visualSampleEntry)
+                .box('dvav', Mp4Parser.visualSampleEntry)
+                .box('dva1', Mp4Parser.visualSampleEntry)
+                .box('dvh1', Mp4Parser.visualSampleEntry)
+                .box('dvhe', Mp4Parser.visualSampleEntry)
+                .box('vexu', Mp4Parser.children)
+                .box('proj', Mp4Parser.children)
+                .fullBox('prji', (box) => {
+                  const parsedPRJIBox = Mp4BoxParsers.parsePRJI(box.reader);
+                  spatialVideoInfo.projection = parsedPRJIBox.projection;
+                })
+                .box('hfov', (box) => {
+                  const parsedHFOVBox = Mp4BoxParsers.parseHFOV(box.reader);
+                  spatialVideoInfo.hfov = parsedHFOVBox.hfov;
+                })
                 .parse(initSegment);
 
+            this.updateSpatialVideoInfo_(spatialVideoInfo);
+
             if (timescaleMap.has(mediaState.type)) {
               reference.initSegmentReference.timescale =
                   timescaleMap.get(mediaState.type);
@@ -1879,9 +2086,7 @@ shaka.media.StreamingEngine = class {
       // Across discontinuity bounds, we should resync timestamps for
       // sequence mode playbacks.  The next segment appended should
       // land at its theoretical timestamp from the segment index.
-      if (reference.discontinuitySequence != lastDiscontinuitySequence ||
-          mediaState.needsResync) {
-        mediaState.needsResync = false;
+      if (reference.discontinuitySequence != lastDiscontinuitySequence) {
         operations.push(this.playerInterface_.mediaSourceEngine.resync(
             mediaState.type, reference.startTime));
       }
@@ -2164,12 +2369,13 @@ shaka.media.StreamingEngine = class {
 
     const overflow = bufferedBehind - bufferBehind;
     // See: https://github.com/shaka-project/shaka-player/issues/6240
-    if (overflow <= 1) {
+    if (overflow <= this.config_.evictionGoal) {
       shaka.log.v2(logPrefix,
           'buffer behind okay:',
           'presentationTime=' + presentationTime,
           'bufferedBehind=' + bufferedBehind,
           'bufferBehind=' + bufferBehind,
+          'evictionGoal=' + this.config_.evictionGoal,
           'underflow=' + Math.abs(overflow));
       return;
     }
@@ -2179,6 +2385,7 @@ shaka.media.StreamingEngine = class {
         'presentationTime=' + presentationTime,
         'bufferedBehind=' + bufferedBehind,
         'bufferBehind=' + bufferBehind,
+        'evictionGoal=' + this.config_.evictionGoal,
         'overflow=' + overflow);
 
     await this.playerInterface_.mediaSourceEngine.remove(mediaState.type,
@@ -2217,11 +2424,9 @@ shaka.media.StreamingEngine = class {
    * @private
    */
   async fetch_(mediaState, reference, streamDataCallback) {
-    if (reference instanceof shaka.media.InitSegmentReference) {
-      const segmentData = reference.getSegmentData();
-      if (segmentData) {
-        return segmentData;
-      }
+    const segmentData = reference.getSegmentData();
+    if (segmentData) {
+      return segmentData;
     }
     let op = null;
     if (mediaState.segmentPrefetch) {
@@ -2242,8 +2447,8 @@ shaka.media.StreamingEngine = class {
     const response = await op.promise;
     mediaState.operation = null;
     let result = response.data;
-    if (reference.aes128Key) {
-      result = await this.aes128Decrypt_(result, reference.aes128Key, position);
+    if (reference.aesKey) {
+      result = await this.aesDecrypt_(result, reference.aesKey, position);
     }
     return result;
   }
@@ -2260,6 +2465,27 @@ shaka.media.StreamingEngine = class {
    * @private
    */
   dispatchFetch_(reference, stream, streamDataCallback) {
+    goog.asserts.assert(
+        this.playerInterface_.netEngine, 'Must have net engine');
+    return shaka.media.StreamingEngine.dispatchFetch(
+        reference, stream, streamDataCallback || null,
+        this.config_.retryParameters, this.playerInterface_.netEngine);
+  }
+
+  /**
+   * Fetches the given segment.
+   *
+   * @param {!shaka.extern.Stream} stream
+   * @param {(!shaka.media.InitSegmentReference|!shaka.media.SegmentReference)}
+   *   reference
+   * @param {?function(BufferSource):!Promise} streamDataCallback
+   * @param {shaka.extern.RetryParameters} retryParameters
+   * @param {!shaka.net.NetworkingEngine} netEngine
+   *
+   * @return {!shaka.net.NetworkingEngine.PendingRequest}
+   */
+  static dispatchFetch(
+      reference, stream, streamDataCallback, retryParameters, netEngine) {
     const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
     const segment = reference instanceof shaka.media.SegmentReference ?
         reference : undefined;
@@ -2270,17 +2496,13 @@ shaka.media.StreamingEngine = class {
         reference.getUris(),
         reference.startByte,
         reference.endByte,
-        this.config_.retryParameters,
+        retryParameters,
         streamDataCallback);
+    request.contentType = stream.type;
 
     shaka.log.v2('fetching: reference=', reference);
 
-    return this.playerInterface_.netEngine.request(
-        requestType, request, {
-          type: type,
-          stream: stream,
-          segment: segment,
-        });
+    return netEngine.request(requestType, request, {type, stream, segment});
   }
 
   /**
@@ -2310,7 +2532,8 @@ shaka.media.StreamingEngine = class {
     mediaState.segmentIterator = null;
 
     shaka.log.debug(logPrefix, 'clearing buffer');
-    if (mediaState.segmentPrefetch) {
+    if (mediaState.segmentPrefetch &&
+        !this.audioPrefetchMap_.has(mediaState.stream)) {
       mediaState.segmentPrefetch.clearAll();
     }
 
@@ -2504,6 +2727,31 @@ shaka.media.StreamingEngine = class {
     return true;
   }
 
+  /**
+   * Update the spatial video info and notify to the app.
+   *
+   * @param {shaka.extern.SpatialVideoInfo} info
+   * @private
+   */
+  updateSpatialVideoInfo_(info) {
+    if (this.spatialVideoInfo_.projection != info.projection ||
+        this.spatialVideoInfo_.hfov != info.hfov) {
+      const EventName = shaka.util.FakeEvent.EventName;
+      let event;
+      if (info.projection != null || info.hfov != null) {
+        const eventName = EventName.SpatialVideoInfoEvent;
+        const data = (new Map()).set('detail', info);
+        event = new shaka.util.FakeEvent(eventName, data);
+      } else {
+        const eventName = EventName.NoSpatialVideoInfoEvent;
+        event = new shaka.util.FakeEvent(eventName);
+      }
+      event.cancelable = true;
+      this.playerInterface_.onEvent(event);
+      this.spatialVideoInfo_ = info;
+    }
+  }
+
   /**
    * @param {shaka.media.StreamingEngine.MediaState_} mediaState
    * @return {string} A log prefix of the form ($CONTENT_TYPE:$STREAM_ID), e.g.,
@@ -2591,7 +2839,6 @@ shaka.media.StreamingEngine.PlayerInterface;
  *   clearBufferSafeMargin: number,
  *   clearingBuffer: boolean,
  *   seeked: boolean,
- *   needsResync: boolean,
  *   adaptation: boolean,
  *   recovering: boolean,
  *   hasError: boolean,
@@ -2646,9 +2893,6 @@ shaka.media.StreamingEngine.PlayerInterface;
  *   True indicates that the presentation just seeked.
  * @property {boolean} adaptation
  *   True indicates that the presentation just automatically switched variants.
- * @property {boolean} needsResync
- *   True indicates that the stream needs to be resynced in sequence mode,
- *   regardless of discontinuity sequence.
  * @property {boolean} recovering
  *   True indicates that the last segment was not appended because it could not
  *   fit in the buffer.