shaka-player 4.3.11 → 4.4.1

package/lib/media/streaming_engine.js

@@ -17,6 +17,7 @@ goog.require('shaka.media.InitSegmentReference');
 goog.require('shaka.media.MediaSourceEngine');
 goog.require('shaka.media.SegmentIterator');
 goog.require('shaka.media.SegmentReference');
+goog.require('shaka.media.SegmentPrefetch');
 goog.require('shaka.net.Backoff');
 goog.require('shaka.net.NetworkingEngine');
 goog.require('shaka.util.DelayedTick');
@@ -173,6 +174,21 @@ shaka.media.StreamingEngine = class {
     const autoReset = true;
     this.failureCallbackBackoff_ =
         new shaka.net.Backoff(failureRetryParams, autoReset);
+
+    // Allow configuring the segment prefetch in middle of the playback.
+    for (const type of this.mediaStates_.keys()) {
+      const state = this.mediaStates_.get(type);
+      if (state.segmentPrefetch) {
+        state.segmentPrefetch.resetLimit(config.segmentPrefetchLimit);
+        if (!(config.segmentPrefetchLimit > 0)) {
+          // ResetLimit is still needed in this case,
+          // to abort existing prefetch operations.
+          state.segmentPrefetch = null;
+        }
+      } else if (config.segmentPrefetchLimit > 0) {
+        state.segmentPrefetch = this.createSegmentPrefetch_(state.stream);
+      }
+    }
   }
 
 
@@ -451,6 +467,10 @@ shaka.media.StreamingEngine = class {
       return;
     }
 
