shaka-player 4.0.0 → 4.1.0

package/lib/media/gap_jumping_controller.js

@@ -11,6 +11,7 @@ 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');
 
@@ -32,8 +33,13 @@ 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) {
+  constructor(video, timeline, config, stallDetector, onEvent) {
+    /** @private {?function(!Event)} */
+    this.onEvent_ = onEvent;
+
     /** @private {HTMLMediaElement} */
     this.video_ = video;
 
@@ -52,6 +58,9 @@ shaka.media.GapJumpingController = class {
     /** @private {number} */
     this.prevReadyState_ = video.readyState;
 
+    /** @private {number} */
+    this.gapsJumped_ = 0;
+
     /**
      * The stall detector tries to keep the playhead moving forward. It is
      * managed by the gap-jumping controller to avoid conflicts. On some
@@ -98,6 +107,7 @@ shaka.media.GapJumpingController = class {
       this.stallDetector_ = null;
     }
 
+    this.onEvent_ = null;
     this.timeline_ = null;
     this.video_ = null;
   }
@@ -121,6 +131,15 @@ shaka.media.GapJumpingController = class {
   }
 
 
+  /**
+   * Returns the total number of playback gaps jumped.
+   * @return {number}
+   */
+  getGapsJumped() {
+    return this.gapsJumped_;
+  }
+
+
   /**
    * Called on a recurring timer to check for gaps in the media.  This is also
    * called in a 'waiting' event.
@@ -209,6 +228,9 @@ shaka.media.GapJumpingController = class {
     }
 
     this.video_.currentTime = jumpTo;
+    this.gapsJumped_++;
+    this.onEvent_(
+        new shaka.util.FakeEvent(shaka.util.FakeEvent.EventName.GapJumped));
   }
 };
 

package/lib/media/media_source_engine.js

@@ -106,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();
   }
 
   /**
@@ -331,6 +337,8 @@ shaka.media.MediaSourceEngine = class {
 
     await this.mediaSourceOpen_;
 
+    this.sequenceMode_ = sequenceMode;
+
     for (const contentType of streamsByType.keys()) {
       const stream = streamsByType.get(contentType);
       goog.asserts.assert(
@@ -348,11 +356,9 @@ shaka.media.MediaSourceEngine = class {
           mimeType =
               shaka.media.Transmuxer.convertTsCodecs(contentType, mimeType);
         }
+
         const sourceBuffer = this.mediaSource_.addSourceBuffer(mimeType);
-        if (sequenceMode) {
-          sourceBuffer.mode =
-              shaka.media.MediaSourceEngine.SourceBufferMode_.SEQUENCE;
-        }
+
         this.eventManager_.listen(
             sourceBuffer, 'error',
             () => this.onError_(contentType));
@@ -515,35 +521,29 @@ shaka.media.MediaSourceEngine = class {
    * @param {?boolean} hasClosedCaptions True if the buffer contains CEA closed
    * captions
    * @param {boolean=} seeked True if we just seeked
-   * @param {boolean=} sequenceMode True if sequence mode
    * @return {!Promise}
    */
-  async appendBuffer(contentType, data, startTime, endTime, hasClosedCaptions,
-      seeked, sequenceMode) {
+  async appendBuffer(
+      contentType, data, startTime, endTime, hasClosedCaptions, seeked) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
-    if (startTime != null && sequenceMode && contentType != ContentType.TEXT) {
-      // If we just cleared buffer and is on an unbuffered seek, we need to set
-      // the new timestampOffset of the sourceBuffer.
-      // Don't do this for text streams, though, since they don't use
-      // MediaSource anyway.
-      if (seeked) {
-        const timestampOffset = /** @type {number} */ (startTime);
-        this.enqueueOperation_(
-            contentType,
-            () => this.setTimestampOffset_(contentType, timestampOffset));
+    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);
+      return;
     }
 
-    if (contentType == ContentType.TEXT) {
-      await this.textEngine_.appendBuffer(data, startTime, endTime);
-    } else if (this.transmuxers_[contentType]) {
+    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', sequenceMode || false);
+        this.reinitText('text/vtt', this.sequenceMode_);
       }
 
       if (transmuxedData.metadata) {
@@ -562,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', sequenceMode || false);
+        this.reinitText('text/vtt', this.sequenceMode_);
       }
       // If it is the init segment for closed captions, initialize the closed
       // caption parser.
@@ -585,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));
   }
 
   /**

package/lib/media/playhead.js

@@ -41,6 +41,20 @@ shaka.media.Playhead = class {
    */
   setStartTime(startTime) {}
 
+  /**
+   * Get the number of playback stalls detected by the StallDetector.
+   *
+   * @return {number}
+   */
+  getStallsDetected() {}
+
+  /**
+   * Get the number of playback gaps jumped by the GapJumpingController.
+   *
+   * @return {number}
+   */
+  getGapsJumped() {}
+
   /**
    * Get the current playhead position. The position will be restricted to valid
    * time ranges.
@@ -133,6 +147,16 @@ shaka.media.SrcEqualsPlayhead = class {
     return time || 0;
   }
 
+  /** @override */
+  getStallsDetected() {
+    return 0;
+  }
+
+  /** @override */
+  getGapsJumped() {
+    return 0;
+  }
+
   /** @override */
   notifyOfBufferingChange() {}
 };
