shaka-player 4.3.0 → 4.3.2

package/lib/polyfill/abort_controller.js

@@ -0,0 +1,143 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.polyfill.AbortController');
+
+goog.require('shaka.polyfill');
+goog.require('shaka.util.FakeEvent');
+goog.require('shaka.util.FakeEventTarget');
+
+/**
+ * @summary A polyfill for systems that do not implement AbortController.
+ * This is used both with the fetch API for HTTP requests and inside the HLS
+ * parser.
+ * @export
+ * @extends AbortController
+ */
+shaka.polyfill.AbortController = class {
+  /**
+   * Install the polyfill if needed.
+   * @export
+   */
+  static install() {
+    if (window.AbortController) {
+      // Not needed.
+      return;
+    }
+
+    window.AbortController = shaka.polyfill.AbortController;
+    window.AbortSignal = shaka.polyfill.AbortController.AbortSignal;
+  }
+
+  /** */
+  constructor() {
+    /** @private {!shaka.polyfill.AbortController.AbortSignal} */
+    this.signal_ = new shaka.polyfill.AbortController.AbortSignal();
+  }
+
+  /**
+   * @override
+   * @suppress {const|duplicate} Since the original is defined as "const", we
+   *   need this suppression to override it.
+   */
+  get signal() {
+    return this.signal_;
+  }
+
+  /**
+   * @param {*=} reason
+   * @override
+   */
+  abort(reason) {
+    this.signal_.doAbort_(reason);
+  }
+};
+
+/**
+ * @summary A polyfill for AbortSignal, part of the AbortController API.
+ * @implements {AbortSignal}
+ */
+shaka.polyfill.AbortController.AbortSignal =
+class extends shaka.util.FakeEventTarget {
+  /** */
+  constructor() {
+    super();
+
+    /** @private {boolean} */
+    this.aborted_ = false;
+
+    /** @private {*} */
+    this.reason_ = undefined;
+
+    /** @type {?function(!Event)} */
+    this.onabort = null;
+  }
+
+  /** @override */
+  get aborted() {
+    return this.aborted_;
+  }
+
+  /** @return {*} */
+  get reason() {
+    return this.reason_;
+  }
+
+  /**
+   * @param {*} reason
+   * @private
+   */
+  doAbort_(reason) {
+    if (this.aborted_) {
+      return;
+    }
+
+    this.aborted_ = true;
+    this.reason_ = reason;
+    if (this.reason_ === undefined) {
+      // This is equivalent to a native implementation.
+      this.reason_ = new DOMException(
+          'signal is aborted without reason', 'AbortError');
+    }
+
+    // According to MDN:
+    // "Event type - A generic Event with no added properties."
+    const event = new shaka.util.FakeEvent('abort');
+    if (this.onabort) {
+      this.onabort(event);
+    }
+    this.dispatchEvent(event);
+  }
+
+
+  /**
+   * @param {*=} reason
+   * @return {!AbortSignal}
+   */
+  static abort(reason) {
+    const signal = new shaka.polyfill.AbortController.AbortSignal();
+    signal.doAbort_(reason);
+    return signal;
+  }
+
+  /**
+   * @param {number} timeMs
+   * @return {!AbortSignal}
+   */
+  static timeout(timeMs) {
+    const signal = new shaka.polyfill.AbortController.AbortSignal();
+
+    window.setTimeout(() => {
+      // This is equivalent to a native implementation.
+      signal.doAbort_(new DOMException('signal timed out', 'TimeoutError'));
+    }, timeMs);
+
+    return signal;
+  }
+};
+
+
+shaka.polyfill.register(shaka.polyfill.AbortController.install);

package/lib/polyfill/media_capabilities.js

@@ -7,7 +7,9 @@
 goog.provide('shaka.polyfill.MediaCapabilities');
 
 goog.require('shaka.log');
+goog.require('shaka.media.Capabilities');
 goog.require('shaka.polyfill');
