shaka-player 4.7.13 → 4.8.0

package/lib/util/platform.js

@@ -6,6 +6,7 @@
 
 goog.provide('shaka.util.Platform');
 
+goog.require('shaka.log');
 goog.require('shaka.util.Timer');
 
 
@@ -149,10 +150,9 @@ shaka.util.Platform = class {
    * @return {boolean}
    */
   static isWebOS3() {
-    // See: http://webostv.developer.lge.com/discover/specifications/web-engine/
-    return shaka.util.Platform.userAgentContains_('Web0S') &&
-        shaka.util.Platform.userAgentContains_(
-            'Chrome/38.0.2125.122 Safari/537.36');
+    // See: https://webostv.developer.lge.com/develop/specifications/web-api-and-web-engine#useragent-string
+    return shaka.util.Platform.isWebOS() &&
+        shaka.util.Platform.chromeVersion() === 38;
   }
 
   /**
@@ -161,18 +161,20 @@ shaka.util.Platform = class {
    * @return {boolean}
    */
   static isWebOS4() {
-    // See: http://webostv.developer.lge.com/discover/specifications/web-engine/
-    return !!navigator.userAgent.match(/webOS\/4/i);
+    // See: https://webostv.developer.lge.com/develop/specifications/web-api-and-web-engine#useragent-string
+    return shaka.util.Platform.isWebOS() &&
+        shaka.util.Platform.chromeVersion() === 53;
   }
 
   /**
-   * Check if the current platform is a WebOS 4.
+   * Check if the current platform is a WebOS 5.
    *
    * @return {boolean}
    */
   static isWebOS5() {
-    // See: http://webostv.developer.lge.com/discover/specifications/web-engine/
-    return !!navigator.userAgent.match(/webOS\/5/i);
+    // See: https://webostv.developer.lge.com/develop/specifications/web-api-and-web-engine#useragent-string
+    return shaka.util.Platform.isWebOS() &&
+        shaka.util.Platform.chromeVersion() === 68;
   }
 
   /**
@@ -440,6 +442,25 @@ shaka.util.Platform = class {
     return shaka.util.Platform.userAgentContains_('Android');
   }
 
+  /**
+   * Return true if the platform is controlled by a remote control.
+   *
+   * @return {boolean}
+   */
+  static isSmartTV() {
+    const Platform = shaka.util.Platform;
+    if (Platform.isTizen() || Platform.isWebOS() ||
+        Platform.isXboxOne() || Platform.isPS4() ||
+        Platform.isPS5() || Platform.isAmazonFireTV() ||
+        Platform.isEOS() || Platform.isAPL() ||
+        Platform.isVirginMedia() || Platform.isOrange() ||
+        Platform.isWPE() || Platform.isChromecast() ||
+        Platform.isHisense()) {
+      return true;
+    }
+    return false;
+  }
+
   /**
    * Check if the user agent contains a key. This is the best way we know of
    * right now to detect platforms. If there is a better way, please send a
@@ -554,6 +575,137 @@ shaka.util.Platform = class {
 
     return false;
   }
+
+  /**
+   * Detect the maximum resolution that the platform's hardware can handle.
+   *
+   * @return {!Promise.<{width: number, height: number}>}
+   */
+  static async detectMaxHardwareResolution() {
+    const Platform = shaka.util.Platform;
+    const maxResolution = {
+      width: Infinity,
+      height: Infinity,
+    };
+
+    if (Platform.isChromecast()) {
+      // In our tests, the original Chromecast seems to have trouble decoding
+      // above 1080p.  It would be a waste to select a higher res anyway, given
+      // that the device only outputs 1080p to begin with.
+      // Chromecast has an extension to query the device/display's resolution.
+      if (window.cast && cast.__platform__ &&
+          cast.__platform__.canDisplayType && cast.__platform__.canDisplayType(
+          'video/mp4; codecs="avc1.640028"; width=3840; height=2160')) {
+        // The device and display can both do 4k.  Assume a 4k limit.
+        maxResolution.width = 3840;
+        maxResolution.height = 2160;
+      } else {
+        // Chromecast has always been able to do 1080p.  Assume a 1080p limit.
+        maxResolution.width = 1920;
+        maxResolution.height = 1080;
+      }
+    } else if (Platform.isTizen()) {
+      maxResolution.width = 1920;
+      maxResolution.height = 1080;
+      try {
+        if (webapis.systeminfo && webapis.systeminfo.getMaxVideoResolution) {
+          const maxVideoResolution =
+              webapis.systeminfo.getMaxVideoResolution();
+          maxResolution.width = maxVideoResolution.width;
+          maxResolution.height = maxVideoResolution.height;
+        } else {
+          if (webapis.productinfo.is8KPanelSupported &&
+              webapis.productinfo.is8KPanelSupported()) {
+            maxResolution.width = 7680;
+            maxResolution.height = 4320;
+          } else if (webapis.productinfo.isUdPanelSupported &&
+              webapis.productinfo.isUdPanelSupported()) {
+            maxResolution.width = 3840;
+            maxResolution.height = 2160;
+          }
+        }
+      } catch (e) {
+        shaka.log.alwaysWarn('Tizen: Error detecting screen size, default ' +
+            'screen size 1920x1080.');
+      }
+    } else if (Platform.isXboxOne()) {
+      const protectionCapabilities =
+          new Windows.Media.Protection.ProtectionCapabilities();
+      const protectionResult =
+          Windows.Media.Protection.ProtectionCapabilityResult;
+      // isTypeSupported may return "maybe", which means the operation is not
+      // completed. This means we need to retry
+      // https://learn.microsoft.com/en-us/uwp/api/windows.media.protection.protectioncapabilityresult?view=winrt-22621
+      let result = null;
+      try {
+        const type =
+            'video/mp4;codecs="hvc1,mp4a";features="decode-res-x=3840,' +
+            'decode-res-y=2160,decode-bitrate=20000,decode-fps=30,' +
+            'decode-bpc=10,display-res-x=3840,display-res-y=2160,' +
+            'display-bpc=8"';
+        const keySystem = 'com.microsoft.playready.recommendation';
+        do {
+          result = protectionCapabilities.isTypeSupported(type, keySystem);
+        } while (result === protectionResult.maybe);
+      } catch (e) {
+        result = protectionResult.notSupported;
+      }
+      if (result === protectionResult.probably) {
+        maxResolution.width = 3840;
+        maxResolution.height = 2160;
+      } else {
+        maxResolution.width = 1920;
+        maxResolution.height = 1080;
+      }
+    } else if (Platform.isWebOS()) {
+      try {
+        const deviceInfo =
+        /** @type {{screenWidth: number, screenHeight: number}} */(
+            JSON.parse(window.PalmSystem.deviceInfo));
+        // WebOS has always been able to do 1080p.  Assume a 1080p limit.
+        maxResolution.width = Math.max(1920, deviceInfo.screenWidth);
+        maxResolution.height = Math.max(1080, deviceInfo.screenHeight);
+      } catch (e) {
+        shaka.log.alwaysWarn('WebOS: Error detecting screen size, default ' +
+            'screen size 1920x1080.');
+        maxResolution.width = 1920;
+        maxResolution.height = 1080;
+      }
+    } else if (Platform.isHisense()) {
+      // eslint-disable-next-line new-cap
+      if (window.Hisense_Get4KSupportState &&
+          // eslint-disable-next-line new-cap
+          window.Hisense_Get4KSupportState()) {
+        maxResolution.width = 3840;
+        maxResolution.height = 2160;
+      } else {
+        maxResolution.width = 1920;
+        maxResolution.height = 1080;
+      }
+    } else if (Platform.isPS4() || Platform.isPS5()) {
+      let supports4K = false;
+      try {
+        const result = await window.msdk.device.getDisplayInfo();
+        supports4K = result.resolution === '4K';
+      } catch (e) {
+        try {
+          const result = await window.msdk.device.getDisplayInfoImmediate();
+          supports4K = result.resolution === '4K';
+        } catch (e) {
+          shaka.log.alwaysWarn(
+              'PlayStation: Failed to get the display info:', e);
+        }
+      }
+      if (supports4K) {
+        maxResolution.width = 3840;
+        maxResolution.height = 2160;
+      } else {
+        maxResolution.width = 1920;
+        maxResolution.height = 1080;
+      }
+    }
+    return maxResolution;
+  }
 };
 
 /** @private {shaka.util.Timer} */

