shaka-player 4.3.9 → 4.4.0

package/lib/polyfill/media_capabilities.js

@@ -216,10 +216,27 @@ shaka.polyfill.MediaCapabilities = class {
         mediaKeySystemConfig.videoCapabilities = videoCapabilities;
       }
 
+      const cacheKey = shaka.polyfill.MediaCapabilities
+          .generateKeySystemCacheKey_(
+              mediaDecodingConfig.video ?
+                  mediaDecodingConfig.video.contentType : '',
+              mediaDecodingConfig.audio ?
+                  mediaDecodingConfig.audio.contentType : '',
+              mediaDecodingConfig.keySystemConfiguration.keySystem);
+
       let keySystemAccess;
       try {
-        keySystemAccess = await navigator.requestMediaKeySystemAccess(
-            mediaCapkeySystemConfig.keySystem, [mediaKeySystemConfig]);
+        if (cacheKey in shaka.polyfill.MediaCapabilities
+            .memoizedMediaKeySystemAccessRequests_) {
+          keySystemAccess = shaka.polyfill.MediaCapabilities
+              .memoizedMediaKeySystemAccessRequests_[cacheKey];
+        } else {
+          keySystemAccess = await navigator.requestMediaKeySystemAccess(
+              mediaCapkeySystemConfig.keySystem, [mediaKeySystemConfig]);
+          shaka.polyfill.MediaCapabilities
+              .memoizedMediaKeySystemAccessRequests_[cacheKey] =
+                keySystemAccess;
+        }
       } catch (e) {
         shaka.log.info('navigator.requestMediaKeySystemAccess failed.');
       }
@@ -265,11 +282,24 @@ shaka.polyfill.MediaCapabilities = class {
     }
     return cast.__platform__.canDisplayType(displayType);
   }
+
+  /**
+   * A method for generating a key for the MediaKeySystemAccessRequests cache.
+   *
+   * @param {!string} videoCodec
+   * @param {!string} audioCodec
+   * @param {!string} keySystem
+   * @return {!string}
+   * @private
+   */
+  static generateKeySystemCacheKey_(videoCodec, audioCodec, keySystem) {
+    return `${videoCodec}#${audioCodec}#${keySystem}`;
+  }
 };
 
 /**
  * A copy of the MediaCapabilities instance, to prevent Safari from
- * garbage-collecting the polyfilled method on it.  We make it public and export
+ * garbage-collecting the polyfilled method on it. We make it public and export
  * it to ensure that it is not stripped out by the compiler.
  *
  * @type {MediaCapabilities}
@@ -277,6 +307,16 @@ shaka.polyfill.MediaCapabilities = class {
  */
 shaka.polyfill.MediaCapabilities.originalMcap = null;
 
+/**
+ * A cache that stores the MediaKeySystemAccess result of calling
+ * `navigator.requestMediaKeySystemAccess` by a key combination of
+ * video/audio codec and key system string.
+ *
+ * @type {(Object<(!string), (!MediaKeySystemAccess)>)}
+ * @export
+ */
+shaka.polyfill.MediaCapabilities.memoizedMediaKeySystemAccessRequests_ = {};
+
 // Install at a lower priority than MediaSource polyfill, so that we have
 // MediaSource available first.
 shaka.polyfill.register(shaka.polyfill.MediaCapabilities.install, -1);

package/lib/polyfill/patchedmediakeys_apple.js

@@ -457,6 +457,11 @@ shaka.polyfill.PatchedMediaKeysApple.MediaKeys = class {
       return Promise.reject(exception);
     }
   }
+
+  /** @override */
+  getStatusForPolicy(policy) {
+    return Promise.resolve('usable');
+  }
 };
 
 

package/lib/polyfill/patchedmediakeys_nop.js

@@ -108,6 +108,11 @@ shaka.polyfill.PatchedMediaKeysNop.MediaKeys = class {
 
   /** @override */
   setServerCertificate() {}
+
+  /** @override */
+  getStatusForPolicy(policy) {
+    return Promise.resolve('usable');
+  }
 };
 
 

package/lib/polyfill/patchedmediakeys_webkit.js