+goog.require('shaka.util.Error');
 goog.require('shaka.util.Platform');
 
 
@@ -96,37 +98,51 @@ shaka.polyfill.MediaCapabilities = class {
       return res;
     }
 
+    const videoConfig = mediaDecodingConfig['video'];
+    const audioConfig = mediaDecodingConfig['audio'];
+
+    const Capabilities = shaka.media.Capabilities;
+
     if (mediaDecodingConfig.type == 'media-source') {
       if (!shaka.util.Platform.supportsMediaSource()) {
         return res;
       }
-      // Use 'MediaSource.isTypeSupported' to check if the stream is supported.
-      if (mediaDecodingConfig['video']) {
-        const contentType = mediaDecodingConfig['video'].contentType;
-        const isSupported = MediaSource.isTypeSupported(contentType);
+      // Use 'shaka.media.Capabilities.isTypeSupported'to check if
+      // the stream is supported.
+      // Cast platforms will additionally check canDisplayType(), which
+      // accepts extended MIME type parameters.
+      // See: https://github.com/shaka-project/shaka-player/issues/4726
+      if (videoConfig) {
+        let isSupported;
+        if (shaka.util.Platform.isChromecast()) {
+          isSupported =
+              shaka.polyfill.MediaCapabilities.canCastDisplayType_(videoConfig);
+        } else {
+          isSupported = Capabilities.isTypeSupported(videoConfig.contentType);
+        }
         if (!isSupported) {
           return res;
         }
       }
 
-      if (mediaDecodingConfig['audio']) {
-        const contentType = mediaDecodingConfig['audio'].contentType;
-        const isSupported = MediaSource.isTypeSupported(contentType);
+      if (audioConfig) {
+        const contentType = audioConfig.contentType;
+        const isSupported = Capabilities.isTypeSupported(contentType);
         if (!isSupported) {
           return res;
         }
       }
     } else if (mediaDecodingConfig.type == 'file') {
-      if (mediaDecodingConfig['video']) {
-        const contentType = mediaDecodingConfig['video'].contentType;
+      if (videoConfig) {
+        const contentType = videoConfig.contentType;
         const isSupported = shaka.util.Platform.supportsMediaType(contentType);
         if (!isSupported) {
           return res;
         }
       }
 
-      if (mediaDecodingConfig['audio']) {
-        const contentType = mediaDecodingConfig['audio'].contentType;
+      if (audioConfig) {
+        const contentType = audioConfig.contentType;
         const isSupported = shaka.util.Platform.supportsMediaType(contentType);
         if (!isSupported) {
           return res;
@@ -201,6 +217,44 @@ shaka.polyfill.MediaCapabilities = class {
 
     return res;
   }
+
+  /**
+   * Checks if the given media parameters of the video or audio streams are
+   * supported by the Cast platform.
+   * @param {!VideoConfiguration} videoConfig The 'video' field of the
+   *     MediaDecodingConfiguration.
+   * @return {boolean} `true` when the stream can be displayed on a Cast device.
+   * @private
+   */
+  static canCastDisplayType_(videoConfig) {
+    if (!(window.cast)) {
+      shaka.log.error('Expected cast namespace to be available!');
+      throw new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.CAST,
+          shaka.util.Error.Code.CAST_API_UNAVAILABLE);
+    } else if (!(cast.__platform__ && cast.__platform__.canDisplayType)) {
+      shaka.log.warning('Expected cast APIs to be available! Falling back to ' +
+          'shaka.media.Capabilities.isTypeSupported() for type support.');
+      return shaka.media.Capabilities.isTypeSupported(videoConfig.contentType);
+    }
+
+    let displayType = videoConfig.contentType;
+    if (videoConfig.width && videoConfig.height) {
+      displayType +=
+          `; width=${videoConfig.width}; height=${videoConfig.height}`;
+    }
+    if (videoConfig.framerate) {
+      displayType += `; framerate=${videoConfig.framerate}`;
+    }
+    if (videoConfig.transferFunction === 'pq') {
+      // A "PQ" transfer function indicates this is an HDR-capable stream;
+      // "smpte2084" is the published standard. We need to inform the platform
+      // this query is specifically for HDR.
+      displayType += '; eotf=smpte2084';
+    }
+    return cast.__platform__.canDisplayType(displayType);
+  }
 };
 
 /**

package/lib/polyfill/patchedmediakeys_apple.js

@@ -27,38 +27,39 @@ goog.require('shaka.util.StringUtils');
 shaka.polyfill.PatchedMediaKeysApple = class {
   /**
    * Installs the polyfill if needed.
-   * @param {boolean} enableUninstall enables uninstalling the polyfill
+   * @param {boolean=} enableUninstall enables uninstalling the polyfill
    * @export
    */
   static install(enableUninstall = false) {
+    // Alias
+    const PatchedMediaKeysApple = shaka.polyfill.PatchedMediaKeysApple;
+
     if (!window.HTMLVideoElement || !window.WebKitMediaKeys) {
       // No HTML5 video or no prefixed EME.
       return;
     }
 
     if (enableUninstall) {
-      this.enableUninstall = true;
-      this.originalHTMLMediaElementPrototypeMediaKeys =
+      PatchedMediaKeysApple.enableUninstall = true;
+      PatchedMediaKeysApple.originalHTMLMediaElementPrototypeMediaKeys =
         /** @type {!Object} */ (
           Object.getOwnPropertyDescriptor(
               // eslint-disable-next-line no-restricted-syntax
               HTMLMediaElement.prototype, 'mediaKeys',
           )
         );
-      // eslint-disable-next-line no-restricted-syntax
-      this.originalHTMLMediaElementPrototypeSetMediaKeys = HTMLMediaElement
-          .prototype.setMediaKeys;
-      this.originalWindowMediaKeys = window.MediaKeys;
-      this.originalWindowMediaKeySystemAccess = window.MediaKeySystemAccess;
-      this.originalNavigatorRequestMediaKeySystemAccess = navigator
-          .requestMediaKeySystemAccess;
+      PatchedMediaKeysApple.originalHTMLMediaElementPrototypeSetMediaKeys =
+          // eslint-disable-next-line no-restricted-syntax
+          HTMLMediaElement.prototype.setMediaKeys;
+      PatchedMediaKeysApple.originalWindowMediaKeys = window.MediaKeys;
+      PatchedMediaKeysApple.originalWindowMediaKeySystemAccess =
+          window.MediaKeySystemAccess;
+      PatchedMediaKeysApple.originalNavigatorRequestMediaKeySystemAccess =
+          navigator.requestMediaKeySystemAccess;
     }
 
     shaka.log.info('Using Apple-prefixed EME');
 
-    // Alias
-    const PatchedMediaKeysApple = shaka.polyfill.PatchedMediaKeysApple;
-
     // Delete mediaKeys to work around strict mode compatibility issues.
     // eslint-disable-next-line no-restricted-syntax
     delete HTMLMediaElement.prototype['mediaKeys'];
@@ -83,32 +84,36 @@ shaka.polyfill.PatchedMediaKeysApple = class {
    * @export
    */
   static uninstall() {
-    if (!this.enableUninstall) {
+    // Alias
+    const PatchedMediaKeysApple = shaka.polyfill.PatchedMediaKeysApple;
+
+    if (!PatchedMediaKeysApple.enableUninstall) {
       return;
     }
 
     shaka.log.info('Un-installing Apple-prefixed EME');
 
-    this.enableUninstall = false;
+    PatchedMediaKeysApple.enableUninstall = false;
     Object.defineProperty(
         // eslint-disable-next-line no-restricted-syntax
         HTMLMediaElement.prototype,
         'mediaKeys',
-        this.originalHTMLMediaElementPrototypeMediaKeys,
+        PatchedMediaKeysApple.originalHTMLMediaElementPrototypeMediaKeys,
     );
     // eslint-disable-next-line no-restricted-syntax
-    HTMLMediaElement.prototype.setMediaKeys = this
-        .originalHTMLMediaElementPrototypeSetMediaKeys;
-    window.MediaKeys = this.originalWindowMediaKeys;
-    window.MediaKeySystemAccess = this.originalWindowMediaKeySystemAccess;
-    navigator.requestMediaKeySystemAccess = this
-        .originalNavigatorRequestMediaKeySystemAccess;
-
-    this.originalWindowMediaKeys = null;
-    this.originalWindowMediaKeySystemAccess = null;
-    this.originalHTMLMediaElementPrototypeSetMediaKeys = null;
-    this.originalNavigatorRequestMediaKeySystemAccess = null;
-    this.originalHTMLMediaElementPrototypeMediaKeys = null;
+    HTMLMediaElement.prototype.setMediaKeys =
+        PatchedMediaKeysApple.originalHTMLMediaElementPrototypeSetMediaKeys;
+    window.MediaKeys = PatchedMediaKeysApple.originalWindowMediaKeys;
+    window.MediaKeySystemAccess =
+        PatchedMediaKeysApple.originalWindowMediaKeySystemAccess;
+    navigator.requestMediaKeySystemAccess =
+        PatchedMediaKeysApple.originalNavigatorRequestMediaKeySystemAccess;
+
+    PatchedMediaKeysApple.originalWindowMediaKeys = null;
+    PatchedMediaKeysApple.originalWindowMediaKeySystemAccess = null;
+    PatchedMediaKeysApple.originalHTMLMediaElementPrototypeSetMediaKeys = null;
+    PatchedMediaKeysApple.originalNavigatorRequestMediaKeySystemAccess = null;
+    PatchedMediaKeysApple.originalHTMLMediaElementPrototypeMediaKeys = null;
 
     window.shakaMediaKeysPolyfill = false;
   }

package/lib/text/ttml_text_parser.js

@@ -136,7 +136,7 @@ shaka.text.TtmlTextParser = class {
     }
 
     const cue = TtmlTextParser.parseCue_(
-        body, time.periodStart, rateInfo, metadataElements, styles,
+        body, time, rateInfo, metadataElements, styles,
         regionElements, cueRegions, whitespaceTrim,
         cellResolutionInfo, /* parentCueElement= */ null,
         /* isContent= */ false);
@@ -157,7 +157,7 @@ shaka.text.TtmlTextParser = class {
    * Parses a TTML node into a Cue.
    *
    * @param {!Node} cueNode
-   * @param {number} offset
+   * @param {shaka.extern.TextParser.TimeContext} timeContext
    * @param {!shaka.text.TtmlTextParser.RateInfo_} rateInfo
    * @param {!Array.<!Element>} metadataElements
    * @param {!Array.<!Element>} styles
@@ -171,7 +171,7 @@ shaka.text.TtmlTextParser = class {
    * @private
    */
   static parseCue_(
-      cueNode, offset, rateInfo, metadataElements, styles, regionElements,
+      cueNode, timeContext, rateInfo, metadataElements, styles, regionElements,
       cueRegions, whitespaceTrim, cellResolution, parentCueElement, isContent) {
     /** @type {Element} */
     let cueElement;
@@ -236,7 +236,7 @@ shaka.text.TtmlTextParser = class {
       for (const childNode of cueElement.childNodes) {
         const nestedCue = shaka.text.TtmlTextParser.parseCue_(
             childNode,
-            offset,
+            timeContext,
             rateInfo,
             metadataElements,
             styles,
@@ -293,15 +293,20 @@ shaka.text.TtmlTextParser = class {
     if (start == null) {
       start = 0;
     }
-    start += offset;
+    start += timeContext.periodStart;
 
     // If end is null, that means the duration is effectively infinite.
     if (end == null) {
       end = Infinity;
     } else {
-      end += offset;
+      end += timeContext.periodStart;
     }
 
+    // Clip times to segment boundaries.
+    // https://github.com/shaka-project/shaka-player/issues/4631
+    start = Math.max(start, timeContext.segmentStart);
+    end = Math.min(end, timeContext.segmentEnd);
+
     if (!hasTimeAttributes && nestedCues.length > 0) {
       // If no time is defined for this cue, base the timing information on
       // the time of the nested cues. In the case of multiple nested cues with
@@ -569,8 +574,28 @@ shaka.text.TtmlTextParser = class {
 
     const fontFamily = TtmlTextParser.getStyleAttribute_(
         cueElement, region, styles, 'fontFamily', shouldInheritRegionStyles);
+    // See https://github.com/sandflow/imscJS/blob/1.1.3/src/main/js/html.js#L1384
     if (fontFamily) {
-      cue.fontFamily = fontFamily;
+      switch (fontFamily) {
+        case 'monospaceSerif':
+          cue.fontFamily = 'Courier New,Liberation Mono,Courier,monospace';
+          break;
+        case 'proportionalSansSerif':
+          cue.fontFamily = 'Arial,Helvetica,Liberation Sans,sans-serif';
+          break;
+        case 'sansSerif':
+          cue.fontFamily = 'sans-serif';
+          break;
+        case 'monospaceSansSerif':
+          cue.fontFamily = 'Consolas,monospace';
+          break;
+        case 'proportionalSerif':
+          cue.fontFamily = 'serif';
+          break;
+        default:
+          cue.fontFamily = fontFamily;
+          break;
+      }
     }
 
     const fontWeight = TtmlTextParser.getStyleAttribute_(

package/lib/text/ui_text_displayer.js

@@ -199,6 +199,19 @@ shaka.text.UITextDisplayer = class {
     this.isTextVisible_ = on;
   }
 
+  /**
+   * @private
+   */
+  isElementUnderTextContainer_(elemToCheck) {
+    while (elemToCheck != null) {
+      if (elemToCheck == this.textContainer_) {
+        return true;
+      }
+      elemToCheck = elemToCheck.parentElement;
+    }
+    return false;
+  }
+
   /**
    * @param {!Array.<!shaka.extern.Cue>} cues
    * @param {!HTMLElement} container
@@ -260,6 +273,9 @@ shaka.text.UITextDisplayer = class {
           cueRegistry = this.currentCuesMap_.get(cue);
           wrapper = cueRegistry.wrapper;
           updateDOM = true;
+        } else if (!this.isElementUnderTextContainer_(wrapper)) {
+          // We found that the wrapper needs to be in the DOM
+          updateDOM = true;
         }
       }
 
@@ -276,6 +292,7 @@ shaka.text.UITextDisplayer = class {
       const topCue = parents.pop();
       goog.asserts.assert(topCue == cue, 'Parent cues should be kept in order');
     }
+
     if (updateDOM) {
       for (const element of toUproot) {
         // NOTE: Because we uproot shared region elements, too, we might hit an

package/lib/util/mp4_box_parsers.js

@@ -7,6 +7,7 @@
 goog.provide('shaka.util.Mp4BoxParsers');
 
 goog.require('shaka.util.DataViewReader');
+goog.require('shaka.util.Mp4Parser');
 
 shaka.util.Mp4BoxParsers = class {
   /**
@@ -188,6 +189,17 @@ shaka.util.Mp4BoxParsers = class {
       trackId,
     };
   }
+
+  /**
+   * Parses a FRMA box.
+   * @param {!shaka.util.DataViewReader} reader
+   * @return {!shaka.util.ParsedFRMABox}
+   */
+  static parseFRMA(reader) {
+    const fourcc = reader.readUint32();
+    const codec = shaka.util.Mp4Parser.typeToString(fourcc);
+    return {codec};
+  }
 };
 
 
@@ -306,3 +318,15 @@ shaka.util.ParsedTRUNSample;
  * @exportDoc
  */
 shaka.util.ParsedTKHDBox;
+
+/**
+ * @typedef {{
+ *    codec: string
+ *  }}
+ *
+ * @property {string} codec
+ *   A fourcc for a codec
+ *
+ * @exportDoc
+ */
+shaka.util.ParsedFRMABox;

package/lib/util/mp4_parser.js

@@ -172,6 +172,7 @@ shaka.util.Mp4Parser = class {
 
       /** @type {shaka.extern.ParsedBox} */
       const box = {
+        name,
         parser: this,
         partialOkay: partialOkay || false,
         version,
@@ -236,6 +237,40 @@ shaka.util.Mp4Parser = class {
   }
 
 
+  /**
+   * A callback that tells the Mp4 parser to treat the body of a box as a visual
+   * sample entry.  A visual sample entry has some fixed-sized fields
+   * describing the video codec parameters, followed by an arbitrary number of
+   * appended children.  Each child is a box.
+   *
+   * @param {!shaka.extern.ParsedBox} box
+   * @export
+   */
+  static visualSampleEntry(box) {
+    // The "reader" starts at the payload, so we need to add the header to the
+    // start position.  The header size varies.
+    const headerSize = shaka.util.Mp4Parser.headerSize(box);
+
+    // Skip 6 reserved bytes.
+    // Skip 2-byte data reference index.
+    // Skip 16 more reserved bytes.
+    // Skip 4 bytes for width/height.
+    // Skip 8 bytes for horizontal/vertical resolution.
+    // Skip 4 more reserved bytes (0)
+    // Skip 2-byte frame count.
+    // Skip 32-byte compressor name (length byte, then name, then 0-padding).
+    // Skip 2-byte depth.
+    // Skip 2 more reserved bytes (0xff)
+    // 78 bytes total.
+    // See also https://github.com/shaka-project/shaka-packager/blob/d5ca6e84/packager/media/formats/mp4/box_definitions.cc#L1544
+    box.reader.skip(78);
+
+    while (box.reader.hasMoreData() && !box.parser.done_) {
+      box.parser.parseNext(box.start + headerSize, box.reader, box.partialOkay);
+    }
+  }
+
+
   /**
    * Create a callback that tells the Mp4 parser to treat the body of a box as a
    * binary blob and to parse the body's contents using the provided callback.

package/lib/util/player_configuration.js

@@ -12,6 +12,7 @@ goog.require('shaka.config.AutoShowText');
 goog.require('shaka.log');
 goog.require('shaka.net.NetworkingEngine');
 goog.require('shaka.util.ConfigUtils');
+goog.require('shaka.util.FairPlayUtils');
 goog.require('shaka.util.LanguageUtils');
 goog.require('shaka.util.ManifestParserUtils');
 goog.require('shaka.util.Platform');
@@ -68,9 +69,15 @@ shaka.util.PlayerConfiguration = class {
       advanced: {},    // key is arbitrary key system ID, value is a record type
       delayLicenseRequestUntilPlayed: false,
       initDataTransform: (initData, initDataType, drmInfo) => {
-        return shaka.util.ConfigUtils.referenceParametersAndReturn(
-            [initData, initDataType, drmInfo],
-            initData);
+        const keySystem = drmInfo.keySystem;
+        if (keySystem == 'com.apple.fps.1_0' && initDataType == 'skd') {
+          const cert = drmInfo.serverCertificate;
+          const contentId =
+              shaka.util.FairPlayUtils.defaultGetContentId(initData);
+          initData = shaka.util.FairPlayUtils.initDataTransform(
+              initData, contentId, cert);
+        }
+        return initData;
       },
       logLicenseExchange: false,
       updateExpirationTime: 1,