shaka-player 4.3.10 → 4.4.0

package/lib/media/playhead.js

@@ -252,7 +252,7 @@ shaka.media.MediaSourcePlayhead = class {
         mediaElement,
         () => this.onSeeking_(),
         (realStartTime) => this.onStarted_(realStartTime),
-        this.getStartTime_(startTime));
+        () => this.getStartTime_(startTime));
 
     /** @type {shaka.util.Timer} */
     this.checkWindowTimer_ = new shaka.util.Timer(() => {

package/lib/media/presentation_timeline.js

@@ -219,6 +219,46 @@ shaka.media.PresentationTimeline = class {
     return this.presentationDelay_;
   }
 
+  /**
+   * Gives PresentationTimeline a Stream's timeline so it can size and position
+   * the segment availability window, and account for missing segment
+   * information.
+   *
+   * @param {!Array.<shaka.media.PresentationTimeline.TimeRange>} timeline
+   * @param {number} startOffset
+   * @export
+   */
+  notifyTimeRange(timeline, startOffset) {
+    if (timeline.length == 0) {
+      return;
+    }
+
+    const firstStartTime = timeline[0].start + startOffset;
+    const lastEndTime = timeline[timeline.length - 1].end + startOffset;
+
+    this.notifyMinSegmentStartTime(firstStartTime);
+
+    this.maxSegmentDuration_ = timeline.reduce(
+        (max, r) => { return Math.max(max, r.end - r.start); },
+        this.maxSegmentDuration_);
+
+    this.maxSegmentEndTime_ =
+          Math.max(this.maxSegmentEndTime_, lastEndTime);
+
+    if (this.presentationStartTime_ != null && this.autoCorrectDrift_ &&
+            !this.startTimeLocked_) {
+      // Since we have explicit segment end times, calculate a presentation
+      // start based on them.  This start time accounts for drift.
+      // Date.now() is in milliseconds, from which we compute "now" in seconds.
+      const now = (Date.now() + this.clockOffset_) / 1000.0;
+      this.presentationStartTime_ =
+            now - this.maxSegmentEndTime_ - this.maxSegmentDuration_;
+    }
+
+    shaka.log.v1('notifySegments:',
+        'maxSegmentDuration=' + this.maxSegmentDuration_);
+  }
+
 
   /**
    * Gives PresentationTimeline an array of segments so it can size and position
@@ -573,3 +613,25 @@ shaka.media.PresentationTimeline = class {
     }
   }
 };
+
+
+/**
+ * @typedef {{
+ *   start: number,
+ *   unscaledStart: number,
+ *   end: number
+ * }}
+ *
+ * @description
+ * Defines a time range of a media segment.  Times are in seconds.
+ *
+ * @property {number} start
+ *   The start time of the range.
+ * @property {number} unscaledStart
+ *   The start time of the range in representation timescale units.
+ * @property {number} end
+ *   The end time (exclusive) of the range.
+ *
+ * @export
+ */
+shaka.media.PresentationTimeline.TimeRange;

package/lib/media/segment_index.js

@@ -9,6 +9,7 @@ goog.provide('shaka.media.SegmentIndex');
 goog.provide('shaka.media.SegmentIterator');
 
 goog.require('goog.asserts');
+goog.require('shaka.log');
 goog.require('shaka.media.SegmentReference');
 goog.require('shaka.util.IReleasable');
 goog.require('shaka.util.Timer');
@@ -44,12 +45,29 @@ shaka.media.SegmentIndex = class {
      *
      * @protected {number}
      */
-    this.numEvicted = 0;
+    this.numEvicted_ = 0;
 
     /** @private {boolean} */
     this.immutable_ = false;
   }
 
+  /**
+   * Get immutability
+   *
+   * @return {boolean}
+   */
+  getIsImmutable() {
+    return this.immutable_;
+  }
+
+  /**
+   * Get number of references
+   * @protected
+   * @return {number}
+   */
+  getNumReferences() {
+    return this.references.length;
+  }
 
   /**
    * @override
@@ -140,11 +158,11 @@ shaka.media.SegmentIndex = class {
         this.references[i + 1].startTime : r.endTime;
       // Note that a segment ends immediately before the end time.
       if ((time >= start) && (time < end)) {
-        return i + this.numEvicted;
+        return i + this.numEvicted_;
       }
     }
     if (this.references.length && time < this.references[0].startTime) {
-      return this.numEvicted;
+      return this.numEvicted_;
     }
 
     return null;
@@ -164,7 +182,7 @@ shaka.media.SegmentIndex = class {
       return null;
     }
 
-    const index = position - this.numEvicted;
+    const index = position - this.numEvicted_;
     if (index < 0 || index >= this.references.length) {
       return null;
     }
@@ -290,7 +308,7 @@ shaka.media.SegmentIndex = class {
     const diff = oldSize - newSize;
     // Tracking the number of evicted refs will keep their "positions" stable
     // for the caller.
-    this.numEvicted += diff;
+    this.numEvicted_ += diff;
   }
 
 
@@ -332,7 +350,7 @@ shaka.media.SegmentIndex = class {
       if (firstReference.endTime <= windowStart) {
         this.references.shift();
         if (!isNew) {
-          this.numEvicted++;
+          this.numEvicted_++;
         }
       } else {
         break;
@@ -407,10 +425,17 @@ shaka.media.SegmentIndex = class {
 
   /**
    * Returns a new iterator that initially points to the segment that contains
-   * the given time.  Like the normal iterator, next() must be called first to
-   * get to the first element. Returns null if we do not find a segment at the
+   * the given time, or the nearest independent segment before it.
+   *
+   * Like the normal iterator, next() must be called first to get to the first
+   * element. Returns null if we do not find a segment at the
    * requested time.
    *
+   * The first segment returned by the iterator _MUST_ be an independent
+   * segment.  Assumes that only partial references can be dependent, based on
+   * RFC 8216 rev 13, section 8.1: "Each (non-Partial) Media Segment in a Media
+   * Playlist will contain at least one independent frame."
+   *
    * @param {number} time
    * @return {?shaka.media.SegmentIterator}
    * @export
@@ -430,9 +455,18 @@ shaka.media.SegmentIndex = class {
     if (ref && ref.hasPartialSegments()) {
       // Look for a partial SegmentReference.
       for (let i = ref.partialReferences.length - 1; i >= 0; --i) {
-        const r = ref.partialReferences[i];
+        let r = ref.partialReferences[i];
         // Note that a segment ends immediately before the end time.
         if ((time >= r.startTime) && (time < r.endTime)) {
+          // Find an independent partial segment by moving backwards.
+          while (i && !r.isIndependent()) {
+            i--;
+            r = ref.partialReferences[i];
+          }
+          if (!r.isIndependent()) {
+            shaka.log.alwaysError('No independent partial segment found!');
+            return null;
+          }
           // Call to next() should move the partial segment, not the full
           // segment.
           index++;
@@ -448,7 +482,7 @@ shaka.media.SegmentIndex = class {
    * @return {boolean}
    */
   isEmpty() {
-    return this.references.length == 0;
+    return this.getNumReferences() == 0;
   }
 
   /**
@@ -629,7 +663,7 @@ shaka.media.MetaSegmentIndex = class extends shaka.media.SegmentIndex {
    */
   appendSegmentIndex(segmentIndex) {
     goog.asserts.assert(
-        this.indexes_.length == 0 || segmentIndex.numEvicted == 0,
+        this.indexes_.length == 0 || segmentIndex.numEvicted_ == 0,
         'Should not append a new segment index with already-evicted segments');
     this.indexes_.push(segmentIndex);
   }
@@ -673,7 +707,8 @@ shaka.media.MetaSegmentIndex = class extends shaka.media.SegmentIndex {
         return position + numPassedInEarlierIndexes;
       }
 
-      numPassedInEarlierIndexes += index.numEvicted + index.references.length;
+      numPassedInEarlierIndexes += index.numEvicted_ +
+        index.references.length;
     }
 
     return null;
@@ -689,7 +724,7 @@ shaka.media.MetaSegmentIndex = class extends shaka.media.SegmentIndex {
 
     for (const index of this.indexes_) {
       goog.asserts.assert(
-          !sawSegments || index.numEvicted == 0,
+          !sawSegments || index.numEvicted_ == 0,
           'Should not see evicted segments after available segments');
       const reference = index.get(position - numPassedInEarlierIndexes);
 
@@ -697,7 +732,8 @@ shaka.media.MetaSegmentIndex = class extends shaka.media.SegmentIndex {
         return reference;
       }
 
-      numPassedInEarlierIndexes += index.numEvicted + index.references.length;
+      numPassedInEarlierIndexes += index.numEvicted_ +
+        index.references.length;
       sawSegments = sawSegments || index.references.length != 0;
     }
 

package/lib/media/segment_prefetch.js

@@ -0,0 +1,277 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.require('goog.asserts');
+goog.require('shaka.net.NetworkingEngine');
+goog.require('shaka.media.InitSegmentReference');
+goog.require('shaka.media.SegmentReference');
+goog.provide('shaka.media.SegmentPrefetch');
+goog.require('shaka.log');
+
+/**
+ * @summary
+ * This class manages segment prefetch operations.
+ * Called by StreamingEngine to prefetch next N segments
+ * ahead of playhead, to reduce the chances of rebuffering.
+ */
+shaka.media.SegmentPrefetch = class {
+  /**
+   * @param {number} prefetchLimit
+   * @param {shaka.extern.Stream} stream
+   * @param {shaka.media.SegmentPrefetch.FetchDispatcher} fetchDispatcher
+   */
+  constructor(prefetchLimit, stream, fetchDispatcher) {
+    /** @private {number} */
+    this.prefetchLimit_ = prefetchLimit;
+
+    /** @private {shaka.extern.Stream} */
+    this.stream_ = stream;
+
+    /** @private {number} */
+    this.prefetchPosTime_ = 0;
+
+    /** @private {shaka.media.SegmentPrefetch.FetchDispatcher} */
+    this.fetchDispatcher_ = fetchDispatcher;
+
+    /**
+     * @private {!Map.<shaka.media.SegmentReference,
+     *           !shaka.media.SegmentPrefetchOperation>}
+     */
+    this.segmentPrefetchMap_ = new Map();
+  }
+
+  /**
+   * Fetch next segments ahead of current segment.
+   *
+   * @param {(!shaka.media.SegmentReference)} startReference
+   * @public
+   */
+  prefetchSegments(startReference) {
+    goog.asserts.assert(this.prefetchLimit_ > 0,
+        'SegmentPrefetch can not be used when prefetchLimit <= 0.');
+
+    const logPrefix = shaka.media.SegmentPrefetch.logPrefix_(this.stream_);
+    if (!this.stream_.segmentIndex) {
+      shaka.log.info(logPrefix, 'missing segmentIndex');
+      return;
+    }
+    const currTime = startReference.startTime;
+    const maxTime = Math.max(currTime, this.prefetchPosTime_);
+    const iterator = this.stream_.segmentIndex.getIteratorForTime(maxTime);
+    if (!iterator) {
+      return;
+    }
+    let reference = startReference;
+    while (this.segmentPrefetchMap_.size < this.prefetchLimit_ &&
+            reference != null) {
+      // By default doesn't prefech preload partial segments when using
+      // byterange
+      let prefetchAllowed = true;
+      if (reference.isPreload() && reference.endByte != null) {
+        prefetchAllowed = false;
+      }
+      if (reference.getStatus() ==
+          shaka.media.SegmentReference.Status.MISSING) {
+        prefetchAllowed = false;
+      }
+      if (prefetchAllowed && !this.segmentPrefetchMap_.has(reference)) {
+        const segmentPrefetchOperation =
+          new shaka.media.SegmentPrefetchOperation(this.fetchDispatcher_);
+        segmentPrefetchOperation.dispatchFetch(reference, this.stream_);
+        this.segmentPrefetchMap_.set(reference, segmentPrefetchOperation);
+      }
+      this.prefetchPosTime_ = reference.startTime;
+      reference = iterator.next().value;
+    }
+  }
+
+  /**
+   * Get the result of prefetched segment if already exists.
+   * @param {(!shaka.media.SegmentReference)} reference
+   * @param {?function(BufferSource):!Promise=} streamDataCallback
+   * @return {?shaka.net.NetworkingEngine.PendingRequest} op
+   * @public
+   */
+  getPrefetchedSegment(reference, streamDataCallback) {
+    goog.asserts.assert(this.prefetchLimit_ > 0,
+        'SegmentPrefetch can not be used when prefetchLimit <= 0.');
+    goog.asserts.assert(reference instanceof shaka.media.SegmentReference,
+        'getPrefetchedSegment is only used for shaka.media.SegmentReference.');
+
+    const logPrefix = shaka.media.SegmentPrefetch.logPrefix_(this.stream_);
+
+    if (this.segmentPrefetchMap_.has(reference)) {
+      const segmentPrefetchOperation = this.segmentPrefetchMap_.get(reference);
+      if (streamDataCallback) {
+        segmentPrefetchOperation.setStreamDataCallback(streamDataCallback);
+      }
+      this.segmentPrefetchMap_.delete(reference);
+      shaka.log.debug(
+          logPrefix,
+          'reused prefetched segment at time:', reference.startTime,
+          'mapSize', this.segmentPrefetchMap_.size);
+      return segmentPrefetchOperation.getOperation();
+    } else {
+      shaka.log.debug(
+          logPrefix,
+          'missed segment at time:', reference.startTime,
+          'mapSize', this.segmentPrefetchMap_.size);
+      return null;
+    }
+  }
+
+  /**
+   * Clear all segment data.
+   * @public
+   */
+  clearAll() {
+    if (this.segmentPrefetchMap_.size === 0) {
+      return;
+    }
+    const logPrefix = shaka.media.SegmentPrefetch.logPrefix_(this.stream_);
+    for (const reference of this.segmentPrefetchMap_.keys()) {
+      if (reference) {
+        this.abortPrefetchedSegment_(reference);
+      }
+    }
+    shaka.log.info(logPrefix, 'cleared all');
+    this.prefetchPosTime_ = 0;
+  }
+
+  /**
+   * Reset the prefetchLimit and clear all internal states.
+   * Called by StreamingEngine when configure() was called.
+   * @param {number} newPrefetchLimit
+   * @public
+   */
+  resetLimit(newPrefetchLimit) {
+    goog.asserts.assert(newPrefetchLimit >= 0,
+        'The new prefetch limit must be >= 0.');
+    this.prefetchLimit_ = newPrefetchLimit;
+    const keyArr = Array.from(this.segmentPrefetchMap_.keys());
+    while (keyArr.length > newPrefetchLimit) {
+      const reference = keyArr.pop();
+      if (reference) {
+        this.abortPrefetchedSegment_(reference);
+      }
+    }
+  }
+
+  /**
+   * Called by Streaming Engine when switching variant.
+   * @param {shaka.extern.Stream} stream
+   * @public
+   */
+  switchStream(stream) {
+    if (stream && stream !== this.stream_) {
+      this.clearAll();
+      this.stream_ = stream;
+    }
+  }
+
+  /**
+   * Remove a segment from prefetch map and abort it.
+   * @param {(!shaka.media.SegmentReference)} reference
+   * @private
+   */
+  abortPrefetchedSegment_(reference) {
+    const logPrefix = shaka.media.SegmentPrefetch.logPrefix_(this.stream_);
+    const segmentPrefetchOperation = this.segmentPrefetchMap_.get(reference);
+    this.segmentPrefetchMap_.delete(reference);
+    if (segmentPrefetchOperation) {
+      segmentPrefetchOperation.abort();
+      shaka.log.info(
+          logPrefix,
+          'pop and abort prefetched segment at time:', reference.startTime);
+    }
+  }
+
+  /**
+   * The prefix of the logs that are created in this class.
+   * @return {string}
+   * @private
+   */
+  static logPrefix_(stream) {
+    return 'SegmentPrefetch(' + stream.type + ':' + stream.id + ')';
+  }
+};
+
+/**
+ * @summary
+ * This class manages a segment prefetch operation.
+ */
+shaka.media.SegmentPrefetchOperation = class {
+  /**
+   * @param {shaka.media.SegmentPrefetch.FetchDispatcher} fetchDispatcher
+   */
+  constructor(fetchDispatcher) {
+    /** @private {shaka.media.SegmentPrefetch.FetchDispatcher} */
+    this.fetchDispatcher_ = fetchDispatcher;
+
+    /** @private {?function(BufferSource):!Promise} */
+    this.streamDataCallback_ = null;
+
+    /** @private {?shaka.net.NetworkingEngine.PendingRequest} */
+    this.operation_ = null;
+  }
+
+  /**
+   * Fetch a segments
+   *
+   * @param {!shaka.media.SegmentReference}
+   *   reference
+   * @param {!shaka.extern.Stream} stream
+   * @public
+   */
+  dispatchFetch(reference, stream) {
+    this.operation_ = this.fetchDispatcher_(
+        reference, stream, async (data) => {
+          if (this.streamDataCallback_) {
+            await this.streamDataCallback_(data);
+          }
+        });
+  }
+
+  /**
+   * Get the operation of prefetched segment if already exists.
+   *
+   * @return {?shaka.net.NetworkingEngine.PendingRequest} op
+   * @public
+   */
+  getOperation() {
+    return this.operation_;
+  }
+
+  /**
+   * @param {?function(BufferSource):!Promise} streamDataCallback
+   * @public
+   */
+  setStreamDataCallback(streamDataCallback) {
+    this.streamDataCallback_ = streamDataCallback;
+  }
+
+  /**
+   * Abort the current operation if exists.
+   */
+  abort() {
+    if (this.operation_) {
+      this.operation_.abort();
+    }
+  }
+};
+
+/**
+ * @typedef {function(
+ *  !(shaka.media.InitSegmentReference|shaka.media.SegmentReference),
+ *  shaka.extern.Stream,
+ *  ?function(BufferSource):!Promise=
+ * ):!shaka.net.NetworkingEngine.PendingRequest}
+ *
+ * @description
+ * A callback function that fetches a segment.
+ * @export
+ */
+shaka.media.SegmentPrefetch.FetchDispatcher;

package/lib/media/segment_reference.js

@@ -10,6 +10,7 @@ goog.provide('shaka.media.SegmentReference');
 goog.require('goog.asserts');
 goog.require('shaka.log');
 goog.require('shaka.util.ArrayUtils');
+goog.require('shaka.util.BufferUtils');
 
 
 /**
@@ -29,9 +30,11 @@ shaka.media.InitSegmentReference = class {
    *   segment extends to the end of the resource.
    * @param {null|shaka.extern.MediaQualityInfo=} mediaQuality Information about
    *   the quality of the media associated with this init segment.
-   * @param {number=} timescale
+   * @param {(null|number)=} timescale
+   * @param {(null|BufferSource)=} segmentData
    */
-  constructor(uris, startByte, endByte, mediaQuality = null, timescale) {
+  constructor(uris, startByte, endByte, mediaQuality = null, timescale = null,
+      segmentData = null) {
     /** @type {function():!Array.<string>} */
     this.getUris = uris;
 
@@ -44,8 +47,11 @@ shaka.media.InitSegmentReference = class {
     /** @const {shaka.extern.MediaQualityInfo|null} */
     this.mediaQuality = mediaQuality;
 
-    /** @type {number|undefined} */
+    /** @type {number|null} */
     this.timescale = timescale;
+
+    /** @type {BufferSource|null} */
+    this.segmentData = segmentData;
   }
 
   /**
@@ -93,6 +99,16 @@ shaka.media.InitSegmentReference = class {
     return this.mediaQuality;
   }
 
+  /**
+   * Return the segment data.
+   *
+   * @return {?BufferSource}
+   */
+  getSegmentData() {
+    return this.segmentData;
+  }
+
+
   /**
    * Check if two initSegmentReference have all the same values.
    * @param {?shaka.media.InitSegmentReference} reference1
@@ -101,12 +117,15 @@ shaka.media.InitSegmentReference = class {
    */
   static equal(reference1, reference2) {
     const ArrayUtils = shaka.util.ArrayUtils;
+    const BufferUtils = shaka.util.BufferUtils;
     if (!reference1 || !reference2) {
       return reference1 == reference2;
     } else {
       return reference1.getStartByte() == reference2.getStartByte() &&
           reference1.getEndByte() == reference2.getEndByte() &&
-          ArrayUtils.equal(reference1.getUris(), reference2.getUris());
+          ArrayUtils.equal(reference1.getUris(), reference2.getUris()) &&
+          BufferUtils.equal(reference1.getSegmentData(),
+              reference2.getSegmentData());
     }
   }
 };
@@ -246,6 +265,12 @@ shaka.media.SegmentReference = class {
     /** @type {boolean} */
     this.preload = false;
 
+    /** @type {boolean} */
+    this.independent = true;
+
+    /** @type {boolean} */
+    this.byterangeOptimization = false;
+
     /** @type {?shaka.extern.HlsAes128Key} */
     this.hlsAes128Key = hlsAes128Key;
 
@@ -388,6 +413,47 @@ shaka.media.SegmentReference = class {
     return this.preload;
   }
 
+  /**
+   * Mark the reference as non-independent.
+   *
+   * @export
+   */
+  markAsNonIndependent() {
+    this.independent = false;
+  }
+
+  /**
+   * Returns true if the segment is independent.
+   *
+   * @return {boolean}
+   * @export
+   */
+  isIndependent() {
+    return this.independent;
+  }
+
+  /**
+   * Mark the reference as byterange optimization.
+   *
+   * The "byterange optimization" means that it is playable using MP4 low
+   * latency streaming with chunked data.
+   *
+   * @export
+   */
+  markAsByterangeOptimization() {
+    this.byterangeOptimization = true;
+  }
+
+  /**
+   * Returns true if the segment has a byterange optimization.
+   *
+   * @return {boolean}
+   * @export
+   */
+  hasByterangeOptimization() {
+    return this.byterangeOptimization;
+  }
+
   /**
    * Set the segment's thumbnail sprite.
    *