shaka-player 4.7.13 → 4.8.1

package/lib/media/presentation_timeline.js

@@ -198,6 +198,17 @@ shaka.media.PresentationTimeline = class {
   }
 
 
+  /**
+   * Gets the presentation's segment availability duration.
+   *
+   * @return {number}
+   * @export
+   */
+  getSegmentAvailabilityDuration() {
+    return this.segmentAvailabilityDuration_;
+  }
+
+
   /**
    * Sets the presentation delay in seconds.
    *

package/lib/media/segment_index.js

@@ -18,6 +18,7 @@ goog.require('shaka.util.Timer');
 /**
  * SegmentIndex.
  *
+ * @implements {shaka.extern.SegmentIndex}
  * @implements {shaka.util.IReleasable}
  * @implements {Iterable.<!shaka.media.SegmentReference>}
  * @export
@@ -61,14 +62,21 @@ shaka.media.SegmentIndex = class {
   }
 
   /**
-   * Get number of references
-   * @protected
-   * @return {number}
+   * @override
+   * @export
    */
   getNumReferences() {
     return this.references.length;
   }
 
+  /**
+   * @override
+   * @export
+   */
+  getNumEvicted() {
+    return this.numEvicted_;
+  }
+
   /**
    * @override
    * @export
@@ -132,14 +140,7 @@ shaka.media.SegmentIndex = class {
 
 
   /**
-   * 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
-   * with the largest end time if more than one segment is known for the given
-   * time.
-   *
-   * @param {number} time
-   * @return {?number} The position of the segment, or null if the position of
-   *   the segment could not be determined.
+   * @override
    * @export
    */
   find(time) {
@@ -170,11 +171,7 @@ shaka.media.SegmentIndex = class {
 
 
   /**
-   * Gets the SegmentReference for the segment at the given position.
-   *
-   * @param {number} position The position of the segment as returned by find().
-   * @return {shaka.media.SegmentReference} The SegmentReference, or null if
-   *   no such SegmentReference exists.
+   * @override
    * @export
    */
   get(position) {
@@ -378,7 +375,7 @@ shaka.media.SegmentIndex = class {
         lastReference.tileDuration,
         lastReference.syncTime,
         lastReference.status,
-        lastReference.aes128Key,
+        lastReference.aesKey,
     );
     newReference.mimeType = lastReference.mimeType;
     newReference.codecs = lastReference.codecs;
@@ -438,10 +435,12 @@ shaka.media.SegmentIndex = class {
    * Playlist will contain at least one independent frame."
    *
    * @param {number} time
+   * @param {boolean=} allowNonIndepedent
+   * @param {boolean=} reverse
    * @return {?shaka.media.SegmentIterator}
    * @export
    */
-  getIteratorForTime(time) {
+  getIteratorForTime(time, allowNonIndepedent = false, reverse = false) {
     let index = this.find(time);
     if (index == null) {
       return null;
@@ -459,14 +458,16 @@ shaka.media.SegmentIndex = class {
         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;
+          if (!allowNonIndepedent) {
+            // 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.
@@ -476,7 +477,8 @@ shaka.media.SegmentIndex = class {
         }
       }
     }
-    return new shaka.media.SegmentIterator(this, index, partialSegmentIndex);
+    return new shaka.media.SegmentIterator(
+        this, index, partialSegmentIndex, reverse);
   }
 
   /**
@@ -552,8 +554,9 @@ shaka.media.SegmentIterator = class {
    * @param {shaka.media.SegmentIndex} segmentIndex
    * @param {number} index
    * @param {number} partialSegmentIndex
+   * @param {boolean} reverse
    */
-  constructor(segmentIndex, index, partialSegmentIndex) {
+  constructor(segmentIndex, index, partialSegmentIndex, reverse) {
     /** @private {shaka.media.SegmentIndex} */
     this.segmentIndex_ = segmentIndex;
 
@@ -562,6 +565,17 @@ shaka.media.SegmentIterator = class {
 
     /** @private {number} */
     this.currentPartialPosition_ = partialSegmentIndex;
+
+    /** @private {boolean} */
+    this.reverse = reverse;
+  }
+
+  /**
+   * @param {boolean} reverse
+   * @export
+   */
+  setReverse(reverse) {
+    this.reverse = reverse;
   }
 
   /**
@@ -606,25 +620,47 @@ shaka.media.SegmentIterator = class {
   next() {
     const ref = this.segmentIndex_.get(this.currentPosition_);
 
-    if (ref && ref.hasPartialSegments()) {
-      // If the regular segment contains partial segments, move to the next
-      // partial SegmentReference.
-      this.currentPartialPosition_++;
-      // If the current regular segment has been published completely, and
-      // we've reached the end of its partial segments list, move to the next
-      // regular segment.
-      // If the Partial Segments list is still on the fly, do not move to
-      // the next regular segment.
-      if (ref.hasAllPartialSegments() &&
-          this.currentPartialPosition_ == ref.partialReferences.length) {
+    if (!this.reverse) {
+      if (ref && ref.hasPartialSegments()) {
+        // If the regular segment contains partial segments, move to the next
+        // partial SegmentReference.
+        this.currentPartialPosition_++;
+        // If the current regular segment has been published completely, and
+        // we've reached the end of its partial segments list, move to the next
+        // regular segment.
+        // If the Partial Segments list is still on the fly, do not move to
+        // the next regular segment.
+        if (ref.hasAllPartialSegments() &&
+            this.currentPartialPosition_ == ref.partialReferences.length) {
+          this.currentPosition_++;
+          this.currentPartialPosition_ = 0;
+        }
+      } else {
+        // If the regular segment doesn't contain partial segments, move to the
+        // next regular segment.
         this.currentPosition_++;
         this.currentPartialPosition_ = 0;
       }
     } else {
-      // If the regular segment doesn't contain partial segments, move to the
-      // next regular segment.
-      this.currentPosition_++;
-      this.currentPartialPosition_ = 0;
+      if (ref && ref.hasPartialSegments()) {
+        // If the regular segment contains partial segments, move to the
+        // previous partial SegmentReference.
+        this.currentPartialPosition_--;
+        if (this.currentPartialPosition_ < 0) {
+          this.currentPosition_--;
+          const prevRef = this.segmentIndex_.get(this.currentPosition_);
+          if (prevRef && prevRef.hasPartialSegments()) {
+            this.currentPartialPosition_ = prevRef.partialReferences.length - 1;
+          } else {
+            this.currentPartialPosition_ = 0;
+          }
+        }
+      } else {
+        // If the regular segment doesn't contain partial segments, move to the
+        // previous regular segment.
+        this.currentPosition_--;
+        this.currentPartialPosition_ = 0;
+      }
     }
 
     const res = this.current();
@@ -664,7 +700,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.getNumEvicted() == 0,
         'Should not append a new segment index with already-evicted segments');
     this.indexes_.push(segmentIndex);
   }
@@ -694,6 +730,16 @@ shaka.media.MetaSegmentIndex = class extends shaka.media.SegmentIndex {
     this.indexes_ = [];
   }
 
+  /**
+   * @override
+   * @export
+   */
+  forEachTopLevelReference(fn) {
+    for (const index of this.indexes_) {
+      index.forEachTopLevelReference(fn);
+    }
+  }
+
   /**
    * @override
    * @export
@@ -708,7 +754,7 @@ shaka.media.MetaSegmentIndex = class extends shaka.media.SegmentIndex {
         return position + numPassedInEarlierIndexes;
       }
 
-      numPassedInEarlierIndexes += index.numEvicted_ +
+      numPassedInEarlierIndexes += index.getNumEvicted() +
         index.getNumReferences();
     }
 
@@ -725,7 +771,7 @@ shaka.media.MetaSegmentIndex = class extends shaka.media.SegmentIndex {
 
     for (const index of this.indexes_) {
       goog.asserts.assert(
-          !sawSegments || index.numEvicted_ == 0,
+          !sawSegments || index.getNumEvicted() == 0,
           'Should not see evicted segments after available segments');
       const reference = index.get(position - numPassedInEarlierIndexes);
 
@@ -734,7 +780,7 @@ shaka.media.MetaSegmentIndex = class extends shaka.media.SegmentIndex {
       }
 
       const num = index.getNumReferences();
-      numPassedInEarlierIndexes += index.numEvicted_ + num;
+      numPassedInEarlierIndexes += index.getNumEvicted() + num;
       sawSegments = sawSegments || num != 0;
     }
 

package/lib/media/segment_prefetch.js

@@ -41,42 +41,64 @@ shaka.media.SegmentPrefetch = class {
 
     /**
      * @private {!Map.<
-     *        !(shaka.media.SegmentReference|shaka.media.InitSegmentReference),
+     *        !(shaka.media.SegmentReference),
      *        !shaka.media.SegmentPrefetchOperation>}
      */
     this.segmentPrefetchMap_ = new Map();
+
+    /**
+     * @private {!Map.<
+     *        !(shaka.media.InitSegmentReference),
+     *        !shaka.media.SegmentPrefetchOperation>}
+     */
+    this.initSegmentPrefetchMap_ = new Map();
+  }
+
+  /**
+   * @param {shaka.media.SegmentPrefetch.FetchDispatcher} fetchDispatcher
+   */
+  replaceFetchDispatcher(fetchDispatcher) {
+    this.fetchDispatcher_ = fetchDispatcher;
+    for (const operation of this.segmentPrefetchMap_.values()) {
+      operation.replaceFetchDispatcher(fetchDispatcher);
+    }
   }
 
   /**
-   * Fetch next segments ahead of current segment.
+   * @return {number}
+   */
+  getLastKnownPosition() {
+    return this.prefetchPosTime_;
+  }
+
+  /**
+   * Fetch next segments ahead of current time.
    *
-   * @param {(!shaka.media.SegmentReference)} startReference
+   * @param {number} currTime
    * @param {boolean=} skipFirst
    * @public
    */
-  prefetchSegments(startReference, skipFirst = false) {
+  prefetchSegmentsByTime(currTime, skipFirst = false) {
     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');
+      shaka.log.debug(logPrefix, 'missing segmentIndex');
       return;
     }
-    const currTime = startReference.startTime;
     const maxTime = Math.max(currTime, this.prefetchPosTime_);
-    const iterator = this.stream_.segmentIndex.getIteratorForTime(maxTime);
+    const iterator = this.stream_.segmentIndex.getIteratorForTime(
+        maxTime, /* allowNonIndepedent= */ true);
     if (!iterator) {
       return;
     }
-    let reference = startReference;
+    let reference = iterator.next().value;
     if (skipFirst) {
       reference = iterator.next().value;
-      if (reference &&
-          reference.startTime == startReference.startTime &&
-          reference.endTime == startReference.endTime) {
-        reference = null;
-      }
+    }
+    if (!reference) {
+      return;
     }
     while (this.segmentPrefetchMap_.size < this.prefetchLimit_ &&
             reference != null) {
@@ -90,6 +112,9 @@ shaka.media.SegmentPrefetch = class {
           shaka.media.SegmentReference.Status.MISSING) {
         prefetchAllowed = false;
       }
+      if (prefetchAllowed && reference.initSegmentReference) {
+        this.prefetchInitSegment(reference.initSegmentReference);
+      }
       if (prefetchAllowed && !this.segmentPrefetchMap_.has(reference)) {
         const segmentPrefetchOperation =
           new shaka.media.SegmentPrefetchOperation(this.fetchDispatcher_);
@@ -103,13 +128,13 @@ shaka.media.SegmentPrefetch = class {
       }
       reference = iterator.next().value;
     }
+    this.clearInitSegments_();
   }
 
   /**
    * Fetch init segment.
    *
    * @param {!shaka.media.InitSegmentReference} initSegmentReference
-   * @public
    */
   prefetchInitSegment(initSegmentReference) {
     goog.asserts.assert(this.prefetchLimit_ > 0,
@@ -117,19 +142,18 @@ shaka.media.SegmentPrefetch = class {
 
     const logPrefix = shaka.media.SegmentPrefetch.logPrefix_(this.stream_);
     if (!this.stream_.segmentIndex) {
-      shaka.log.info(logPrefix, 'missing segmentIndex');
+      shaka.log.debug(logPrefix, 'missing segmentIndex');
       return;
     }
 
-    if (this.segmentPrefetchMap_.size < this.prefetchLimit_) {
-      if (!this.segmentPrefetchMap_.has(initSegmentReference)) {
-        const segmentPrefetchOperation =
-          new shaka.media.SegmentPrefetchOperation(this.fetchDispatcher_);
-        segmentPrefetchOperation.dispatchFetch(
-            initSegmentReference, this.stream_);
-        this.segmentPrefetchMap_.set(
-            initSegmentReference, segmentPrefetchOperation);
-      }
+    // init segments are ignored from the prefetch limit
+    if (!this.initSegmentPrefetchMap_.has(initSegmentReference)) {
+      const segmentPrefetchOperation =
+        new shaka.media.SegmentPrefetchOperation(this.fetchDispatcher_);
+      segmentPrefetchOperation.dispatchFetch(
+          initSegmentReference, this.stream_);
+      this.initSegmentPrefetchMap_.set(
+          initSegmentReference, segmentPrefetchOperation);
     }
   }
 
@@ -147,22 +171,26 @@ shaka.media.SegmentPrefetch = class {
 
     const logPrefix = shaka.media.SegmentPrefetch.logPrefix_(this.stream_);
 
-    if (this.segmentPrefetchMap_.has(reference)) {
-      const segmentPrefetchOperation = this.segmentPrefetchMap_.get(reference);
+    let prefetchMap = this.segmentPrefetchMap_;
+    if (reference instanceof shaka.media.InitSegmentReference) {
+      prefetchMap = this.initSegmentPrefetchMap_;
+    }
+
+    if (prefetchMap.has(reference)) {
+      const segmentPrefetchOperation = prefetchMap.get(reference);
       if (streamDataCallback) {
         segmentPrefetchOperation.setStreamDataCallback(streamDataCallback);
       }
-      this.segmentPrefetchMap_.delete(reference);
       if (reference instanceof shaka.media.SegmentReference) {
         shaka.log.debug(
             logPrefix,
             'reused prefetched segment at time:', reference.startTime,
-            'mapSize', this.segmentPrefetchMap_.size);
+            'mapSize', prefetchMap.size);
       } else {
         shaka.log.debug(
             logPrefix,
             'reused prefetched init segment at time, mapSize',
-            this.segmentPrefetchMap_.size);
+            prefetchMap.size);
       }
       return segmentPrefetchOperation.getOperation();
     } else {
@@ -170,33 +198,75 @@ shaka.media.SegmentPrefetch = class {
         shaka.log.debug(
             logPrefix,
             'missed segment at time:', reference.startTime,
-            'mapSize', this.segmentPrefetchMap_.size);
+            'mapSize', prefetchMap.size);
       } else {
         shaka.log.debug(
             logPrefix,
             'missed init segment at time, mapSize',
-            this.segmentPrefetchMap_.size);
+            prefetchMap.size);
       }
       return null;
     }
   }
 
+  /**
+   * Clear All Helper
+   * @private
+   */
+  clearMap_(map) {
+    for (const reference of map.keys()) {
+      if (reference) {
+        this.abortPrefetchedSegment_(reference);
+      }
+    }
+  }
+
   /**
    * Clear all segment data.
    * @public
    */
   clearAll() {
-    if (this.segmentPrefetchMap_.size === 0) {
-      return;
-    }
+    this.clearMap_(this.segmentPrefetchMap_);
+    this.clearMap_(this.initSegmentPrefetchMap_);
     const logPrefix = shaka.media.SegmentPrefetch.logPrefix_(this.stream_);
-    for (const reference of this.segmentPrefetchMap_.keys()) {
-      if (reference) {
-        this.abortPrefetchedSegment_(reference);
+    shaka.log.debug(logPrefix, 'cleared all');
+    this.prefetchPosTime_ = 0;
+  }
+
+  /**
+   * @param {number} time
+   * @param {boolean=} clearInitSegments
+   */
+  evict(time, clearInitSegments = false) {
+    for (const ref of this.segmentPrefetchMap_.keys()) {
+      if (time > ref.endTime) {
+        this.abortPrefetchedSegment_(ref);
+      }
+    }
+    if (clearInitSegments) {
+      this.clearInitSegments_();
+    }
+  }
+
+  /**
+   * Remove all init segments that don't have associated segments in
+   * the segment prefetch map.
+   * By default, with delete on get, the init segments should get removed as
+   * they are used. With deleteOnGet set to false, we need to clear them
+   * every so often once the segments that are associated with each init segment
+   * is no longer prefetched.
+   * @private
+   */
+  clearInitSegments_() {
+    const segmentReferences = Array.from(this.segmentPrefetchMap_.keys());
+    for (const initSegmentReference of this.initSegmentPrefetchMap_.keys()) {
+      // if no segment references this init segment, we should remove it.
+      if (!segmentReferences.some(
+          (segmentReference) =>
+            segmentReference.initSegmentReference === initSegmentReference)) {
+        this.abortPrefetchedSegment_(initSegmentReference);
       }
     }
-    shaka.log.info(logPrefix, 'cleared all');
-    this.prefetchPosTime_ = 0;
   }
 
   /**
@@ -208,6 +278,9 @@ shaka.media.SegmentPrefetch = class {
   resetLimit(newPrefetchLimit) {
     goog.asserts.assert(newPrefetchLimit >= 0,
         'The new prefetch limit must be >= 0.');
+
+    const logPrefix = shaka.media.SegmentPrefetch.logPrefix_(this.stream_);
+    shaka.log.debug(logPrefix, 'resetting prefetch limit to', newPrefetchLimit);
     this.prefetchLimit_ = newPrefetchLimit;
     const keyArr = Array.from(this.segmentPrefetchMap_.keys());
     while (keyArr.length > newPrefetchLimit) {
@@ -216,6 +289,7 @@ shaka.media.SegmentPrefetch = class {
         this.abortPrefetchedSegment_(reference);
       }
     }
+    this.clearInitSegments_();
   }
 
   /**
@@ -230,6 +304,15 @@ shaka.media.SegmentPrefetch = class {
     }
   }
 
+  /**
+   * Get the current stream.
+   * @public
+   * @return {shaka.extern.Stream}
+   */
+  getStream() {
+    return this.stream_;
+  }
+
   /**
    * Remove a segment from prefetch map and abort it.
    * @param {!(shaka.media.SegmentReference|shaka.media.InitSegmentReference)}
@@ -238,16 +321,23 @@ shaka.media.SegmentPrefetch = class {
    */
   abortPrefetchedSegment_(reference) {
     const logPrefix = shaka.media.SegmentPrefetch.logPrefix_(this.stream_);
-    const segmentPrefetchOperation = this.segmentPrefetchMap_.get(reference);
-    this.segmentPrefetchMap_.delete(reference);
+
+    let prefetchMap = this.segmentPrefetchMap_;
+    if (reference instanceof shaka.media.InitSegmentReference) {
+      prefetchMap = this.initSegmentPrefetchMap_;
+    }
+
+    const segmentPrefetchOperation = prefetchMap.get(reference);
+    prefetchMap.delete(reference);
+
     if (segmentPrefetchOperation) {
       segmentPrefetchOperation.abort();
       if (reference instanceof shaka.media.SegmentReference) {
-        shaka.log.info(
+        shaka.log.debug(
             logPrefix,
             'pop and abort prefetched segment at time:', reference.startTime);
       } else {
-        shaka.log.info(logPrefix, 'pop and abort prefetched init segment');
+        shaka.log.debug(logPrefix, 'pop and abort prefetched init segment');
       }
     }
   }
@@ -281,6 +371,13 @@ shaka.media.SegmentPrefetchOperation = class {
     this.operation_ = null;
   }
 
+  /**
+   * @param {shaka.media.SegmentPrefetch.FetchDispatcher} fetchDispatcher
+   */
+  replaceFetchDispatcher(fetchDispatcher) {
+    this.fetchDispatcher_ = fetchDispatcher;
+  }
+
   /**
    * Fetch a segments
    *