@@ -417,6 +417,11 @@ shaka.polyfill.PatchedMediaKeysWebkit.MediaKeys = class {
     return Promise.resolve(false);
   }
 
+  /** @override */
+  getStatusForPolicy(policy) {
+    return Promise.resolve('usable');
+  }
+
   /**
    * @param {!MediaKeyEvent} event
    * @suppress {constantProperty} We reassign what would be const on a real

package/lib/text/cue.js

@@ -11,7 +11,6 @@ goog.require('shaka.util.ArrayUtils');
 
 
 /**
- * @implements {shaka.extern.Cue}
  * @export
  */
 shaka.text.Cue = class {
@@ -24,220 +23,281 @@ shaka.text.Cue = class {
     const Cue = shaka.text.Cue;
 
     /**
-     * @override
-     * @exportInterface
+     * The start time of the cue in seconds, relative to the start of the
+     * presentation.
+     * @type {number}
+     * @exportDoc
      */
     this.startTime = startTime;
 
     /**
-     * @override
-     * @exportInterface
-     */
-    this.direction = Cue.direction.HORIZONTAL_LEFT_TO_RIGHT;
-
-    /**
-     * @override
-     * @exportInterface
+     * The end time of the cue in seconds, relative to the start of the
+     * presentation.
+     * @type {number}
+     * @exportDoc
      */
     this.endTime = endTime;
 
     /**
-     * @override
-     * @exportInterface
+     * The text payload of the cue.  If nestedCues is non-empty, this should be
+     * empty.  Top-level block containers should have no payload of their own.
+     * @type {string}
+     * @exportDoc
      */
     this.payload = payload;
 
     /**
-     * @override
-     * @exportInterface
+     * The region to render the cue into.  Only supported on top-level cues,
+     * because nested cues are inline elements.
+     * @type {shaka.text.CueRegion}
+     * @exportDoc
      */
     this.region = new shaka.text.CueRegion();
 
     /**
-     * @override
-     * @exportInterface
+     * The indent (in percent) of the cue box in the direction defined by the
+     * writing direction.
+     * @type {?number}
+     * @exportDoc
      */
     this.position = null;
 
     /**
-     * @override
-     * @exportInterface
+     * Position alignment of the cue.
+     * @type {shaka.text.Cue.positionAlign}
+     * @exportDoc
      */
     this.positionAlign = Cue.positionAlign.AUTO;
 
     /**
-     * @override
-     * @exportInterface
+     * Size of the cue box (in percents), where 0 means "auto".
+     * @type {number}
+     * @exportDoc
      */
     this.size = 0;
 
     /**
-     * @override
-     * @exportInterface
+     * Alignment of the text inside the cue box.
+     * @type {shaka.text.Cue.textAlign}
+     * @exportDoc
      */
     this.textAlign = Cue.textAlign.CENTER;
 
     /**
-     * @override
-     * @exportInterface
+     * Text direction of the cue.
+     * @type {shaka.text.Cue.direction}
+     * @exportDoc
+     */
+    this.direction = Cue.direction.HORIZONTAL_LEFT_TO_RIGHT;
+
+    /**
+     * Text writing mode of the cue.
+     * @type {shaka.text.Cue.writingMode}
+     * @exportDoc
      */
     this.writingMode = Cue.writingMode.HORIZONTAL_TOP_TO_BOTTOM;
 
     /**
-     * @override
-     * @exportInterface
+     * The way to interpret line field. (Either as an integer line number or
+     * percentage from the display box).
+     * @type {shaka.text.Cue.lineInterpretation}
+     * @exportDoc
      */
     this.lineInterpretation = Cue.lineInterpretation.LINE_NUMBER;
 
     /**
-     * @override
-     * @exportInterface
+     * The offset from the display box in either number of lines or
+     * percentage depending on the value of lineInterpretation.
+     * @type {?number}
+     * @exportDoc
      */
     this.line = null;
 
     /**
-     * @override
-     * @exportInterface
+     * Separation between line areas inside the cue box in px or em
+     * (e.g. '100px'/'100em'). If not specified, this should be no less than
+     * the largest font size applied to the text in the cue.
+     * @type {string}.
+     * @exportDoc
      */
     this.lineHeight = '';
 
     /**
-     * Line Alignment is set to start by default.
-     * @override
-     * @exportInterface
+     * Line alignment of the cue box.
+     * Start alignment means the cue box’s top side (for horizontal cues), left
+     * side (for vertical growing right), or right side (for vertical growing
+     * left) is aligned at the line.
+     * Center alignment means the cue box is centered at the line.
+     * End alignment The cue box’s bottom side (for horizontal cues), right side
+     * (for vertical growing right), or left side (for vertical growing left) is
+     * aligned at the line.
+     * @type {shaka.text.Cue.lineAlign}
+     * @exportDoc
      */
     this.lineAlign = Cue.lineAlign.START;
 
     /**
-     * Set the captions at the bottom of the text container by default.
-     * @override
-     * @exportInterface
+     * Vertical alignments of the cues within their extents.
+     * 'BEFORE' means displaying the captions at the top of the text display
+     * container box, 'CENTER' means in the middle, 'AFTER' means at the bottom.
+     * @type {shaka.text.Cue.displayAlign}
+     * @exportDoc
      */
     this.displayAlign = Cue.displayAlign.AFTER;
 
     /**
-     * @override
-     * @exportInterface
+     * Text color as a CSS color, e.g. "#FFFFFF" or "white".
+     * @type {string}
+     * @exportDoc
      */
     this.color = '';
 
     /**
-     * @override
-     * @exportInterface
+     * Text background color as a CSS color, e.g. "#FFFFFF" or "white".
+     * @type {string}
+     * @exportDoc
      */
     this.backgroundColor = '';
 
     /**
-     * @override
-     * @exportInterface
+     * The URL of the background image, e.g. "data:[mime type];base64,[data]".
+     * @type {string}
+     * @exportDoc
      */
     this.backgroundImage = '';
 
     /**
-     * @override
-     * @exportInterface
+     * The border around this cue as a CSS border.
+     * @type {string}
+     * @exportDoc
      */
     this.border = '';
 
     /**
-     * @override
-     * @exportInterface
+     * Text font size in px or em (e.g. '100px'/'100em').
+     * @type {string}
+     * @exportDoc
      */
-    this.textShadow = '';
+    this.fontSize = '';
 
     /**
-     * @override
-     * @exportInterface
+     * Text font weight. Either normal or bold.
+     * @type {shaka.text.Cue.fontWeight}
+     * @exportDoc
      */
-    this.textStrokeColor = '';
+    this.fontWeight = Cue.fontWeight.NORMAL;
 
     /**
-     * @override
-     * @exportInterface
+     * Text font style. Normal, italic or oblique.
+     * @type {shaka.text.Cue.fontStyle}
+     * @exportDoc
      */
-    this.textStrokeWidth = '';
+    this.fontStyle = Cue.fontStyle.NORMAL;
 
     /**
-     * @override
-     * @exportInterface
+     * Text font family.
+     * @type {string}
+     * @exportDoc
      */
-    this.fontSize = '';
+    this.fontFamily = '';
 
     /**
-     * @override
-     * @exportInterface
+     * Text letter spacing as a CSS letter-spacing value.
+     * @type {string}
+     * @exportDoc
      */
-    this.fontWeight = Cue.fontWeight.NORMAL;
+    this.letterSpacing = '';
 
     /**
-     * @override
-     * @exportInterface
+     * Text line padding as a CSS line-padding value.
+     * @type {string}
+     * @exportDoc
      */
-    this.fontStyle = Cue.fontStyle.NORMAL;
+    this.linePadding = '';
 
     /**
-     * @override
-     * @exportInterface
+     * Opacity of the cue element, from 0-1.
+     * @type {number}
+     * @exportDoc
      */
-    this.fontFamily = '';
+    this.opacity = 1;
 
     /**
-     * @override
-     * @exportInterface
+     * Text decoration. A combination of underline, overline
+     * and line through. Empty array means no decoration.
+     * @type {!Array.<!shaka.text.Cue.textDecoration>}
+     * @exportDoc
      */
-    this.letterSpacing = '';
+    this.textDecoration = [];
 
     /**
-     * @override
-     * @exportInterface
+     * Text shadow color as a CSS text-shadow value.
+     * @type {string}
+     * @exportDoc
      */
-    this.linePadding = '';
+    this.textShadow = '';
 
     /**
-     * @override
-     * @exportInterface
+     * Text stroke color as a CSS color, e.g. "#FFFFFF" or "white".
+     * @type {string}
+     * @exportDoc
      */
-    this.opacity = 1;
+    this.textStrokeColor = '';
 
     /**
-     * @override
-     * @exportInterface
+     * Text stroke width as a CSS stroke-width value.
+     * @type {string}
+     * @exportDoc
      */
-    this.textDecoration = [];
+    this.textStrokeWidth = '';
 
     /**
-     * @override
-     * @exportInterface
+     * Whether or not line wrapping should be applied to the cue.
+     * @type {boolean}
+     * @exportDoc
      */
     this.wrapLine = true;
 
     /**
-     * @override
-     * @exportInterface
+     * Id of the cue.
+     * @type {string}
+     * @exportDoc
      */
     this.id = '';
 
     /**
-     * @override
-     * @exportInterface
+     * Nested cues, which should be laid out horizontally in one block.
+     * Top-level cues are blocks, and nested cues are inline elements.
+     * Cues can be nested arbitrarily deeply.
+     * @type {!Array.<!shaka.text.Cue>}
+     * @exportDoc
      */
     this.nestedCues = [];
 
     /**
-     * @override
-     * @exportInterface
+     * If true, this represents a container element that is "above" the main
+     * cues. For example, the <body> and <div> tags that contain the <p> tags
+     * in a TTML file. This controls the flow of the final cues; any nested cues
+     * within an "isContainer" cue will be laid out as separate lines.
+     * @type {boolean}
+     * @exportDoc
      */
     this.isContainer = false;
 
     /**
-     * @override
-     * @exportInterface
+     * Whether or not the cue only acts as a line break between two nested cues.
+     * Should only appear in nested cues.
+     * @type {boolean}
+     * @exportDoc
      */
     this.lineBreak = false;
 
     /**
-     * @override
-     * @exportInterface
+     * The number of horizontal and vertical cells into which the Root Container
+     * Region area is divided.
+     *
+     * @type {{ columns: number, rows: number }}
+     * @exportDoc
      */
     this.cellResolution = {
       columns: 32,
@@ -260,6 +320,7 @@ shaka.text.Cue = class {
    * Create a copy of the cue with the same properties.
    * @return {!shaka.text.Cue}
    * @suppress {checkTypes} since we must use [] and "in" with a struct type.
+   * @export
    */
   clone() {
     const clone = new shaka.text.Cue(0, 0, '');
@@ -284,6 +345,7 @@ shaka.text.Cue = class {
    * @param {!shaka.text.Cue} cue2
    * @return {boolean}
    * @suppress {checkTypes} since we must use [] and "in" with a struct type.
+   * @export
    */
   static equal(cue1, cue2) {
     // Compare the start time, end time and payload of the cues first for
@@ -415,14 +477,14 @@ shaka.text.Cue.lineAlign = {
  * @export
  */
 shaka.text.Cue.defaultTextColor = {
-  'white': '#FFF',
-  'lime': '#0F0',
-  'cyan': '#0FF',
-  'red': '#F00',
-  'yellow': '#FF0',
-  'magenta': '#F0F',
-  'blue': '#00F',
-  'black': '#000',
+  'white': 'white',
+  'lime': 'lime',
+  'cyan': 'cyan',
+  'red': 'red',
+  'yellow': 'yellow',
+  'magenta': 'magenta',
+  'blue': 'blue',
+  'black': 'black',
 };
 
 
@@ -433,14 +495,14 @@ shaka.text.Cue.defaultTextColor = {
  * @export
  */
 shaka.text.Cue.defaultTextBackgroundColor = {
-  'bg_white': '#FFF',
-  'bg_lime': '#0F0',
-  'bg_cyan': '#0FF',
-  'bg_red': '#F00',
-  'bg_yellow': '#FF0',
-  'bg_magenta': '#F0F',
-  'bg_blue': '#00F',
-  'bg_black': '#000',
+  'bg_white': 'white',
+  'bg_lime': 'lime',
+  'bg_cyan': 'cyan',
+  'bg_red': 'red',
+  'bg_yellow': 'yellow',
+  'bg_magenta': 'magenta',
+  'bg_blue': 'blue',
+  'bg_black': 'black',
 };
 
 
@@ -479,8 +541,6 @@ shaka.text.Cue.textDecoration = {
 
 
 /**
- * @implements {shaka.extern.CueRegion}
- * @struct
  * @export
  */
 shaka.text.CueRegion = class {
@@ -489,68 +549,86 @@ shaka.text.CueRegion = class {
     const CueRegion = shaka.text.CueRegion;
 
     /**
-     * @override
-     * @exportInterface
+     * Region identifier.
+     * @type {string}
+     * @exportDoc
      */
     this.id = '';
 
     /**
-     * @override
-     * @exportInterface
+     * The X offset to start the rendering area in viewportAnchorUnits of the
+     * video width.
+     * @type {number}
+     * @exportDoc
      */
     this.viewportAnchorX = 0;
 
     /**
-     * @override
-     * @exportInterface
+     * The X offset to start the rendering area in viewportAnchorUnits of the
+     * video height.
+     * @type {number}
+     * @exportDoc
      */
     this.viewportAnchorY = 0;
 
     /**
-     * @override
-     * @exportInterface
+     * The X offset to start the rendering area in percentage (0-100) of this
+     * region width.
+     * @type {number}
+     * @exportDoc
      */
     this.regionAnchorX = 0;
 
     /**
-     * @override
-     * @exportInterface
+     * The Y offset to start the rendering area in percentage (0-100) of the
+     * region height.
+     * @type {number}
+     * @exportDoc
      */
     this.regionAnchorY = 0;
 
     /**
-     * @override
-     * @exportInterface
+     * The width of the rendering area in widthUnits.
+     * @type {number}
+     * @exportDoc
      */
     this.width = 100;
 
     /**
-     * @override
-     * @exportInterface
+     * The width of the rendering area in heightUnits.
+     * @type {number}
+     * @exportDoc
      */
     this.height = 100;
 
     /**
-     * @override
-     * @exportInterface
+     * The units (percentage, pixels or lines) the region height is in.
+     * @type {shaka.text.CueRegion.units}
+     * @exportDoc
      */
     this.heightUnits = CueRegion.units.PERCENTAGE;
 
     /**
-     * @override
-     * @exportInterface
+     * The units (percentage or pixels) the region width is in.
+     * @type {shaka.text.CueRegion.units}
+     * @exportDoc
      */
     this.widthUnits = CueRegion.units.PERCENTAGE;
 
     /**
-     * @override
-     * @exportInterface
+     * The units (percentage or pixels) the region viewportAnchors are in.
+     * @type {shaka.text.CueRegion.units}
+     * @exportDoc
      */
     this.viewportAnchorUnits = CueRegion.units.PERCENTAGE;
 
     /**
-     * @override
-     * @exportInterface
+     * If scroll=UP, it means that cues in the region will be added to the
+     * bottom of the region and will push any already displayed cues in the
+     * region up.  Otherwise (scroll=NONE) cues will stay fixed at the location
+     * they were first painted in.
+     * @type {shaka.text.CueRegion.scrollMode}
+     * @exportDoc
      */
     this.scroll = CueRegion.scrollMode.NONE;
   }

package/lib/text/lrc_text_parser.js

@@ -47,10 +47,10 @@ shaka.text.LrcTextParser = class {
     // Get the input as a string.
     const str = StringUtils.fromUTF8(data);
 
-    /** @type {shaka.extern.Cue} */
+    /** @type {shaka.text.Cue} */
     let prevCue = null;
 
-    /** @type {!Array.<!shaka.extern.Cue>} */
+    /** @type {!Array.<!shaka.text.Cue>} */
     const cues = [];
     const lines = str.split(/\r?\n/);
     for (const line of lines) {