shaka-player 2.5.1 → 2.5.5

package/lib/util/error.js

@@ -84,17 +84,20 @@ shaka.util.Error = function(severity, category, code, ...varArgs) {
      */
     this.message = 'Shaka Error ' + categoryName + '.' + codeName +
                    ' (' + this.data.toString() + ')';
-    try {
-      throw new Error(this.message);
-    } catch (e) {
-      /**
-       * A stack-trace showing where the error occurred.
-       * <i>(Only available in uncompiled mode.)</i>
-       *
-       * @const {string}
-       * @exportDoc
-       */
-      this.stack = e.stack;
+
+    if (shaka.util.Error.createStack) {
+      try {
+        throw new Error(this.message);
+      } catch (e) {
+        /**
+         * A stack-trace showing where the error occurred.
+         * <i>(Only available in uncompiled mode.)</i>
+         *
+         * @const {string}
+         * @exportDoc
+         */
+        this.stack = e.stack;
+      }
     }
   }
 };
@@ -109,6 +112,19 @@ shaka.util.Error.prototype.toString = function() {
 };
 
 
+if (goog.DEBUG) {
+  /**
+   * If true, create a stack trace in Error objects.
+   *
+   * Only available in uncompiled mode, and disabled in tests to avoid issues
+   * with karma-jasmine.  See comments in test/test/boot.js for details.
+   *
+   * @type {boolean}
+   */
+  shaka.util.Error.createStack = true;
+}
+
+
 /**
  * @enum {number}
  * @export
@@ -717,6 +733,18 @@ shaka.util.Error.Code = {
    */
   'EXPIRED': 6014,
 
+  /**
+   * A server certificate wasn't given when it is required.  FairPlay requires
+   * setting an explicit server certificate in the configuration.
+   */
+  'SERVER_CERTIFICATE_REQUIRED': 6015,
+
+  /**
+   * An error was thrown while executing the init data transformation.
+   * <br> error.data[0] is the original error.
+   */
+  'INIT_DATA_TRANSFORM_ERROR': 6016,
+
 
   /**
    * The call to Player.load() was interrupted by a call to Player.unload()
@@ -783,6 +811,12 @@ shaka.util.Error.Code = {
   'CAST_RECEIVER_APP_UNAVAILABLE': 8006,
 
 
+  /**
+   * No receiver app id has been provided, making casting impossible.
+   */
+  'CAST_RECEIVER_APP_ID_MISSING': 8007,
+
+
   /**
    * Offline storage is not supported on this browser; it is required for
    * offline support.

package/lib/util/event_manager.js

@@ -23,143 +23,254 @@ goog.require('shaka.util.MultiMap');
 
 
 /**
- * Creates a new EventManager. An EventManager maintains a collection of "event
+ * @summary
+ * An EventManager maintains a collection of "event
  * bindings" between event targets and event listeners.
  *
- * @struct
- * @constructor
  * @implements {shaka.util.IReleasable}
+ * @export
  */
