shaka-player 3.3.5 → 4.0.2

package/lib/hls/manifest_text_parser.js

@@ -179,9 +179,8 @@ shaka.hls.ManifestTextParser = class {
           segmentTags.push(currentMapTag);
         }
         // The URI appears after all of the tags describing the segment.
-        const segment =
-            new shaka.hls.Segment(absoluteSegmentUri, segmentTags,
-                partialSegmentTags);
+        const segment = new shaka.hls.Segment(absoluteSegmentUri, segmentTags,
+            partialSegmentTags);
         segments.push(segment);
         segmentTags = [];
         partialSegmentTags = [];

package/lib/media/drm_engine.js

@@ -14,7 +14,6 @@ goog.require('shaka.util.BufferUtils');
 goog.require('shaka.util.Destroyer');
 goog.require('shaka.util.Error');
 goog.require('shaka.util.EventManager');
-goog.require('shaka.util.FairPlayUtils');
 goog.require('shaka.util.FakeEvent');
 goog.require('shaka.util.IDestroyable');
 goog.require('shaka.util.Iterables');
@@ -128,6 +127,9 @@ shaka.media.DrmEngine = class {
 
     /** @private {boolean} */
     this.srcEquals_ = false;
+
+    /** @private {Promise} */
+    this.mediaKeysAttached_ = null;
   }
 
   /** @override */
@@ -184,6 +186,7 @@ shaka.media.DrmEngine = class {
     this.onError_ = () => {};
     this.playerInterface_ = null;
     this.srcEquals_ = false;
+    this.mediaKeysAttached_ = null;
   }
 
   /**
@@ -387,7 +390,59 @@ shaka.media.DrmEngine = class {
   }
 
   /**
-   * Attach MediaKeys to the video element and start processing events.
+   * Attach MediaKeys to the video element
+   * @return {Promise}
+   * @private
+   */
+  async attachMediaKeys_() {
+    if (this.video_.mediaKeys) {
+      return;
+    }
+
+    // An attach process has already started, let's wait it out
+    if (this.mediaKeysAttached_) {
+      await this.mediaKeysAttached_;
+
+      return;
+    }
+
+    try {
+      this.mediaKeysAttached_ = this.video_.setMediaKeys(this.mediaKeys_);
+
+      await this.mediaKeysAttached_;
+    } catch (exception) {
+      goog.asserts.assert(exception instanceof Error, 'Wrong error type!');
+
+      this.onError_(new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.DRM,
+          shaka.util.Error.Code.FAILED_TO_ATTACH_TO_VIDEO,
+          exception.message));
+    }
+
+    this.destroyer_.ensureNotDestroyed();
+  }
+
+  /**
+   * Processes encrypted event and start licence challenging
+   * @return {!Promise}
+   * @private
+   */
+  async onEncryptedEvent_(event) {
+    /**
+     * MediaKeys should be added when receiving an encrypted event. Setting
+     * mediaKeys before could result into encrypted event not being fired on
+     * some browsers
+     */
+    await this.attachMediaKeys_();
+
+    this.newInitData(
+        event.initDataType,
+        shaka.util.BufferUtils.toUint8(event.initData));
+  }
+
+  /**
+   * Start processing events.
    * @param {HTMLMediaElement} video
    * @return {!Promise}
    */
@@ -420,27 +475,30 @@ shaka.media.DrmEngine = class {
           () => this.closeOpenSessions_());
     }
 
-    let setMediaKeys = this.video_.setMediaKeys(this.mediaKeys_);
-    setMediaKeys = setMediaKeys.catch((exception) => {
-      goog.asserts.assert(exception instanceof Error, 'Wrong error type!');
-      return Promise.reject(new shaka.util.Error(
-          shaka.util.Error.Severity.CRITICAL,
-          shaka.util.Error.Category.DRM,
-          shaka.util.Error.Code.FAILED_TO_ATTACH_TO_VIDEO,
-          exception.message));
-    });
+    const manifestInitData = this.currentDrmInfo_.initData.find(
+        (initDataOverride) => initDataOverride.initData.length > 0);
 
-    await setMediaKeys;
-    this.destroyer_.ensureNotDestroyed();
+    /**
+     * We can attach media keys before the playback actually begins when:
+     *  - Using legacy implementations requires MediaKeys to be set before
+     *    having webkitneedkey / msneedkey event, which will be translated as
+     *    an encrypted event by the polyfills
+     *  - Some initData already has been generated (through the manifest)
+     *  - In case of an offline session
+     */
+    if (manifestInitData ||
+        shaka.util.Platform.isMediaKeysPolyfilled() ||
+        this.offlineSessionIds_.length) {
+      await this.attachMediaKeys_();
+    }
 
     this.createOrLoad();
