shaka-player 4.4.3 → 4.6.0

package/lib/cast/cast_receiver.js

@@ -408,7 +408,7 @@ shaka.cast.CastReceiver = class extends shaka.util.FakeEventTarget {
       } catch (error) {
         // Pass any errors through to the app.
         goog.asserts.assert(error instanceof shaka.util.Error,
-            'Wrong error type!');
+            'Wrong error type! Error: ' + error);
         const eventType = shaka.util.FakeEvent.EventName.Error;
         const data = (new Map()).set('detail', error);
         const event = new shaka.util.FakeEvent(eventType, data);

package/lib/cea/cea_decoder.js

@@ -83,6 +83,12 @@ shaka.cea.CeaDecoder = class {
      */
     this.waitingForFirstPacket_ = true;
 
+    /**
+     * Set used to track available streams.
+     * @private {!Set.<string>}
+     */
+    this.streams_ = new Set();
+
     this.reset();
   }
 
@@ -131,6 +137,9 @@ shaka.cea.CeaDecoder = class {
     const reader = new shaka.util.DataViewReader(
         userDataSeiMessage, shaka.util.DataViewReader.Endianness.BIG_ENDIAN);
 
+    if (reader.getLength() < shaka.cea.CeaDecoder.MIN_LENGTH) {
+      return;
+    }
     if (reader.readUint8() !== shaka.cea.CeaDecoder.USA_COUNTRY_CODE) {
       return;
     }
@@ -300,6 +309,8 @@ shaka.cea.CeaDecoder = class {
       return null;
     }
 
+    this.streams_.add(selectedMode);
+
     // Process the clean CC data pair.
     let parsedClosedCaption = null;
     if (shaka.cea.Cea608DataChannel.isControlCode(ccPacket.ccData1)) {
@@ -340,6 +351,7 @@ shaka.cea.CeaDecoder = class {
 
         // As per CEA-708-E, service number 0 is invalid, and should be ignored.
         if (serviceNumber != 0) {
+          this.streams_.add('svc'+ serviceNumber);
           // If the service doesn't already exist, create it.
           if (!this.serviceNumberToService_.has(serviceNumber)) {
             const service = new shaka.cea.Cea708Service(serviceNumber);
@@ -386,6 +398,15 @@ shaka.cea.CeaDecoder = class {
     }
     return parity === 1;
   }
+
+  /**
+   * Returns the streams that the CEA decoder found.
+   *
+   * @override
+   */
+  getStreams() {
+    return Array.from(this.streams_);
+  }
 };
 
 /**
@@ -417,5 +438,12 @@ shaka.cea.CeaDecoder.NTSC_CC_FIELD_2 = 1;
  */
 shaka.cea.CeaDecoder.USA_COUNTRY_CODE = 0xb5;
 
+/**
+ * Caption packet min length
+ * Country Code + ATSC_PROVIDER_CODE + ATSC_1_USER_IDENTIFIER + USER_DATA_TYPE
+ * @private @const {number}
+ */
+shaka.cea.CeaDecoder.MIN_LENGTH = 8;
+
 shaka.media.ClosedCaptionParser.registerDecoder(
     () => new shaka.cea.CeaDecoder());

package/lib/cea/dummy_caption_decoder.js

@@ -18,4 +18,9 @@ shaka.cea.DummyCaptionDecoder = class {
 
   /** @override */
   clear() {}
+
+  /** @override */
+  getStreams() {
+    return [];
+  }
 };

package/lib/cea/ts_cea_parser.js

@@ -49,10 +49,23 @@ shaka.cea.TsCeaParser = class {
       return captionPackets;
     }
     const tsParser = new shaka.util.TsParser().parse(uint8ArrayData);
+    const codecs = tsParser.getCodecs();
     const videoNalus = tsParser.getVideoNalus();
+    const validNaluTypes = [];
+    switch (codecs.video) {
+      case 'avc':
+        validNaluTypes.push(CeaUtils.H264_NALU_TYPE_SEI);
+        break;
+      case 'hvc':
+        validNaluTypes.push(CeaUtils.H265_PREFIX_NALU_TYPE_SEI);
+        validNaluTypes.push(CeaUtils.H265_SUFFIX_NALU_TYPE_SEI);
+        break;
+    }
+    if (!validNaluTypes.length) {
+      return captionPackets;
+    }
     for (const nalu of videoNalus) {
-      if (nalu.type == CeaUtils.H264_NALU_TYPE_SEI &&
-          nalu.time != null) {
+      if (validNaluTypes.includes(nalu.type) && nalu.time != null) {
         for (const packet of this.seiProcessor_.process(nalu.data)) {
           captionPackets.push({
             packet: packet,

package/lib/config/codec_switching_strategy.js

@@ -0,0 +1,24 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.config.CodecSwitchingStrategy');
+
+/**
+ * @enum {string}
+ * @export
+ */
+shaka.config.CodecSwitchingStrategy = {
+  // Allow codec switching which will always involve reloading the
+  // `MediaSource`.
+  RELOAD: 'reload',
+  // Allow codec switching; determine if `SourceBuffer.changeType` is available
+  // and attempt to use this first, but fall back to reloading `MediaSource` if
+  // not available.
+  //
+  // Note: Some devices that support `SourceBuffer.changeType` can become stuck
+  // in a pause state.
+  SMOOTH: 'smooth',
+};

package/lib/dash/content_protection.js

@@ -39,6 +39,8 @@ shaka.dash.ContentProtection = class {
     /** @type {!Array.<shaka.extern.DrmInfo>} */
     let drmInfos = [];
     let parsedNonCenc = [];
+    /** @type {?shaka.dash.ContentProtection.Aes128Info} */
+    let aes128Info = null;
 
     // Get the default key ID; if there are multiple, they must all match.
     const keyIds = new Set(parsed.map((element) => element.keyId));
@@ -53,6 +55,21 @@ shaka.dash.ContentProtection = class {
     }
 
     if (!ignoreDrmInfo) {
+      const aes128Elements = parsed.filter((elem) => {
+        return elem.schemeUri == ContentProtection.Aes128Protection_;
+      });
+
+      if (aes128Elements.length > 1) {
+        throw new shaka.util.Error(
+            shaka.util.Error.Severity.CRITICAL,
+            shaka.util.Error.Category.MANIFEST,
+            shaka.util.Error.Code.DASH_CONFLICTING_AES_128);
+      }
+
+      if (aes128Elements.length) {
+        aes128Info = ContentProtection.parseAes128_(aes128Elements[0]);
+      }
+
       // Find the default key ID and init data.  Create a new array of all the
       // non-CENC elements.
       parsedNonCenc = parsed.filter((elem) => {
@@ -62,7 +79,7 @@ shaka.dash.ContentProtection = class {
           defaultInit = elem.init || defaultInit;
           return false;
         } else {
-          return true;
+          return elem.schemeUri != ContentProtection.Aes128Protection_;
         }
       });
 
@@ -80,7 +97,8 @@ shaka.dash.ContentProtection = class {
 
     // If there are only CENC element(s) or ignoreDrmInfo flag is set, assume
     // all key-systems are supported.
-    if (parsed.length && (ignoreDrmInfo || !parsedNonCenc.length)) {
+    if (parsed.length && !aes128Info &&
+        (ignoreDrmInfo || !parsedNonCenc.length)) {
       drmInfos = [];
 
       for (const keySystem of Object.values(keySystemsByURI)) {
@@ -110,6 +128,7 @@ shaka.dash.ContentProtection = class {
       defaultKeyId: defaultKeyId,
       defaultInit: defaultInit,
       drmInfos: drmInfos,
+      aes128Info: aes128Info,
       firstRepresentation: true,
     };
   }
@@ -551,6 +570,79 @@ shaka.dash.ContentProtection = class {
       init: (init.length > 0 ? init : null),
     };
   }
+
+  /**
+   * Parses the given AES-128 ContentProtection element.
+   *
+   * @param {shaka.dash.ContentProtection.Element} element
+   * @return {?shaka.dash.ContentProtection.Aes128Info}
+   * @private
+   */
+  static parseAes128_(element) {
+    // Check if the Web Crypto API is available.
+    if (!window.crypto || !window.crypto.subtle) {
+      shaka.log.alwaysWarn('Web Crypto API is not available to decrypt ' +
+          'AES-128. (Web Crypto only exists in secure origins like https)');
+      throw new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.MANIFEST,
+          shaka.util.Error.Code.NO_WEB_CRYPTO_API);
+    }
+
+    const namespace = 'urn:mpeg:dash:schema:sea:2012';
+    const segmentEncryption = shaka.util.XmlUtils.findChildNS(
+        element.node, namespace, 'SegmentEncryption');
+
+    if (!segmentEncryption) {
+      throw new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.MANIFEST,
+          shaka.util.Error.Code.DASH_UNSUPPORTED_AES_128);
+    }
+
+    const aesSchemeIdUri = 'urn:mpeg:dash:sea:aes128-cbc:2013';
+    const segmentEncryptionSchemeIdUri =
+        segmentEncryption.getAttribute('schemeIdUri');
+    if (segmentEncryptionSchemeIdUri != aesSchemeIdUri) {
+      throw new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.MANIFEST,
+          shaka.util.Error.Code.DASH_UNSUPPORTED_AES_128);
+    }
+
+    const cryptoPeriod = shaka.util.XmlUtils.findChildNS(
+        element.node, namespace, 'CryptoPeriod');
+
+    if (!cryptoPeriod) {
+      throw new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.MANIFEST,
+          shaka.util.Error.Code.DASH_UNSUPPORTED_AES_128);
+    }
+
+    const ivHex = cryptoPeriod.getAttribute('IV');
+    const keyUri = cryptoPeriod.getAttribute('keyUriTemplate');
+    if (!ivHex || !keyUri) {
+      throw new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.MANIFEST,
+          shaka.util.Error.Code.DASH_UNSUPPORTED_AES_128);
+    }
+
+    // Exclude 0x at the start of string.
+    const iv = shaka.util.Uint8ArrayUtils.fromHex(ivHex.substr(2));
+    if (iv.byteLength != 16) {
+      throw new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.MANIFEST,
+          shaka.util.Error.Code.AES_128_INVALID_IV_LENGTH);
+    }
+
+    return {
+      keyUri,
+      iv,
+    };
+  }
 };
 
 /**
@@ -584,6 +676,7 @@ shaka.dash.ContentProtection.PLAYREADY_RECORD_TYPES = {
  *   defaultKeyId: ?string,
  *   defaultInit: Array.<shaka.extern.InitDataOverride>,
  *   drmInfos: !Array.<shaka.extern.DrmInfo>,
+ *   aes128Info: ?shaka.dash.ContentProtection.Aes128Info,
  *   firstRepresentation: boolean
  * }}
  *
@@ -599,6 +692,8 @@ shaka.dash.ContentProtection.PLAYREADY_RECORD_TYPES = {
  *   is no default.
  * @property {!Array.<shaka.extern.DrmInfo>} drmInfos
  *   The DrmInfo objects.
+ * @property {?shaka.dash.ContentProtection.Aes128Info} aes128Info
+ *   The AES-128 key info.
  * @property {boolean} firstRepresentation
  *   True when first parsed; changed to false after the first call to
  *   parseKeyIds.  This is used to determine if a dummy key-system should be
@@ -607,6 +702,22 @@ shaka.dash.ContentProtection.PLAYREADY_RECORD_TYPES = {
  */
 shaka.dash.ContentProtection.Context;
 
+/**
+ * @typedef {{
+ *   keyUri: string,
+ *   iv: !Uint8Array
+ * }}
+ *
+ * @description
+ * Contains information about the AES-128 keyUri and IV found at the
+ * AdaptationSet level.
+ *
+ * @property {string} method
+ *   The keyUri in the manifest.
+ * @property {!Uint8Array} iv
+ *   The IV in the manifest.
+ */
+shaka.dash.ContentProtection.Aes128Info;
 
 /**
  * @typedef {{
@@ -658,6 +769,13 @@ shaka.dash.ContentProtection.licenseUrlParsers_ = new Map()
 shaka.dash.ContentProtection.MP4Protection_ =
     'urn:mpeg:dash:mp4protection:2011';
 
+/**
+ * @const {string}
+ * @private
+ */
+shaka.dash.ContentProtection.Aes128Protection_ =
+    'urn:mpeg:dash:sea:2012';
+
 
 /**
  * @const {string}