shaka-player 3.1.3 → 3.2.2

package/lib/util/fake_event.js

@@ -6,6 +6,8 @@
 
 goog.provide('shaka.util.FakeEvent');
 
+goog.require('goog.asserts');
+
 
 /**
  * @summary Create an Event work-alike object based on the provided dictionary.
@@ -16,18 +18,62 @@ goog.provide('shaka.util.FakeEvent');
  */
 shaka.util.FakeEvent = class {
   /**
-   * @param {string} type
-   * @param {Object=} dict
+   * @param {!Event} event
+   * @return {!shaka.util.FakeEvent}
    */
-  constructor(type, dict = {}) {
-    // Take properties from dict if present.
-    for (const key in dict) {
-      Object.defineProperty(this, key, {
-        value: dict[key],
+  static fromRealEvent(event) {
+    const fakeEvent = new shaka.util.FakeEvent(event.type);
+    for (const key in event) {
+      Object.defineProperty(fakeEvent, key, {
+        value: event[key],
         writable: true,
         enumerable: true,
       });
     }
+    return fakeEvent;
+  }
+
+  /**
+   * Allows us to tell the compiler that the dictionary "map" is actually a
+   * generic object, for backwards compatibility.
+   * @param {!Map.<string, Object>} dict
+   * @return {!Object}
+   * @suppress {invalidCasts}
+   * @private
+   */
+  static recastDictAsObject_(dict) {
+    goog.asserts.assert(!(dict instanceof Map), 'dict should not be a map');
+    return /** @type {!Object} */ (dict);
+  }
+
+  /**
+   * @param {string} type
+   * @param {Map.<string, Object>=} dict
+   */
+  constructor(type, dict) {
+    if (dict) {
+      if (dict instanceof Map) {
+        // Take properties from dict if present.
+        for (const key of dict.keys()) {
+          Object.defineProperty(this, key, {
+            value: dict.get(key),
+            writable: true,
+            enumerable: true,
+          });
+        }
+      } else {
+        // For backwards compatibility with external apps that may make use of
+        // this public constructor, this should still accept generic objects.
+        const obj = shaka.util.FakeEvent.recastDictAsObject_(dict);
+        for (const key in obj) {
+          Object.defineProperty(this, key, {
+            value: obj[key],
+            writable: true,
+            enumerable: true,
+          });
+        }
+      }
+    }
 
     // The properties below cannot be set by the dict.  They are all provided
     // for compatibility with native events.

package/lib/util/manifest_parser_utils.js

@@ -55,6 +55,7 @@ shaka.util.ManifestParserUtils = class {
       audioRobustness: '',
       videoRobustness: '',
       serverCertificate: null,
+      serverCertificateUri: '',
       sessionType: '',
       initData: initData || [],
       keyIds: new Set(),

package/lib/util/mp4_box_parsers.js

@@ -14,7 +14,7 @@ shaka.util.Mp4BoxParsers = class {
   /**
    * Parses a TFHD Box.
    * @param {!shaka.util.DataViewReader} reader
-   * @param {!number} flags
+   * @param {number} flags
    * @return {!shaka.util.ParsedTFHDBox}
    */
   static parseTFHD(reader, flags) {
@@ -53,7 +53,7 @@ shaka.util.Mp4BoxParsers = class {
   /**
    * Parses a TFDT Box.
    * @param {!shaka.util.DataViewReader} reader
-   * @param {!number} version
+   * @param {number} version
    * @return {!shaka.util.ParsedTFDTBox}
    */
   static parseTFDT(reader, version) {
@@ -68,7 +68,7 @@ shaka.util.Mp4BoxParsers = class {
   /**
    * Parses a MDHD Box.
    * @param {!shaka.util.DataViewReader} reader
-   * @param {!number} version
+   * @param {number} version
    * @return {!shaka.util.ParsedMDHDBox}
    */
   static parseMDHD(reader, version) {
@@ -107,8 +107,8 @@ shaka.util.Mp4BoxParsers = class {
   /**
    * Parses a TRUN Box.
    * @param {!shaka.util.DataViewReader} reader
-   * @param {!number} version
-   * @param {!number} flags
+   * @param {number} version
+   * @param {number} flags
    * @return {!shaka.util.ParsedTRUNBox}
    */
   static parseTRUN(reader, version, flags) {
@@ -168,7 +168,7 @@ shaka.util.Mp4BoxParsers = class {
   /**
    * Parses a TKHD Box.
    * @param {!shaka.util.DataViewReader} reader
-   * @param {!number} version
+   * @param {number} version
    * @return {!shaka.util.ParsedTKHDBox}
    */
   static parseTKHD(reader, version) {
@@ -192,12 +192,12 @@ shaka.util.Mp4BoxParsers = class {
 
 /**
  * @typedef {{
- *    trackId: !number,
+ *    trackId: number,
  *    defaultSampleDuration: ?number,
  *    defaultSampleSize: ?number
  * }}
  *
- * @property {!number} trackId
+ * @property {number} trackId
  *   As per the spec: an integer that uniquely identifies this
  *   track over the entire life‐time of this presentation
  * @property {?number} defaultSampleDuration
@@ -213,10 +213,10 @@ shaka.util.ParsedTFHDBox;
 
 /**
  * @typedef {{
- *    baseMediaDecodeTime: !number
+ *    baseMediaDecodeTime: number
  * }}
  *
- * @property {!number} baseMediaDecodeTime
+ * @property {number} baseMediaDecodeTime
  *   As per the spec: the absolute decode time, measured on the media
  *   timeline, of the first sample in decode order in the track fragment
  *
@@ -226,10 +226,10 @@ shaka.util.ParsedTFDTBox;
 
 /**
  * @typedef {{
- *    timescale: !number
+ *    timescale: number
  * }}
  *
- * @property {!number} timescale
+ * @property {number} timescale
  *   As per the spec: an integer that specifies the time‐scale for this media;
  *   this is the number of time units that pass in one second
  *
@@ -239,13 +239,13 @@ shaka.util.ParsedMDHDBox;
 
 /**
  * @typedef {{
- *    defaultSampleDuration: !number,
- *    defaultSampleSize: !number
+ *    defaultSampleDuration: number,
+ *    defaultSampleSize: number
  * }}
  *
- * @property {!number} defaultSampleDuration
+ * @property {number} defaultSampleDuration
  *   The default sample duration to be used in track fragments
- * @property {!number} defaultSampleSize
+ * @property {number} defaultSampleSize
  *   The default sample size to be used in track fragments
  *
  * @exportDoc
@@ -254,11 +254,11 @@ shaka.util.ParsedTREXBox;
 
 /**
  * @typedef {{
- *    sampleCount: !number,
+ *    sampleCount: number,
  *    sampleData: !Array.<shaka.util.ParsedTRUNSample>
  * }}
  *
- * @property {!number} sampleCount
+ * @property {number} sampleCount
  *   As per the spec: the number of samples being added in this run;
  * @property {!Array.<shaka.util.ParsedTRUNSample>} sampleData
  *   An array of size <sampleCount> containing data for each sample
@@ -290,10 +290,10 @@ shaka.util.ParsedTRUNSample;
 
 /**
  * @typedef {{
- *    trackId: !number
+ *    trackId: number
  *  }}
  *
- * @property {!number} trackId
+ * @property {number} trackId
  *   Unique ID indicative of this track
  *
  * @exportDoc

package/lib/util/multi_map.js

@@ -102,4 +102,12 @@ shaka.util.MultiMap = class {
   size() {
     return Object.keys(this.map_).length;
   }
+
+  /**
+   * Get a list of all the keys.
+   * @return {!Array.<string>}
+   */
+  keys() {
+    return Object.keys(this.map_);
+  }
 };

package/lib/util/periods.js

@@ -80,7 +80,10 @@ shaka.util.PeriodCombiner = class {
 
   /** @return {!Array.<shaka.extern.Stream>} */
   getTextStreams() {
-    return this.textStreams_;
+    // Return a copy of the array because makeTextStreamsForClosedCaptions
+    // may make changes to the contents of the array. Those changes should not
+    // propagate back to the PeriodCombiner.
+    return this.textStreams_.slice();
   }
 
   /** @return {!Array.<shaka.extern.Stream>} */

package/lib/util/platform.js

@@ -163,7 +163,6 @@ shaka.util.Platform = class {
            !shaka.util.Platform.isEdge();
   }
 
-
   /**
    * Check if the current platform is from Apple.
    *
@@ -179,6 +178,19 @@ shaka.util.Platform = class {
             && !shaka.util.Platform.isTizen();
   }
 
+  /**
+   * Check if the current platform is Playstation 5.
+   *
+   * Returns true on Playstation 5 browsers.
+   *
+   * Returns false for Playstation 5 browsers
+   *
+   * @return {boolean}
+   */
+  static isPS5() {
+    return shaka.util.Platform.userAgentContains_('PlayStation 5');
+  }
+
   /**
    * Returns a major version number for Safari, or Safari-based iOS browsers.
    *

package/lib/util/player_configuration.js

@@ -75,6 +75,7 @@ shaka.util.PlayerConfiguration = class {
       initDataTransform: shaka.media.DrmEngine.defaultInitDataTransform,
       logLicenseExchange: false,
       updateExpirationTime: 1,
+      preferredKeySystems: [],
     };
 
     const manifest = {
@@ -108,9 +109,16 @@ shaka.util.PlayerConfiguration = class {
           'urn:uuid:f239e769-efa3-4850-9c16-a903c6932efb':
             'com.adobe.primetime',
         },
+        // Need some operation in the callback or else closure may remove calls
+        // to the function as it would be a no-op.  The operation can't just be
+        // a log message, because those are stripped in the compiled build.
+        manifestPreprocessor: (element) => {
+          return element;
+        },
       },
       hls: {
         ignoreTextStreamFailures: false,
+        ignoreImageStreamFailures: false,
         useFullSegmentsForStartTime: false,
       },
     };
@@ -154,6 +162,7 @@ shaka.util.PlayerConfiguration = class {
       autoLowLatencyMode: false,
       forceHTTPS: false,
       preferNativeHls: false,
+      updateIntervalSeconds: 1,
     };
 
     // Some browsers will stop earlier than others before a gap (e.g., Edge
@@ -241,7 +250,10 @@ shaka.util.PlayerConfiguration = class {
       preferredVariantRole: '',
       preferredTextRole: '',
       preferredAudioChannelCount: 2,
+      preferredVideoCodecs: [],
+      preferredAudioCodecs: [],
       preferForcedSubs: false,
+      preferredDecodingAttributes: [],
       restrictions: {
         minWidth: 0,
         maxWidth: Infinity,
@@ -256,7 +268,6 @@ shaka.util.PlayerConfiguration = class {
       },
       playRangeStart: 0,
       playRangeEnd: Infinity,
-      useMediaCapabilities: false,
       textDisplayFactory: () => null,
     };
 
@@ -293,6 +304,7 @@ shaka.util.PlayerConfiguration = class {
         audioRobustness: '',
         sessionType: '',
         serverCertificate: new Uint8Array(0),
+        serverCertificateUri: '',
         individualizationServer: '',
       },
     };

package/lib/util/stream_utils.js

@@ -8,7 +8,6 @@ goog.provide('shaka.util.StreamUtils');
 
 goog.require('goog.asserts');
 goog.require('shaka.log');
-goog.require('shaka.media.MediaSourceEngine');
 goog.require('shaka.text.TextEngine');
 goog.require('shaka.util.Functional');
 goog.require('shaka.util.LanguageUtils');
@@ -28,30 +27,43 @@ shaka.util.StreamUtils = class {
    * bandwidth and filter out the rest.
    * Also filters out variants that have too many audio channels.
    * @param {!shaka.extern.Manifest} manifest
+   * @param {!Array.<string>} preferredVideoCodecs
+   * @param {!Array.<string>} preferredAudioCodecs
    * @param {number} preferredAudioChannelCount
+   * @param {!Array.<string>} preferredDecodingAttributes
    */
-  static chooseCodecsAndFilterManifest(manifest, preferredAudioChannelCount) {
+  static chooseCodecsAndFilterManifest(manifest, preferredVideoCodecs,
+      preferredAudioCodecs, preferredAudioChannelCount,
+      preferredDecodingAttributes) {
     const StreamUtils = shaka.util.StreamUtils;
 
-    // To start, consider a subset of variants based on audio channel
+    let variants = manifest.variants;
+    // To start, choose the codecs based on configured preferences if available.
+    if (preferredVideoCodecs.length || preferredAudioCodecs.length) {
+      variants = StreamUtils.choosePreferredCodecs(variants,
+          preferredVideoCodecs, preferredAudioCodecs);
+    }
+
+    // Consider a subset of variants based on audio channel
     // preferences.
     // For some content (#1013), surround-sound variants will use a different
     // codec than stereo variants, so it is important to choose codecs **after**
     // considering the audio channel config.
-    const variants = StreamUtils.filterVariantsByAudioChannelCount(
-        manifest.variants, preferredAudioChannelCount);
+    variants = StreamUtils.filterVariantsByAudioChannelCount(
+        variants, preferredAudioChannelCount);
 
     // Now organize variants into buckets by codecs.
     /** @type {!shaka.util.MultiMap.<shaka.extern.Variant>} */
     let variantsByCodecs = StreamUtils.getVariantsByCodecs_(variants);
     variantsByCodecs = StreamUtils.filterVariantsByDensity_(variantsByCodecs);
 
-    const bestCodecs = StreamUtils.findBestCodecs_(variantsByCodecs);
+    const bestCodecs = StreamUtils.chooseCodecsByDecodingAttributes_(
+        variantsByCodecs, preferredDecodingAttributes);
 
     // Filter out any variants that don't match, forcing AbrManager to choose
-    // from the most efficient variants possible.
+    // from a single video codec and a single audio codec possible.
     manifest.variants = manifest.variants.filter((variant) => {
-      const codecs = StreamUtils.getGroupVariantCodecs_(variant);
+      const codecs = StreamUtils.getVariantCodecs_(variant);
       if (codecs == bestCodecs) {
         return true;
       }
@@ -71,8 +83,8 @@ shaka.util.StreamUtils = class {
   static getVariantsByCodecs_(variants) {
     const variantsByCodecs = new shaka.util.MultiMap();
     for (const variant of variants) {
-      const group = shaka.util.StreamUtils.getGroupVariantCodecs_(variant);
-      variantsByCodecs.push(group, variant);
+      const variantCodecs = shaka.util.StreamUtils.getVariantCodecs_(variant);
+      variantsByCodecs.push(variantCodecs, variant);
     }
 
     return variantsByCodecs;
@@ -80,6 +92,8 @@ shaka.util.StreamUtils = class {
 
   /**
   * Filters variants by density.
+  * Get variants by codecs map with the max density where all codecs are
+  * present.
   *
   * @param {!shaka.util.MultiMap.<shaka.extern.Variant>} variantsByCodecs
   * @return {!shaka.util.MultiMap.<shaka.extern.Variant>}
@@ -120,6 +134,107 @@ shaka.util.StreamUtils = class {
     return maxDensity ? codecGroupsByDensity.get(maxDensity) : variantsByCodecs;
   }
 
+  /**
+   * Choose the codecs by configured preferred audio and video codecs.
+   *
+   * @param {!Array<shaka.extern.Variant>} variants
+   * @param {!Array.<string>} preferredVideoCodecs
+   * @param {!Array.<string>} preferredAudioCodecs
+   * @return {!Array<shaka.extern.Variant>}
+   */
+  static choosePreferredCodecs(variants, preferredVideoCodecs,
+      preferredAudioCodecs) {
+    let subset = variants;
+    for (const videoCodec of preferredVideoCodecs) {
+      const filtered = subset.filter((variant) => {
+        return variant.video && variant.video.codecs.startsWith(videoCodec);
+      });
+      if (filtered.length) {
+        subset = filtered;
+        break;
+      }
+    }
+
+    for (const audioCodec of preferredAudioCodecs) {
+      const filtered = subset.filter((variant) => {
+        return variant.audio && variant.audio.codecs.startsWith(audioCodec);
+      });
+      if (filtered.length) {
+        subset = filtered;
+        break;
+      }
+    }
+    return subset;
+  }
+
+  /**
+   * Choose the codecs by configured preferred decoding attributes.
+   *
+   * @param {!shaka.util.MultiMap.<shaka.extern.Variant>} variantsByCodecs
+   * @param {!Array.<string>} attributes
+   * @return {string}
+   * @private
+   */
+  static chooseCodecsByDecodingAttributes_(variantsByCodecs, attributes) {
+    const StreamUtils = shaka.util.StreamUtils;
+
+    for (const attribute of attributes) {
+      if (attribute == StreamUtils.DecodingAttributes.SMOOTH ||
+          attribute == StreamUtils.DecodingAttributes.POWER) {
+        variantsByCodecs = StreamUtils.chooseCodecsByMediaCapabilitiesInfo_(
+            variantsByCodecs, attribute);
+        // If we only have one smooth or powerEfficient codecs, choose it as the
+        // best codecs.
+        if (variantsByCodecs.size() == 1) {
+          return variantsByCodecs.keys()[0];
+        }
+      } else if (attribute == StreamUtils.DecodingAttributes.BANDWIDTH) {
+        return StreamUtils.findCodecsByLowestBandwidth_(variantsByCodecs);
+      }
+    }
+    // If there's no configured decoding preferences, or we have multiple codecs
+    // that meets the configured decoding preferences, choose the one with
+    // the lowest bandwidth.
+    return StreamUtils.findCodecsByLowestBandwidth_(variantsByCodecs);
+  }
+
+  /**
+   * Choose the best codecs by configured preferred MediaCapabilitiesInfo
+   * attributes.
+   *
+   * @param {!shaka.util.MultiMap.<shaka.extern.Variant>} variantsByCodecs
+   * @param {string} attribute
+   * @return {!shaka.util.MultiMap.<shaka.extern.Variant>}
+   * @private
+   */
+  static chooseCodecsByMediaCapabilitiesInfo_(variantsByCodecs, attribute) {
+    let highestScore = 0;
+    const bestVariantsByCodecs = new shaka.util.MultiMap();
+    variantsByCodecs.forEach((codecs, variants) => {
+      let sum = 0;
+      let num = 0;
+
+      for (const variant of variants) {
+        if (variant.decodingInfos.length) {
+          sum += variant.decodingInfos[0][attribute] ? 1 : 0;
+          num++;
+        }
+      }
+
+      const averageScore = sum / num;
+      shaka.log.debug('codecs', codecs, 'avg', attribute, averageScore);
+
+      if (averageScore > highestScore) {
+        bestVariantsByCodecs.clear();
+        bestVariantsByCodecs.push(codecs, variants);
+        highestScore = averageScore;
+      } else if (averageScore == highestScore) {
+        bestVariantsByCodecs.push(codecs, variants);
+      }
+    });
+    return bestVariantsByCodecs;
+  }
+
   /**
    * Find the lowest-bandwidth (best) codecs.
    * Compute the average bandwidth for each group of variants.
@@ -128,7 +243,7 @@ shaka.util.StreamUtils = class {
    * @return {string}
    * @private
    */
-  static findBestCodecs_(variantsByCodecs) {
+  static findCodecsByLowestBandwidth_(variantsByCodecs) {
     let bestCodecs = '';
     let lowestAverageBandwidth = Infinity;
 
@@ -163,7 +278,7 @@ shaka.util.StreamUtils = class {
    * @return {string}
    * @private
    */
-  static getGroupVariantCodecs_(variant) {
+  static getVariantCodecs_(variant) {
     // Only consider the base of the codec string.  For example, these should
     // both be considered the same codec: avc1.42c01e, avc1.4d401f
     let baseVideoCodec = '';
@@ -183,7 +298,7 @@ shaka.util.StreamUtils = class {
    * Filter the variants in |manifest| to only include the variants that meet
    * the given restrictions.
    *
-   * @param {shaka.extern.Manifest} manifest
+   * @param {!shaka.extern.Manifest} manifest
    * @param {shaka.extern.Restrictions} restrictions
    * @param {{width: number, height:number}} maxHwResolution
    */
@@ -283,17 +398,11 @@ shaka.util.StreamUtils = class {
    * @param {shaka.media.DrmEngine} drmEngine
    * @param {?shaka.extern.Variant} currentVariant
    * @param {shaka.extern.Manifest} manifest
-   * @param {boolean=} useMediaCapabilities
    */
   static async filterManifest(
-      drmEngine, currentVariant, manifest, useMediaCapabilities) {
-    if (useMediaCapabilities) {
-      await shaka.util.StreamUtils.filterManifestByMediaCapabilities(manifest,
-          manifest.offlineSessionIds.length > 0);
-    } else {
-      shaka.util.StreamUtils.filterManifestByDrm(manifest, drmEngine);
-      shaka.util.StreamUtils.filterManifestByMediaSource(manifest);
-    }
+      drmEngine, currentVariant, manifest) {
+    await shaka.util.StreamUtils.filterManifestByMediaCapabilities(manifest,
+        manifest.offlineSessionIds.length > 0);
     shaka.util.StreamUtils.filterManifestByCurrentVariant(
         currentVariant, manifest);
     shaka.util.StreamUtils.filterTextStreams_(manifest);
@@ -301,29 +410,6 @@ shaka.util.StreamUtils = class {
   }
 
 
-  /**
-   * Filter the variants in |manifest| to only include those that are supported
-   * by |drm|.
-   * @param {shaka.extern.Manifest} manifest
-   * @param {shaka.media.DrmEngine} drmEngine
-   */
-  static filterManifestByDrm(manifest, drmEngine) {
-    manifest.variants = manifest.variants.filter((variant) => {
-      if (drmEngine && drmEngine.initialized()) {
-        if (!drmEngine.supportsVariant(variant)) {
-          shaka.log.debug('Dropping variant - not compatible with key system',
-              variant);
-          return false;
-        }
-        return true;
-      }
-
-      shaka.log.debug('DrmEngine is not initialized yet.');
-      return true;
-    });
-  }
-
-
   /**
    * Alters the given Manifest to filter out any streams unsupported by the
    * platform via MediaCapabilities.decodingInfo() API.
@@ -363,46 +449,6 @@ shaka.util.StreamUtils = class {
   }
 
 
-  /**
-   * Filter the variants in the |manifest| to only include those that are
-   * supported by media source.
-   * TODO: remove once MediaCap implementations are done.
-   * @param {shaka.extern.Manifest} manifest
-   */
-  static filterManifestByMediaSource(manifest) {
-    const StreamUtils = shaka.util.StreamUtils;
-
-    manifest.variants = manifest.variants.filter((variant) => {
-      const audio = variant.audio;
-      const video = variant.video;
-
-      if (audio && !shaka.media.MediaSourceEngine.isStreamSupported(audio)) {
-        shaka.log.debug('Dropping variant - audio not compatible with platform',
-            StreamUtils.getStreamSummaryString_(audio));
-        return false;
-      }
-
-      if (video && !shaka.media.MediaSourceEngine.isStreamSupported(video)) {
-        shaka.log.debug('Dropping variant - video not compatible with platform',
-            StreamUtils.getStreamSummaryString_(video));
-        return false;
-      }
-
-      // See: https://github.com/google/shaka-player/issues/3380
-      if (shaka.util.Platform.isXboxOne() && video &&
-          ((video.width && video.width > 1920) ||
-          (video.height && video.height > 1080)) &&
-          video.codecs.includes('avc1.')) {
-        shaka.log.debug('Dropping variant - video not compatible with platform',
-            StreamUtils.getStreamSummaryString_(video));
-        return false;
-      }
-
-      return true;
-    });
-  }
-
-
   /**
    * Get the decodingInfo results of the variants via MediaCapabilities.
    * This should be called after the DrmEngine is created and configured, and
@@ -501,6 +547,19 @@ shaka.util.StreamUtils = class {
         // framerate must be greater than 0, otherwise the config is invalid.
         framerate: video.frameRate || 1,
       };
+      if (video.hdr) {
+        switch (video.hdr) {
+          case 'SDR':
+            mediaDecodingConfig.video.transferFunction = 'srgb';
+            break;
+          case 'PQ':
+            mediaDecodingConfig.video.transferFunction = 'pq';
+            break;
+          case 'HLG':
+            mediaDecodingConfig.video.transferFunction = 'hlg';
+            break;
+        }
+      }
     }
     if (audio) {
       // Some Tizen devices seem to misreport AC-3 support, but correctly
@@ -1358,3 +1417,12 @@ shaka.util.StreamUtils = class {
 
 /** @private {number} */
 shaka.util.StreamUtils.nextTrackId_ = 0;
+
+/**
+ * @enum {string}
+ */
+shaka.util.StreamUtils.DecodingAttributes = {
+  SMOOTH: 'smooth',
+  POWER: 'powerEfficient',
+  BANDWIDTH: 'bandwidth',
+};