shaka-player 4.4.3 → 4.5.0

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}

package/lib/dash/dash_parser.js

@@ -224,12 +224,10 @@ shaka.dash.DashParser = class {
     const type = shaka.net.NetworkingEngine.AdvancedRequestType.MPD;
     const request = shaka.net.NetworkingEngine.makeRequest(
         this.manifestUris_, this.config_.retryParameters);
-    const networkingEngine = this.playerInterface_.networkingEngine;
     const startTime = Date.now();
-    const operation = networkingEngine.request(requestType, request, {type});
-    this.operationManager_.manage(operation);
 
-    const response = await operation.promise;
+    const response = await this.makeNetworkRequest_(
+        request, requestType, {type});
 
     // Detect calls to stop().
     if (!this.playerInterface_) {
@@ -1169,6 +1167,9 @@ shaka.dash.DashParser = class {
       }
     }
 
+    const adaptationId = context.adaptationSet.id ||
+        ('__fake__' + this.globalId_++);
+
     for (const stream of streams) {
       // Some DRM license providers require that we have a default
       // key ID from the manifest in the wrapped license request.
@@ -1178,6 +1179,9 @@ shaka.dash.DashParser = class {
             new Set([...drmInfo.keyIds, ...stream.keyIds]) :
             drmInfo.keyIds || stream.keyIds;
       }
+      if (this.config_.dash.enableAudioGroups) {
+        stream.groupId = adaptationId;
+      }
     }
 
     const repIds = representations
@@ -1185,7 +1189,7 @@ shaka.dash.DashParser = class {
         .filter(shaka.util.Functional.isNotNull);
 
     return {
-      id: context.adaptationSet.id || ('__fake__' + this.globalId_++),
+      id: adaptationId,
       contentType: context.adaptationSet.contentType,
       language: language,
       main: main,
@@ -1250,21 +1254,61 @@ shaka.dash.DashParser = class {
     const isImage = contentType == ContentType.IMAGE;
 
     try {
+      /** @type {shaka.extern.aes128Key|undefined} */
+      let aes128Key = undefined;
+      if (contentProtection.aes128Info) {
+        const baseUris = context.representation.baseUris;
+        const uris = shaka.util.ManifestParserUtils.resolveUris(
+            baseUris, [contentProtection.aes128Info.keyUri]);
+        const requestType = shaka.net.NetworkingEngine.RequestType.KEY;
+        const request = shaka.net.NetworkingEngine.makeRequest(
+            uris, this.config_.retryParameters);
+
+        aes128Key = {
+          method: 'AES-128',
+          iv: contentProtection.aes128Info.iv,
+          firstMediaSequenceNumber: 0,
+        };
+
+        // Don't download the key object until the segment is parsed, to
+        // avoid a startup delay for long manifests with lots of keys.
+        aes128Key.fetchKey = async () => {
+          const keyResponse =
+              await this.makeNetworkRequest_(request, requestType);
+
+          // keyResponse.status is undefined when URI is
+          // "data:text/plain;base64,"
+          if (!keyResponse.data || keyResponse.data.byteLength != 16) {
+            throw new shaka.util.Error(
+                shaka.util.Error.Severity.CRITICAL,
+                shaka.util.Error.Category.MANIFEST,
+                shaka.util.Error.Code.AES_128_INVALID_KEY_LENGTH);
+          }
+
+          const algorithm = {
+            name: 'AES-CBC',
+          };
+          aes128Key.cryptoKey = await window.crypto.subtle.importKey(
+              'raw', keyResponse.data, algorithm, true, ['decrypt']);
+          aes128Key.fetchKey = undefined; // No longer needed.
+        };
+      }
       const requestSegment = (uris, startByte, endByte, isInit) => {
         return this.requestSegment_(uris, startByte, endByte, isInit);
       };
       if (context.representation.segmentBase) {
         streamInfo = shaka.dash.SegmentBase.createStreamInfo(
-            context, requestSegment);
+            context, requestSegment, aes128Key);
       } else if (context.representation.segmentList) {
         streamInfo = shaka.dash.SegmentList.createStreamInfo(
-            context, this.streamMap_);
+            context, this.streamMap_, aes128Key);
       } else if (context.representation.segmentTemplate) {
         const hasManifest = !!this.manifest_;
 
         streamInfo = shaka.dash.SegmentTemplate.createStreamInfo(
             context, requestSegment, this.streamMap_, hasManifest,
-            this.config_.dash.initialSegmentLimit, this.periodDurations_);
+            this.config_.dash.initialSegmentLimit, this.periodDurations_,
+            aes128Key);
       } else {
         goog.asserts.assert(isText,
             'Must have Segment* with non-text streams.');
@@ -1363,6 +1407,7 @@ shaka.dash.DashParser = class {
       stream = {
         id: this.globalId_++,
         originalId: context.representation.id,
+        groupId: null,
         createSegmentIndex: () => Promise.resolve(),
         closeSegmentIndex: () => {
           if (stream.segmentIndex) {
@@ -1456,6 +1501,8 @@ shaka.dash.DashParser = class {
       return;
     }
 
+    this.playerInterface_.onManifestUpdated();
+
     this.setUpdateTimer_(updateDelay);
   }
 
@@ -1929,10 +1976,8 @@ shaka.dash.DashParser = class {
         endByte,
         this.config_.retryParameters);
 
-    const networkingEngine = this.playerInterface_.networkingEngine;
-    const operation = networkingEngine.request(requestType, request, {type});
-    this.operationManager_.manage(operation);
-    const response = await operation.promise;
+    const response = await this.makeNetworkRequest_(
+        request, requestType, {type});
     return response.data;
   }
 
@@ -1958,6 +2003,24 @@ shaka.dash.DashParser = class {
     // types well.
     return mimeType.split('/')[0];
   }
+
+
+  /**
+   * Create a networking request. This will manage the request using the
+   * parser's operation manager.
+   *
+   * @param {shaka.extern.Request} request
+   * @param {shaka.net.NetworkingEngine.RequestType} type
+   * @param {shaka.extern.RequestContext=} context
+   * @return {!Promise.<shaka.extern.Response>}
+   * @private
+   */
+  makeNetworkRequest_(request, type, context) {
+    const op = this.playerInterface_.networkingEngine.request(
+        type, request, context);
+    this.operationManager_.manage(op);
+    return op.promise;
+  }
 };
 
 

package/lib/dash/mpd_utils.js

@@ -30,7 +30,7 @@ shaka.dash.MpdUtils = class {
    * @param {?string} representationId
    * @param {?number} number
    * @param {?number} bandwidth
-   * @param {?number} time
+   * @param {?(number|bigint)} time
    * @return {string} A URI string.
    * @see ISO/IEC 23009-1:2014 section 5.3.9.4.4
    */
@@ -71,11 +71,15 @@ shaka.dash.MpdUtils = class {
       }
 
       if (name == 'Time') {
-        goog.asserts.assert(typeof value == 'number',
-            'Time value should be a number!');
-        goog.asserts.assert(Math.abs(value - Math.round(value)) < 0.2,
-            'Calculated $Time$ values must be close to integers');
-        value = Math.round(value);
+        if (typeof value != 'bigint') {
+          goog.asserts.assert(typeof value == 'number',
+              'Time value should be a number or bigint!');
+          if (Math.abs(value - Math.round(value)) >= 0.2) {
+            shaka.log.alwaysWarn(
+                'Calculated $Time$ values must be close to integers');
+          }
+          value = Math.round(value);
+        }
       }
 
       /** @type {string} */

package/lib/dash/segment_base.js

@@ -31,9 +31,10 @@ shaka.dash.SegmentBase = class {
    *
    * @param {shaka.dash.DashParser.Context} context
    * @param {function(?shaka.dash.DashParser.InheritanceFrame):Element} callback
+   * @param {shaka.extern.aes128Key|undefined} aes128Key
    * @return {shaka.media.InitSegmentReference}
    */
-  static createInitSegment(context, callback) {
+  static createInitSegment(context, callback, aes128Key) {
     const MpdUtils = shaka.dash.MpdUtils;
     const XmlUtils = shaka.util.XmlUtils;
     const ManifestParserUtils = shaka.util.ManifestParserUtils;
@@ -63,7 +64,13 @@ shaka.dash.SegmentBase = class {
     const getUris = () => resolvedUris;
     const qualityInfo = shaka.dash.SegmentBase.createQualityInfo(context);
     return new shaka.media.InitSegmentReference(
-        getUris, startByte, endByte, qualityInfo);
+        getUris,
+        startByte,
+        endByte,
+        qualityInfo,
+        /* timescale= */ null,
+        /* segmentData= */ null,
+        aes128Key);
   }
 
   /**
@@ -71,9 +78,10 @@ shaka.dash.SegmentBase = class {
    *
    * @param {shaka.dash.DashParser.Context} context
    * @param {shaka.dash.DashParser.RequestSegmentCallback} requestSegment
+   * @param {shaka.extern.aes128Key|undefined} aes128Key
    * @return {shaka.dash.DashParser.StreamInfo}
    */
-  static createStreamInfo(context, requestSegment) {
+  static createStreamInfo(context, requestSegment, aes128Key) {
     goog.asserts.assert(context.representation.segmentBase,
         'Should only be called with SegmentBase');
     // Since SegmentBase does not need updates, simply treat any call as
@@ -95,8 +103,8 @@ shaka.dash.SegmentBase = class {
     const scaledPresentationTimeOffset =
         (unscaledPresentationTimeOffset / timescale) || 0;
 
-    const initSegmentReference =
-        SegmentBase.createInitSegment(context, SegmentBase.fromInheritance_);
+    const initSegmentReference = SegmentBase.createInitSegment(
+        context, SegmentBase.fromInheritance_, aes128Key);
 
     // Throws an immediate error if the format is unsupported.
     SegmentBase.checkSegmentIndexRangeSupport_(context, initSegmentReference);

package/lib/dash/segment_list.js

@@ -31,15 +31,16 @@ shaka.dash.SegmentList = class {
    *
    * @param {shaka.dash.DashParser.Context} context
    * @param {!Object.<string, !shaka.extern.Stream>} streamMap
+   * @param {shaka.extern.aes128Key|undefined} aes128Key
    * @return {shaka.dash.DashParser.StreamInfo}
    */
-  static createStreamInfo(context, streamMap) {
+  static createStreamInfo(context, streamMap, aes128Key) {
     goog.asserts.assert(context.representation.segmentList,
         'Should only be called with SegmentList');
     const SegmentList = shaka.dash.SegmentList;
 
     const initSegmentReference = shaka.dash.SegmentBase.createInitSegment(
-        context, SegmentList.fromInheritance_);
+        context, SegmentList.fromInheritance_, aes128Key);
     const info = SegmentList.parseSegmentListInfo_(context);
 
     SegmentList.checkSegmentListInfo_(context, info);
@@ -59,7 +60,7 @@ shaka.dash.SegmentList = class {
     const references = SegmentList.createSegmentReferences_(
         context.periodInfo.start, context.periodInfo.duration,
         info.startNumber, context.representation.baseUris, info,
-        initSegmentReference);
+        initSegmentReference, aes128Key);
 
     const isNew = !segmentIndex;
     if (segmentIndex) {
@@ -197,12 +198,13 @@ shaka.dash.SegmentList = class {
    * @param {!Array.<string>} baseUris
    * @param {shaka.dash.SegmentList.SegmentListInfo} info
    * @param {shaka.media.InitSegmentReference} initSegmentReference
+   * @param {shaka.extern.aes128Key|undefined} aes128Key
    * @return {!Array.<!shaka.media.SegmentReference>}
    * @private
    */
   static createSegmentReferences_(
       periodStart, periodDuration, startNumber, baseUris, info,
-      initSegmentReference) {
+      initSegmentReference, aes128Key) {
     const ManifestParserUtils = shaka.util.ManifestParserUtils;
 
     let max = info.mediaSegments.length;
@@ -257,7 +259,13 @@ shaka.dash.SegmentList = class {
               segment.end,
               initSegmentReference,
               timestampOffset,
-              appendWindowStart, appendWindowEnd));
+              appendWindowStart, appendWindowEnd,
+              /* partialReferences= */ [],
+              /* tilesLayout= */ '',
+              /* tileDuration= */ null,
+              /* syncTime= */ null,
+              shaka.media.SegmentReference.Status.AVAILABLE,
+              aes128Key));
       prevEndTime = endTime;
     }