package/lib/util/player_configuration.js

@@ -94,6 +94,13 @@ shaka.util.PlayerConfiguration = class {
       ignoreDuplicateInitData: !shaka.util.Platform.isTizen2(),
     };
 
+    // The Xbox One and PS4 only support the Playready DRM, so they should
+    // prefer that key system by default to improve startup performance.
+    if (shaka.util.Platform.isXboxOne() ||
+        shaka.util.Platform.isPS4()) {
+      drm.preferredKeySystems.push('com.microsoft.playready');
+    }
+
     let codecSwitchingStrategy = shaka.config.CodecSwitchingStrategy.RELOAD;
     let multiTypeVariantsAllowed = false;
     if (shaka.util.Platform.supportsSmoothCodecSwitching()) {
@@ -133,17 +140,22 @@ shaka.util.PlayerConfiguration = class {
             'com.microsoft.playready',
           'urn:uuid:79f0049a-4098-8642-ab92-e65be0885f95':
             'com.microsoft.playready',
-          'urn:uuid:f239e769-efa3-4850-9c16-a903c6932efb':
-            'com.adobe.primetime',
         },
         manifestPreprocessor: (element) => {
           return shaka.util.ConfigUtils.referenceParametersAndReturn(
               [element],
               element);
         },
+        manifestPreprocessorTXml: (element) => {
+          return shaka.util.ConfigUtils.referenceParametersAndReturn(
+              [element],
+              element);
+        },
         sequenceMode: false,
         enableAudioGroups: false,
         multiTypeVariantsAllowed,
+        useStreamOnceInPeriodFlattening: false,
+        updatePeriod: -1,
       },
       hls: {
         ignoreTextStreamFailures: false,
@@ -151,6 +163,7 @@ shaka.util.PlayerConfiguration = class {
         defaultAudioCodec: 'mp4a.40.2',
         defaultVideoCodec: 'avc1.42E01E',
         ignoreManifestProgramDateTime: false,
+        ignoreManifestProgramDateTimeForTypes: [],
         mediaPlaylistFullMimeType:
             'video/mp2t; codecs="avc1.42E01E, mp4a.40.2"',
         useSafariBehaviorForLive: true,
@@ -166,6 +179,11 @@ shaka.util.PlayerConfiguration = class {
               [element],
               element);
         },
+        manifestPreprocessorTXml: (element) => {
+          return shaka.util.ConfigUtils.referenceParametersAndReturn(
+              [element],
+              element);
+        },
         sequenceMode: false,
         keySystemsBySystemId: {
           '9a04f079-9840-4286-ab92-e65be0885f95':
@@ -192,6 +210,7 @@ shaka.util.PlayerConfiguration = class {
       rebufferingGoal: 2,
       bufferingGoal: 10,
       bufferBehind: 30,
+      evictionGoal: 1,
       ignoreTextStreamFailures: false,
       alwaysStreamText: false,
       startAtSegmentBoundary: false,
@@ -205,6 +224,7 @@ shaka.util.PlayerConfiguration = class {
       stallThreshold: 1 /* seconds */,
       stallSkip: 0.1 /* seconds */,
       useNativeHlsOnSafari: true,
+      useNativeHlsForFairPlay: true,
       // If we are within 2 seconds of the start of a live segment, fetch the
       // previous one.  This allows for segment drift, but won't download an
       // extra segment if we aren't close to the start.
@@ -223,13 +243,23 @@ shaka.util.PlayerConfiguration = class {
       // When low latency streaming is enabled, segmentPrefetchLimit will
       // default to 2 if not specified.
       segmentPrefetchLimit: 0,
+      prefetchAudioLanguages: [],
+      disableAudioPrefetch: false,
+      disableTextPrefetch: false,
+      disableVideoPrefetch: false,
       liveSync: false,
       liveSyncMaxLatency: 1,
       liveSyncPlaybackRate: 1.1,
       liveSyncMinLatency: 0,
       liveSyncMinPlaybackRate: 1,
+      liveSyncPanicMode: false,
+      liveSyncPanicThreshold: 60,
       allowMediaSourceRecoveries: true,
       minTimeBetweenRecoveries: 5,
+      vodDynamicPlaybackRate: false,
+      vodDynamicPlaybackRateLowBufferRate: 0.95,
+      vodDynamicPlaybackRateBufferRatio: 0.5,
+      infiniteLiveStreamDuration: false,
     };
 
     // WebOS, Tizen, Chromecast and Hisense have long hardware pipelines
@@ -316,7 +346,9 @@ shaka.util.PlayerConfiguration = class {
       enabled: false,
       sessionId: '',
       contentId: '',
+      rtpSafetyFactor: 5,
       useHeaders: false,
+      includeKeys: [],
     };
 
     const cmsd = {
@@ -334,13 +366,38 @@ shaka.util.PlayerConfiguration = class {
 
     const mediaSource = {
       codecSwitchingStrategy: codecSwitchingStrategy,
-      sourceBufferExtraFeatures: '',
+      addExtraFeaturesToSourceBuffer: (mimeType) => {
+        return shaka.util.ConfigUtils.referenceParametersAndReturn(
+            [mimeType],
+            '');
+      },
       forceTransmux: false,
       insertFakeEncryptionInInit: true,
+      modifyCueCallback: (cue, uri) => {
+        return shaka.util.ConfigUtils.referenceParametersAndReturn(
+            [cue, uri],
+            undefined);
+      },
     };
 
+    let skipPlayDetection = false;
+    if (shaka.util.Platform.isWebOS() ||
+        shaka.util.Platform.isTizen() ||
+        shaka.util.Platform.isChromecast() ||
+        shaka.util.Platform.isHisense() ||
+        shaka.util.Platform.isPS5() ||
+        shaka.util.Platform.isPS4() ||
+        shaka.util.Platform.isXboxOne()) {
+      skipPlayDetection = true;
+    }
+
     const ads = {
       customPlayheadTracker: false,
+      skipPlayDetection,
+    };
+
+    const textDisplayer = {
+      captionsUpdatePeriod: 0.25,
     };
 
     const AutoShowText = shaka.config.AutoShowText;
@@ -383,6 +440,7 @@ shaka.util.PlayerConfiguration = class {
       },
       playRangeStart: 0,
       playRangeEnd: Infinity,
+      textDisplayer: textDisplayer,
       textDisplayFactory: () => null,
       cmcd: cmcd,
       cmsd: cmsd,

package/lib/util/stats.js

@@ -62,6 +62,9 @@ shaka.util.Stats = class {
     /** @private {number} */
     this.bandwidthEstimate_ = NaN;
 
+    /** @private {number} */
+    this.bytesDownloaded_ = NaN;
+
     /** @private {!shaka.util.StateHistory} */
     this.stateHistory_ = new shaka.util.StateHistory();
 
@@ -203,6 +206,17 @@ shaka.util.Stats = class {
     this.bandwidthEstimate_ = bandwidth;
   }
 
+  /**
+   * @param {number} bytesDownloaded
+   */
+  addBytesDownloaded(bytesDownloaded) {
+    if (isNaN(this.bytesDownloaded_)) {
+      this.bytesDownloaded_ = bytesDownloaded;
+    } else {
+      this.bytesDownloaded_ += bytesDownloaded;
+    }
+  }
+
   /**
    * @return {!shaka.util.StateHistory}
    */
@@ -244,6 +258,7 @@ shaka.util.Stats = class {
       licenseTime: this.licenseTimeSeconds_,
       liveLatency: this.liveLatencySeconds_,
       maxSegmentDuration: this.maxSegmentDurationSeconds_,
+      bytesDownloaded: this.bytesDownloaded_,
       stateHistory: this.stateHistory_.getCopy(),
       switchHistory: this.switchHistory_.getCopy(),
     };
@@ -276,6 +291,7 @@ shaka.util.Stats = class {
       licenseTime: NaN,
       liveLatency: NaN,
       maxSegmentDuration: NaN,
+      bytesDownloaded: NaN,
       switchHistory: [],
       stateHistory: [],
     };

package/lib/util/stream_utils.js

@@ -263,13 +263,20 @@ shaka.util.StreamUtils = class {
     // |video.width| and |video.height| can be undefined, which breaks
     // the math, so make sure they are there first.
     if (video && video.width && video.height) {
-      if (!inRange(video.width,
+      let videoWidth = video.width;
+      let videoHeight = video.height;
+      if (videoHeight > videoWidth) {
+        // Vertical video.
+        [videoWidth, videoHeight] = [videoHeight, videoWidth];
+      }
+
+      if (!inRange(videoWidth,
           restrictions.minWidth,
           Math.min(restrictions.maxWidth, maxHwRes.width))) {
         return false;
       }
 
-      if (!inRange(video.height,
+      if (!inRange(videoHeight,
           restrictions.minHeight,
           Math.min(restrictions.maxHeight, maxHwRes.height))) {
         return false;
@@ -330,10 +337,12 @@ shaka.util.StreamUtils = class {
    *
    * @param {shaka.media.DrmEngine} drmEngine
    * @param {shaka.extern.Manifest} manifest
+   * @param {!Array<string>=} preferredKeySystems
    */
-  static async filterManifest(drmEngine, manifest) {
+  static async filterManifest(drmEngine, manifest, preferredKeySystems = []) {
     await shaka.util.StreamUtils.filterManifestByMediaCapabilities(
-        drmEngine, manifest, manifest.offlineSessionIds.length > 0);
+        drmEngine, manifest, manifest.offlineSessionIds.length > 0,
+        preferredKeySystems);
     shaka.util.StreamUtils.filterTextStreams_(manifest);
     await shaka.util.StreamUtils.filterImageStreams_(manifest);
   }
@@ -346,15 +355,16 @@ shaka.util.StreamUtils = class {
    * @param {shaka.media.DrmEngine} drmEngine
    * @param {shaka.extern.Manifest} manifest
    * @param {boolean} usePersistentLicenses
+   * @param {!Array<string>} preferredKeySystems
    */
   static async filterManifestByMediaCapabilities(
-      drmEngine, manifest, usePersistentLicenses) {
+      drmEngine, manifest, usePersistentLicenses, preferredKeySystems) {
     goog.asserts.assert(navigator.mediaCapabilities,
         'MediaCapabilities should be valid.');
 
     await shaka.util.StreamUtils.getDecodingInfosForVariants(
         manifest.variants, usePersistentLicenses, /* srcEquals= */ false,
-        /** preferredKeySystems= */ []);
+        preferredKeySystems);
 
     let keySystem = null;
     if (drmEngine) {

package/lib/util/string_utils.js

@@ -276,6 +276,42 @@ shaka.util.StringUtils = class {
   static resetFromCharCode() {
     shaka.util.StringUtils.fromCharCodeImpl_.reset();
   }
+
+  /**
+   * This method converts the HTML entities &, <, >, ", ',
+   *  , ‎ and ‏ in string to their corresponding characters.
+   *
+   * @param {!string} input
+   * @return {string}
+   */
+  static htmlUnescape(input) {
+    // Used to map HTML entities to characters.
+    const htmlUnescapes = {
+      '&': '&',
+      '&lt;': '<',
+      '&gt;': '>',
+      '&quot;': '"',
+      '&#39;': '\'',
+      '&apos;': '\'',
+      '&nbsp;': '\u{a0}',
+      '&lrm;': '\u{200e}',
+      '&rlm;': '\u{200f}',
+    };
+
+    // Used to match HTML entities and HTML characters.
+    const reEscapedHtml = /&(?:amp|lt|gt|quot|apos|#(0+)?39|nbsp|lrm|rlm);/g;
+    const reHasEscapedHtml = RegExp(reEscapedHtml.source);
+    // This check is an optimization, since replace always makes a copy
+    if (input && reHasEscapedHtml.test(input)) {
+      return input.replace(reEscapedHtml, (entity) => {
+        // The only thing that might not match the dictionary above is the
+        // single quote, which can be matched by many strings in the regex, but
+        // only has a single entry in the dictionary.
+        return htmlUnescapes[entity] || '\'';
+      });
+    }
+    return input || '';
+  }
 };