shaka-player 4.2.12 → 4.2.13

package/docs/tutorials/selenium-grid-config.md

@@ -47,17 +47,20 @@ vars:
 FirefoxMac:
   browser: firefox
   os: Mac
-  extra_config: *firefox_config
+  extra_configs:
+    - *firefox_config
 
 FirefoxWindows:
   browser: firefox
   os: Windows
-  extra_config: *firefox_config
+  extra_configs:
+    - *firefox_config
 
 FirefoxLinux:
   browser: firefox
   os: Linux
-  extra_config: *firefox_config
+  extra_configs:
+    - *firefox_config
 ```
 
 ### Browsers
@@ -75,8 +78,8 @@ browser made available to Karma.  Within each of those keys are the following:
        and must match the string and case used in the Selenium node config.
  - `disabled` (optional): If true, this browser is disabled and will not be
        used unless explicitly requested.
- - `extra_config` (optional): A dictionary of extra configs which will be
-       merged with the WebDriver launcher config in Karma.
+ - `extra_configs` (optional): An array of dictionaries of extra configs which
+       will be merged with the WebDriver launcher config in Karma.
 
 Examples of basic desktop browsers definitions:
 
@@ -96,9 +99,9 @@ Safari:
 SafariTP:
   browser: safari
   os: Mac
-  extra_config:
-    safari.options:
-      technologyPreview: true
+  extra_configs:
+    - safari.options:
+        technologyPreview: true
 
 ChromeWindows:
   browser: chrome
@@ -120,3 +123,52 @@ FirefoxLinux:
   browser: firefox
   os: Linux
 ```
+
+### Composing configs
+
+You can define variables for browser configs that can be composed together in
+`extra_configs`.  For example, below you will see some basic definitions for
+Chrome arguments and parameters, and then an additional config with an argument
+that is only needed for some platforms.  `karma.conf.js` will merge those
+argument lists intelligently when it loads the YAML config.
+
+```yaml
+vars:
+  basic_chrome_config: &basic_chrome_config
+    goog:chromeOptions:
+      args:
+        # Normally, Chrome disallows autoplaying videos in many cases.  Enable
+        # it for testing.
+        - "--autoplay-policy=no-user-gesture-required"
+
+      # Instruct chromedriver not to disable component updater.
+      excludeSwitches:
+        - "disable-component-update"
+
+  headless_chrome_config: &headless_chrome_config
+    goog:chromeOptions:
+      args:
+        # Run in headless mode.
+        - "--headless"
+
+ChromeLinux:
+  browser: chrome
+  os: Mac
+  extra_configs:
+    - *basic_chrome_config
+
+ChromeWindows:
+  browser: chrome
+  os: Mac
+  extra_configs:
+    - *basic_chrome_config
+
+ChromeMac:
+  browser: chrome
+  os: Mac
+  # Take the parameters and arguments for basic_chrome_config, then append the
+  # arguments for headless_chrome_config.
+  extra_configs:
+    - *basic_chrome_config
+    - *headless_chrome_config
+```

package/karma.conf.js

@@ -7,9 +7,11 @@
 // Karma configuration
 // Install required modules by running "npm install"
 
-const Jimp = require('jimp');
+// lodash is an indirect dependency, depended on by Karma
+const _ = require('lodash');
 const fs = require('fs');
 const glob = require('glob');
+const Jimp = require('jimp');
 const path = require('path');
 const rimraf = require('rimraf');
 const {ssim} = require('ssim.js');
@@ -17,6 +19,32 @@ const util = require('karma/common/util');
 const which = require('which');
 const yaml = require('js-yaml');
 
+/**
+ * Like Object.assign, but recursive and doesn't clobber objects and arrays.
+ * If two arrays are merged, they are concatenated.
+ * Ex:
+ *   mergeConfigs({ foo: 'bar', args: [1, 2, 3] },
+ *                { baz: 'blah', args: [4, 5, 6] })
+ *       => { foo: 'bar', baz: 'blah', args: [1, 2, 3, 4, 5, 6] }
+ *
+ * @param {Object} first
+ * @param {Object} second
+ * @return {Object}
+ */
+function mergeConfigs(first, second) {
+  return _.mergeWith(
+      first,
+      second,
+      (firstValue, secondValue) => {
+        // Merge arrays by concatenation.
+        if (Array.isArray(firstValue)) {
+          return firstValue.concat(secondValue);
+        }
+        // Use lodash's default merge behavior for everything else.
+        return undefined;
+      });
+}
+
 /**
  * @param {Object} config
  */