@@ -160,8 +184,10 @@ shaka.media.MediaSourcePlayhead = class {
    * @param {function()} onSeek
    *     Called when the user agent seeks to a time within the presentation
    *     timeline.
+   * @param {function(!Event)} onEvent
+   *     Called when an event is raised to be sent to the application.
    */
-  constructor(mediaElement, manifest, config, startTime, onSeek) {
+  constructor(mediaElement, manifest, config, startTime, onSeek, onEvent) {
     /**
      * The seek range must be at least this number of seconds long. If it is
      * smaller than this, change it to be this big so we don't repeatedly seek
@@ -192,12 +218,17 @@ shaka.media.MediaSourcePlayhead = class {
     /** @private {?number} */
     this.lastCorrectiveSeek_ = null;
 
+    /** @private {shaka.media.StallDetector} */
+    this.stallDetector_ =
+        this.createStallDetector_(mediaElement, config, onEvent);
+
     /** @private {shaka.media.GapJumpingController} */
     this.gapController_ = new shaka.media.GapJumpingController(
         mediaElement,
         manifest.presentationTimeline,
         config,
-        this.createStallDetector_(mediaElement, config));
+        this.stallDetector_,
+        onEvent);
 
     /** @private {shaka.media.VideoWrapper} */
     this.videoWrapper_ = new shaka.media.VideoWrapper(
@@ -261,6 +292,16 @@ shaka.media.MediaSourcePlayhead = class {
     return time;
   }
 
+  /** @override */
+  getStallsDetected() {
+    return this.stallDetector_.getStallsDetected();
+  }
+
+  /** @override */
+  getGapsJumped() {
+    return this.gapController_.getGapsJumped();
+  }
+
   /**
    * Gets the playhead's initial position in seconds.
    *
@@ -475,10 +516,12 @@ shaka.media.MediaSourcePlayhead = class {
    *
    * @param {!HTMLMediaElement} mediaElement
    * @param {shaka.extern.StreamingConfiguration} config
+   * @param {function(!Event)} onEvent
+   *     Called when an event is raised to be sent to the application.
    * @return {shaka.media.StallDetector}
    * @private
    */
-  createStallDetector_(mediaElement, config) {
+  createStallDetector_(mediaElement, config, onEvent) {
     if (!config.stallEnabled) {
       return null;
     }
@@ -492,7 +535,7 @@ shaka.media.MediaSourcePlayhead = class {
     // playhead forward.
     const detector = new shaka.media.StallDetector(
         new shaka.media.StallDetector.MediaElementImplementation(mediaElement),
-        threshold);
+        threshold, onEvent);
 
     detector.onStall((at, duration) => {
       shaka.log.debug(`Stall detected at ${at} for ${duration} seconds.`);

package/lib/media/stall_detector.js

@@ -9,6 +9,7 @@ goog.provide('shaka.media.StallDetector.Implementation');
 goog.provide('shaka.media.StallDetector.MediaElementImplementation');
 
 goog.require('shaka.media.TimeRangesUtils');
+goog.require('shaka.util.FakeEvent');
 goog.require('shaka.util.IReleasable');
 
 /**
@@ -23,11 +24,14 @@ shaka.media.StallDetector = class {
   /**
    * @param {shaka.media.StallDetector.Implementation} implementation
    * @param {number} stallThresholdSeconds
+   * @param {function(!Event)} onEvent
+   *     Called when an event is raised to be sent to the application.
    */
-  constructor(implementation, stallThresholdSeconds) {
+  constructor(implementation, stallThresholdSeconds, onEvent) {
+    /** @private {?function(!Event)} */
+    this.onEvent_ = onEvent;
     /** @private {shaka.media.StallDetector.Implementation} */
     this.implementation_ = implementation;
-
     /** @private {boolean} */
     this.wasMakingProgress_ = implementation.shouldBeMakingProgress();
     /** @private {number} */
@@ -36,6 +40,8 @@ shaka.media.StallDetector = class {
     this.lastUpdateSeconds_ = implementation.getWallSeconds();
     /** @private {boolean} */
     this.didJump_ = false;
+    /** @private {number} */
+    this.stallsDetected_ = 0;
 
     /**
      * The amount of time in seconds that we must have the same value of
@@ -53,6 +59,7 @@ shaka.media.StallDetector = class {
   release() {
     // Drop external references to make things easier on the GC.
     this.implementation_ = null;
+    this.onEvent_ = null;
     this.onStall_ = () => {};
   }
 
@@ -66,6 +73,13 @@ shaka.media.StallDetector = class {
     this.onStall_ = doThis;
   }
 
+  /**
+   * Returns the number of playback stalls detected.
+   */
+  getStallsDetected() {
+    return this.stallsDetected_;
+  }
+
   /**
    * Have the detector update itself and fire the "on stall" callback if a stall
    * was detected.
@@ -100,6 +114,9 @@ shaka.media.StallDetector = class {
       // If the onStall_ method updated the current time, update our stored
       // value so we don't think that was an update.
       this.value_ = impl.getPresentationSeconds();
+      this.stallsDetected_++;
+      this.onEvent_(new shaka.util.FakeEvent(
+          shaka.util.FakeEvent.EventName.StallDetected));
     }
 
     return triggerCallback;

package/lib/media/streaming_engine.js

@@ -1215,6 +1215,13 @@ shaka.media.StreamingEngine = class {
     mediaState.performingUpdate = true;
 
     try {
+      if (reference.getStatus() ==
+          shaka.media.SegmentReference.Status.MISSING) {
+        throw new shaka.util.Error(
+            shaka.util.Error.Severity.RECOVERABLE,
+            shaka.util.Error.Category.NETWORK,
+            shaka.util.Error.Code.SEGMENT_MISSING);
+      }
       await this.initSourceBuffer_(mediaState, reference);
       this.destroyer_.ensureNotDestroyed();
       if (this.fatalError_) {
@@ -1605,8 +1612,7 @@ shaka.media.StreamingEngine = class {
         reference.syncTime == null ? reference.startTime : reference.syncTime,
         reference.endTime,
         hasClosedCaptions,
-        seeked,
-        this.manifest_.sequenceMode);
+        seeked);
     this.destroyer_.ensureNotDestroyed();
     shaka.log.v2(logPrefix, 'appended media segment');
   }
@@ -1695,7 +1701,7 @@ shaka.media.StreamingEngine = class {
         };
 
         // Dispatch an event to notify the application about the emsg box.
-        const eventName = shaka.Player.EventName.Emsg;
+        const eventName = shaka.util.FakeEvent.EventName.Emsg;
         const data = (new Map()).set('detail', emsg);
         const event = new shaka.util.FakeEvent(eventName, data);
         this.playerInterface_.onEvent(event);

package/lib/offline/indexeddb/storage_mechanism.js

@@ -368,8 +368,10 @@ shaka.offline.indexeddb.StorageMechanism.SESSION_ID_STORE = 'session-ids';
 shaka.offline.StorageMuxer.register(
     'idb',
     () => {
-      // Offline storage is not supported on the Chromecast platform.
-      if (shaka.util.Platform.isChromecast()) {
+      // Offline storage is not supported on the Chromecast or Xbox One
+      // platforms.
+      if (shaka.util.Platform.isChromecast() ||
+          shaka.util.Platform.isXboxOne()) {
         return null;
       }
       // Offline storage requires the IndexedDB API.

package/lib/offline/manifest_converter.js

@@ -302,6 +302,7 @@ shaka.offline.ManifestConverter = class {
     return {
       id: id,
       language: '',
+      disabledUntilTime: 0,
       primary: false,
       audio: null,
       video: null,