-shaka.util.EventManager = function() {
+shaka.util.EventManager = class {
+  constructor() {
+    /**
+     * Maps an event type to an array of event bindings.
+     * @private {shaka.util.MultiMap.<!shaka.util.EventManager.Binding_>}
+     */
+    this.bindingMap_ = new shaka.util.MultiMap();
+  }
+
+
   /**
-   * Maps an event type to an array of event bindings.
-   * @private {shaka.util.MultiMap.<!shaka.util.EventManager.Binding_>}
+   * Detaches all event listeners.
+   * @override
+   * @export
    */
-  this.bindingMap_ = new shaka.util.MultiMap();
-};
-
+  release() {
+    this.removeAll();
+    this.bindingMap_ = null;
+  }
 
-/**
- * @typedef {function(!Event)}
- */
-shaka.util.EventManager.ListenerType;
 
+  /**
+   * Attaches an event listener to an event target.
+   * @param {EventTarget} target The event target.
+   * @param {string} type The event type.
+   * @param {shaka.util.EventManager.ListenerType} listener The event listener.
+   * @param {(boolean|!AddEventListenerOptions)=} options An object that
+   *    specifies characteristics about the event listener.
+   *    The passive option, if true, indicates that this function will never
+   *    call preventDefault(), which improves scrolling performance.
+   * @export
+   */
+  listen(target, type, listener, options) {
+    if (!this.bindingMap_) {
+      return;
+    }
 
-/**
- * Detaches all event listeners.
- * @override
- */
-shaka.util.EventManager.prototype.release = function() {
-  this.removeAll();
-  this.bindingMap_ = null;
-};
+    const binding =
+        new shaka.util.EventManager.Binding_(target, type, listener, options);
+    this.bindingMap_.push(type, binding);
+  }
 
 
-/**
- * Attaches an event listener to an event target.
- * @param {EventTarget} target The event target.
- * @param {string} type The event type.
- * @param {shaka.util.EventManager.ListenerType} listener The event listener.
- */
-shaka.util.EventManager.prototype.listen = function(target, type, listener) {
-  if (!this.bindingMap_) return;
+  /**
+   * Attaches an event listener to an event target.  The listener will be
+   * removed when the first instance of the event is fired.
+   * @param {EventTarget} target The event target.
+   * @param {string} type The event type.
+   * @param {shaka.util.EventManager.ListenerType} listener The event listener.
+   * @param {(boolean|!AddEventListenerOptions)=} options An object that
+   *    specifies characteristics about the event listener.
+   *    The passive option, if true, indicates that this function will never
+   *    call preventDefault(), which improves scrolling performance.
+   * @export
+   */
+  listenOnce(target, type, listener, options) {
+    // Install a shim listener that will stop listening after the first event.
+    const shim = (event) => {
+      // Stop listening to this event.
+      this.unlisten(target, type, shim);
+      // Call the original listener.
+      listener(event);
+    };
+    this.listen(target, type, shim, options);
+  }
 
-  let binding = new shaka.util.EventManager.Binding_(target, type, listener);
-  this.bindingMap_.push(type, binding);
-};
 
+  /**
+   * Detaches an event listener from an event target.
+   * @param {EventTarget} target The event target.
+   * @param {string} type The event type.
+   * @param {shaka.util.EventManager.ListenerType=} listener The event listener.
+   * @export
+   */
+  unlisten(target, type, listener) {
+    if (!this.bindingMap_) {
+      return;
+    }
 
-/**
- * Attaches an event listener to an event target.  The listener will be removed
- * when the first instance of the event is fired.
- * @param {EventTarget} target The event target.
- * @param {string} type The event type.
- * @param {shaka.util.EventManager.ListenerType} listener The event listener.
- */
-shaka.util.EventManager.prototype.listenOnce =
-    function(target, type, listener) {
-  // Install a shim listener that will stop listening after the first event.
-  const shim = (event) => {
-    // Stop listening to this event.
-    this.unlisten(target, type, shim);
-    // Call the original listener.
-    listener(event);
-  };
-  this.listen(target, type, shim);
-};
+    const list = this.bindingMap_.get(type) || [];
 
+    for (const binding of list) {
+      if (binding.target == target) {
+        if (listener == binding.listener || !listener) {
+          binding.unlisten();
+          this.bindingMap_.remove(type, binding);
+        }
+      }
+    }
+  }
 
-/**
- * Detaches an event listener from an event target.
- * @param {EventTarget} target The event target.
- * @param {string} type The event type.
- * @param {shaka.util.EventManager.ListenerType=} listener The event listener.
- */
-shaka.util.EventManager.prototype.unlisten = function(target, type, listener) {
-  if (!this.bindingMap_) return;
 
-  let list = this.bindingMap_.get(type) || [];
+  /**
+   * Detaches all event listeners from all targets.
+   * @export
+   */
+  removeAll() {
+    if (!this.bindingMap_) {
+      return;
+    }
 
-  for (let i = 0; i < list.length; ++i) {
-    let binding = list[i];
+    const list = this.bindingMap_.getAll();
 
-    if (binding.target == target) {
-      if (listener == binding.listener || !listener) {
-        binding.unlisten();
-        this.bindingMap_.remove(type, binding);
-      }
+    for (const binding of list) {
+      binding.unlisten();
     }
+
+    this.bindingMap_.clear();
   }
 };
 
 
 /**
- * Detaches all event listeners from all targets.
+ * @typedef {function(!Event)}
+ * @export
  */
-shaka.util.EventManager.prototype.removeAll = function() {
-  if (!this.bindingMap_) return;
-
-  let list = this.bindingMap_.getAll();
-
-  for (let i = 0; i < list.length; ++i) {
-    list[i].unlisten();
-  }
-
-  this.bindingMap_.clear();
-};
+shaka.util.EventManager.ListenerType;
 
 
 /**
  * Creates a new Binding_ and attaches the event listener to the event target.
- * @param {EventTarget} target The event target.
- * @param {string} type The event type.
- * @param {shaka.util.EventManager.ListenerType} listener The event listener.
- * @constructor
+ *
  * @private
  */
-shaka.util.EventManager.Binding_ = function(target, type, listener) {
-  /** @type {EventTarget} */
-  this.target = target;
+shaka.util.EventManager.Binding_ = class {
+  /**
+   * @param {EventTarget} target The event target.
+   * @param {string} type The event type.
+   * @param {shaka.util.EventManager.ListenerType} listener The event listener.
+   * @param {(boolean|!AddEventListenerOptions)=} options An object that
+   *    specifies characteristics about the event listener.
+   *    The passive option, if true, indicates that this function will never
+   *    call preventDefault(), which improves scrolling performance.
+   */
+  constructor(target, type, listener, options) {
+    /** @type {EventTarget} */
+    this.target = target;
 
-  /** @type {string} */
-  this.type = type;
+    /** @type {string} */
+    this.type = type;
 
-  /** @type {?shaka.util.EventManager.ListenerType} */
-  this.listener = listener;
+    /** @type {?shaka.util.EventManager.ListenerType} */
+    this.listener = listener;
 
-  this.target.addEventListener(type, listener, false);
-};
+    /** @type {(boolean|!AddEventListenerOptions)} */
+    this.options =
+        shaka.util.EventManager.Binding_.convertOptions_(target, options);
 
+    this.target.addEventListener(type, listener, this.options);
+  }
 
-/**
- * Detaches the event listener from the event target. This does nothing if the
- * event listener is already detached.
- */
-shaka.util.EventManager.Binding_.prototype.unlisten = function() {
-  goog.asserts.assert(this.target, 'Missing target');
-  this.target.removeEventListener(this.type, this.listener, false);
 
-  this.target = null;
-  this.listener = null;
+  /**
+   * Detaches the event listener from the event target. This does nothing if
+   * the event listener is already detached.
+   * @export
+   */
+  unlisten() {
+    goog.asserts.assert(this.target, 'Missing target');
+    this.target.removeEventListener(this.type, this.listener, this.options);
+
+    this.target = null;
+    this.listener = null;
+    this.options = false;
+  }
+
+  /**
+   * Converts the provided options value into a value accepted by the browser.
+   * Some browsers (e.g. IE11 and Tizen) don't support passing options as an
+   * object.  So this detects this case and converts it.
+   *
+   * @param {EventTarget} target
+   * @param {(boolean|!AddEventListenerOptions)=} value
+   * @return {(boolean|!AddEventListenerOptions)}
+   * @private
+   */
+  static convertOptions_(target, value) {
+    if (value == undefined) {
+      return false;
+    } else if (typeof value == 'boolean') {
+      return value;
+    } else {
+      // Ignore the 'passive' option since it is just an optimization and
+      // doesn't affect behavior.  Assert there aren't any other settings to
+      // ensure we don't have different behavior on different browsers by
+      // ignoring an important option.
+      const ignored = new Set(['passive', 'capture']);
+      const keys = Object.keys(value).filter((k) => !ignored.has(k));
+      goog.asserts.assert(
+          keys.length == 0,
+          'Unsupported flag(s) to addEventListener: ' + keys.join(','));
+
+      const supports =
+          shaka.util.EventManager.Binding_.doesSupportObject_(target);
+      if (supports) {
+        return value;
+      } else {
+        return value['capture'] || false;
+      }
+    }
+  }
+
+  /**
+   * Checks whether the browser supports passing objects as the third argument
+   * to addEventListener.  This caches the result value in a static field to
+   * avoid a bunch of checks.
+   *
+   * @param {EventTarget} target
+   * @return {boolean}
+   * @private
+   */
+  static doesSupportObject_(target) {
+    // https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Safely_detecting_option_support
+    let supports = shaka.util.EventManager.Binding_.supportsObject_;
+    if (supports == undefined) {
+      supports = false;
+      try {
+        const options = {};
+        // This defines a getter that will set this variable if called.  So if
+        // the browser gets this property, it supports using an object.  If the
+        // browser doesn't get these fields, it won't support objects.
+        const prop = {
+          get: () => {
+            supports = true;
+            return false;
+          },
+        };
+        Object.defineProperty(options, 'passive', prop);
+        Object.defineProperty(options, 'capture', prop);
+
+        const call = () => {};
+        target.addEventListener('test', call, options);
+        target.removeEventListener('test', call, options);
+      } catch (e) {
+        supports = false;
+      }
+      shaka.util.EventManager.Binding_.supportsObject_ = supports;
+    }
+    return supports || false;  // "false" fallback needed for compiler.
+  }
 };
 
+/** @private {(boolean|undefined)} */
+shaka.util.EventManager.Binding_.supportsObject_ = undefined;

package/lib/util/fairplay_utils.js

@@ -0,0 +1,122 @@
+/**
+ * @license
+ * Copyright 2016 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+goog.provide('shaka.util.FairPlayUtils');
+
+goog.require('goog.Uri');
+
+
+/**
+ * @summary A set of FairPlay utility functions.
+ * @exportInterface
+ */
+shaka.util.FairPlayUtils = class {
+  /**
+   * Using the default method, extract a content ID from the init data.  This is
+   * based on the FairPlay example documentation.
+   *
+   * @param {!BufferSource} initData
+   * @return {string}
+   * @export
+   */
+  static defaultGetContentId(initData) {
+    const uint8 = new Uint8Array(initData);
+    const dataview = new DataView(
+        uint8.buffer, uint8.byteOffset, uint8.byteLength);
+    // The first part is a 4 byte little-endian int, which is the length of
+    // the second part.
+    const length = dataview.getUint32(
+        /* position= */ 0, /* littleEndian= */ true);
+    if (length + 4 != uint8.byteLength) {
+      throw new RangeError('Malformed FairPlay init data');
+    }
+
+    // The second part is a UTF-16 LE URI from the manifest.
+    const uriString = shaka.util.StringUtils.fromUTF16(
+        uint8.subarray(4), /* littleEndian= */ true);
+
+    // The domain of that URI is the content ID according to Apple's FPS
+    // sample.
+    const uri = new goog.Uri(uriString);
+    return uri.getDomain();
+  }
+
+  /**
+   * Transforms the init data buffer using the given data.  The format is:
+   *
+   * <pre>
+   * [4 bytes] initDataSize
+   * [initDataSize bytes] initData
+   * [4 bytes] contentIdSize
+   * [contentIdSize bytes] contentId
+   * [4 bytes] certSize
+   * [certSize bytes] cert
+   * </pre>
+   *
+   * @param {!BufferSource} initData
+   * @param {!BufferSource|string} contentId
+   * @param {?BufferSource} cert  The server certificate; this will throw if not
+   *   provided.
+   * @return {!Uint8Array}
+   * @export
+   */
+  static initDataTransform(initData, contentId, cert) {
+    if (!cert || !cert.byteLength) {
+      throw new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.DRM,
+          shaka.util.Error.Code.SERVER_CERTIFICATE_REQUIRED);
+    }
+
+    // From that, we build a new init data to use in the session.  This is
+    // composed of several parts.  First, the raw init data we already got.
+    // Second, a 4-byte LE length followed by the content ID in UTF-16-LE.
+    // Third, a 4-byte LE length followed by the certificate.
+    /** @type {!Uint8Array} */
+    let contentIdArray;
+    if (typeof contentId == 'string') {
+      contentIdArray = new Uint8Array(
+          shaka.util.StringUtils.toUTF16(contentId, /* littleEndian= */ true));
+    } else {
+      contentIdArray = new Uint8Array(contentId);
+    }
+
+    const rebuiltInitData = new Uint8Array(
+        8 + initData.byteLength + contentIdArray.byteLength + cert.byteLength);
+
+    let offset = 0;
+    /** @param {!Uint8Array} array */
+    const append = (array) => {
+      rebuiltInitData.set(array, offset);
+      offset += array.byteLength;
+    };
+    /** @param {!Uint8Array} array */
+    const appendWithLength = (array) => {
+      const view = new DataView(rebuiltInitData.buffer);
+      const value = array.byteLength;
+      view.setUint32(offset, value, /* littleEndian= */ true);
+      offset += 4;
+      append(array);
+    };
+
+    append(new Uint8Array(initData));
+    appendWithLength(contentIdArray);
+    appendWithLength(new Uint8Array(cert));
+
+    return rebuiltInitData;
+  }
+};

package/lib/util/i_releasable.js

@@ -24,6 +24,7 @@ goog.provide('shaka.util.IReleasable');
  * it should use 'shaka.util.IDestroyable'.
  *
  * @interface
+ * @export
  */
 shaka.util.IReleasable = class {
   /**

package/lib/util/player_configuration.js

@@ -31,6 +31,7 @@ goog.require('shaka.util.ConfigUtils');
 
 /**
  * @final
+ * @export
  */
 shaka.util.PlayerConfiguration = class {
   /** @return {shaka.extern.PlayerConfiguration} */
@@ -82,6 +83,8 @@ shaka.util.PlayerConfiguration = class {
       clearKeys: {},  // key is arbitrary key system ID, value must be string
       advanced: {},    // key is arbitrary key system ID, value is a record type
       delayLicenseRequestUntilPlayed: false,
+      initDataTransform: (initData) => initData,
+      fairPlayTransform: true,
     };
 
     const manifest = {
@@ -101,6 +104,9 @@ shaka.util.PlayerConfiguration = class {
         ignoreMinBufferTime: false,
         autoCorrectDrift: true,
       },
+      hls: {
+        ignoreTextStreamFailures: false,
+      },
     };
 
     const streaming = {
@@ -223,6 +229,7 @@ shaka.util.PlayerConfiguration = class {
    * @param {!Object} updates
    * @param {shaka.extern.PlayerConfiguration=} template
    * @return {boolean}
+   * @export
    */
   static mergeConfigObjects(destination, updates, template) {
     const overrides = {

package/lib/util/pssh.js

@@ -104,3 +104,44 @@ shaka.util.Pssh.prototype.parseBox_ = function(box) {
     shaka.log.warning('Mismatch between box size and data size!');
   }
 };
+
+
+/**
+ * Creates a pssh blob from the given system ID and data.
+ *
+ * @param {!Uint8Array} data
+ * @param {!Uint8Array} systemId
+ * @return {!Uint8Array}
+ */
+shaka.util.Pssh.createPssh = function(data, systemId) {
+  const dataLength = data.length;
+  const psshSize = 0x4 + 0x4 + 0x4 + systemId.length + 0x4 + dataLength;
+
+  /** @type {!ArrayBuffer} */
+  const psshBoxBuffer = new ArrayBuffer(psshSize);
+
+  /** @type {!Uint8Array} */
+  const psshBox = new Uint8Array(psshBoxBuffer);
+
+  /** @type {!DataView} */
+  const psshData = new DataView(psshBoxBuffer);
+
+  let byteCursor = 0;
+  psshData.setUint32(byteCursor, psshSize);
+  byteCursor += 0x4;
+  psshData.setUint32(byteCursor, 0x70737368);  // 'pssh'
+  byteCursor += 0x4;
+  psshData.setUint32(byteCursor, 0);  // flags
+  byteCursor += 0x4;
+  psshBox.set(systemId, byteCursor);
+  byteCursor += systemId.length;
+  psshData.setUint32(byteCursor, dataLength);
+  byteCursor += 0x4;
+  psshBox.set(data, byteCursor);
+  byteCursor += dataLength;
+
+  goog.asserts.assert(byteCursor === psshSize,
+      'MS PRO invalid length.');
+
+  return psshBox;
+};