@@ -78,7 +106,7 @@ module.exports = (config) => {
       }
 
       // Add standard WebDriver configs.
-      Object.assign(launcher, {
+      mergeConfigs(launcher, {
         base: 'WebDriver',
         config: {hostname: gridHostname, port: gridPort},
         pseudoActivityInterval: 20000,
@@ -87,8 +115,10 @@ module.exports = (config) => {
         version: metadata.version,
       });
 
-      if (metadata.extra_config) {
-        Object.assign(launcher, metadata.extra_config);
+      if (metadata.extra_configs) {
+        for (const config of metadata.extra_configs) {
+          mergeConfigs(launcher, config);
+        }
       }
     }
 
@@ -603,15 +633,27 @@ function WebDriverScreenshotMiddlewareFactory(launcher) {
   }
 
   /**
+   * @param {karma.Launcher.Browser.spec} spec
    * @param {wd.remote} webDriverClient A WebDriver client, an object from the
    *   "wd" package, created by "wd.remote()".
    * @return {!Promise.<!Buffer>} A Buffer containing a PNG screenshot
    */
-  function getScreenshot(webDriverClient) {
+  function getScreenshot(spec, webDriverClient) {
     return new Promise((resolve, reject) => {
       webDriverClient.takeScreenshot((error, pngBase64) => {
         if (error) {
           reject(error);
+        } else if (pngBase64.error) {
+          // In some failure cases, pngBase64 is an object with "error",
+          // "message", and "stacktrace" fields.  This happens, for example,
+          // with a timeout from the screenshot command.  This is not an
+          // expected situation, so log it.  The extra newlines keep this from
+          // being overwritten on the terminal when running tests against many
+          // browsers at once.
+          console.log('\n\nUnexpected screenshot failure:\n' +
+              `  Error: ${JSON.stringify(pngBase64)}\n` +
+              `  WebDriver spec: ${JSON.stringify(spec)}\n\n\n`);
+          reject(pngBase64);
         } else {
           // Convert the screenshot to a binary buffer.
           resolve(Buffer.from(pngBase64, 'base64'));
@@ -635,7 +677,8 @@ function WebDriverScreenshotMiddlewareFactory(launcher) {
     }
 
     /** @type {!Buffer} */
-    const fullPageScreenshotData = await getScreenshot(webDriverClient);
+    const fullPageScreenshotData =
+        await getScreenshot(browser.spec, webDriverClient);
 
     // Crop the screenshot to the dimensions specified in the test.
     // Jimp is picky about types, so convert these strings to numbers.
@@ -754,7 +797,7 @@ function WebDriverScreenshotMiddlewareFactory(launcher) {
         // The result is cached for the sake of performance.
         if (webDriverClient.canTakeScreenshot === undefined) {
           try {
-            await getScreenshot(webDriverClient);
+            await getScreenshot(browser.spec, webDriverClient);
             webDriverClient.canTakeScreenshot = true;
           } catch (error) {
             webDriverClient.canTakeScreenshot = false;

package/lib/abr/simple_abr_manager.js

@@ -48,6 +48,9 @@ shaka.abr.SimpleAbrManager = class {
     /** @private {shaka.abr.EwmaBandwidthEstimator} */
     this.bandwidthEstimator_ = new shaka.abr.EwmaBandwidthEstimator();
 
+    /** @private {?function():void} */
+    this.onNetworkInformationChange_ = null;
+
     // Some browsers implement the Network Information API, which allows
     // retrieving information about a user's network connection. We listen
     // to the change event to be able to make quick changes in case the type
@@ -98,9 +101,6 @@ shaka.abr.SimpleAbrManager = class {
     /** @private {ResizeObserver} */
     this.resizeObserver_ = null;
 
-    /** @private {?function():void} */
-    this.onNetworkInformationChange_ = null;
-
     /** @private {shaka.util.Timer} */
     this.resizeObserverTimer_ = new shaka.util.Timer(() => {
       if (this.config_.restrictToElementSize) {
@@ -175,8 +175,8 @@ shaka.abr.SimpleAbrManager = class {
     if (this.resizeObserver_ && this.config_.restrictToElementSize) {
       const devicePixelRatio =
           this.config_.ignoreDevicePixelRatio ? 1 : window.devicePixelRatio;
-      maxHeight = this.mediaElement_.clientWidth * devicePixelRatio;
-      maxWidth = this.mediaElement_.clientHeight * devicePixelRatio;
+      maxHeight = this.mediaElement_.clientHeight * devicePixelRatio;
+      maxWidth = this.mediaElement_.clientWidth * devicePixelRatio;
     }
 
     // Get sorted Variants.

package/lib/player.js

@@ -2069,10 +2069,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
         this.playhead_.setStartTime(adjustedTime);
       }
-
-      // Since the first streams just became active, send an adaptation event.
-      this.onAdaptation_(null,
-          shaka.util.StreamUtils.variantToTrack(initialVariant));
     }
 
     this.playhead_.ready();
@@ -6635,7 +6631,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @define {string} A version number taken from git at compile time.
  * @export
  */
-shaka.Player.version = 'v4.2.12-uncompiled';
+shaka.Player.version = 'v4.2.13-uncompiled';
 
 // Initialize the deprecation system using the version string we just set
 // on the player.

package/lib/polyfill/orientation.js

@@ -6,6 +6,7 @@
 
 goog.provide('shaka.polyfill.Orientation');
 
+goog.require('shaka.log');
 goog.require('shaka.util.FakeEvent');
 goog.require('shaka.util.FakeEventTarget');
 goog.require('shaka.polyfill');
@@ -23,21 +24,47 @@ shaka.polyfill.Orientation = class {
    * @export
    */
   static install() {
-    if (screen.orientation) {
+    if (screen.orientation && screen.orientation.unlock) {
       // Not needed.
+      shaka.log.info('Using native screen.orientation');
       return;
     }
 
-    // There is no way to check to see if the 'orientationchange' event exists
-    // on window, which could theoretically lead to this making a
-    // screen.orientation object that doesn't actually work.
-    // However, it looks like all platforms that support the deprecated
-    // window.orientation feature also support that event.
-    if (window.orientation != undefined) {
+    if (screen.orientation != undefined) {
+      // There are some platforms where screen.orientation is defined but
+      // incomplete (e.g. Safari).
+      // Install a very simple polyfill in that case.
+      shaka.polyfill.Orientation.installBasedOnScreenMethods_();
+    } else if (window.orientation != undefined) {
+      // There is no way to check to see if the 'orientationchange' event exists
+      // on window, which could theoretically lead to this making a
+      // screen.orientation object that doesn't actually work.
+      // However, it looks like all platforms that support the deprecated
+      // window.orientation feature also support that event.
       shaka.polyfill.Orientation.installBasedOnWindowMethods_();
     }
   }
 
+  /**
+   * Modifies screen.orientation to add no-ops for missing methods.
+   * Meant for cases where screen.orientation is defined, but has missing
+   * methods that cannot be properly polyfilled.
+   * @private
+   */
+  static installBasedOnScreenMethods_() {
+    if (screen.orientation.lock === undefined) {
+      screen.orientation.lock = (orientation) => {
+        shaka.log.info('screen.orientation.lock is a no-op');
+        return Promise.resolve();
+      };
+    }
+    if (screen.orientation.unlock === undefined) {
+      screen.orientation.unlock = () => {
+        shaka.log.info('screen.orientation.unlock is a no-op');
+      };
+    }
+  }
+
   /**
    * Makes a polyfill for orientation, based on window methods.
    * Note that some of the features this is based on are deprecated, so this

package/lib/text/vtt_text_parser.js

@@ -674,6 +674,7 @@ shaka.text.VttTextParser = class {
     cue.fontWeight = refCue.fontWeight;
     cue.fontStyle = refCue.fontStyle;
     cue.opacity = refCue.opacity;
+    cue.textShadow = refCue.textShadow;
     cue.wrapLine = refCue.wrapLine;
   }
 

package/lib/util/manifest_parser_utils.js

@@ -180,8 +180,10 @@ shaka.util.ManifestParserUtils.VIDEO_CODEC_REGEXPS_ = [
  */
 shaka.util.ManifestParserUtils.AUDIO_CODEC_REGEXPS_ = [
   /^vorbis$/,
-  /^opus$/,
-  /^flac$/,
+  /^Opus$/, // correct codec string according to RFC 6381 section 3.3
+  /^opus$/, // some manifests wrongfully use this
+  /^fLaC$/, // correct codec string according to RFC 6381 section 3.3
+  /^flac$/, // some manifests wrongfully use this
   /^mp4a/,
   /^[ae]c-3$/,
   /^ac-4$/,

package/lib/util/platform.js

@@ -346,6 +346,20 @@ shaka.util.Platform = class {
     return shaka.util.Platform.isApple() && navigator.maxTouchPoints > 1;
   }
 
+  /**
+   * Return true if the platform is a Mac, regardless of the browser.
+   *
+   * @return {boolean}
+   */
+  static isMac() {
+    // Try the newer standard first.
+    if (navigator.userAgentData && navigator.userAgentData.platform) {
+      return navigator.userAgentData.platform.toLowerCase() == 'macos';
+    }
+    // Fall back to the old API, with less strict matching.
+    return navigator.platform.toLowerCase().includes('mac');
+  }
+
   /**
    * Check if the user agent contains a key. This is the best way we know of
    * right now to detect platforms. If there is a better way, please send a

package/lib/util/stream_utils.js

@@ -436,47 +436,61 @@ shaka.util.StreamUtils = class {
     manifest.variants = manifest.variants.filter((variant) => {
       // See: https://github.com/shaka-project/shaka-player/issues/3860
       const video = variant.video;
+
       const ContentType = shaka.util.ManifestParserUtils.ContentType;
+      const ManifestParserUtils = shaka.util.ManifestParserUtils;
+      const MimeUtils = shaka.util.MimeUtils;
+      const StreamUtils = shaka.util.StreamUtils;
+
       if (video) {
-        let videoCodecs =
-            shaka.util.StreamUtils.getCorrectVideoCodecs_(video.codecs);
+        let videoCodecs = StreamUtils.getCorrectVideoCodecs_(video.codecs);
+
         // For multiplexed streams. Here we must check the audio of the
         // stream to see if it is compatible.
         if (video.codecs.includes(',')) {
           const allCodecs = video.codecs.split(',');
-          videoCodecs = shaka.util.ManifestParserUtils.guessCodecs(
+
+          videoCodecs = ManifestParserUtils.guessCodecs(
               ContentType.VIDEO, allCodecs);
-          videoCodecs =
-              shaka.util.StreamUtils.getCorrectVideoCodecs_(videoCodecs);
-          let audioCodecs = shaka.util.ManifestParserUtils.guessCodecs(
+          videoCodecs = StreamUtils.getCorrectVideoCodecs_(videoCodecs);
+
+          let audioCodecs = ManifestParserUtils.guessCodecs(
               ContentType.AUDIO, allCodecs);
-          audioCodecs =
-              shaka.util.StreamUtils.getCorrectAudioCodecs_(audioCodecs);
-          const audioFullType = shaka.util.MimeUtils.getFullOrConvertedType(
+          audioCodecs = StreamUtils.getCorrectAudioCodecs_(audioCodecs);
+
+          const audioFullType = MimeUtils.getFullOrConvertedType(
               video.mimeType, audioCodecs, ContentType.AUDIO);
+
           if (!MediaSource.isTypeSupported(audioFullType)) {
             return false;
           }
+
           // Update the codec string with the (possibly) converted codecs.
           videoCodecs = [videoCodecs, audioCodecs].join(',');
         }
-        const fullType = shaka.util.MimeUtils.getFullOrConvertedType(
+
+        const fullType = MimeUtils.getFullOrConvertedType(
             video.mimeType, videoCodecs, ContentType.VIDEO);
+
         if (!MediaSource.isTypeSupported(fullType)) {
           return false;
         }
+
         // Update the codec string with the (possibly) converted codecs.
         video.codecs = videoCodecs;
       }
+
       const audio = variant.audio;
+
       if (audio) {
-        const codecs =
-            shaka.util.StreamUtils.getCorrectAudioCodecs_(audio.codecs);
-        const fullType = shaka.util.MimeUtils.getFullOrConvertedType(
+        const codecs = StreamUtils.getCorrectAudioCodecs_(audio.codecs);
+        const fullType = MimeUtils.getFullOrConvertedType(
             audio.mimeType, codecs, ContentType.AUDIO);
+
         if (!MediaSource.isTypeSupported(fullType)) {
           return false;
         }
+
         // Update the codec string with the (possibly) converted codecs.
         audio.codecs = codecs;
       }
@@ -488,7 +502,7 @@ shaka.util.StreamUtils = class {
           (video.codecs.includes('avc1.') ||
           video.codecs.includes('avc3.'))) {
         shaka.log.debug('Dropping variant - not compatible with platform',
-            shaka.util.StreamUtils.getVariantSummaryString_(variant));
+            StreamUtils.getVariantSummaryString_(variant));
         return false;
       }
 
@@ -498,7 +512,7 @@ shaka.util.StreamUtils = class {
       // Filter out all unsupported variants.
       if (!supported) {
         shaka.log.debug('Dropping variant - not compatible with platform',
-            shaka.util.StreamUtils.getVariantSummaryString_(variant));
+            StreamUtils.getVariantSummaryString_(variant));
       }
       return supported;
     });
@@ -562,7 +576,11 @@ shaka.util.StreamUtils = class {
   static getDecodingConfigs_(variant, usePersistentLicenses, srcEquals) {
     const audio = variant.audio;
     const video = variant.video;
+
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
+    const ManifestParserUtils = shaka.util.ManifestParserUtils;
+    const MimeUtils = shaka.util.MimeUtils;
+    const StreamUtils = shaka.util.StreamUtils;
 
     /** @type {!MediaDecodingConfiguration} */
     const mediaDecodingConfig = {
@@ -571,19 +589,23 @@ shaka.util.StreamUtils = class {
 
     if (video) {
       let videoCodecs = video.codecs;
+
       // For multiplexed streams with audio+video codecs, the config should have
       // AudioConfiguration and VideoConfiguration.
       if (video.codecs.includes(',')) {
         const allCodecs = video.codecs.split(',');
-        videoCodecs = shaka.util.ManifestParserUtils.guessCodecs(
+
+        videoCodecs = ManifestParserUtils.guessCodecs(
             ContentType.VIDEO, allCodecs);
-        videoCodecs =
-            shaka.util.StreamUtils.getCorrectVideoCodecs_(videoCodecs);
-        const audioCodecs = shaka.util.ManifestParserUtils.guessCodecs(
+        videoCodecs = StreamUtils.getCorrectVideoCodecs_(videoCodecs);
+
+        let audioCodecs = ManifestParserUtils.guessCodecs(
             ContentType.AUDIO, allCodecs);
+        audioCodecs = StreamUtils.getCorrectAudioCodecs_(audioCodecs);
 
-        const audioFullType = shaka.util.MimeUtils.getFullOrConvertedType(
+        const audioFullType = MimeUtils.getFullOrConvertedType(
             video.mimeType, audioCodecs, ContentType.AUDIO);
+
         mediaDecodingConfig.audio = {
           contentType: audioFullType,
           channels: 2,
@@ -592,9 +614,11 @@ shaka.util.StreamUtils = class {
           spatialRendering: false,
         };
       }
-      videoCodecs = shaka.util.StreamUtils.getCorrectVideoCodecs_(videoCodecs);
-      const fullType = shaka.util.MimeUtils.getFullOrConvertedType(
+
+      videoCodecs = StreamUtils.getCorrectVideoCodecs_(videoCodecs);
+      const fullType = MimeUtils.getFullOrConvertedType(
           video.mimeType, videoCodecs, ContentType.VIDEO);
+
       // VideoConfiguration
       mediaDecodingConfig.video = {
         contentType: fullType,
@@ -627,9 +651,8 @@ shaka.util.StreamUtils = class {
       }
     }
     if (audio) {
-      const codecs =
-          shaka.util.StreamUtils.getCorrectAudioCodecs_(audio.codecs);
-      const fullType = shaka.util.MimeUtils.getFullOrConvertedType(
+      const codecs = StreamUtils.getCorrectAudioCodecs_(audio.codecs);
+      const fullType = MimeUtils.getFullOrConvertedType(
           audio.mimeType, codecs, ContentType.AUDIO);
 
       // AudioConfiguration
@@ -760,6 +783,20 @@ shaka.util.StreamUtils = class {
    * @private
    */
   static getCorrectAudioCodecs_(codecs) {
+    // According to RFC 6381 section 3.3, 'fLaC' is actually the correct
+    // codec string. We still need to map it to 'flac', as some browsers
+    // currently don't support 'fLaC', while 'flac' is supported by most
+    // major browsers.
+    // See https://bugs.chromium.org/p/chromium/issues/detail?id=1422728
+    if (codecs === 'fLaC') {
+      return 'flac';
+    }
+
+    // The same is true for 'Opus'.
+    if (codecs === 'Opus') {
+      return 'opus';
+    }
+
     // Some Tizen devices seem to misreport AC-3 support, but correctly
     // report EC-3 support.  So query EC-3 as a fallback for AC-3.
     // See https://github.com/shaka-project/shaka-player/issues/2989 for
@@ -1238,6 +1275,9 @@ shaka.util.StreamUtils = class {
     if (textTrack.kind == 'captions') {
       track.mimeType = CLOSED_CAPTION_MIMETYPE;
     }
+    if (textTrack.kind == 'subtitles') {
+      track.mimeType = 'text/vtt';
+    }
     if (textTrack.kind) {
       track.roles = [textTrack.kind];
     }
@@ -1285,13 +1325,15 @@ shaka.util.StreamUtils = class {
    * @private
    */
   static html5TrackToGenericShakaTrack_(html5Track) {
+    const language = html5Track.language;
+
     /** @type {shaka.extern.Track} */
     const track = {
       id: shaka.util.StreamUtils.html5TrackId(html5Track),
       active: false,
       type: '',
       bandwidth: 0,
-      language: shaka.util.LanguageUtils.normalize(html5Track.language),
+      language: shaka.util.LanguageUtils.normalize(language || 'und'),
       label: html5Track.label,
       kind: html5Track.kind,
       width: null,
@@ -1321,6 +1363,7 @@ shaka.util.StreamUtils = class {
       originalAudioId: null,
       originalTextId: null,
       originalImageId: null,
+      originalLanguage: language,
     };
 
     return track;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "shaka-player",
   "description": "DASH/EME video player library",
-  "version": "4.2.12",
+  "version": "4.2.13",
   "homepage": "https://github.com/shaka-project/shaka-player",
   "author": "Google",
   "maintainers": [
@@ -42,7 +42,7 @@
     "karma-coverage": "^2.2.0",
     "karma-jasmine": "^4.0.1",
     "karma-jasmine-ajax": "^0.1.13",
-    "karma-local-wd-launcher": "^1.6.2",
+    "karma-local-wd-launcher": "^1.6.4",
     "karma-opera-launcher": "^1.0.0",
     "karma-sourcemap-loader": "^0.3.8",
     "karma-spec-reporter": "^0.0.34",

package/test/cast/cast_utils_unit.js

@@ -171,7 +171,10 @@ describe('CastUtils', () => {
       }
     });
 
-    describe('TimeRanges', () => {
+    // Disable because these tests are flakey on ChromeLinux, and this whole
+    // module will be removed in
+    // https://github.com/shaka-project/shaka-player/issues/4214
+    xdescribe('TimeRanges', () => {
       /** @type {!HTMLVideoElement} */
       let video;
       /** @type {!shaka.util.EventManager} */