shaka-player 4.11.13 → 4.12.1

package/lib/media/media_source_engine.js

@@ -20,8 +20,10 @@ goog.require('shaka.text.TextEngine');
 goog.require('shaka.transmuxer.TransmuxerEngine');
 goog.require('shaka.util.BufferUtils');
 goog.require('shaka.util.Destroyer');
+goog.require('shaka.util.Dom');
 goog.require('shaka.util.Error');
 goog.require('shaka.util.EventManager');
+goog.require('shaka.util.FakeEvent');
 goog.require('shaka.util.Functional');
 goog.require('shaka.util.IDestroyable');
 goog.require('shaka.util.Id3Utils');
@@ -116,6 +118,22 @@ shaka.media.MediaSourceEngine = class {
     /** @private {boolean} */
     this.playbackHasBegun_ = false;
 
+    /** @private {boolean} */
+    this.streamingAllowed_ = true;
+
+    /** @private {boolean} */
+    this.usingRemotePlayback_ = false;
+
+    /** @private {HTMLSourceElement} */
+    this.source_ = null;
+
+    /**
+     * Fallback source element with direct media URI, used for casting
+     * purposes.
+     * @private {HTMLSourceElement}
+     */
+    this.secondarySource_ = null;
+
     /** @private {MediaSource} */
     this.mediaSource_ = this.createMediaSource(this.mediaSourceOpen_);
 
@@ -143,9 +161,6 @@ shaka.media.MediaSourceEngine = class {
     /** @private {boolean} */
     this.needSplitMuxedContent_ = false;
 
-    /** @private {boolean} */
-    this.streamingAllowed_ = true;
-
     /** @private {?number} */
     this.lastDuration_ = null;
 
@@ -167,6 +182,22 @@ shaka.media.MediaSourceEngine = class {
 
     /** @private {!shaka.util.PublicPromise.<number>} */
     this.audioCompensation_ = new shaka.util.PublicPromise();
+
+    if (this.video_.remote) {
+      this.usingRemotePlayback_ = this.video_.remote.state != 'disconnected';
+
+      this.eventManager_.listen(this.video_.remote, 'connect', () => {
+        this.usingRemotePlayback_ = this.video_.remote.state != 'disconnected';
+      });
+
+      this.eventManager_.listen(this.video_.remote, 'connecting', () => {
+        this.usingRemotePlayback_ = this.video_.remote.state != 'disconnected';
+      });
+
+      this.eventManager_.listen(this.video_.remote, 'disconnect', () => {
+        this.usingRemotePlayback_ = this.video_.remote.state != 'disconnected';
+      });
+    }
   }
 
   /**
@@ -185,7 +216,9 @@ shaka.media.MediaSourceEngine = class {
     let mediaSource;
 
     if (window.ManagedMediaSource) {
-      this.video_.disableRemotePlayback = true;
+      if (!this.secondarySource_) {
+        this.video_.disableRemotePlayback = true;
+      }
 
       mediaSource = new ManagedMediaSource();
 
@@ -216,11 +249,41 @@ shaka.media.MediaSourceEngine = class {
     // Store the object URL for releasing it later.
     this.url_ = shaka.media.MediaSourceEngine.createObjectURL(mediaSource);
 
-    this.video_.src = this.url_;
+    this.video_.removeAttribute('src');
+    if (this.source_) {
+      this.video_.removeChild(this.source_);
+    }
+    if (this.secondarySource_) {
+      this.video_.removeChild(this.secondarySource_);
+    }
+    this.source_ = shaka.util.Dom.createSourceElement(this.url_);
+    this.video_.appendChild(this.source_);
+    if (this.secondarySource_) {
+      this.video_.appendChild(this.secondarySource_);
+    }
+    this.video_.load();
 
     return mediaSource;
   }
 
+  /**
+   * @param {string} uri
+   * @param {string} mimeType
+   */
+  addSecondarySource(uri, mimeType) {
+    if (!this.video_ || !(this.mediaSource_ instanceof ManagedMediaSource)) {
+      shaka.log.warning(
+          'Secondary source is used only with ManagedMediaSource');
+      return;
+    }
+    if (this.secondarySource_) {
+      this.video_.removeChild(this.secondarySource_);
+    }
+    this.secondarySource_ = shaka.util.Dom.createSourceElement(uri, mimeType);
+    this.video_.appendChild(this.secondarySource_);
+    this.video_.disableRemotePlayback = false;
+  }
+
   /**
    * @param {shaka.util.PublicPromise} p
    * @private
@@ -317,6 +380,7 @@ shaka.media.MediaSourceEngine = class {
       'video/mp4; codecs="vp9"',
       'video/mp4; codecs="vp09.00.10.08"',
       'video/mp4; codecs="av01.0.01M.08"',
+      'video/mp4; codecs="dvh1.05.01"',
       'video/mp4; codecs="dvh1.20.01"',
       'audio/mp4; codecs="mp4a.40.2"',
       'audio/mp4; codecs="ac-3"',
@@ -413,13 +477,19 @@ shaka.media.MediaSourceEngine = class {
       this.eventManager_ = null;
     }
 
-    if (this.video_) {
+    if (this.video_ && this.secondarySource_) {
+      this.video_.removeChild(this.secondarySource_);
+    }
+    if (this.video_ && this.source_) {
       // "unload" the video element.
-      this.video_.removeAttribute('src');
+      this.video_.removeChild(this.source_);
       this.video_.load();
-      this.video_ = null;
+      this.video_.disableRemotePlayback = false;
     }
 
+    this.video_ = null;
+    this.source_ = null;
+    this.secondarySource_ = null;
     this.config_ = null;
     this.mediaSource_ = null;
     this.textEngine_ = null;
@@ -492,6 +562,11 @@ shaka.media.MediaSourceEngine = class {
         !this.ignoreManifestTimestampsInSegmentsMode_;
 
     this.tsParsers_ = {};
+    this.firstVideoTimestamp_ = null;
+    this.firstVideoReferenceStartTime_ = null;
+    this.firstAudioTimestamp_ = null;
+    this.firstAudioReferenceStartTime_ = null;
+    this.audioCompensation_ = new shaka.util.PublicPromise();
 
     for (const contentType of streamsByType.keys()) {
       const stream = streamsByType.get(contentType);
@@ -504,6 +579,10 @@ shaka.media.MediaSourceEngine = class {
         this.queues_[contentType] = [];
       }
     }
+    const audio = streamsByType.get(ContentType.AUDIO);
+    if (audio && audio.isAudioMuxedInVideo) {
+      this.needSplitMuxedContent_ = true;
+    }
   }
 
   /**
@@ -613,7 +692,7 @@ shaka.media.MediaSourceEngine = class {
    * @return {boolean}
    */
   isStreamingAllowed() {
-    return this.streamingAllowed_;
+    return this.streamingAllowed_ && !this.usingRemotePlayback_;
   }
 
   /**
@@ -752,7 +831,7 @@ shaka.media.MediaSourceEngine = class {
    * @private
    */
   getBuffered_(contentType) {
-    if (this.reloadingMediaSource_) {
+    if (this.reloadingMediaSource_ || this.usingRemotePlayback_) {
       return null;
     }
     try {
@@ -780,15 +859,18 @@ shaka.media.MediaSourceEngine = class {
   }
 
   /**
+   * This method is only public for testing.
+   *
    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
    * @param {!BufferSource} data
-   * @param {?shaka.media.SegmentReference} reference The segment reference
-   *   we are appending, or null for init segments
+   * @param {!shaka.media.SegmentReference} reference The segment reference
+   *   we are appending
+   * @param {shaka.extern.Stream} stream
    * @param {!string} mimeType
    * @return {{timestamp: ?number, metadata: !Array.<shaka.extern.ID3Metadata>}}
-   * @private
    */
-  getTimestampAndDispatchMetadata_(contentType, data, reference, mimeType) {
+  getTimestampAndDispatchMetadata(contentType, data, reference, stream,
+      mimeType) {
     let timestamp = null;
     let metadata = [];
 
@@ -815,15 +897,23 @@ shaka.media.MediaSourceEngine = class {
             [id3Metadata], /* offset= */ 0, reference.endTime);
       }
     } else if (mimeType.includes('/mp4') &&
-        reference && reference.timestampOffset == 0 &&
+        reference &&
         reference.initSegmentReference &&
         reference.initSegmentReference.timescale) {
       const timescale = reference.initSegmentReference.timescale;
       if (!isNaN(timescale)) {
+        const hasEmsg = ((stream.emsgSchemeIdUris != null &&
+            stream.emsgSchemeIdUris.length > 0) ||
+            this.config_.dispatchAllEmsgBoxes);
         const Mp4Parser = shaka.util.Mp4Parser;
         let startTime = 0;
         let parsedMedia = false;
-        new Mp4Parser()
+        const parser = new Mp4Parser();
+        if (hasEmsg) {
+          parser.fullBox('emsg', (box) =>
+            this.parseEMSG_(reference, stream.emsgSchemeIdUris, box));
+        }
+        parser.fullBox('prft', (box) => this.parsePrft_(timescale, box))
             .box('moof', Mp4Parser.children)
             .box('traf', Mp4Parser.children)
             .fullBox('tfdt', (box) => {
@@ -836,7 +926,7 @@ shaka.media.MediaSourceEngine = class {
               parsedMedia = true;
               box.parser.stop();
             }).parse(data, /* partialOkay= */ true);
-        if (parsedMedia) {
+        if (parsedMedia && reference.timestampOffset == 0) {
           timestamp = startTime;
         }
       }
@@ -857,6 +947,172 @@ shaka.media.MediaSourceEngine = class {
     return {timestamp, metadata};
   }
 
+
+  /**
+   * Parse the EMSG box from a MP4 container.
+   *
+   * @param {!shaka.media.SegmentReference} reference
+   * @param {?Array.<string>} emsgSchemeIdUris Array of emsg
+   *     scheme_id_uri for which emsg boxes should be parsed.
+   * @param {!shaka.extern.ParsedBox} box
+   * @private
+   * https://dashif-documents.azurewebsites.net/Events/master/event.html#emsg-format
+   * aligned(8) class DASHEventMessageBox
+   *    extends FullBox(‘emsg’, version, flags = 0){
+   * if (version==0) {
+   *   string scheme_id_uri;
+   *   string value;
+   *   unsigned int(32) timescale;
+   *   unsigned int(32) presentation_time_delta;
+   *   unsigned int(32) event_duration;
+   *   unsigned int(32) id;
+   * } else if (version==1) {
+   *   unsigned int(32) timescale;
+   *   unsigned int(64) presentation_time;
+   *   unsigned int(32) event_duration;
+   *   unsigned int(32) id;
+   *   string scheme_id_uri;
+   *   string value;
+   * }
+   * unsigned int(8) message_data[];
+   */
+  parseEMSG_(reference, emsgSchemeIdUris, box) {
+    let timescale;
+    let id;
+    let eventDuration;
+    let schemeId;
+    let startTime;
+    let presentationTimeDelta;
+    let value;
+
+    if (box.version === 0) {
+      schemeId = box.reader.readTerminatedString();
+      value = box.reader.readTerminatedString();
+      timescale = box.reader.readUint32();
+      presentationTimeDelta = box.reader.readUint32();
+      eventDuration = box.reader.readUint32();
+      id = box.reader.readUint32();
+      startTime = reference.startTime + (presentationTimeDelta / timescale);
+    } else {
+      timescale = box.reader.readUint32();
+      const pts = box.reader.readUint64();
+      startTime = (pts / timescale) + reference.timestampOffset;
+      presentationTimeDelta = startTime - reference.startTime;
+      eventDuration = box.reader.readUint32();
+      id = box.reader.readUint32();
+      schemeId = box.reader.readTerminatedString();
+      value = box.reader.readTerminatedString();
+    }
+    const messageData = box.reader.readBytes(
+        box.reader.getLength() - box.reader.getPosition());
+
+    // See DASH sec. 5.10.3.3.1
+    // If a DASH client detects an event message box with a scheme that is not
+    // defined in MPD, the client is expected to ignore it.
+    if ((emsgSchemeIdUris && emsgSchemeIdUris.includes(schemeId)) ||
+        this.config_.dispatchAllEmsgBoxes) {
+      // See DASH sec. 5.10.4.1
+      // A special scheme in DASH used to signal manifest updates.
+      if (schemeId == 'urn:mpeg:dash:event:2012') {
+        this.playerInterface_.onManifestUpdate();
+      } else {
+        // All other schemes are dispatched as a general 'emsg' event.
+        const endTime = startTime + (eventDuration / timescale);
+        /** @type {shaka.extern.EmsgInfo} */
+        const emsg = {
+          startTime: startTime,
+          endTime: endTime,
+          schemeIdUri: schemeId,
+          value: value,
+          timescale: timescale,
+          presentationTimeDelta: presentationTimeDelta,
+          eventDuration: eventDuration,
+          id: id,
+          messageData: messageData,
+        };
+
+        // Dispatch an event to notify the application about the emsg box.
+        const eventName = shaka.util.FakeEvent.EventName.Emsg;
+        const data = (new Map()).set('detail', emsg);
+        const event = new shaka.util.FakeEvent(eventName, data);
+        // A user can call preventDefault() on a cancelable event.
+        event.cancelable = true;
+
+        this.playerInterface_.onEvent(event);
+
+        if (event.defaultPrevented) {
+          // If the caller uses preventDefault() on the 'emsg' event, don't
+          // process any further, and don't generate an ID3 'metadata' event
+          // for the same data.
+          return;
+        }
+
+        // Additionally, ID3 events generate a 'metadata' event.  This is a
+        // pre-parsed version of the metadata blob already dispatched in the
+        // 'emsg' event.
+        if (schemeId == 'https://aomedia.org/emsg/ID3' ||
+            schemeId == 'https://developer.apple.com/streaming/emsg-id3') {
+          // See https://aomediacodec.github.io/id3-emsg/
+          const frames = shaka.util.Id3Utils.getID3Frames(messageData);
+          if (frames.length) {
+            /** @private {shaka.extern.ID3Metadata} */
+            const metadata = {
+              cueTime: startTime,
+              data: messageData,
+              frames: frames,
+              dts: startTime,
+              pts: startTime,
+            };
+            this.playerInterface_.onMetadata(
+                [metadata], /* offset= */ 0, endTime);
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Parse PRFT box.
+   * @param {number} timescale
+   * @param {!shaka.extern.ParsedBox} box
+   * @private
+   */
+  parsePrft_(timescale, box) {
+    goog.asserts.assert(
+        box.version == 0 || box.version == 1,
+        'PRFT version can only be 0 or 1');
+    const parsed = shaka.util.Mp4BoxParsers.parsePRFTInaccurate(
+        box.reader, box.version);
+
+    const wallClockTime = this.convertNtp_(parsed.ntpTimestamp);
+    const programStartDate = new Date(wallClockTime -
+      (parsed.mediaTime / timescale) * 1000);
+    /** @type {shaka.extern.ProducerReferenceTime} */
+    const prftInfo = {
+      wallClockTime,
+      programStartDate,
+    };
+
+    const eventName = shaka.util.FakeEvent.EventName.Prft;
+    const data = (new Map()).set('detail', prftInfo);
+    const event = new shaka.util.FakeEvent(
+        eventName, data);
+    this.playerInterface_.onEvent(event);
+  }
+
+
+  /**
+   * Convert Ntp ntpTimeStamp to UTC Time
+   *
+   * @param {number} ntpTimeStamp
+   * @return {number} utcTime
+   * @private
+   */
+  convertNtp_(ntpTimeStamp) {
+    const start = new Date(Date.UTC(1900, 0, 1, 0, 0, 0));
+    return new Date(start.getTime() + ntpTimeStamp).getTime();
+  }
+
   /**
    * Enqueue an operation to append data to the SourceBuffer.
    * Start and end times are needed for TextEngine, but not for MediaSource.
@@ -918,8 +1174,8 @@ shaka.media.MediaSourceEngine = class {
       mimeType = this.transmuxers_[contentType].getOriginalMimeType();
     }
     if (reference) {
-      const {timestamp, metadata} = this.getTimestampAndDispatchMetadata_(
-          contentType, data, reference, mimeType);
+      const {timestamp, metadata} = this.getTimestampAndDispatchMetadata(
+          contentType, data, reference, stream, mimeType);
       if (timestamp != null) {
         if (this.firstVideoTimestamp_ == null &&
             contentType == ContentType.VIDEO) {
@@ -1940,6 +2196,10 @@ shaka.media.MediaSourceEngine = class {
           this.queues_[contentType] = [];
         }
       }
+      const audio = streamsByType.get(ContentType.AUDIO);
+      if (audio && audio.isAudioMuxedInVideo) {
+        this.needSplitMuxedContent_ = true;
+      }
 
       // Fake a seek to catchup the playhead.
       this.video_.currentTime = currentTime;
@@ -2215,7 +2475,9 @@ shaka.media.MediaSourceEngine.SourceBufferMode_ = {
 /**
  * @typedef {{
  *   getKeySystem: function():?string,
- *   onMetadata: function(!Array<shaka.extern.ID3Metadata>, number, ?number)
+ *   onMetadata: function(!Array<shaka.extern.ID3Metadata>, number, ?number),
+ *   onEvent: function(!Event),
+ *   onManifestUpdate: function()
  * }}
  *
  * @summary Player interface
@@ -2224,5 +2486,9 @@ shaka.media.MediaSourceEngine.SourceBufferMode_ = {
  * @property {function(
  *     !Array<shaka.extern.ID3Metadata>, number, ?number)} onMetadata
  *   Callback to use when metadata arrives.
+ * @property {function(!Event)} onEvent
+ *   Called when an event occurs that should be sent to the app.
+ * @property {function()} onManifestUpdate
+ *   Called when an embedded 'emsg' box should trigger a manifest update.
  */
 shaka.media.MediaSourceEngine.PlayerInterface;

package/lib/media/playhead.js

@@ -517,7 +517,9 @@ shaka.media.MediaSourcePlayhead = class {
 
     if (currentTime > end) {
       shaka.log.v1('Playhead past end.');
-      return end;
+      // We remove the safeSeekEndOffset of the seek end to avoid the player
+      // to be block at the edge in a live stream
+      return end - this.config_.safeSeekEndOffset;
     }
 
     if (currentTime < start) {

package/lib/media/preload_manager.js

@@ -607,9 +607,10 @@ shaka.media.PreloadManager = class extends shaka.util.FakeEventTarget {
    * Performs a final filtering of the manifest, and chooses the initial
    * variant.
    *
+   * @return {!Promise}
    * @private
    */
-  chooseInitialVariantInner_() {
+  async chooseInitialVariantInner_() {
     goog.asserts.assert(
         this.manifest_, 'The manifest should already be parsed.');
 
@@ -630,7 +631,6 @@ shaka.media.PreloadManager = class extends shaka.util.FakeEventTarget {
               this.config_.preferredAudioLabel,
               this.config_.preferredVideoLabel,
               this.config_.mediaSource.codecSwitchingStrategy,
-              this.config_.manifest.dash.enableAudioGroups,
               /* audioCodec= */ '');
     }
 
@@ -656,13 +656,15 @@ shaka.media.PreloadManager = class extends shaka.util.FakeEventTarget {
       this.abrManager_.setVariants(Array.from(adaptationSet.values()));
       const variant = this.abrManager_.chooseVariant();
       if (variant) {
+        const promises = [];
         this.prefetchedVariant_ = variant;
         if (variant.video) {
-          this.makePrefetchForStream_(variant.video, isLive);
+          promises.push(this.prefetchStream_(variant.video, isLive));
         }
         if (variant.audio) {
-          this.makePrefetchForStream_(variant.audio, isLive);
+          promises.push(this.prefetchStream_(variant.audio, isLive));
         }
+        await Promise.all(promises);
       }
     }
   }
@@ -673,7 +675,7 @@ shaka.media.PreloadManager = class extends shaka.util.FakeEventTarget {
    * @return {!Promise}
    * @private
    */
-  async makePrefetchForStream_(stream, isLive) {
+  async prefetchStream_(stream, isLive) {
     // Use the prefetch limit from the config if this is set, otherwise use 2.
     const prefetchLimit = this.config_.streaming.segmentPrefetchLimit || 2;
     const prefetch = new shaka.media.SegmentPrefetch(
@@ -701,13 +703,14 @@ shaka.media.PreloadManager = class extends shaka.util.FakeEventTarget {
       if (isLive) {
         // Preload only the init segment for Live
         if (prefetchSegment.initSegmentReference) {
-          prefetch.prefetchInitSegment(prefetchSegment.initSegmentReference);
+          await prefetch.prefetchInitSegment(
+              prefetchSegment.initSegmentReference);
         }
       } else {
         // Preload a segment, too... either the first segment, or the segment
         // that corresponds with this.startTime_, as appropriate.
         // Note: this method also preload the init segment
-        prefetch.prefetchSegmentsByTime(prefetchSegment.startTime);
+        await prefetch.prefetchSegmentsByTime(prefetchSegment.startTime);
       }
     }
   }

package/lib/media/segment_prefetch.js

@@ -12,6 +12,7 @@ goog.require('shaka.media.InitSegmentReference');
 goog.require('shaka.media.SegmentIterator');
 goog.require('shaka.media.SegmentReference');
 goog.require('shaka.net.NetworkingEngine');
+goog.require('shaka.util.Error');
 goog.require('shaka.util.Uint8ArrayUtils');
 
 
@@ -74,6 +75,7 @@ shaka.media.SegmentPrefetch = class {
    *
    * @param {number} currTime
    * @param {boolean=} skipFirst
+   * @return {!Promise}
    * @public
    */
   prefetchSegmentsByTime(currTime, skipFirst = false) {
@@ -83,7 +85,7 @@ shaka.media.SegmentPrefetch = class {
     const logPrefix = shaka.media.SegmentPrefetch.logPrefix_(this.stream_);
     if (!this.stream_.segmentIndex) {
       shaka.log.debug(logPrefix, 'missing segmentIndex');
-      return;
+      return Promise.resolve();
     }
     if (!this.iterator_) {
       this.iterator_ = this.stream_.segmentIndex.getIteratorForTime(
@@ -91,11 +93,12 @@ shaka.media.SegmentPrefetch = class {
     }
     if (!this.iterator_) {
       shaka.log.debug(logPrefix, 'missing iterator');
-      return;
+      return Promise.resolve();
     }
     if (skipFirst) {
       this.iterator_.next();
     }
+    const promises = [];
     while (this.segmentPrefetchMap_.size < this.prefetchLimit_) {
       const reference = this.iterator_.next().value;
       if (!reference) {
@@ -115,22 +118,26 @@ shaka.media.SegmentPrefetch = class {
         prefetchAllowed = false;
       }
       if (prefetchAllowed && reference.initSegmentReference) {
-        this.prefetchInitSegment(reference.initSegmentReference);
+        promises.push(this.prefetchInitSegment(
+            reference.initSegmentReference));
       }
       if (prefetchAllowed && !this.segmentPrefetchMap_.has(reference)) {
         const segmentPrefetchOperation =
           new shaka.media.SegmentPrefetchOperation(this.fetchDispatcher_);
-        segmentPrefetchOperation.dispatchFetch(reference, this.stream_);
+        promises.push(segmentPrefetchOperation.dispatchFetch(
+            reference, this.stream_));
         this.segmentPrefetchMap_.set(reference, segmentPrefetchOperation);
       }
     }
     this.clearInitSegments_();
+    return Promise.all(promises);
   }
 
   /**
    * Fetch init segment.
    *
    * @param {!shaka.media.InitSegmentReference} initSegmentReference
+   * @return {!Promise}
    */
   prefetchInitSegment(initSegmentReference) {
     goog.asserts.assert(this.prefetchLimit_ > 0,
@@ -139,11 +146,11 @@ shaka.media.SegmentPrefetch = class {
     const logPrefix = shaka.media.SegmentPrefetch.logPrefix_(this.stream_);
     if (!this.stream_.segmentIndex) {
       shaka.log.debug(logPrefix, 'missing segmentIndex');
-      return;
+      return Promise.resolve();
     }
 
     if (initSegmentReference.getSegmentData()) {
-      return;
+      return Promise.resolve();
     }
 
     // init segments are ignored from the prefetch limit
@@ -152,14 +159,16 @@ shaka.media.SegmentPrefetch = class {
       return shaka.media.InitSegmentReference.equal(
           reference, initSegmentReference);
     });
-    if (!someReference) {
-      const segmentPrefetchOperation =
-        new shaka.media.SegmentPrefetchOperation(this.fetchDispatcher_);
-      segmentPrefetchOperation.dispatchFetch(
-          initSegmentReference, this.stream_);
-      this.initSegmentPrefetchMap_.set(
-          initSegmentReference, segmentPrefetchOperation);
+    if (someReference) {
+      return Promise.resolve();
     }
+    const segmentPrefetchOperation = new shaka.media.SegmentPrefetchOperation(
+        this.fetchDispatcher_);
+    const promise = segmentPrefetchOperation.dispatchFetch(
+        initSegmentReference, this.stream_);
+    this.initSegmentPrefetchMap_.set(
+        initSegmentReference, segmentPrefetchOperation);
+    return promise;
   }
 
   /**
@@ -415,6 +424,7 @@ shaka.media.SegmentPrefetchOperation = class {
    * @param {!(shaka.media.SegmentReference|shaka.media.InitSegmentReference)}
    *        reference
    * @param {!shaka.extern.Stream} stream
+   * @return {!Promise}
    * @public
    */
   dispatchFetch(reference, stream) {
@@ -433,6 +443,15 @@ shaka.media.SegmentPrefetchOperation = class {
             buffered = new Uint8Array(0);
           }
         });
+    return this.operation_.promise.catch((e) => {
+      // Ignore OPERATION_ABORTED errors.
+      if (e instanceof shaka.util.Error &&
+          e.code == shaka.util.Error.Code.OPERATION_ABORTED) {
+        return Promise.resolve();
+      }
+      // Continue to surface other errors.
+      return Promise.reject(e);
+    });
   }
 
   /**

package/lib/media/segment_reference.js

@@ -291,7 +291,7 @@ shaka.media.SegmentReference = class {
     /** @type {?shaka.extern.aesKey} */
     this.aesKey = aesKey;
 
-    /** @type {?shaka.media.SegmentReference.ThumbnailSprite} */
+    /** @type {?shaka.extern.ThumbnailSprite} */
     this.thumbnailSprite = null;
 
     /** @type {number} */
@@ -550,7 +550,7 @@ shaka.media.SegmentReference = class {
   /**
    * Set the segment's thumbnail sprite.
    *
-   * @param {shaka.media.SegmentReference.ThumbnailSprite} thumbnailSprite
+   * @param {shaka.extern.ThumbnailSprite} thumbnailSprite
    * @export
    */
   setThumbnailSprite(thumbnailSprite) {
@@ -560,7 +560,7 @@ shaka.media.SegmentReference = class {
   /**
    * Returns the segment's thumbnail sprite.
    *
-   * @return {?shaka.media.SegmentReference.ThumbnailSprite}
+   * @return {?shaka.extern.ThumbnailSprite}
    * @export
    */
   getThumbnailSprite() {