shaka-player 3.3.2 → 4.0.0

package/lib/media/media_source_engine.js

@@ -63,9 +63,17 @@ shaka.media.MediaSourceEngine = class {
                            string>} */
     this.sourceBufferTypes_ = {};
 
+
+    /** @private {!Object.<shaka.util.ManifestParserUtils.ContentType,
+                           boolean>} */
+    this.expectedEncryption_ = {};
+
     /** @private {shaka.text.TextEngine} */
     this.textEngine_ = null;
 
+    /** @private {boolean} */
+    this.segmentRelativeVttTiming_ = false;
+
     const onMetadataNoOp = (metadata, timestampOffset, segmentEnd) => {};
 
     /** @private {!function(!Array.<shaka.extern.ID3Metadata>,
@@ -196,6 +204,8 @@ shaka.media.MediaSourceEngine = class {
       // TTML types
       'application/ttml+xml',
       'application/mp4; codecs="stpp"',
+      // Containerless types
+      ...shaka.media.MediaSourceEngine.RAW_FORMATS,
     ];
 
     const support = {};
@@ -310,10 +320,13 @@ 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_;
@@ -327,7 +340,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)) {
@@ -336,6 +349,10 @@ shaka.media.MediaSourceEngine = class {
               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));
@@ -345,6 +362,7 @@ shaka.media.MediaSourceEngine = class {
         this.sourceBuffers_[contentType] = sourceBuffer;
         this.sourceBufferTypes_[contentType] = mimeType;
         this.queues_[contentType] = [];
+        this.expectedEncryption_[contentType] = !!stream.drmInfos.length;
       }
     }
   }
@@ -352,12 +370,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_);
   }
 
   /**
@@ -404,17 +424,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);
     }
   }
 
@@ -496,11 +514,27 @@ 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
+   * @param {boolean=} sequenceMode True if sequence mode
    * @return {!Promise}
    */