-    if (!this.currentDrmInfo_.initData.length &&
-        !this.offlineSessionIds_.length) {
-      // Explicit init data for any one stream or an offline session is
-      // sufficient to suppress 'encrypted' events for all streams.
-      const cb = (e) => this.newInitData(
-          e.initDataType, shaka.util.BufferUtils.toUint8(e.initData));
-      this.eventManager_.listen(this.video_, 'encrypted', cb);
+
+    // Explicit init data for any one stream or an offline session is
+    // sufficient to suppress 'encrypted' events for all streams.
+    if (!manifestInitData && !this.offlineSessionIds_.length) {
+      this.eventManager_.listen(
+          this.video_, 'encrypted', (e) => this.onEncryptedEvent_(e));
     }
   }
 
@@ -589,6 +647,10 @@ shaka.media.DrmEngine = class {
    * @param {!Uint8Array} initData
    */
   newInitData(initDataType, initData) {
+    if (!initData.length) {
+      return;
+    }
+
     // Suppress duplicate init data.
     // Note that some init data are extremely large and can't portably be used
     // as keys in a dictionary.
@@ -1106,6 +1168,7 @@ shaka.media.DrmEngine = class {
 
     const metadata = {
       initData: null,
+      initDataType: null,
       loaded: false,
       oldExpiration: Infinity,
       updatePromise: null,
@@ -1182,6 +1245,7 @@ shaka.media.DrmEngine = class {
 
     const metadata = {
       initData: initData,
+      initDataType: initDataType,
       loaded: false,
       oldExpiration: Infinity,
       updatePromise: null,
@@ -1239,23 +1303,6 @@ shaka.media.DrmEngine = class {
     });
   }
 
-  /**
-   * @param {!Uint8Array} initData
-   * @param {string} initDataType
-   * @param {?shaka.extern.DrmInfo} drmInfo
-   * @return {!Uint8Array}
-   */
-  static defaultInitDataTransform(initData, initDataType, drmInfo) {
-    if (initDataType == 'skd') {
-      const cert = drmInfo.serverCertificate;
-      const contentId =
-          shaka.util.FairPlayUtils.defaultGetContentId(initData);
-      initData = shaka.util.FairPlayUtils.initDataTransform(
-          initData, contentId, cert);
-    }
-    return initData;
-  }
-
   /**
    * @param {!MediaKeyMessageEvent} event
    * @private
@@ -1316,6 +1363,11 @@ shaka.media.DrmEngine = class {
     request.method = 'POST';
     request.licenseRequestType = event.messageType;
     request.sessionId = session.sessionId;
+    request.drmInfo = this.currentDrmInfo_;
+    if (metadata) {
+      request.initData = metadata.initData;
+      request.initDataType = metadata.initDataType;
+    }
     // NOTE: allowCrossSiteCredentials can be set in a request filter.
 
     if (shaka.media.DrmEngine.isPlayReadyKeySystem(
@@ -1372,6 +1424,9 @@ shaka.media.DrmEngine = class {
       }
       return;
     }
+    if (this.destroyer_.destroyed()) {
+      return;
+    }
 
     const updateEvent = new shaka.util.FakeEvent('drmsessionupdate');
     this.playerInterface_.onEvent(updateEvent);
@@ -1642,6 +1697,16 @@ shaka.media.DrmEngine = class {
 
     const testSystem = async (keySystem) => {
       try {
+        // 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()) {
+          throw new Error('Unsupported keySystem');
+        }
+
         const access = await navigator.requestMediaKeySystemAccess(
             keySystem, configs);
 
@@ -2262,6 +2327,7 @@ shaka.media.DrmEngine = class {
  * @typedef {{
  *   loaded: boolean,
  *   initData: Uint8Array,
+ *   initDataType: ?string,
  *   oldExpiration: number,
  *   type: string,
  *   updatePromise: shaka.util.PublicPromise
@@ -2273,6 +2339,8 @@ shaka.media.DrmEngine = class {
  *   does not mean the session is 'usable'.
  * @property {Uint8Array} initData
  *   The init data used to create the session.
+ * @property {?string} initDataType
+ *   The init data type used to create the session.
  * @property {!MediaKeySession} session
  *   The session object.
  * @property {number} oldExpiration

package/lib/media/gap_jumping_controller.js

@@ -11,7 +11,6 @@ goog.require('shaka.media.PresentationTimeline');
 goog.require('shaka.media.StallDetector');
 goog.require('shaka.media.TimeRangesUtils');
 goog.require('shaka.util.EventManager');
-goog.require('shaka.util.FakeEvent');
 goog.require('shaka.util.IReleasable');
 goog.require('shaka.util.Timer');
 
@@ -33,10 +32,8 @@ shaka.media.GapJumpingController = class {
    *   playable region. The gap jumping controller takes ownership over the
    *   stall detector.
    *   If no stall detection logic is desired, |null| may be provided.
-   * @param {function(!Event)} onEvent Called when an event is raised to be sent
-   *   to the application.
    */
-  constructor(video, timeline, config, stallDetector, onEvent) {
+  constructor(video, timeline, config, stallDetector) {
     /** @private {HTMLMediaElement} */
     this.video_ = video;
 
@@ -46,9 +43,6 @@ shaka.media.GapJumpingController = class {
     /** @private {?shaka.extern.StreamingConfiguration} */
     this.config_ = config;
 
-    /** @private {?function(!Event)} */
-    this.onEvent_ = onEvent;
-
     /** @private {shaka.util.EventManager} */
     this.eventManager_ = new shaka.util.EventManager();
 
@@ -58,9 +52,6 @@ shaka.media.GapJumpingController = class {
     /** @private {number} */
     this.prevReadyState_ = video.readyState;
 
-    /** @private {boolean} */
-    this.didFireLargeGap_ = false;
-
     /**
      * The stall detector tries to keep the playhead moving forward. It is
      * managed by the gap-jumping controller to avoid conflicts. On some
@@ -107,7 +98,6 @@ shaka.media.GapJumpingController = class {
       this.stallDetector_ = null;
     }
 
-    this.onEvent_ = null;
     this.timeline_ = null;
     this.video_ = null;
   }
@@ -128,7 +118,6 @@ shaka.media.GapJumpingController = class {
   onSeeking() {
     this.seekingEventReceived_ = true;
     this.hadSegmentAppended_ = false;
-    this.didFireLargeGap_ = false;
   }
 
 
@@ -165,7 +154,6 @@ shaka.media.GapJumpingController = class {
     // When the ready state changes, we have moved on, so we should fire the
     // large gap event if we see one.
     if (this.video_.readyState != this.prevReadyState_) {
-      this.didFireLargeGap_ = false;
       this.prevReadyState_ = this.video_.readyState;
     }
 
@@ -175,7 +163,6 @@ shaka.media.GapJumpingController = class {
     }
 
 
-    const smallGapLimit = this.config_.smallGapLimit;
     const currentTime = this.video_.currentTime;
     const buffered = this.video_.buffered;
     const gapDetectionThreshold = this.config_.gapDetectionThreshold;
@@ -203,8 +190,6 @@ shaka.media.GapJumpingController = class {
     }
 
     const jumpSize = jumpTo - currentTime;
-    const isGapSmall = jumpSize <= smallGapLimit;
-    let jumpLargeGap = false;
 
     // If we jump to exactly the gap start, we may detect a small gap due to
     // rounding errors or browser bugs.  We can ignore these extremely small
@@ -213,37 +198,17 @@ shaka.media.GapJumpingController = class {
       return;
     }
 
-    if (!isGapSmall && !this.didFireLargeGap_) {
-      this.didFireLargeGap_ = true;
-
-      // Event firing is synchronous.
-      const data = new Map()
-          .set('currentTime', currentTime)
-          .set('gapSize', jumpSize);
-      const event = new shaka.util.FakeEvent('largegap', data);
-      event.cancelable = true;
-      this.onEvent_(event);
-
-      if (this.config_.jumpLargeGaps && !event.defaultPrevented) {
-        jumpLargeGap = true;
-      } else {
-        shaka.log.info('Ignoring large gap at', currentTime, 'size', jumpSize);
-      }
+    if (gapIndex == 0) {
+      shaka.log.info(
+          'Jumping forward', jumpSize,
+          'seconds because of gap before start time of', jumpTo);
+    } else {
+      shaka.log.info(
+          'Jumping forward', jumpSize, 'seconds because of gap starting at',
+          buffered.end(gapIndex - 1), 'and ending at', jumpTo);
     }
 
-    if (isGapSmall || jumpLargeGap) {
-      if (gapIndex == 0) {
-        shaka.log.info(
-            'Jumping forward', jumpSize,
-            'seconds because of gap before start time of', jumpTo);
-      } else {
-        shaka.log.info(
-            'Jumping forward', jumpSize, 'seconds because of gap starting at',
-            buffered.end(gapIndex - 1), 'and ending at', jumpTo);
-      }
-
-      this.video_.currentTime = jumpTo;
-    }
+    this.video_.currentTime = jumpTo;
   }
 };
 

package/lib/media/media_source_engine.js

@@ -71,6 +71,9 @@ shaka.media.MediaSourceEngine = class {
     /** @private {shaka.text.TextEngine} */
     this.textEngine_ = null;
 
+    /** @private {boolean} */
+    this.segmentRelativeVttTiming_ = false;
+
     const onMetadataNoOp = (metadata, timestampOffset, segmentEnd) => {};
 
     /** @private {!function(!Array.<shaka.extern.ID3Metadata>,
@@ -103,6 +106,12 @@ shaka.media.MediaSourceEngine = class {
 
     /** @private {string} */
     this.url_ = '';
+
+    /** @private {boolean} */
+    this.sequenceMode_ = false;
+
+    /** @private {!shaka.util.PublicPromise.<number>} */
+    this.textSequenceModeOffset_ = new shaka.util.PublicPromise();
   }
 
   /**
@@ -201,6 +210,8 @@ shaka.media.MediaSourceEngine = class {
       // TTML types
       'application/ttml+xml',
       'application/mp4; codecs="stpp"',
+      // Containerless types
+      ...shaka.media.MediaSourceEngine.RAW_FORMATS,
     ];
 
     const support = {};
@@ -315,14 +326,19 @@ shaka.media.MediaSourceEngine = class {
    *   according to MediaSourceEngine.isStreamSupported.
    * @param {boolean} forceTransmuxTS
    *   If true, this will transmux TS content even if it is natively supported.
+   * @param {boolean=} sequenceMode
+   *   If true, the media segments are appended to the SourceBuffer in strict
+   *   sequence.
    *
    * @return {!Promise}
    */
-  async init(streamsByType, forceTransmuxTS) {
+  async init(streamsByType, forceTransmuxTS, sequenceMode=false) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
     await this.mediaSourceOpen_;
 
+    this.sequenceMode_ = sequenceMode;
+
     for (const contentType of streamsByType.keys()) {
       const stream = streamsByType.get(contentType);
       goog.asserts.assert(
@@ -332,7 +348,7 @@ shaka.media.MediaSourceEngine = class {
       let mimeType = shaka.util.MimeUtils.getFullType(
           stream.mimeType, stream.codecs);
       if (contentType == ContentType.TEXT) {
-        this.reinitText(mimeType);
+        this.reinitText(mimeType, sequenceMode);
       } else {
         if ((forceTransmuxTS || !MediaSource.isTypeSupported(mimeType)) &&
             shaka.media.Transmuxer.isSupported(mimeType, contentType)) {
@@ -340,7 +356,9 @@ shaka.media.MediaSourceEngine = class {
           mimeType =
               shaka.media.Transmuxer.convertTsCodecs(contentType, mimeType);
         }
+
         const sourceBuffer = this.mediaSource_.addSourceBuffer(mimeType);
+
         this.eventManager_.listen(
             sourceBuffer, 'error',
             () => this.onError_(contentType));
@@ -358,12 +376,14 @@ shaka.media.MediaSourceEngine = class {
   /**
    * Reinitialize the TextEngine for a new text type.
    * @param {string} mimeType
+   * @param {boolean} sequenceMode
    */
-  reinitText(mimeType) {
+  reinitText(mimeType, sequenceMode) {
     if (!this.textEngine_) {
       this.textEngine_ = new shaka.text.TextEngine(this.textDisplayer_);
     }
-    this.textEngine_.initParser(mimeType);
+    this.textEngine_.initParser(mimeType, sequenceMode,
+        this.segmentRelativeVttTiming_);
   }
 
   /**
@@ -410,17 +430,15 @@ shaka.media.MediaSourceEngine = class {
    *
    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
    * @param {number} time Playhead time
-   * @param {number=} smallGapLimit
    * @return {boolean}
    */
-  isBuffered(contentType, time, smallGapLimit) {
+  isBuffered(contentType, time) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     if (contentType == ContentType.TEXT) {
       return this.textEngine_.isBuffered(time);
     } else {
       const buffered = this.getBuffered_(contentType);
-      return shaka.media.TimeRangesUtils.isBuffered(
-          buffered, time, smallGapLimit);
+      return shaka.media.TimeRangesUtils.isBuffered(buffered, time);
     }
   }
 
@@ -502,20 +520,30 @@ shaka.media.MediaSourceEngine = class {
    * @param {?number} endTime relative to the start of the presentation
    * @param {?boolean} hasClosedCaptions True if the buffer contains CEA closed
    * captions
+   * @param {boolean=} seeked True if we just seeked
    * @return {!Promise}
    */
-  async appendBuffer(contentType, data, startTime, endTime, hasClosedCaptions) {
+  async appendBuffer(
+      contentType, data, startTime, endTime, hasClosedCaptions, seeked) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
     if (contentType == ContentType.TEXT) {
+      if (this.sequenceMode_) {
+        // This won't be known until the first video segment is appended.
+        const offset = await this.textSequenceModeOffset_;
+        this.textEngine_.setTimestampOffset(offset);
+      }
       await this.textEngine_.appendBuffer(data, startTime, endTime);
-    } else if (this.transmuxers_[contentType]) {
+      return;
+    }
+
+    if (this.transmuxers_[contentType]) {
       const transmuxedData =
           await this.transmuxers_[contentType].transmux(data);
       // For HLS CEA-608/708 CLOSED-CAPTIONS, text data is embedded in
       // the video stream, so textEngine may not have been initialized.
       if (!this.textEngine_) {
-        this.reinitText('text/vtt');
+        this.reinitText('text/vtt', this.sequenceMode_);
       }
 
       if (transmuxedData.metadata) {
@@ -534,15 +562,10 @@ shaka.media.MediaSourceEngine = class {
             closedCaptions, startTime, endTime, videoOffset);
       }
 
-      let transmuxedSegment = transmuxedData.data;
-      transmuxedSegment = this.workAroundBrokenPlatforms_(
-          transmuxedSegment, startTime, contentType);
-
-      await this.enqueueOperation_(
-          contentType, () => this.append_(contentType, transmuxedSegment));
+      data = transmuxedData.data;
     } else if (hasClosedCaptions) {
       if (!this.textEngine_) {
-        this.reinitText('text/vtt');
+        this.reinitText('text/vtt', this.sequenceMode_);
       }
       // If it is the init segment for closed captions, initialize the closed
       // caption parser.
@@ -557,19 +580,78 @@ shaka.media.MediaSourceEngine = class {
               closedCaptions, startTime, endTime, videoOffset);
         }
       }
+    }
 
-      data = this.workAroundBrokenPlatforms_(data, startTime, contentType);
+    data = this.workAroundBrokenPlatforms_(data, startTime, contentType);
+
+    const sourceBuffer = this.sourceBuffers_[contentType];
+    const SEQUENCE = shaka.media.MediaSourceEngine.SourceBufferMode_.SEQUENCE;
+
+    if (this.sequenceMode_ && sourceBuffer.mode != SEQUENCE &&
+        startTime != null) {
+      // This is the first media segment to be appended to a SourceBuffer in
+      // sequence mode.  We set the mode late so that we can trick MediaSource
+      // into extracting a timestamp for us to align text segments in sequence
+      // mode.
+
+      // Timestamps can only be reliably extracted from video, not audio.
+      // Packed audio formats do not have internal timestamps at all.
+      // Prefer video for this when available.
+      const isBestSourceBufferForTimestamps =
+          contentType == ContentType.VIDEO ||
+          !(ContentType.VIDEO in this.sourceBuffers_);
+      if (isBestSourceBufferForTimestamps) {
+        // Append the segment in segments mode first, with offset of 0 and an
+        // open append window.
+        const originalRange =
+            [sourceBuffer.appendWindowStart, sourceBuffer.appendWindowEnd];
+        sourceBuffer.appendWindowStart = 0;
+        sourceBuffer.appendWindowEnd = Infinity;
+
+        const originalOffset = sourceBuffer.timestampOffset;
+        sourceBuffer.timestampOffset = 0;
+
+        await this.enqueueOperation_(
+            contentType, () => this.append_(contentType, data));
+
+        // Reset the offset and append window.
+        sourceBuffer.timestampOffset = originalOffset;
+        sourceBuffer.appendWindowStart = originalRange[0];
+        sourceBuffer.appendWindowEnd = originalRange[1];
+
+        // Now get the timestamp of the segment and compute the offset for text
+        // segments.
+        const mediaStartTime = shaka.media.TimeRangesUtils.bufferStart(
+            this.getBuffered_(contentType));
+        const textOffset = (startTime || 0) - (mediaStartTime || 0);
+        this.textSequenceModeOffset_.resolve(textOffset);
+
+        // Finally, clear the buffer.
+        await this.enqueueOperation_(
+            contentType,
+            () => this.remove_(contentType, 0, this.mediaSource_.duration));
+      }
 
-      await this.enqueueOperation_(
-          contentType,
-          () => this.append_(contentType, data));
-    } else {
-      data = this.workAroundBrokenPlatforms_(data, startTime, contentType);
+      // Now switch to sequence mode and fall through to our normal operations.
+      sourceBuffer.mode = SEQUENCE;
+    }
 
-      await this.enqueueOperation_(
-          contentType,
-          () => this.append_(contentType, data));
+    if (startTime != null && this.sequenceMode_ &&
+        contentType != ContentType.TEXT) {
+      // In sequence mode, for non-text streams, if we just cleared the buffer
+      // and are performing an unbuffered seek, we need to set a new
+      // timestampOffset on the sourceBuffer.
+      if (seeked) {
+        const timestampOffset = /** @type {number} */ (startTime);
+        this.enqueueOperation_(
+            contentType,
+            () => this.setTimestampOffset_(contentType, timestampOffset));
+      }
     }
+
+    await this.enqueueOperation_(
+        contentType,
+        () => this.append_(contentType, data));
   }
 
   /**
@@ -670,13 +752,18 @@ shaka.media.MediaSourceEngine = class {
    * @param {number} appendWindowEnd The timestamp to set the append window end
    *   to.  For future appends, frames/samples with timestamps greater than this
    *   value will be dropped.
+   * @param {boolean} sequenceMode  If true, the timestampOffset will not be
+   *   applied in this step.
    * @return {!Promise}
    */
   async setStreamProperties(
-      contentType, timestampOffset, appendWindowStart, appendWindowEnd) {
+      contentType, timestampOffset, appendWindowStart, appendWindowEnd,
+      sequenceMode) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     if (contentType == ContentType.TEXT) {
-      this.textEngine_.setTimestampOffset(timestampOffset);
+      if (!sequenceMode) {
+        this.textEngine_.setTimestampOffset(timestampOffset);
+      }
       this.textEngine_.setAppendWindow(appendWindowStart, appendWindowEnd);
       return;
     }
@@ -693,7 +780,10 @@ shaka.media.MediaSourceEngine = class {
       this.enqueueOperation_(
           contentType,
           () => this.abort_(contentType)),
-      this.enqueueOperation_(
+      // Don't set the timestampOffset here when in sequenceMode, since we
+      // use timestampOffset for a different purpose in that mode (e.g. to
+      // indicate where the current segment is).
+      sequenceMode ? Promise.resolve() : this.enqueueOperation_(
           contentType,
           () => this.setTimestampOffset_(contentType, timestampOffset)),
       this.enqueueOperation_(
@@ -1085,6 +1175,13 @@ shaka.media.MediaSourceEngine = class {
     }
   }
 
+  /**
+   * @param {boolean} segmentRelativeVttTiming
+   */
+  setSegmentRelativeVttTiming(segmentRelativeVttTiming) {
+    this.segmentRelativeVttTiming_ = segmentRelativeVttTiming;
+  }
+
   /**
    * Apply platform-specific transformations to this segment to work around
    * issues in the platform.
@@ -1145,3 +1242,26 @@ shaka.media.MediaSourceEngine.createObjectURL = window.URL.createObjectURL;
  *   The PublicPromise which is associated with this operation.
  */
 shaka.media.MediaSourceEngine.Operation;
+
+
+/**
+ * @enum {string}
+ * @private
+ */
+shaka.media.MediaSourceEngine.SourceBufferMode_ = {
+  SEQUENCE: 'sequence',
+  SEGMENTS: 'segments',
+};
+
+
+/**
+ * MIME types of raw formats.
+ *
+ * @const {!Array.<string>}
+ */
+shaka.media.MediaSourceEngine.RAW_FORMATS = [
+  'audio/aac',
+  'audio/ac3',
+  'audio/ec3',
+  'audio/mpeg',
+];