shaka-player 3.3.1 → 3.3.2

package/karma.conf.js

@@ -11,6 +11,7 @@ const Jimp = require('jimp');
 const fs = require('fs');
 const path = require('path');
 const rimraf = require('rimraf');
+const {ssim} = require('ssim.js');
 const util = require('karma/common/util');
 const which = require('which');
 
@@ -336,6 +337,10 @@ module.exports = (config) => {
 
   config.set({reporters: reporters});
 
+  if (reporters.includes('spec') && settings.spec_hide_passed) {
+    config.set({specReporter: {suppressPassed: true}});
+  }
+
   if (settings.random) {
     // If --seed was specified use that value, else generate a seed so that the
     // exact order can be reproduced if it catches an issue.
@@ -518,8 +523,7 @@ function WebDriverScreenshotMiddlewareFactory(launcher) {
    *
    * @param {karma.Launcher.Browser} browser
    * @param {!Object.<string, string>} params
-   * @return {!Promise.<number>} The number of pixels changed between the old
-   *   and new screenshots, after cropping and scaling.
+   * @return {!Promise.<number>} A similarity score between 0 and 1.
    */
   async function diffScreenshot(browser, params) {
     const webDriverClient = getWebDriverClient(browser);
@@ -604,22 +608,22 @@ function WebDriverScreenshotMiddlewareFactory(launcher) {
     // Compare the new screenshot to the old one and produce a diff image.
     // Initially, the image data will be raw pixels, 4 bytes per pixel.
     // The threshold parameter affects the sensitivity of individual pixel
-    // comparisons.  Setting it too low means small rendering changes in the
-    // browser can cause failures even when a human can't see the difference,
-    // and setting it too high means human-noticeable changes could go
-    // undetected by a test.
-    const diff = Jimp.diff(oldScreenshot, newScreenshot, /* threshold= */ 0.07);
+    // comparisons.  This diff is only used for visual review, not for
+    // automated similarity checks, so the threshold setting is not so critical
+    // as it used to be.
+    const threshold = 0.10;
+    const diff = Jimp.diff(oldScreenshot, newScreenshot, threshold);
 
     // Write the diff to disk.  This is used to review when there are changes.
+    const fullSizeDiff =
+        diff.image.clone().resize(width, height, Jimp.RESIZE_BICUBIC);
     fs.writeFileSync(
-        diffScreenshotPath, await diff.image.getBufferAsync('image/png'));
-
-    // "percent" is, surprisingly, a number between 0 and 1, not between 0 and
-    // 100.  Convert this to a number of pixels changed, which has been found to
-    // be a more effective and less flaky metric.
-    const pixelsChanged =
-        diff.percent * diff.image.bitmap.width * diff.image.bitmap.height;
-    return pixelsChanged;
+        diffScreenshotPath, await fullSizeDiff.getBufferAsync('image/png'));
+
+    // Compare with a structural similarity algorithm.  This produces a
+    // similarity score that we will use to pass or fail the test.
+    const ssimResult = ssim(oldScreenshot.bitmap, newScreenshot.bitmap);
+    return ssimResult.mssim;  // A score between 0 and 1.
   }
 
   /**

package/lib/ads/ad_manager.js

@@ -448,6 +448,7 @@ shaka.ads.AdManager = class extends shaka.util.FakeEventTarget {
       this.ssAdManager_.release();
       this.ssAdManager_ = null;
     }
+    super.release();
   }
 
 

package/lib/cast/cast_proxy.js

@@ -120,6 +120,9 @@ shaka.cast.CastProxy = class extends shaka.util.FakeEventTarget {
     this.videoProxy_ = null;
     this.playerProxy_ = null;
 
+    // FakeEventTarget implements IReleasable
+    super.release();
+
     return Promise.all(waitFor);
   }
 

package/lib/cast/cast_receiver.js

@@ -238,6 +238,9 @@ shaka.cast.CastReceiver = class extends shaka.util.FakeEventTarget {
     this.shakaBus_ = null;
     this.genericBus_ = null;
 
+    // FakeEventTarget implements IReleasable
+    super.release();
+
     await Promise.all(waitFor);
 
     const manager = cast.receiver.CastReceiverManager.getInstance();

package/lib/dash/dash_parser.js

@@ -410,6 +410,24 @@ shaka.dash.DashParser = class {
           this.config_.dash.autoCorrectDrift);
     }
 
+    presentationTimeline.setStatic(mpdType == 'static');
+
+    const isLive = presentationTimeline.isLive();
+
+    // If it's live, we check for an override.
+    if (isLive && !isNaN(this.config_.availabilityWindowOverride)) {
+      segmentAvailabilityDuration = this.config_.availabilityWindowOverride;
+    }
+
+    // If it's null, that means segments are always available.  This is always
+    // the case for VOD, and sometimes the case for live.
+    if (segmentAvailabilityDuration == null) {
+      segmentAvailabilityDuration = Infinity;
+    }
+
+    presentationTimeline.setSegmentAvailabilityDuration(
+        segmentAvailabilityDuration);
+
     const profiles = mpd.getAttribute('profiles') || '';
 
     /** @type {shaka.dash.DashParser.Context} */
@@ -432,7 +450,6 @@ shaka.dash.DashParser = class {
     const duration = periodsAndDuration.duration;
     const periods = periodsAndDuration.periods;
 
-    presentationTimeline.setStatic(mpdType == 'static');
     if (mpdType == 'static' ||
         !periodsAndDuration.durationDerivedFromPeriods) {
       // Ignore duration calculated from Period lengths if this is dynamic.
@@ -451,6 +468,7 @@ shaka.dash.DashParser = class {
         this.lowLatencyMode_ = this.playerInterface_.isLowLatencyMode();
       }
     }
+
     if (this.lowLatencyMode_) {
       presentationTimeline.setAvailabilityTimeOffset(
           this.minTotalAvailabilityTimeOffset_);
@@ -464,22 +482,6 @@ shaka.dash.DashParser = class {
         'https://bit.ly/3clctcj for details.');
     }
 
-    const isLive = presentationTimeline.isLive();
-
-    // If it's live, we check for an override.
-    if (isLive && !isNaN(this.config_.availabilityWindowOverride)) {
-      segmentAvailabilityDuration = this.config_.availabilityWindowOverride;
-    }
-
-    // If it's null, that means segments are always available.  This is always
-    // the case for VOD, and sometimes the case for live.
-    if (segmentAvailabilityDuration == null) {
-      segmentAvailabilityDuration = Infinity;
-    }
-
-    presentationTimeline.setSegmentAvailabilityDuration(
-        segmentAvailabilityDuration);
-
     // Use @maxSegmentDuration to override smaller, derived values.
     presentationTimeline.notifyMaxSegmentDuration(maxSegmentDuration || 1);
     if (goog.DEBUG) {
@@ -714,8 +716,12 @@ shaka.dash.DashParser = class {
 
     const eventStreamNodes =
         XmlUtils.findChildren(periodInfo.node, 'EventStream');
+    const availabilityStart =
+        context.presentationTimeline.getSegmentAvailabilityStart();
+
     for (const node of eventStreamNodes) {
-      this.parseEventStream_(periodInfo.start, periodInfo.duration, node);
+      this.parseEventStream_(
+          periodInfo.start, periodInfo.duration, node, availabilityStart);
     }
 
     const adaptationSetNodes =
@@ -1769,9 +1775,10 @@ shaka.dash.DashParser = class {
    * @param {number} periodStart
    * @param {?number} periodDuration
    * @param {!Element} elem
+   * @param {number} availabilityStart
    * @private
    */
-  parseEventStream_(periodStart, periodDuration, elem) {
+  parseEventStream_(periodStart, periodDuration, elem, availabilityStart) {
     const XmlUtils = shaka.util.XmlUtils;
     const parseNumber = XmlUtils.parseNonNegativeInt;
 
@@ -1794,6 +1801,11 @@ shaka.dash.DashParser = class {
         endTime = Math.min(endTime, periodStart + periodDuration);
       }
 
+      // Don't add unavailable regions to the timeline.
+      if (endTime < availabilityStart) {
+        continue;
+      }
+
       /** @type {shaka.extern.TimelineRegionInfo} */
       const region = {
         schemeIdUri: schemeIdUri,

package/lib/hls/manifest_text_parser.js

@@ -277,6 +277,7 @@ shaka.hls.ManifestTextParser = class {
         const attrValue = blockAttrs[2] || blockAttrs[3];
         const attribute = new shaka.hls.Attribute(attrName, attrValue);
         attributes.push(attribute);
+        parser.skipWhitespace();
       }
     }
 

package/lib/media/quality_observer.js

@@ -8,48 +8,40 @@ goog.provide('shaka.media.QualityObserver');
 
 goog.require('shaka.media.IPlayheadObserver');
 goog.require('shaka.log');
+goog.require('shaka.util.FakeEvent');
+goog.require('shaka.util.FakeEventTarget');
 
 /**
- * Monitors the quality of content being appended to the source
- * buffers and fires onQualityChange events when the media quality
- * at the playhead changes.
+ * Monitors the quality of content being appended to the source buffers and
+ * fires 'qualitychange' events when the media quality at the playhead changes.
  *
  * @implements {shaka.media.IPlayheadObserver}
  * @final
  */
-shaka.media.QualityObserver = class {
+shaka.media.QualityObserver = class extends shaka.util.FakeEventTarget {
   /**
    * Creates a new QualityObserver.
    *
    * @param {!function():!shaka.extern.BufferedInfo} getBufferedInfo
-   *  Buffered info is needed to purge QualityChanges that are no
-   * longer relevant.
+   *   Buffered info is needed to purge QualityChanges that are no
+   *   longer relevant.
    */
   constructor(getBufferedInfo) {
+    super();
+
     /**
      * @private {!Map.<string,!shaka.media.QualityObserver.ContentTypeState>}
      */
     this.contentTypeStates_ = new Map();
 
-    /** @private {shaka.media.QualityObserver.EventListener} */
-    this.onQualityChange_ = (mediaQuality, position) => {};
-
     /** @private function():!shaka.extern.BufferedInfo */
     this.getBufferedInfo_ = getBufferedInfo;
   }
 
-  /**
-   * Set all the listeners. This overrides any previous calls to |setListeners|.
-   *
-   * @param {shaka.media.QualityObserver.EventListener} onQualityChange
-   */
-  setListeners(onQualityChange) {
-    this.onQualityChange_ = onQualityChange;
-  }
-
   /** @override */
   release() {
     this.contentTypeStates_.clear();
+    super.release();
   }
 
   /**
@@ -169,10 +161,15 @@ shaka.media.QualityObserver = class {
         if (this.positionIsBuffered_(
             positionInSeconds, qualityAtPosition.contentType)) {
           contentTypeState.currentQuality = qualityAtPosition;
+
           shaka.log.debug('Media quality changed at position ' +
             positionInSeconds + ' ' + JSON.stringify(qualityAtPosition));
-          this.onQualityChange_(
-              qualityAtPosition, positionInSeconds);
+
+          const event = new shaka.util.FakeEvent('qualitychange', new Map([
+            ['quality', qualityAtPosition],
+            ['position', positionInSeconds],
+          ]));
+          this.dispatchEvent(event);
         }
       }
     }
@@ -237,20 +234,6 @@ shaka.media.QualityObserver = class {
   }
 };
 
-/**
- * @typedef {function(shaka.extern.MediaQualityInfo, number)}
- *
- * @description
- * A callback function used to notify the player when media quality changes
- * are detected at the playhead.
- *
- * The first argument is information about media quality at the playhead
- * position.
- *
- * The second argument is the playhead position in seconds.
- */
-shaka.media.QualityObserver.EventListener;
-
 /**
   * @typedef {{
   *   mediaQuality: !shaka.extern.MediaQualityInfo,

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/streaming_engine.js

@@ -1659,7 +1659,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)) ||
         this.config_.dispatchAllEmsgBoxes) {
       // See DASH sec. 5.10.4.1
       // A special scheme in DASH used to signal manifest updates.

package/lib/net/networking_engine.js

@@ -232,6 +232,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();
   }
 

package/lib/offline/storage.js

@@ -681,16 +681,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.
@@ -702,24 +701,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.