shaka-player 4.4.3 → 4.6.0

package/lib/media/play_rate_controller.js

@@ -6,7 +6,6 @@
 
 goog.provide('shaka.media.PlayRateController');
 
-goog.require('goog.asserts');
 goog.require('shaka.log');
 goog.require('shaka.util.IReleasable');
 goog.require('shaka.util.Timer');
@@ -17,8 +16,6 @@ goog.require('shaka.util.Timer');
  * the playback rate on the media element can change outside of the controller,
  * the playback controller will need to be updated to stay in-sync.
  *
- * TODO: Try not to manage buffering above the browser with playbackRate=0.
- *
  * @implements {shaka.util.IReleasable}
  * @final
  */
@@ -30,9 +27,6 @@ shaka.media.PlayRateController = class {
     /** @private {?shaka.media.PlayRateController.Harness} */
     this.harness_ = harness;
 
-    /** @private {boolean} */
-    this.isBuffering_ = false;
-
     /** @private {number} */
     this.rate_ = this.harness_.getRate();
 
@@ -56,25 +50,15 @@ shaka.media.PlayRateController = class {
   }
 
   /**
-   * Sets the buffering flag, which controls the effective playback rate.
-   *
-   * @param {boolean} isBuffering If true, forces playback rate to 0 internally.
-   */
-  setBuffering(isBuffering) {
-    this.isBuffering_ = isBuffering;
-    this.apply_();
-  }
-
-  /**
-   * Set the playback rate. This rate will only be used as provided when the
-   * player is not buffering. You should never set the rate to 0.
+   * Set the playback rate.
    *
    * @param {number} rate
    */
   set(rate) {
-    goog.asserts.assert(rate != 0, 'Should never set rate of 0 explicitly!');
-    this.rate_ = rate;
-    this.apply_();
+    if (this.rate_ != rate) {
+      this.rate_ = rate;
+      this.apply_();
+    }
   }
 
   /**
@@ -108,14 +92,11 @@ shaka.media.PlayRateController = class {
     // Always stop the timer. We may not start it again.
     this.timer_.stop();
 
-    /** @type {number} */
-    const rate = this.calculateCurrentRate_();
+    shaka.log.v1('Changing effective playback rate to', this.rate_);
 
-    shaka.log.v1('Changing effective playback rate to', rate);
-
-    if (rate >= 0) {
+    if (this.rate_ >= 0) {
       try {
-        this.applyRate_(rate);
+        this.applyRate_(this.rate_);
         return;
       } catch (e) {
         // Fall through to the next clause.
@@ -135,17 +116,6 @@ shaka.media.PlayRateController = class {
     this.applyRate_(0);
   }
 
-  /**
-   * Calculate the rate that the controller wants the media element to have
-   * based on the current state of the controller.
-   *
-   * @return {number}
-   * @private
-   */
-  calculateCurrentRate_() {
-    return this.isBuffering_ ? 0 : this.rate_;
-  }
-
   /**
    * If the new rate is different than the media element's playback rate, this
    * will change the playback rate. If the rate does not need to change, it will

package/lib/media/presentation_timeline.js

@@ -619,7 +619,9 @@ shaka.media.PresentationTimeline = class {
  * @typedef {{
  *   start: number,
  *   unscaledStart: number,
- *   end: number
+ *   end: number,
+ *   partialSegments: number,
+ *   segmentPosition: number
  * }}
  *
  * @description
@@ -631,6 +633,10 @@ shaka.media.PresentationTimeline = class {
  *   The start time of the range in representation timescale units.
  * @property {number} end
  *   The end time (exclusive) of the range.
+ * @property {number} partialSegments
+ *   The number of partial segments
+ * @property {number} segmentPosition
+ *   The segment position of the timeline entry as it appears in the manifest
  *
  * @export
  */

package/lib/media/quality_observer.js

@@ -261,7 +261,7 @@ shaka.media.QualityObserver.QualityChangePosition;
   *
   * @description
   * Contains media quality information for a specific content type
-  * e.g video or audio.
+  * e.g. video or audio.
   *
   * @property {!Array.<shaka.media.QualityObserver.QualityChangePosition>}
   * qualityChangePositions

package/lib/media/segment_index.js

@@ -379,7 +379,7 @@ shaka.media.SegmentIndex = class {
             lastReference.tileDuration,
             lastReference.syncTime,
             lastReference.status,
-            lastReference.hlsAes128Key,
+            lastReference.aes128Key,
         );
     this.references[this.references.length - 1].discontinuitySequence =
         lastReference.discontinuitySequence;
@@ -582,7 +582,7 @@ shaka.media.SegmentIterator = class {
     // new references in merge(), the pointers may not make sense any more.
     // This adjusts the invalid pointer values to point to the next newly added
     // segment or partial segment.
-    if (ref && ref.hasPartialSegments() && ref.getUris().length &&
+    if (ref && ref.hasPartialSegments() && ref.hasAllPartialSegments() &&
         this.currentPartialPosition_ >= ref.partialReferences.length) {
       this.currentPosition_++;
       this.currentPartialPosition_ = 0;
@@ -609,12 +609,12 @@ shaka.media.SegmentIterator = class {
       // If the regular segment contains partial segments, move to the next
       // partial SegmentReference.
       this.currentPartialPosition_++;
-      // If the current regular segment has been published completely (has a
-      // valid Uri), and we've reached the end of its partial segments list,
-      // move to the next regular segment.
+      // 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.getUris().length &&
+      if (ref.hasAllPartialSegments() &&
           this.currentPartialPosition_ == ref.partialReferences.length) {
         this.currentPosition_++;
         this.currentPartialPosition_ = 0;

package/lib/media/segment_prefetch.js

@@ -4,12 +4,15 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+goog.provide('shaka.media.SegmentPrefetch');
+
 goog.require('goog.asserts');
-goog.require('shaka.net.NetworkingEngine');
+goog.require('shaka.log');
 goog.require('shaka.media.InitSegmentReference');
 goog.require('shaka.media.SegmentReference');
-goog.provide('shaka.media.SegmentPrefetch');
-goog.require('shaka.log');
+goog.require('shaka.net.NetworkingEngine');
+goog.require('shaka.util.Uint8ArrayUtils');
+
 
 /**
  * @summary
@@ -37,8 +40,9 @@ shaka.media.SegmentPrefetch = class {
     this.fetchDispatcher_ = fetchDispatcher;
 
     /**
-     * @private {!Map.<shaka.media.SegmentReference,
-     *           !shaka.media.SegmentPrefetchOperation>}
+     * @private {!Map.<
+     *        !(shaka.media.SegmentReference|shaka.media.InitSegmentReference),
+     *        !shaka.media.SegmentPrefetchOperation>}
      */
     this.segmentPrefetchMap_ = new Map();
   }
@@ -47,9 +51,10 @@ shaka.media.SegmentPrefetch = class {
    * Fetch next segments ahead of current segment.
    *
    * @param {(!shaka.media.SegmentReference)} startReference
+   * @param {boolean=} skipFirst
    * @public
    */
-  prefetchSegments(startReference) {
+  prefetchSegments(startReference, skipFirst = false) {
     goog.asserts.assert(this.prefetchLimit_ > 0,
         'SegmentPrefetch can not be used when prefetchLimit <= 0.');
 
@@ -65,6 +70,14 @@ shaka.media.SegmentPrefetch = class {
       return;
     }
     let reference = startReference;
+    if (skipFirst) {
+      reference = iterator.next().value;
+      if (reference &&
+          reference.startTime == startReference.startTime &&
+          reference.endTime == startReference.endTime) {
+        reference = null;
+      }
+    }
     while (this.segmentPrefetchMap_.size < this.prefetchLimit_ &&
             reference != null) {
       // By default doesn't prefech preload partial segments when using
@@ -88,9 +101,38 @@ shaka.media.SegmentPrefetch = class {
     }
   }
 
+  /**
+   * Fetch init segment.
+   *
+   * @param {!shaka.media.InitSegmentReference} initSegmentReference
+   * @public
+   */
+  prefetchInitSegment(initSegmentReference) {
+    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;
+    }
+
+    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);
+      }
+    }
+  }
+
   /**
    * Get the result of prefetched segment if already exists.
-   * @param {(!shaka.media.SegmentReference)} reference
+   * @param {!(shaka.media.SegmentReference|shaka.media.InitSegmentReference)}
+   *        reference
    * @param {?function(BufferSource):!Promise=} streamDataCallback
    * @return {?shaka.net.NetworkingEngine.PendingRequest} op
    * @public
@@ -98,8 +140,6 @@ shaka.media.SegmentPrefetch = class {
   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_);
 
@@ -109,16 +149,30 @@ shaka.media.SegmentPrefetch = class {
         segmentPrefetchOperation.setStreamDataCallback(streamDataCallback);
       }
       this.segmentPrefetchMap_.delete(reference);
-      shaka.log.debug(
-          logPrefix,
-          'reused prefetched segment at time:', reference.startTime,
-          'mapSize', this.segmentPrefetchMap_.size);
+      if (reference instanceof shaka.media.SegmentReference) {
+        shaka.log.debug(
+            logPrefix,
+            'reused prefetched segment at time:', reference.startTime,
+            'mapSize', this.segmentPrefetchMap_.size);
+      } else {
+        shaka.log.debug(
+            logPrefix,
+            'reused prefetched init segment at time, mapSize',
+            this.segmentPrefetchMap_.size);
+      }
       return segmentPrefetchOperation.getOperation();
     } else {
-      shaka.log.debug(
-          logPrefix,
-          'missed segment at time:', reference.startTime,
-          'mapSize', this.segmentPrefetchMap_.size);
+      if (reference instanceof shaka.media.SegmentReference) {
+        shaka.log.debug(
+            logPrefix,
+            'reused prefetched segment at time:', reference.startTime,
+            'mapSize', this.segmentPrefetchMap_.size);
+      } else {
+        shaka.log.debug(
+            logPrefix,
+            'reused prefetched init segment at time, mapSize',
+            this.segmentPrefetchMap_.size);
+      }
       return null;
     }
   }
@@ -174,7 +228,8 @@ shaka.media.SegmentPrefetch = class {
 
   /**
    * Remove a segment from prefetch map and abort it.
-   * @param {(!shaka.media.SegmentReference)} reference
+   * @param {!(shaka.media.SegmentReference|shaka.media.InitSegmentReference)}
+   *        reference
    * @private
    */
   abortPrefetchedSegment_(reference) {
@@ -183,9 +238,13 @@ shaka.media.SegmentPrefetch = class {
     this.segmentPrefetchMap_.delete(reference);
     if (segmentPrefetchOperation) {
       segmentPrefetchOperation.abort();
-      shaka.log.info(
-          logPrefix,
-          'pop and abort prefetched segment at time:', reference.startTime);
+      if (reference instanceof shaka.media.SegmentReference) {
+        shaka.log.info(
+            logPrefix,
+            'pop and abort prefetched segment at time:', reference.startTime);
+      } else {
+        shaka.log.info(logPrefix, 'pop and abort prefetched init segment');
+      }
     }
   }
 
@@ -221,16 +280,25 @@ shaka.media.SegmentPrefetchOperation = class {
   /**
    * Fetch a segments
    *
-   * @param {!shaka.media.SegmentReference}
-   *   reference
+   * @param {!(shaka.media.SegmentReference|shaka.media.InitSegmentReference)}
+   *        reference
    * @param {!shaka.extern.Stream} stream
    * @public
    */
   dispatchFetch(reference, stream) {
+    // We need to store the data, because streamDataCallback_ might not be
+    // available when you start getting the first data.
+    let buffered = new Uint8Array(0);
     this.operation_ = this.fetchDispatcher_(
         reference, stream, async (data) => {
+          if (buffered.byteLength > 0) {
+            buffered = shaka.util.Uint8ArrayUtils.concat(buffered, data);
+          } else {
+            buffered = data;
+          }
           if (this.streamDataCallback_) {
-            await this.streamDataCallback_(data);
+            await this.streamDataCallback_(buffered);
+            buffered = new Uint8Array(0);
           }
         });
   }

package/lib/media/segment_reference.js

@@ -32,7 +32,7 @@ shaka.media.InitSegmentReference = class {
    *   the quality of the media associated with this init segment.
    * @param {(null|number)=} timescale
    * @param {(null|BufferSource)=} segmentData
-   * @param {?shaka.extern.HlsAes128Key=} aes128Key
+   * @param {?shaka.extern.aes128Key=} aes128Key
    *  The segment's AES-128-CBC full segment encryption key and iv.
    */
   constructor(uris, startByte, endByte, mediaQuality = null, timescale = null,
@@ -55,8 +55,8 @@ shaka.media.InitSegmentReference = class {
     /** @type {BufferSource|null} */
     this.segmentData = segmentData;
 
-    /** @type {?shaka.extern.HlsAes128Key} */
-    this.hlsAes128Key = aes128Key;
+    /** @type {?shaka.extern.aes128Key} */
+    this.aes128Key = aes128Key;
   }
 
   /**
@@ -196,15 +196,17 @@ shaka.media.SegmentReference = class {
    * @param {shaka.media.SegmentReference.Status=} status
    *  The segment status is used to indicate that a segment does not exist or is
    *  not available.
-   * @param {?shaka.extern.HlsAes128Key=} hlsAes128Key
+   * @param {?shaka.extern.aes128Key=} aes128Key
    *  The segment's AES-128-CBC full segment encryption key and iv.
+   * @param {boolean=} allPartialSegments
+   *  Indicate if the segment has all partial segments
    */
   constructor(
       startTime, endTime, uris, startByte, endByte, initSegmentReference,
       timestampOffset, appendWindowStart, appendWindowEnd,
       partialReferences = [], tilesLayout = '', tileDuration = null,
       syncTime = null, status = shaka.media.SegmentReference.Status.AVAILABLE,
-      hlsAes128Key = null) {
+      aes128Key = null, allPartialSegments = false) {
     // 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');
@@ -276,14 +278,32 @@ shaka.media.SegmentReference = class {
     /** @type {boolean} */
     this.byterangeOptimization = false;
 
-    /** @type {?shaka.extern.HlsAes128Key} */
-    this.hlsAes128Key = hlsAes128Key;
+    /** @type {?shaka.extern.aes128Key} */
+    this.aes128Key = aes128Key;
 
     /** @type {?shaka.media.SegmentReference.ThumbnailSprite} */
     this.thumbnailSprite = null;
 
     /** @type {number} */
     this.discontinuitySequence = 0;
+
+    /** @type {boolean} */
+    this.allPartialSegments = allPartialSegments;
+
+    /** @type {boolean} */
+    this.partial = false;
+
+    /** @type {boolean} */
+    this.lastPartial = false;
+
+    for (const partial of this.partialReferences) {
+      partial.markAsPartial();
+    }
+    if (this.allPartialSegments && this.partialReferences.length) {
+      const lastPartial =
+          this.partialReferences[this.partialReferences.length - 1];
+      lastPartial.markAsLastPartial();
+    }
   }
 
   /**
@@ -359,6 +379,14 @@ shaka.media.SegmentReference = class {
     return this.partialReferences.length > 0;
   }
 
+  /**
+   * Returns true if it contains all partial SegmentReferences.
+   * @return {boolean}
+   */
+  hasAllPartialSegments() {
+    return this.allPartialSegments;
+  }
+
   /**
    * Returns the segment's tiles layout. Only defined in image segments.
    *
@@ -437,6 +465,44 @@ shaka.media.SegmentReference = class {
     return this.independent;
   }
 
+  /**
+   * Mark the reference as partial.
+   *
+   * @export
+   */
+  markAsPartial() {
+    this.partial = true;
+  }
+
+  /**
+   * Returns true if the segment is partial.
+   *
+   * @return {boolean}
+   * @export
+   */
+  isPartial() {
+    return this.partial;
+  }
+
+  /**
+   * Mark the reference as being the last part of the full segment
+   *
+   * @export
+   */
+  markAsLastPartial() {
+    this.lastPartial = true;
+  }
+
+  /**
+   * Returns true if reference as being the last part of the full segment.
+   *
+   * @return {boolean}
+   * @export
+   */
+  isLastPartial() {
+    return this.lastPartial;
+  }
+
   /**
    * Mark the reference as byterange optimization.
    *