shaka-player 3.2.0 → 3.2.4

package/lib/media/region_observer.js

@@ -8,16 +8,19 @@ goog.provide('shaka.media.RegionObserver');
 
 goog.require('shaka.media.IPlayheadObserver');
 goog.require('shaka.media.RegionTimeline');
+goog.require('shaka.util.EventManager');
+goog.require('shaka.util.FakeEvent');
+goog.require('shaka.util.FakeEventTarget');
 
 
 /**
  * The region observer watches a region timeline and playhead, and fires events
- * (onEnter, onExit, and onSkip) as the playhead moves.
+ * ('enter', 'exit', 'skip') as the playhead moves.
  *
  * @implements {shaka.media.IPlayheadObserver}
  * @final
  */
-shaka.media.RegionObserver = class {
+shaka.media.RegionObserver = class extends shaka.util.FakeEventTarget {
   /**
    * Create a region observer for the given timeline. The observer does not
    * own the timeline, only uses it. This means that the observer should NOT
@@ -26,6 +29,8 @@ shaka.media.RegionObserver = class {
    * @param {!shaka.media.RegionTimeline} timeline
    */
   constructor(timeline) {
+    super();
+
     /** @private {shaka.media.RegionTimeline} */
     this.timeline_ = timeline;
 
@@ -39,13 +44,6 @@ shaka.media.RegionObserver = class {
      */
     this.oldPosition_ = new Map();
 
-    /** @private {shaka.media.RegionObserver.EventListener} */
-    this.onEnter_ = (region, seeking) => {};
-    /** @private {shaka.media.RegionObserver.EventListener} */
-    this.onExit_ = (region, seeking) => {};
-    /** @private {shaka.media.RegionObserver.EventListener} */
-    this.onSkip_ = (region, seeking) => {};
-
     // To make the rules easier to read, alias all the relative positions.
     const RelativePosition = shaka.media.RegionObserver.RelativePosition_;
     const BEFORE_THE_REGION = RelativePosition.BEFORE_THE_REGION;
@@ -62,39 +60,48 @@ shaka.media.RegionObserver = class {
       {
         weWere: null,
         weAre: IN_THE_REGION,
-        invoke: (region, seeking) => this.onEnter_(region, seeking),
+        invoke: (region, seeking) => this.onEvent_('enter', region, seeking),
       },
       {
         weWere: BEFORE_THE_REGION,
         weAre: IN_THE_REGION,
-        invoke: (region, seeking) => this.onEnter_(region, seeking),
+        invoke: (region, seeking) => this.onEvent_('enter', region, seeking),
       },
       {
         weWere: AFTER_THE_REGION,
         weAre: IN_THE_REGION,
-        invoke: (region, seeking) => this.onEnter_(region, seeking),
+        invoke: (region, seeking) => this.onEvent_('enter', region, seeking),
       },
       {
         weWere: IN_THE_REGION,
         weAre: BEFORE_THE_REGION,
-        invoke: (region, seeking) => this.onExit_(region, seeking),
+        invoke: (region, seeking) => this.onEvent_('exit', region, seeking),
       },
       {
         weWere: IN_THE_REGION,
         weAre: AFTER_THE_REGION,
-        invoke: (region, seeking) => this.onExit_(region, seeking),
+        invoke: (region, seeking) => this.onEvent_('exit', region, seeking),
       },
       {
         weWere: BEFORE_THE_REGION,
         weAre: AFTER_THE_REGION,
-        invoke: (region, seeking) => this.onSkip_(region, seeking),
+        invoke: (region, seeking) => this.onEvent_('skip', region, seeking),
       },
       {
         weWere: AFTER_THE_REGION,
         weAre: BEFORE_THE_REGION,
-        invoke: (region, seeking) => this.onSkip_(region, seeking),
+        invoke: (region, seeking) => this.onEvent_('skip', region, seeking),
       },
     ];
+
+    /** @private {shaka.util.EventManager} */
+    this.eventManager_ = new shaka.util.EventManager();
+
+    this.eventManager_.listen(this.timeline_, 'regionremove', (event) => {
+      /** @type {shaka.extern.TimelineRegionInfo} */
+      const region = event['region'];
+      this.oldPosition_.delete(region);
+    });
   }
 
   /** @override */
@@ -105,11 +112,10 @@ shaka.media.RegionObserver = class {
     // needed.
     this.oldPosition_.clear();
 
-    // Clear the callbacks so that we don't hold onto any references external
-    // to this class.
-    this.onEnter_ = (region, seeking) => {};
-    this.onExit_ = (region, seeking) => {};
-    this.onSkip_ = (region, seeking) => {};
+    this.eventManager_.release();
+    this.eventManager_ = null;
+
+    super.release();
   }
 
   /** @override */
@@ -134,20 +140,20 @@ shaka.media.RegionObserver = class {
   }
 
   /**
-   * Set all the listeners. This overrides any previous calls to |setListeners|.
+   * Dispatch events of the given type.  All event types in this class have the
+   * same parameters: region and seeking.
    *
-   * @param {shaka.media.RegionObserver.EventListener} onEnter
-   *    The callback for when we move from outside a region to inside a region.
-   * @param {shaka.media.RegionObserver.EventListener} onExit
-   *    The callback for when we move from inside a region to outside a region.
-   * @param {shaka.media.RegionObserver.EventListener} onSkip
-   *    The callback for when we move from before to after a region or from
-   *    after to before a region.
+   * @param {string} eventType
+   * @param {shaka.extern.TimelineRegionInfo} region
+   * @param {boolean} seeking
+   * @private
    */
-  setListeners(onEnter, onExit, onSkip) {
-    this.onEnter_ = onEnter;
-    this.onExit_ = onExit;
-    this.onSkip_ = onSkip;
+  onEvent_(eventType, region, seeking) {
+    const event = new shaka.util.FakeEvent(eventType, new Map([
+      ['region', region],
+      ['seeking', seeking],
+    ]));
+    this.dispatchEvent(event);
   }
 
   /**

package/lib/media/region_timeline.js

@@ -6,26 +6,30 @@
 
 goog.provide('shaka.media.RegionTimeline');
 
+goog.require('shaka.util.FakeEvent');
+goog.require('shaka.util.FakeEventTarget');
 goog.require('shaka.util.IReleasable');
 goog.require('shaka.util.Timer');
 
 
 /**
  * The region timeline is a set of unique timeline region info entries. When
- * a new entry is added, the |onAddRegion| callback will be called.
+ * a new entry is added, the 'regionadd' event will be fired.  When an entry is
+ * deleted, the 'regionremove' event will be fired.
  *
  * @implements {shaka.util.IReleasable}
  * @final
  */
-shaka.media.RegionTimeline = class {
+shaka.media.RegionTimeline = class extends shaka.util.FakeEventTarget {
   /**
    * @param {!function():{start: number, end: number}} getSeekRange
    */
   constructor(getSeekRange) {
-    /** @private {function(shaka.extern.TimelineRegionInfo)} */
-    this.onAddRegion_ = (region) => {};
+    super();
+
     /** @private {!Set.<shaka.extern.TimelineRegionInfo>} */
     this.regions_ = new Set();
+
     /** @private {!function():{start: number, end: number}} */
     this.getSeekRange_ = getSeekRange;
 
@@ -44,22 +48,9 @@ shaka.media.RegionTimeline = class {
 
   /** @override */
   release() {
-    // Prevent us from holding onto any external references via the callback.
-    this.onAddRegion_ = (region) => {};
     this.regions_.clear();
     this.filterTimer_.stop();
-  }
-
-  /**
-   * Set the callbacks for events. This will override any previous calls to
-   * |setListeners|.
-   *
-   * @param {function(shaka.extern.TimelineRegionInfo)} onAddRegion
-   *    Set the callback for when we add a new region. This callback will only
-   *    be called when a region is unique (we reject duplicate regions).
-   */
-  setListeners(onAddRegion) {
-    this.onAddRegion_ = onAddRegion;
+    super.release();
   }
 
   /**
@@ -72,7 +63,10 @@ shaka.media.RegionTimeline = class {
     // instead of making the parser track it.
     if (similarRegion == null) {
       this.regions_.add(region);
-      this.onAddRegion_(region);
+      const event = new shaka.util.FakeEvent('regionadd', new Map([
+        ['region', region],
+      ]));
+      this.dispatchEvent(event);
     }
   }
 
@@ -89,6 +83,10 @@ shaka.media.RegionTimeline = class {
       // reson to store or process them.
       if (region.endTime < seekRange.start) {
         this.regions_.delete(region);
+        const event = new shaka.util.FakeEvent('regionremove', new Map([
+          ['region', region],
+        ]));
+        this.dispatchEvent(event);
       }
     }
   }

package/lib/media/segment_index.js

@@ -347,7 +347,8 @@ shaka.media.SegmentIndex = class {
             lastReference.appendWindowStart,
             lastReference.appendWindowEnd,
             lastReference.partialReferences,
-            lastReference.tilesLayout);
+            lastReference.tilesLayout,
+            lastReference.tileDuration);
   }
 
 

package/lib/media/segment_reference.js

@@ -140,11 +140,15 @@ shaka.media.SegmentReference = class {
    *   The value is a grid-item-dimension consisting of two positive decimal
    *   integers in the format: column-x-row ('4x3'). It describes the
    *   arrangement of Images in a Grid. The minimum valid LAYOUT is '1x1'.
+   * @param {?number=} tileDuration
+   *  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.
    */
   constructor(
       startTime, endTime, uris, startByte, endByte, initSegmentReference,
       timestampOffset, appendWindowStart, appendWindowEnd,
-      partialReferences = [], tilesLayout = '') {
+      partialReferences = [], tilesLayout = '', tileDuration = null) {
     // 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');
@@ -191,6 +195,9 @@ shaka.media.SegmentReference = class {
 
     /** @type {?string} */
     this.tilesLayout = tilesLayout;
+
+    /** @type {?number} */
+    this.tileDuration = tileDuration;
   }
 
   /**
@@ -275,6 +282,17 @@ shaka.media.SegmentReference = class {
   getTilesLayout() {
     return this.tilesLayout;
   }
+
+  /**
+   * Returns the segment's explicit tile duration.
+   * Only defined in image segments.
+   *
+   * @return {?number}
+   * @export
+   */
+  getTileDuration() {
+    return this.tileDuration;
+  }
 };
 
 

package/lib/media/streaming_engine.js

@@ -623,7 +623,7 @@ shaka.media.StreamingEngine = class {
 
         // Don't clear the buffer unless something is buffered.  This extra
         // check prevents extra, useless calls to clear the buffer.
-        if (somethingBuffered) {
+        if (somethingBuffered || mediaState.performingUpdate) {
           this.forceClearBuffer_(mediaState);
           streamCleared = true;
         }
@@ -977,7 +977,10 @@ shaka.media.StreamingEngine = class {
         unscaledBufferingGoal * this.bufferingGoalScale_;
 
     // Check if we've buffered to the end of the presentation.
-    if (timeNeeded >= this.manifest_.presentationTimeline.getDuration()) {
+    const timeUntilEnd =
+        this.manifest_.presentationTimeline.getDuration() - timeNeeded;
+    const oneMicrosecond = 1e-6;
+    if (timeUntilEnd < oneMicrosecond) {
       // We shouldn't rebuffer if the playhead is close to the end of the
       // presentation.
       shaka.log.debug(logPrefix, 'buffered to end of presentation');
@@ -1641,7 +1644,7 @@ shaka.media.StreamingEngine = class {
     // See DASH sec. 5.10.3.3.1
     // If a DASH client detects an event message box with a scheme that is not
     // defined in MPD, the client is expected to ignore it.
-    if (emsgSchemeIdUris.includes(schemeId)) {
+    if (emsgSchemeIdUris && emsgSchemeIdUris.includes(schemeId)) {
       // See DASH sec. 5.10.4.1
       // A special scheme in DASH used to signal manifest updates.
       if (schemeId == 'urn:mpeg:dash:event:2012') {
@@ -1662,7 +1665,8 @@ shaka.media.StreamingEngine = class {
 
         // Dispatch an event to notify the application about the emsg box.
         const eventName = shaka.Player.EventName.Emsg;
-        const event = new shaka.util.FakeEvent(eventName, {'detail': emsg});
+        const data = (new Map()).set('detail', emsg);
+        const event = new shaka.util.FakeEvent(eventName, data);
         this.playerInterface_.onEvent(event);
       }
     }

package/lib/net/networking_engine.js

@@ -222,6 +222,10 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
     this.destroyed_ = true;
     this.requestFilters_.clear();
     this.responseFilters_.clear();
+
+    // FakeEventTarget implements IReleasable
+    super.release();
+
     return this.operationManager_.destroy();
   }
 
@@ -544,7 +548,8 @@ shaka.net.NetworkingEngine = class extends shaka.util.FakeEventTarget {
         }
 
         if (error.severity == shaka.util.Error.Severity.RECOVERABLE) {
-          const event = new shaka.util.FakeEvent('retry', {'error': error});
+          const data = (new Map()).set('error', error);
+          const event = new shaka.util.FakeEvent('retry', data);
           this.dispatchEvent(event);
 
           // Move to the next URI.

package/lib/offline/download_manager.js

@@ -44,9 +44,8 @@ shaka.offline.DownloadManager = class {
 
     /** @private {!shaka.util.Destroyer} */
     this.destroyer_ = new shaka.util.Destroyer(() => {
-      const promises = Array.from(this.groups_.values());
       // Add a "catch" block to stop errors from being returned.
-      return Promise.all(promises.map((p) => p.catch(() => {})));
+      return this.abortAll().catch(() => {});
     });
 
     /**

package/lib/offline/storage.js

@@ -477,16 +477,15 @@ shaka.offline.Storage = class {
    * @private
    */
   async filterManifest_(manifest, drmEngine, config) {
-    const StreamUtils = shaka.util.StreamUtils;
-
     // Filter the manifest based on the restrictions given in the player
     // configuration.
     const maxHwRes = {width: Infinity, height: Infinity};
-    StreamUtils.filterByRestrictions(manifest, config.restrictions, maxHwRes);
+    shaka.util.StreamUtils.filterByRestrictions(
+        manifest, config.restrictions, maxHwRes);
 
     // Filter the manifest based on what we know MediaCapabilities will be able
     // to play later (no point storing something we can't play).
-    StreamUtils.filterManifestByMediaCapabilities(
+    await shaka.util.StreamUtils.filterManifestByMediaCapabilities(
         manifest, config.offline.usePersistentLicense);
 
     // Gather all tracks.
@@ -498,24 +497,24 @@ shaka.offline.Storage = class {
     const preferredVideoCodecs = config.preferredVideoCodecs;
     const preferredAudioCodecs = config.preferredAudioCodecs;
 
-    StreamUtils.chooseCodecsAndFilterManifest(
+    shaka.util.StreamUtils.chooseCodecsAndFilterManifest(
         manifest, preferredVideoCodecs, preferredAudioCodecs,
         preferredAudioChannelCount, preferredDecodingAttributes);
 
     for (const variant of manifest.variants) {
       goog.asserts.assert(
-          StreamUtils.isPlayable(variant),
+          shaka.util.StreamUtils.isPlayable(variant),
           'We should have already filtered by "is playable"');
 
-      allTracks.push(StreamUtils.variantToTrack(variant));
+      allTracks.push(shaka.util.StreamUtils.variantToTrack(variant));
     }
 
     for (const text of manifest.textStreams) {
-      allTracks.push(StreamUtils.textStreamToTrack(text));
+      allTracks.push(shaka.util.StreamUtils.textStreamToTrack(text));
     }
 
     for (const image of manifest.imageStreams) {
-      allTracks.push(StreamUtils.imageStreamToTrack(image));
+      allTracks.push(shaka.util.StreamUtils.imageStreamToTrack(image));
     }
 
     // Let the application choose which tracks to store.