-  async appendBuffer(contentType, data, startTime, endTime, hasClosedCaptions) {
+  async appendBuffer(contentType, data, startTime, endTime, hasClosedCaptions,
+      seeked, sequenceMode) {
     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) {
       await this.textEngine_.appendBuffer(data, startTime, endTime);
     } else if (this.transmuxers_[contentType]) {
@@ -509,7 +543,7 @@ shaka.media.MediaSourceEngine = class {
       // 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', sequenceMode || false);
       }
 
       if (transmuxedData.metadata) {
@@ -536,7 +570,7 @@ shaka.media.MediaSourceEngine = class {
           contentType, () => this.append_(contentType, transmuxedSegment));
     } else if (hasClosedCaptions) {
       if (!this.textEngine_) {
-        this.reinitText('text/vtt');
+        this.reinitText('text/vtt', sequenceMode || false);
       }
       // If it is the init segment for closed captions, initialize the closed
       // caption parser.
@@ -664,13 +698,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;
     }
@@ -687,7 +726,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_(
@@ -830,7 +872,8 @@ shaka.media.MediaSourceEngine = class {
    * @private
    */
   setTimestampOffset_(contentType, timestampOffset) {
-    // Work around for https://github.com/google/shaka-player/issues/1281:
+    // Work around for
+    // https://github.com/shaka-project/shaka-player/issues/1281:
     // TODO(https://bit.ly/2ttKiBU): follow up when this is fixed in Edge
     if (timestampOffset < 0) {
       // Try to prevent rounding errors in Edge from removing the first
@@ -1078,6 +1121,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.
@@ -1090,7 +1140,7 @@ shaka.media.MediaSourceEngine = class {
    */
   workAroundBrokenPlatforms_(segment, startTime, contentType) {
     const isInitSegment = startTime == null;
-    const encryptionExpected = this.video_.mediaKeys;
+    const encryptionExpected = this.expectedEncryption_[contentType];
 
     // If:
     //   1. this is an init segment,
@@ -1100,7 +1150,7 @@ shaka.media.MediaSourceEngine = class {
     // then insert fake encryption metadata for init segments that lack it.
     // The MP4 requirement is because we can currently only do this
     // transformation on MP4 containers.
-    // See: https://github.com/google/shaka-player/issues/2759
+    // See: https://github.com/shaka-project/shaka-player/issues/2759
     if (isInitSegment &&
         encryptionExpected &&
         shaka.util.Platform.requiresEncryptionInfoInAllInitSegments() &&
@@ -1138,3 +1188,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',
+];

package/lib/media/mp4_segment_index_parser.js

@@ -11,8 +11,6 @@ goog.require('shaka.log');
 goog.require('shaka.media.InitSegmentReference');
 goog.require('shaka.media.SegmentReference');
 goog.require('shaka.util.Error');
-goog.require('shaka.util.Functional');
-goog.require('shaka.util.Iterables');
 goog.require('shaka.util.Mp4Parser');
 
 
@@ -123,8 +121,7 @@ shaka.media.Mp4SegmentIndexParser = class {
     let unscaledStartTime = earliestPresentationTime;
     let startByte = sidxOffset + box.size + firstOffset;
 
-    for (const _ of shaka.util.Iterables.range(referenceCount)) {
-      shaka.util.Functional.ignored(_);
+    for (let i = 0; i < referenceCount; i++) {
       // |chunk| is 1 bit for |referenceType|, and 31 bits for |referenceSize|.
       const chunk = box.reader.readUint32();
       const referenceType = (chunk & 0x80000000) >>> 31;

package/lib/media/playhead.js

@@ -160,10 +160,8 @@ 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, onEvent) {
+  constructor(mediaElement, manifest, config, startTime, onSeek) {
     /**
      * 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
@@ -199,8 +197,7 @@ shaka.media.MediaSourcePlayhead = class {
         mediaElement,
         manifest.presentationTimeline,
         config,
-        this.createStallDetector_(mediaElement, config),
-        onEvent);
+        this.createStallDetector_(mediaElement, config));
 
     /** @private {shaka.media.VideoWrapper} */
     this.videoWrapper_ = new shaka.media.VideoWrapper(
@@ -256,7 +253,7 @@ shaka.media.MediaSourcePlayhead = class {
     // We don't buffer when the livestream video is paused and the playhead time
     // is out of the seek range; thus, we do not clamp the current time when the
     // video is paused.
-    // https://github.com/google/shaka-player/issues/1121
+    // https://github.com/shaka-project/shaka-player/issues/1121
     if (this.mediaElement_.readyState > 0 && !this.mediaElement_.paused) {
       return this.clampTime_(time);
     }
@@ -362,7 +359,7 @@ shaka.media.MediaSourcePlayhead = class {
    * presentation duration.  Seeking to or starting at duration does not work
    * consistently across browsers.
    *
-   * @see https://github.com/google/shaka-player/issues/979
+   * @see https://github.com/shaka-project/shaka-player/issues/979
    * @param {number} time
    * @return {number} The adjusted seek time.
    * @private

package/lib/media/presentation_timeline.js

@@ -249,8 +249,7 @@ shaka.media.PresentationTimeline = class {
    * @param {number} startTime
    * @export
    */
-  notifyMinSegmentStartTime(
-      startTime) {
+  notifyMinSegmentStartTime(startTime) {
     if (this.minSegmentStartTime_ == null) {
       // No data yet, and Math.min(null, startTime) is always 0.  So just store
       // startTime.
@@ -355,14 +354,23 @@ shaka.media.PresentationTimeline = class {
    * starting after this time should be assumed to be unavailable.
    *
    * @return {number} The current segment availability end time, in seconds,
-   *   relative to the start of the presentation.  Always returns the
-   *   presentation's duration for video-on-demand.
+   *   relative to the start of the presentation.  For VOD, the availability
+   *   end time is the content's duration.  If the Player's playRangeEnd
+   *   configuration is used, this can override the duration.
    * @export
    */
   getSegmentAvailabilityEnd() {
     if (!this.isLive() && !this.isInProgress()) {
       // It's a static manifest (can also be a dynamic->static conversion)
-      return this.maxSegmentEndTime_ || this.duration_;
+      if (this.maxSegmentEndTime_) {
+        // If we know segment times, use the min of that and duration.
+        // Note that the playRangeEnd configuration changes this.duration_.
+        // See https://github.com/shaka-project/shaka-player/issues/4026
+        return Math.min(this.maxSegmentEndTime_, this.duration_);
+      } else {
+        // If we don't have segment times, use duration.
+        return this.duration_;
+      }
     }
     // Can be either live or "in-progress recording" (live with known duration)
     return Math.min(this.getLiveEdge_() + this.availabilityTimeOffset_,
@@ -389,10 +397,11 @@ shaka.media.PresentationTimeline = class {
     // For VOD, the offset and end time are ignored, and we just return the
     // earliest segment time.  All segments are "safe" in VOD.  However, we
     // should round up to the nearest millisecond to avoid issues like
-    // https://github.com/google/shaka-player/issues/2831, in which we tried to
-    // seek repeatedly to catch up to the seek range, and never actually
-    // "arrived" within it.  The video's currentTime is not as accurate as the
-    // JS number representing the earliest segment time for some content.
+    // https://github.com/shaka-project/shaka-player/issues/2831, in which we
+    // tried to seek repeatedly to catch up to the seek range, and never
+    // actually "arrived" within it.  The video's currentTime is not as
+    // accurate as the JS number representing the earliest segment time for
+    // some content.
     if (this.segmentAvailabilityDuration_ == Infinity) {
       return Math.ceil(earliestSegmentTime * 1e3) / 1e3;
     }
@@ -407,7 +416,7 @@ shaka.media.PresentationTimeline = class {
     // Add the offset to the availability start to ensure that we don't fall
     // outside the availability window while we buffer; we don't need to add the
     // offset to earliestSegmentTime since that won't change over time.
-    // Also see: https://github.com/google/shaka-player/issues/692
+    // Also see: https://github.com/shaka-project/shaka-player/issues/692
     const desiredStart =
         Math.min(availabilityStart + offset, this.getSeekRangeEnd());
     return Math.max(earliestSegmentTime, desiredStart);

package/lib/media/segment_index.js

@@ -9,7 +9,6 @@ goog.provide('shaka.media.SegmentIndex');
 goog.provide('shaka.media.SegmentIterator');
 
 goog.require('goog.asserts');
-goog.require('shaka.Deprecate');
 goog.require('shaka.media.SegmentReference');
 goog.require('shaka.util.IReleasable');
 goog.require('shaka.util.Timer');
@@ -52,23 +51,6 @@ shaka.media.SegmentIndex = class {
   }
 
 
-  /**
-   * SegmentIndex used to be an IDestroyable.  Now it is an IReleasable.
-   * This method is provided for backward compatibility.
-   *
-   * @deprecated
-   * @return {!Promise}
-   * @export
-   */
-  destroy() {
-    shaka.Deprecate.deprecateFeature(4,
-        'shaka.media.SegmentIndex',
-        'Please use release() instead of destroy().');
-    this.release();
-    return Promise.resolve();
-  }
-
-
   /**
    * @override
    * @export
@@ -101,6 +83,17 @@ shaka.media.SegmentIndex = class {
   }
 
 
+  /**
+   * Iterates over all top-level segment references in this segment index.
+   * @param {function(!shaka.media.SegmentReference)} fn
+   */
+  forEachTopLevelReference(fn) {
+    for (const reference of this.references) {
+      fn(reference);
+    }
+  }
+
+
   /**
    * Finds the position of the segment for the given time, in seconds, relative
    * to the start of the presentation.  Returns the position of the segment
@@ -191,9 +184,6 @@ shaka.media.SegmentIndex = class {
    * @param {!Array.<!shaka.media.SegmentReference>} references The list of
    *   SegmentReferences, which must be sorted first by their start times
    *   (ascending) and second by their end times (ascending).
-   * @deprecated Not used directly by our own parsers, so will become private in
-   *   v4.  Use mergeAndEvict() instead.
-   * @export
    */
   merge(references) {
     if (goog.DEBUG) {
@@ -348,7 +338,8 @@ shaka.media.SegmentIndex = class {
             lastReference.appendWindowEnd,
             lastReference.partialReferences,
             lastReference.tilesLayout,
-            lastReference.tileDuration);
+            lastReference.tileDuration,
+            lastReference.syncTime);
   }
 
 
@@ -513,30 +504,6 @@ shaka.media.SegmentIterator = class {
     this.currentPartialPosition_ = partialSegmentIndex;
   }
 
-  /**
-   * Move the iterator to a given timestamp in the underlying SegmentIndex.
-   *
-   * @param {number} time
-   * @return {shaka.media.SegmentReference}
-   * @deprecated Use SegmentIndex.getIteratorForTime instead
-   * @export
-   */
-  seek(time) {
-    shaka.Deprecate.deprecateFeature(
-        4, 'shaka.media.SegmentIterator',
-        'Please use SegmentIndex.getIteratorForTime instead of seek().');
-
-    const iter = this.segmentIndex_.getIteratorForTime(time);
-    if (iter) {
-      this.currentPosition_ = iter.currentPosition_;
-      this.currentPartialPosition_ = iter.currentPartialPosition_;
-    } else {
-      this.currentPosition_ = Number.MAX_VALUE;
-      this.currentPartialPosition_ = 0;
-    }
-    return this.next().value;
-  }
-
   /**
    * @return {shaka.media.SegmentReference}
    * @export

package/lib/media/segment_reference.js

@@ -159,11 +159,18 @@ shaka.media.SegmentReference = class {
    *  The explicit duration of an individual tile within the tiles grid.
    *  If not provided, the duration should be automatically calculated based on
    *  the duration of the reference.
+   * @param {?number=} syncTime
+   *  A time value, expressed in the same scale as the start and end time, which
+   *  is used to synchronize between streams.
+   * @param {shaka.media.SegmentReference.Status=} status
+   *  The segment status is used to indicate that a segment does not exist or is
+   *  not available.
    */
   constructor(
       startTime, endTime, uris, startByte, endByte, initSegmentReference,
       timestampOffset, appendWindowStart, appendWindowEnd,
-      partialReferences = [], tilesLayout = '', tileDuration = null) {
+      partialReferences = [], tilesLayout = '', tileDuration = null,
+      syncTime = null, status = shaka.media.SegmentReference.Status.AVAILABLE) {
     // A preload hinted Partial Segment has the same startTime and endTime.
     goog.asserts.assert(startTime <= endTime,
         'startTime must be less than or equal to endTime');
@@ -213,6 +220,12 @@ shaka.media.SegmentReference = class {
 
     /** @type {?number} */
     this.tileDuration = tileDuration;
+
+    /** @type {?number} */
+    this.syncTime = syncTime;
+
+    /** @type {shaka.media.SegmentReference.Status} */
+    this.status = status;
   }
 
   /**
@@ -308,6 +321,39 @@ shaka.media.SegmentReference = class {
   getTileDuration() {
     return this.tileDuration;
   }
+
+  /**
+   * Returns the segment's status.
+   *
+   * @return {shaka.media.SegmentReference.Status}
+   * @export
+   */
+  getStatus() {
+    return this.status;
+  }
+
+  /**
+   * Mark the reference as unavailable.
+   *
+   * @export
+   */
+  markAsUnavailable() {
+    this.status = shaka.media.SegmentReference.Status.UNAVAILABLE;
+  }
+};
+
+
+/**
+ * Rather than using booleans to communicate what the state of the reference,
+ * we have this enum.
+ *
+ * @enum {number}
+ * @export
+ */
+shaka.media.SegmentReference.Status = {
+  AVAILABLE: 0,
+  UNAVAILABLE: 1,
+  MISSING: 2,
 };