+    if (mediaState.segmentPrefetch) {
+      mediaState.segmentPrefetch.switchStream(stream);
+    }
+
     if (stream.type == ContentType.TEXT) {
       // Mime types are allowed to change for text streams.
       // Reinitialize the text parser, but only if we are going to fetch the
@@ -806,10 +826,12 @@ shaka.media.StreamingEngine = class {
 
     // Init MediaSourceEngine.
     const mediaSourceEngine = this.playerInterface_.mediaSourceEngine;
-    const forceTransmux = this.config_.forceTransmux;
 
-    await mediaSourceEngine.init(streamsByType, forceTransmux,
-        this.manifest_.sequenceMode);
+    await mediaSourceEngine.init(streamsByType,
+        this.manifest_.sequenceMode,
+        this.manifest_.type,
+        this.manifest_.ignoreManifestTimestampsInSegmentsMode,
+    );
     this.destroyer_.ensureNotDestroyed();
 
     this.updateDuration();
@@ -837,6 +859,7 @@ shaka.media.StreamingEngine = class {
       stream,
       type: stream.type,
       segmentIterator: null,
+      segmentPrefetch: this.createSegmentPrefetch_(stream),
       lastSegmentReference: null,
       lastInitSegmentReference: null,
       lastTimestampOffset: null,
@@ -860,6 +883,31 @@ shaka.media.StreamingEngine = class {
     });
   }
 
+  /**
+   * Creates a media state.
+   *
+   * @param {shaka.extern.Stream} stream
+   * @return {shaka.media.SegmentPrefetch | null}
+   * @private
+   */
+  createSegmentPrefetch_(stream) {
+    if (
+      stream.type !== shaka.util.ManifestParserUtils.ContentType.VIDEO &&
+      stream.type !== shaka.util.ManifestParserUtils.ContentType.AUDIO
+    ) {
+      return null;
+    }
+    if (this.config_.segmentPrefetchLimit > 0) {
+      return new shaka.media.SegmentPrefetch(
+          this.config_.segmentPrefetchLimit,
+          stream,
+          (reference, stream, streamDataCallback) => {
+            return this.dispatchFetch_(reference, stream, streamDataCallback);
+          },
+      );
+    }
+    return null;
+  }
 
   /**
    * Sets the MediaSource's duration.
@@ -947,7 +995,7 @@ shaka.media.StreamingEngine = class {
         mediaState.hasError = false;
       }
     } catch (error) {
-      await this.handleStreamingError_(error);
+      await this.handleStreamingError_(mediaState, error);
       return;
     }
 
@@ -1114,6 +1162,10 @@ shaka.media.StreamingEngine = class {
       return this.config_.updateIntervalSeconds;
     }
 
+    if (mediaState.segmentPrefetch && mediaState.segmentIterator) {
+      mediaState.segmentPrefetch.prefetchSegments(reference);
+    }
+
     const p = this.fetchAndAppend_(mediaState, presentationTime, reference);
     p.catch(() => {});  // TODO(#1993): Handle asynchronous errors.
     return null;
@@ -1278,10 +1330,10 @@ shaka.media.StreamingEngine = class {
               stream.mimeType == 'audio/mp4';
       const isReadableStreamSupported = window.ReadableStream;
       // Enable MP4 low latency streaming with ReadableStream chunked data.
-      // Disabled when AES-128 is present, as we cannot decrypt part of a
-      // segment.
+      // And only for DASH and HLS with byterange optimization.
       if (this.config_.lowLatencyMode && isReadableStreamSupported && isMP4 &&
-          !reference.hlsAes128Key) {
+          (this.manifest_.type != shaka.media.ManifestParser.HLS ||
+          reference.hasByterangeOptimization())) {
         let remaining = new Uint8Array(0);
         let processingResult = false;
         let callbackCalled = false;
@@ -1443,7 +1495,7 @@ shaka.media.StreamingEngine = class {
         mediaState.hasError = true;
 
         error.severity = shaka.util.Error.Severity.CRITICAL;
-        await this.handleStreamingError_(error);
+        await this.handleStreamingError_(mediaState, error);
       }
     }
   }
@@ -1602,6 +1654,8 @@ shaka.media.StreamingEngine = class {
    * @private
    */
   async initSourceBuffer_(mediaState, reference) {
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
+    const MimeUtils = shaka.util.MimeUtils;
     const StreamingEngine = shaka.media.StreamingEngine;
     const logPrefix = StreamingEngine.logPrefix_(mediaState);
 
@@ -1620,28 +1674,69 @@ shaka.media.StreamingEngine = class {
         reference.startTime <= appendWindowEnd,
         logPrefix + ' segment should start before append window end');
 
+    const codecs = MimeUtils.getCodecBase(mediaState.stream.codecs);
+    const mimeType = MimeUtils.getBasicType(mediaState.stream.mimeType);
     const timestampOffset = reference.timestampOffset;
     if (timestampOffset != mediaState.lastTimestampOffset ||
         appendWindowStart != mediaState.lastAppendWindowStart ||
-        appendWindowEnd != mediaState.lastAppendWindowEnd) {
+        appendWindowEnd != mediaState.lastAppendWindowEnd ||
+        codecs != mediaState.lastCodecs ||
+        mimeType != mediaState.lastMimeType) {
       shaka.log.v1(logPrefix, 'setting timestamp offset to ' + timestampOffset);
       shaka.log.v1(logPrefix,
           'setting append window start to ' + appendWindowStart);
       shaka.log.v1(logPrefix,
           'setting append window end to ' + appendWindowEnd);
 
+      if ((mediaState.lastCodecs && codecs != mediaState.lastCodecs) ||
+          (mediaState.lastMimeType && mimeType != mediaState.lastMimeType)) {
+        if (mediaState.type === ContentType.VIDEO) {
+          /** @type {shaka.media.StreamingEngine.MediaState_} */
+          const audioState = this.mediaStates_.get(ContentType.AUDIO);
+          if (audioState) {
+            audioState.lastInitSegmentReference = null;
+            this.abortOperations_(audioState);
+          }
+        } else if (mediaState.type === ContentType.AUDIO) {
+          /** @type {shaka.media.StreamingEngine.MediaState_} */
+          const videoState = this.mediaStates_.get(ContentType.VIDEO);
+          if (videoState) {
+            videoState.lastInitSegmentReference = null;
+            this.abortOperations_(videoState);
+          }
+        }
+      }
+
       const setProperties = async () => {
+        /**
+         * @type {!Map.<shaka.util.ManifestParserUtils.ContentType,
+         *              shaka.extern.Stream>}
+         */
+        const streamsByType = new Map();
+        if (this.currentVariant_.audio) {
+          streamsByType.set(ContentType.AUDIO, this.currentVariant_.audio);
+        }
+        if (this.currentVariant_.video) {
+          streamsByType.set(ContentType.VIDEO, this.currentVariant_.video);
+        }
         try {
           mediaState.lastAppendWindowStart = appendWindowStart;
           mediaState.lastAppendWindowEnd = appendWindowEnd;
+          mediaState.lastCodecs = codecs;
+          mediaState.lastMimeType = mimeType;
           mediaState.lastTimestampOffset = timestampOffset;
 
+          const ignoreTimestampOffset = this.manifest_.sequenceMode ||
+              this.manifest_.type == shaka.media.ManifestParser.HLS;
+
           await this.playerInterface_.mediaSourceEngine.setStreamProperties(
               mediaState.type, timestampOffset, appendWindowStart,
-              appendWindowEnd, this.manifest_.sequenceMode);
+              appendWindowEnd, ignoreTimestampOffset,
+              mediaState.stream, streamsByType);
         } catch (error) {
           mediaState.lastAppendWindowStart = null;
           mediaState.lastAppendWindowEnd = null;
+          mediaState.lastCodecs = null;
           mediaState.lastTimestampOffset = null;
 
           throw error;
@@ -1658,22 +1753,52 @@ shaka.media.StreamingEngine = class {
         shaka.log.v1(logPrefix, 'fetching init segment');
 
         const fetchInit =
-            this.fetch_(mediaState, reference.initSegmentReference);
+            this.fetch_(mediaState, reference.initSegmentReference,
+            /* streamDataCallback= */ undefined, /* isInit= */ true);
         const append = async () => {
           try {
             const initSegment = await fetchInit;
             this.destroyer_.ensureNotDestroyed();
 
+            let lastTimescale = null;
+            const timescaleMap = new Map();
+
             const parser = new shaka.util.Mp4Parser();
             const Mp4Parser = shaka.util.Mp4Parser;
             parser.box('moov', Mp4Parser.children)
                 .box('trak', Mp4Parser.children)
                 .box('mdia', Mp4Parser.children)
                 .fullBox('mdhd', (box) => {
-                  this.parseMDHD_(reference, box);
+                  goog.asserts.assert(
+                      box.version != null,
+                      'MDHD is a full box and should have a valid version.');
+                  const parsedMDHDBox = shaka.util.Mp4BoxParsers.parseMDHD(
+                      box.reader, box.version);
+                  lastTimescale = parsedMDHDBox.timescale;
+                })
+                .box('hdlr', (box) => {
+                  const parsedHDLR = shaka.util.Mp4BoxParsers.parseHDLR(
+                      box.reader);
+                  switch (parsedHDLR.handlerType) {
+                    case 'soun':
+                      timescaleMap.set(ContentType.AUDIO, lastTimescale);
+                      break;
+                    case 'vide':
+                      timescaleMap.set(ContentType.VIDEO, lastTimescale);
+                      break;
+                  }
+                  lastTimescale = null;
                 })
                 .parse(initSegment);
 
+            if (timescaleMap.has(mediaState.type)) {
+              reference.initSegmentReference.timescale =
+                  timescaleMap.get(mediaState.type);
+            } else if (lastTimescale != null) {
+              // Fallback for segments without HDLR box
+              reference.initSegmentReference.timescale = lastTimescale;
+            }
+
             shaka.log.v1(logPrefix, 'appending init segment');
             const hasClosedCaptions = mediaState.stream.closedCaptions &&
                 mediaState.stream.closedCaptions.size > 0;
@@ -1681,7 +1806,7 @@ shaka.media.StreamingEngine = class {
                 mediaState.type, initSegment);
             await this.playerInterface_.mediaSourceEngine.appendBuffer(
                 mediaState.type, initSegment, /* reference= */ null,
-                hasClosedCaptions);
+                mediaState.stream, hasClosedCaptions);
           } catch (error) {
             mediaState.lastInitSegmentReference = null;
             throw error;
@@ -1706,7 +1831,7 @@ shaka.media.StreamingEngine = class {
         operations.push(this.playerInterface_.mediaSourceEngine.resync(
             mediaState.type, reference.startTime));
       }
-    } else {
+    } else if (this.manifest_.ignoreManifestTimestampsInSegmentsMode) {
       // In segments mode, we need to resync to set the timestampOffset
       // to the start of the current discontinuity sequence. This is
       // because individual discontinuity sequences may have internal
@@ -1789,6 +1914,7 @@ shaka.media.StreamingEngine = class {
         mediaState.type,
         segment,
         reference,
+        stream,
         hasClosedCaptions,
         seeked,
         adaptation,
@@ -1920,18 +2046,6 @@ shaka.media.StreamingEngine = class {
     }
   }
 
-  /**
-   * Parse MDHD box.
-   * @param {!shaka.media.SegmentReference} reference
-   * @param {!shaka.extern.ParsedBox} box
-   * @private
-   */
-  parseMDHD_(reference, box) {
-    const parsedMDHDBox = shaka.util.Mp4BoxParsers.parseMDHD(
-        box.reader || 0, box.version || 0);
-    reference.initSegmentReference.timescale = parsedMDHDBox.timescale;
-  }
-
   /**
    * Parse PRFT box.
    * @param {!shaka.media.SegmentReference} reference
@@ -1943,30 +2057,16 @@ shaka.media.StreamingEngine = class {
       !reference.initSegmentReference.timescale) {
       return;
     }
-    box.reader.readUint32(); // Ignore referenceTrackId
-    const ntpTimestampSec = box.reader.readUint32();
-    const ntpTimestampFrac = box.reader.readUint32();
-    const ntpTimestamp = ntpTimestampSec * 1000 +
-        ntpTimestampFrac / 2**32 * 1000;
-
-    let mediaTime;
-    if (box.version === 0) {
-      mediaTime = box.reader.readUint32();
-    } else {
-      try {
-        mediaTime = box.reader.readUint64();
-      } catch (e) {
-        shaka.log.warning('parsePrft_: parsing mediatime resulted in a '+
-          'MEDIA.JS_INTEGER_OVERFLOW exception');
-        this.parsedPrftEventRaised_ = true;
-        return;
-      }
-    }
+    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 timescale = reference.initSegmentReference.timescale;
-    const wallClockTime = this.convertNtp(ntpTimestamp);
+    const wallClockTime = this.convertNtp(parsed.ntpTimestamp);
     const programStartDate = new Date(wallClockTime -
-      (mediaTime / timescale) * 1000);
+      (parsed.mediaTime / timescale) * 1000);
     const prftInfo = {
       wallClockTime,
       programStartDate,
@@ -1982,11 +2082,11 @@ shaka.media.StreamingEngine = class {
 
 
   /**
-     * Convert Ntp ntpTimeStamp to UTC Time
-     *
-     * @param {number} ntpTimeStamp
-     * @return {number} utcTime
-     */
+   * Convert Ntp ntpTimeStamp to UTC Time
+   *
+   * @param {number} ntpTimeStamp
+   * @return {number} utcTime
+   */
   convertNtp(ntpTimeStamp) {
     const start = new Date(Date.UTC(1900, 0, 1, 0, 0, 0));
     return new Date(start.getTime() + ntpTimeStamp).getTime();
@@ -2070,14 +2170,58 @@ shaka.media.StreamingEngine = class {
    * @param {(!shaka.media.InitSegmentReference|!shaka.media.SegmentReference)}
    *   reference
    * @param {?function(BufferSource):!Promise=} streamDataCallback
+   * @param {boolean=} isInit
    *
    * @return {!Promise.<BufferSource>}
    * @private
    * @suppress {strictMissingProperties}
    */
-  async fetch_(mediaState, reference, streamDataCallback) {
-    const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
+  async fetch_(mediaState, reference, streamDataCallback, isInit) {
+    if (reference instanceof shaka.media.InitSegmentReference) {
+      const segmentData = reference.getSegmentData();
+      if (segmentData) {
+        return segmentData;
+      }
+    }
+    let op = null;
+    if (
+      mediaState.segmentPrefetch &&
+      reference instanceof shaka.media.SegmentReference
+    ) {
+      op = mediaState.segmentPrefetch.getPrefetchedSegment(
+          reference, streamDataCallback);
+    }
+    if (!op) {
+      op = this.dispatchFetch_(
+          reference, mediaState.stream, streamDataCallback, isInit,
+      );
+    }
+
+    mediaState.operation = op;
+    const response = await op.promise;
+    mediaState.operation = null;
+    return response.data;
+  }
 
+  /**
+   * Fetches the given segment.
+   *
+   * @param {!shaka.extern.Stream} stream
+   * @param {(!shaka.media.InitSegmentReference|!shaka.media.SegmentReference)}
+   *   reference
+   * @param {?function(BufferSource):!Promise=} streamDataCallback
+   * @param {boolean=} isInit
+   *
+   * @return {!shaka.net.NetworkingEngine.PendingRequest}
+   * @private
+   */
+  dispatchFetch_(reference, stream, streamDataCallback, isInit) {
+    const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
+    const type = isInit ?
+        shaka.net.NetworkingEngine.AdvancedRequestType.INIT_SEGMENT :
+        shaka.net.NetworkingEngine.AdvancedRequestType.MEDIA_SEGMENT;
+    const segment = reference instanceof shaka.media.SegmentReference ?
+        reference : undefined;
     const request = shaka.util.Networking.createSegmentRequest(
         reference.getUris(),
         reference.startByte,
@@ -2087,27 +2231,14 @@ shaka.media.StreamingEngine = class {
 
     shaka.log.v2('fetching: reference=', reference);
 
-    const stream = mediaState.stream;
-    this.playerInterface_.modifySegmentRequest(
-        request,
-        {
-          type: stream.type,
-          init: reference instanceof shaka.media.InitSegmentReference,
-          duration: reference.endTime - reference.startTime,
-          mimeType: stream.mimeType,
-          codecs: stream.codecs,
-          bandwidth: stream.bandwidth,
-        },
-    );
-
-    const op = this.playerInterface_.netEngine.request(requestType, request);
-    mediaState.operation = op;
-    const response = await op.promise;
-    mediaState.operation = null;
-    return response.data;
+    return this.playerInterface_.netEngine.request(
+        requestType, request, {
+          type: type,
+          stream: stream,
+          segment: segment,
+        });
   }
 
-
   /**
    * Clears the buffer and schedules another update.
    * The optional parameter safeMargin allows to retain a certain amount
@@ -2135,6 +2266,9 @@ shaka.media.StreamingEngine = class {
     mediaState.segmentIterator = null;
 
     shaka.log.debug(logPrefix, 'clearing buffer');
+    if (mediaState.segmentPrefetch) {
+      mediaState.segmentPrefetch.clearAll();
+    }
 
     if (safeMargin) {
       const presentationTime = this.playerInterface_.getPresentationTime();
@@ -2150,6 +2284,7 @@ shaka.media.StreamingEngine = class {
             mediaState.type);
       }
     }
+
     this.destroyer_.ensureNotDestroyed();
 
     shaka.log.debug(logPrefix, 'cleared buffer');
@@ -2230,17 +2365,31 @@ shaka.media.StreamingEngine = class {
    * Handle streaming errors by delaying, then notifying the application by
    * error callback and by streaming failure callback.
    *
+   * @param {shaka.media.StreamingEngine.MediaState_} mediaState
    * @param {!shaka.util.Error} error
    * @return {!Promise}
    * @private
    */
-  async handleStreamingError_(error) {
+  async handleStreamingError_(mediaState, error) {
     // If we invoke the callback right away, the application could trigger a
     // rapid retry cycle that could be very unkind to the server.  Instead,
     // use the backoff system to delay and backoff the error handling.
     await this.failureCallbackBackoff_.attempt();
     this.destroyer_.ensureNotDestroyed();
 
+    const maxDisabledTime = this.getDisabledTime_(error);
+    // Try to recover from network errors
+    if (error.category === shaka.util.Error.Category.NETWORK &&
+        maxDisabledTime > 0) {
+      error.handled = this.playerInterface_.disableStream(
+          mediaState.stream, maxDisabledTime);
+
+      // Decrease the error severity to recoverable
+      if (error.handled) {
+        error.severity = shaka.util.Error.Severity.RECOVERABLE;
+      }
+    }
+
     // First fire an error event.
     this.playerInterface_.onError(error);
 
@@ -2251,6 +2400,25 @@ shaka.media.StreamingEngine = class {
     }
   }
 
+  /**
+   * @param {!shaka.util.Error} error
+   * @private
+   */
+  getDisabledTime_(error) {
+    if (this.config_.maxDisabledTime === 0 &&
+        error.code == shaka.util.Error.Code.SEGMENT_MISSING) {
+      // Spec: https://datatracker.ietf.org/doc/html/draft-pantos-hls-rfc8216bis#section-6.3.3
+      // The client SHOULD NOT attempt to load Media Segments that have been
+      // marked with an EXT-X-GAP tag, or to load Partial Segments with a
+      // GAP=YES attribute. Instead, clients are encouraged to look for
+      // another Variant Stream of the same Rendition which does not have the
+      // same gap, and play that instead.
+      return 1;
+    }
+
+    return this.config_.maxDisabledTime;
+  }
+
   /**
    * @param {shaka.media.StreamingEngine.MediaState_} mediaState
    * @return {string} A log prefix of the form ($CONTENT_TYPE:$STREAM_ID), e.g.,
@@ -2267,8 +2435,6 @@ shaka.media.StreamingEngine = class {
  * @typedef {{
  *   getPresentationTime: function():number,
  *   getBandwidthEstimate: function():number,
- *   modifySegmentRequest: function(shaka.extern.Request,
- *     shaka.util.CmcdManager.SegmentInfo),
  *   mediaSourceEngine: !shaka.media.MediaSourceEngine,
  *   netEngine: shaka.net.NetworkingEngine,
  *   onError: function(!shaka.util.Error),
@@ -2279,7 +2445,8 @@ shaka.media.StreamingEngine = class {
  *   onInitSegmentAppended: function(!number,!shaka.media.InitSegmentReference),
  *   beforeAppendSegment: function(
  *     shaka.util.ManifestParserUtils.ContentType,!BufferSource):Promise,
- *   onMetadata: !function(!Array.<shaka.extern.ID3Metadata>, number, ?number)
+ *   onMetadata: !function(!Array.<shaka.extern.ID3Metadata>, number, ?number),
+ *   disableStream: function(!shaka.extern.Stream, number):boolean
  * }}
  *
  * @property {function():number} getPresentationTime
@@ -2287,9 +2454,6 @@ shaka.media.StreamingEngine = class {
  *   viewer is seeing on screen right now.
  * @property {function():number} getBandwidthEstimate
  *   Get the estimated bandwidth in bits per second.
- * @property {function(shaka.extern.Request,
- *   shaka.extern.Cmcd.SegmentInfo)} modifySegmentRequest
- *   The request modifier
  * @property {!shaka.media.MediaSourceEngine} mediaSourceEngine
  *   The MediaSourceEngine. The caller retains ownership.
  * @property {shaka.net.NetworkingEngine} netEngine
@@ -2315,6 +2479,9 @@ shaka.media.StreamingEngine = class {
  * @property
  *  {!function(!Array.<shaka.extern.ID3Metadata>, number, ?number)} onMetadata
  *   Called when an ID3 is found in a EMSG.
+ * @property {function(!shaka.extern.Stream, number):boolean} disableStream
+ *   Called to temporarily disable a stream i.e. disabling all variant
+ *   containing said stream.
  */
 shaka.media.StreamingEngine.PlayerInterface;
 
@@ -2329,6 +2496,8 @@ shaka.media.StreamingEngine.PlayerInterface;
  *   lastTimestampOffset: ?number,
  *   lastAppendWindowStart: ?number,
  *   lastAppendWindowEnd: ?number,
+ *   lastCodecs: ?string,
+ *   lastMimeType: ?string,
  *   restoreStreamAfterTrickPlay: ?shaka.extern.Stream,
  *   endOfStream: boolean,
  *   performingUpdate: boolean,
@@ -2342,7 +2511,8 @@ shaka.media.StreamingEngine.PlayerInterface;
  *   adaptation: boolean,
  *   recovering: boolean,
  *   hasError: boolean,
- *   operation: shaka.net.NetworkingEngine.PendingRequest
+ *   operation: shaka.net.NetworkingEngine.PendingRequest,
+ *   segmentPrefetch: shaka.media.SegmentPrefetch
  * }}
  *
  * @description
@@ -2366,6 +2536,10 @@ shaka.media.StreamingEngine.PlayerInterface;
  *   The last append window start given to MediaSourceEngine for this type.
  * @property {?number} lastAppendWindowEnd
  *   The last append window end given to MediaSourceEngine for this type.
+ * @property {?string} lastCodecs
+ *   The last append codecs given to MediaSourceEngine for this type.
+ * @property {?string} lastMimeType
+ *   The last append mime type given to MediaSourceEngine for this type.
  * @property {?shaka.extern.Stream} restoreStreamAfterTrickPlay
  *   The Stream to restore after trick play mode is turned off.
  * @property {boolean} endOfStream
@@ -2399,6 +2573,9 @@ shaka.media.StreamingEngine.PlayerInterface;
  *   updating.
  * @property {shaka.net.NetworkingEngine.PendingRequest} operation
  *   Operation with the number of bytes to be downloaded.
+ * @property {?shaka.media.SegmentPrefetch} segmentPrefetch
+ *   A prefetch object for managing prefetching. Null if unneeded
+ *   (if prefetching is disabled, etc).
  */
 shaka.media.StreamingEngine.MediaState_;
 

package/lib/media/video_wrapper.js

@@ -28,9 +28,9 @@ shaka.media.VideoWrapper = class {
    * @param {!HTMLMediaElement} video
    * @param {function()} onSeek Called when the video seeks.
    * @param {function(number)} onStarted Called when the video has started.
-   * @param {number} startTime The time to start at.
+   * @param {function():number} getStartTime Calle to get the time to start at.
    */
-  constructor(video, onSeek, onStarted, startTime) {
+  constructor(video, onSeek, onStarted, getStartTime) {
     /** @private {HTMLMediaElement} */
     this.video_ = video;
 
@@ -40,8 +40,16 @@ shaka.media.VideoWrapper = class {
     /** @private {function(number)} */
     this.onStarted_ = onStarted;
 
-    /** @private {number} */
-    this.startTime_ = startTime;
+    /** @private {?number} */
+    this.startTime_ = null;
+
+    /** @private {function():number} */
+    this.getStartTime_ = () => {
+      if (this.startTime_ == null) {
+        this.startTime_ = getStartTime();
+      }
+      return this.startTime_;
+    };
 
     /** @private {boolean} */
     this.started_ = false;
@@ -62,7 +70,7 @@ shaka.media.VideoWrapper = class {
         HTMLMediaElement.HAVE_METADATA,
         this.eventManager_,
         () => {
-          this.setStartTime_(this.startTime_);
+          this.setStartTime_(this.getStartTime_());
         });
   }
 
@@ -90,7 +98,7 @@ shaka.media.VideoWrapper = class {
    * @return {number}
    */
   getTime() {
-    return this.started_ ? this.video_.currentTime : this.startTime_;
+    return this.started_ ? this.video_.currentTime : this.getStartTime_();
   }
 
 
@@ -107,7 +115,7 @@ shaka.media.VideoWrapper = class {
           HTMLMediaElement.HAVE_METADATA,
           this.eventManager_,
           () => {
-            this.setStartTime_(this.startTime_);
+            this.setStartTime_(this.getStartTime_());
           });
     }
   }