shaka-player 4.2.2 → 4.2.4

package/lib/text/ttml_text_parser.js

@@ -49,8 +49,6 @@ shaka.text.TtmlTextParser = class {
     const ttsNs = TtmlTextParser.styleNs_;
     const str = shaka.util.StringUtils.fromUTF8(data);
     const cues = [];
-    const parser = new DOMParser();
-    let xml = null;
 
     // dont try to parse empty string as
     // DOMParser will not throw error but return an errored xml
@@ -58,9 +56,8 @@ shaka.text.TtmlTextParser = class {
       return cues;
     }
 
-    try {
-      xml = parser.parseFromString(str, 'text/xml');
-    } catch (exception) {
+    const tt = XmlUtils.parseXmlString(str, 'tt');
+    if (!tt) {
       throw new shaka.util.Error(
           shaka.util.Error.Severity.CRITICAL,
           shaka.util.Error.Category.TEXT,
@@ -68,110 +65,89 @@ shaka.text.TtmlTextParser = class {
           'Failed to parse TTML.');
     }
 
-    if (xml) {
-      const parserError = xml.getElementsByTagName('parsererror')[0];
-      if (parserError) {
-        throw new shaka.util.Error(
-            shaka.util.Error.Severity.CRITICAL,
-            shaka.util.Error.Category.TEXT,
-            shaka.util.Error.Code.INVALID_XML,
-            parserError.textContent);
-      }
-
-      const tt = xml.getElementsByTagName('tt')[0];
-      // TTML should always have tt element.
-      if (!tt) {
-        throw new shaka.util.Error(
-            shaka.util.Error.Severity.CRITICAL,
-            shaka.util.Error.Category.TEXT,
-            shaka.util.Error.Code.INVALID_XML,
-            'TTML does not contain <tt> tag.');
-      }
-
-      const body = tt.getElementsByTagName('body')[0];
-      if (!body) {
-        return [];
-      }
+    const body = tt.getElementsByTagName('body')[0];
+    if (!body) {
+      return [];
+    }
 
-      // Get the framerate, subFrameRate and frameRateMultiplier if applicable.
-      const frameRate = XmlUtils.getAttributeNSList(tt, ttpNs, 'frameRate');
-      const subFrameRate = XmlUtils.getAttributeNSList(
-          tt, ttpNs, 'subFrameRate');
-      const frameRateMultiplier =
-          XmlUtils.getAttributeNSList(tt, ttpNs, 'frameRateMultiplier');
-      const tickRate = XmlUtils.getAttributeNSList(tt, ttpNs, 'tickRate');
+    // Get the framerate, subFrameRate and frameRateMultiplier if applicable.
+    const frameRate = XmlUtils.getAttributeNSList(tt, ttpNs, 'frameRate');
+    const subFrameRate = XmlUtils.getAttributeNSList(
+        tt, ttpNs, 'subFrameRate');
+    const frameRateMultiplier =
+        XmlUtils.getAttributeNSList(tt, ttpNs, 'frameRateMultiplier');
+    const tickRate = XmlUtils.getAttributeNSList(tt, ttpNs, 'tickRate');
 
-      const cellResolution = XmlUtils.getAttributeNSList(
-          tt, ttpNs, 'cellResolution');
-      const spaceStyle = tt.getAttribute('xml:space') || 'default';
-      const extent = XmlUtils.getAttributeNSList(tt, ttsNs, 'extent');
+    const cellResolution = XmlUtils.getAttributeNSList(
+        tt, ttpNs, 'cellResolution');
+    const spaceStyle = tt.getAttribute('xml:space') || 'default';
+    const extent = XmlUtils.getAttributeNSList(tt, ttsNs, 'extent');
 
-      if (spaceStyle != 'default' && spaceStyle != 'preserve') {
-        throw new shaka.util.Error(
-            shaka.util.Error.Severity.CRITICAL,
-            shaka.util.Error.Category.TEXT,
-            shaka.util.Error.Code.INVALID_XML,
-            'Invalid xml:space value: ' + spaceStyle);
-      }
-      const whitespaceTrim = spaceStyle == 'default';
+    if (spaceStyle != 'default' && spaceStyle != 'preserve') {
+      throw new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.TEXT,
+          shaka.util.Error.Code.INVALID_XML,
+          'Invalid xml:space value: ' + spaceStyle);
+    }
+    const whitespaceTrim = spaceStyle == 'default';
 
-      const rateInfo = new TtmlTextParser.RateInfo_(
-          frameRate, subFrameRate, frameRateMultiplier, tickRate);
+    const rateInfo = new TtmlTextParser.RateInfo_(
+        frameRate, subFrameRate, frameRateMultiplier, tickRate);
 
-      const cellResolutionInfo =
-        TtmlTextParser.getCellResolution_(cellResolution);
+    const cellResolutionInfo =
+      TtmlTextParser.getCellResolution_(cellResolution);
 
-      const metadata = tt.getElementsByTagName('metadata')[0];
-      const metadataElements = metadata ? XmlUtils.getChildren(metadata) : [];
-      const styles = Array.from(tt.getElementsByTagName('style'));
-      const regionElements = Array.from(tt.getElementsByTagName('region'));
+    const metadata = tt.getElementsByTagName('metadata')[0];
+    const metadataElements = metadata ? XmlUtils.getChildren(metadata) : [];
+    const styles = Array.from(tt.getElementsByTagName('style'));
+    const regionElements = Array.from(tt.getElementsByTagName('region'));
 
-      const cueRegions = [];
-      for (const region of regionElements) {
-        const cueRegion =
-            TtmlTextParser.parseCueRegion_(region, styles, extent);
-        if (cueRegion) {
-          cueRegions.push(cueRegion);
-        }
+    const cueRegions = [];
+    for (const region of regionElements) {
+      const cueRegion =
+          TtmlTextParser.parseCueRegion_(region, styles, extent);
+      if (cueRegion) {
+        cueRegions.push(cueRegion);
       }
+    }
 
-      // A <body> element should only contain <div> elements, not <p> or <span>
-      // elements.  We used to allow this, but it is non-compliant, and the
-      // loose nature of our previous parser made it difficult to implement TTML
-      // nesting more fully.
-      if (XmlUtils.findChildren(body, 'p').length) {
+    // A <body> element should only contain <div> elements, not <p> or <span>
+    // elements.  We used to allow this, but it is non-compliant, and the
+    // loose nature of our previous parser made it difficult to implement TTML
+    // nesting more fully.
+    if (XmlUtils.findChildren(body, 'p').length) {
+      throw new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.TEXT,
+          shaka.util.Error.Code.INVALID_TEXT_CUE,
+          '<p> can only be inside <div> in TTML');
+    }
+
+    for (const div of XmlUtils.findChildren(body, 'div')) {
+      // A <div> element should only contain <p>, not <span>.
+      if (XmlUtils.findChildren(div, 'span').length) {
         throw new shaka.util.Error(
             shaka.util.Error.Severity.CRITICAL,
             shaka.util.Error.Category.TEXT,
             shaka.util.Error.Code.INVALID_TEXT_CUE,
-            '<p> can only be inside <div> in TTML');
-      }
-
-      for (const div of XmlUtils.findChildren(body, 'div')) {
-        // A <div> element should only contain <p>, not <span>.
-        if (XmlUtils.findChildren(div, 'span').length) {
-          throw new shaka.util.Error(
-              shaka.util.Error.Severity.CRITICAL,
-              shaka.util.Error.Category.TEXT,
-              shaka.util.Error.Code.INVALID_TEXT_CUE,
-              '<span> can only be inside <p> in TTML');
-        }
+            '<span> can only be inside <p> in TTML');
       }
+    }
 
-      const cue = TtmlTextParser.parseCue_(
-          body, time.periodStart, rateInfo, metadataElements, styles,
-          regionElements, cueRegions, whitespaceTrim,
-          cellResolutionInfo, /* parentCueElement= */ null,
-          /* isContent= */ false);
-      if (cue) {
-        // According to the TTML spec, backgrounds default to transparent.
-        // So default the background of the top-level element to transparent.
-        // Nested elements may override that background color already.
-        if (!cue.backgroundColor) {
-          cue.backgroundColor = 'transparent';
-        }
-        cues.push(cue);
+    const cue = TtmlTextParser.parseCue_(
+        body, time.periodStart, rateInfo, metadataElements, styles,
+        regionElements, cueRegions, whitespaceTrim,
+        cellResolutionInfo, /* parentCueElement= */ null,
+        /* isContent= */ false);
+    if (cue) {
+      // According to the TTML spec, backgrounds default to transparent.
+      // So default the background of the top-level element to transparent.
+      // Nested elements may override that background color already.
+      if (!cue.backgroundColor) {
+        cue.backgroundColor = 'transparent';
       }
+      cues.push(cue);
     }
 
     return cues;

package/lib/text/vtt_text_parser.js

@@ -105,7 +105,7 @@ shaka.text.VttTextParser = class {
 
         const rolloverSeconds =
             shaka.text.VttTextParser.TS_ROLLOVER_ / mpegTimescale;
-        let segmentStart = time.segmentStart;
+        let segmentStart = time.segmentStart - time.periodStart;
         while (segmentStart >= rolloverSeconds) {
           segmentStart -= rolloverSeconds;
           mpegTime += shaka.text.VttTextParser.TS_ROLLOVER_;

package/lib/util/error.js

@@ -1013,6 +1013,13 @@ shaka.util.Error.Code = {
    */
   'MODIFY_OPERATION_NOT_SUPPORTED': 9016,
 
+  /**
+   * When attempting to open an indexedDB instance, nothing happened for long
+   * enough for us to time out.  This keeps the storage mechanism from hanging
+   * indefinitely, if neither the success nor error callbacks are called.
+   */
+  'INDEXED_DB_INIT_TIMED_OUT': 9017,
+
   /**
    * CS IMA SDK, required for ad insertion, has not been included on the page.
    */

package/lib/util/manifest_parser_utils.js

@@ -168,6 +168,7 @@ shaka.util.ManifestParserUtils.VIDEO_CODEC_REGEXPS_ = [
   /^hvc/,
   /^vp0?[89]/,
   /^av01/,
+  /^dvhe/,
 ];
 
 
@@ -183,6 +184,9 @@ shaka.util.ManifestParserUtils.AUDIO_CODEC_REGEXPS_ = [
   /^flac$/,
   /^mp4a/,
   /^[ae]c-3$/,
+  /^ac-4$/,
+  /^dts[cx]$/, // DTS Surround Sound
+  /^[du]dts$/, // DTS Surround Sound
 ];
 
 

package/lib/util/periods.js

@@ -1180,15 +1180,6 @@ shaka.util.PeriodCombiner = class {
       return false;
     }
 
-    // If the language doesn't match, but the candidate is the "primary"
-    // language, then that should be preferred as a fallback.
-    if (!best.primary && candidate.primary) {
-      return true;
-    }
-    if (best.primary && !candidate.primary) {
-      return false;
-    }
-
     // If language-based differences haven't decided this, look at roles.  If
     // the candidate has more roles in common with the output, upgrade to the
     // candidate.
@@ -1222,6 +1213,15 @@ shaka.util.PeriodCombiner = class {
       return false;
     }
 
+    // If the language doesn't match, but the candidate is the "primary"
+    // language, then that should be preferred as a fallback.
+    if (!best.primary && candidate.primary) {
+      return true;
+    }
+    if (best.primary && !candidate.primary) {
+      return false;
+    }
+
     // If language-based and role-based features are equivalent, take the audio
     // with the closes channel count to the output.
     const channelsBetterOrWorse =

package/lib/util/platform.js

@@ -163,16 +163,6 @@ shaka.util.Platform = class {
     return shaka.util.Platform.userAgentContains_('CrKey');
   }
 
-  /**
-   * Check if the current platform is a Android-based Cast devices.
-   *
-   * @return {boolean}
-   */
-  static isAndroidCastDevice() {
-    return shaka.util.Platform.isChromecast() &&
-        shaka.util.Platform.userAgentContains_('Android');
-  }
-
   /**
    * Returns a major version number for Chrome, or Chromium-based browsers.
    *

package/lib/util/xml_utils.js

@@ -8,6 +8,7 @@ goog.provide('shaka.util.XmlUtils');
 
 goog.require('goog.asserts');
 goog.require('shaka.log');
+goog.require('shaka.util.Lazy');
 goog.require('shaka.util.StringUtils');
 
 
@@ -348,19 +349,21 @@ shaka.util.XmlUtils = class {
    */
   static parseXmlString(xmlString, expectedRootElemName) {
     const parser = new DOMParser();
-    let xml = null;
+    const unsafeXmlString =
+        shaka.util.XmlUtils.trustedHTMLFromString_.value()(xmlString);
+    let unsafeXml = null;
     try {
-      xml = parser.parseFromString(xmlString, 'text/xml');
+      unsafeXml = parser.parseFromString(unsafeXmlString, 'text/xml');
     } catch (exception) {
       shaka.log.error('XML parsing exception:', exception);
       return null;
     }
 
     // According to MDN, parseFromString never returns null.
-    goog.asserts.assert(xml, 'Parsed XML document cannot be null!');
+    goog.asserts.assert(unsafeXml, 'Parsed XML document cannot be null!');
 
     // Check for empty documents.
-    const rootElem = xml.documentElement;
+    const rootElem = unsafeXml.documentElement;
     if (!rootElem) {
       shaka.log.error('XML document was empty!');
       return null;
@@ -374,13 +377,28 @@ shaka.util.XmlUtils = class {
     }
 
     // The top-level element in the loaded XML should have the name we expect.
-    if (xml.documentElement.tagName != expectedRootElemName) {
+    if (rootElem.tagName != expectedRootElemName) {
       shaka.log.error(
           `XML tag name does not match expected "${expectedRootElemName}":`,
-          xml.documentElement.tagName);
+          rootElem.tagName);
       return null;
     }
 
+    // SECURITY: Verify that the document does not contain elements from the
+    // HTML or SVG namespaces, which could trigger script execution and XSS.
+    const iterator = document.createNodeIterator(
+        unsafeXml,
+        NodeFilter.SHOW_ALL,
+    );
+    let currentNode;
+    while (currentNode = iterator.nextNode()) {
+      if (currentNode instanceof HTMLElement ||
+          currentNode instanceof SVGElement) {
+        shaka.log.error('XML document embeds unsafe content!');
+        return null;
+      }
+    }
+
     return rootElem;
   }
 
@@ -402,3 +420,24 @@ shaka.util.XmlUtils = class {
     }
   }
 };
+
+/**
+ * Promote a string to TrustedHTML. This function is security-sensitive and
+ * should only be used with security approval where the string is guaranteed not
+ * to cause an XSS vulnerability.
+ *
+ * @private {!shaka.util.Lazy.<function(!string): (!TrustedHTML|!string)>}
+ */
+shaka.util.XmlUtils.trustedHTMLFromString_ = new shaka.util.Lazy(() => {
+  if (typeof trustedTypes !== 'undefined') {
+    // Create a Trusted Types policy for promoting the string to TrustedHTML.
+    // The Lazy wrapper ensures this policy is only created once.
+    const policy = trustedTypes.createPolicy('shaka-player#xml', {
+      createHTML: (s) => s,
+    });
+    return (s) => policy.createHTML(s);
+  }
+  // Fall back to strings in environments that don't support Trusted Types.
+  return (s) => s;
+});
+

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "shaka-player",
   "description": "DASH/EME video player library",
-  "version": "4.2.2",
+  "version": "4.2.4",
   "homepage": "https://github.com/shaka-project/shaka-player",
   "author": "Google",
   "maintainers": [

package/roadmap.md

@@ -9,28 +9,46 @@ The goals of future milestones are fluid until we begin that development cycle,
 so the exact milestone for future features is not pre-determined.
 
 Priority features up next:
- - Preload API
-   https://github.com/shaka-project/shaka-player/issues/880
+ - HLS improvements
+   https://github.com/shaka-project/shaka-player/projects/6
 
 Candidate features for future release cycles:
+ - Preload API
+   https://github.com/shaka-project/shaka-player/issues/880
  - Official TypeScript defs, generated from source
    https://github.com/shaka-project/shaka-player/issues/1030
  - Codec-switching
    https://github.com/shaka-project/shaka-player/issues/1528
  - Background fetch for offline storage
    https://github.com/shaka-project/shaka-player/issues/879
+ - Smaller, more modular binary
+
+v4.3 - 2022 Q4 / 2023 Q1
  - Support ID3 tags in mp4
    https://github.com/shaka-project/shaka-player/issues/3351
- - Smaller, more modular binary
+ - Lazy-load HLS playlists on adaptation
+   https://github.com/shaka-project/shaka-player/issues/1936
 
-v3.4 - 2022 Q1 or Q2
+=====
+
+v4.2 - 2022 Q3
+ - Automatic ABR quality restrictions based on size
+   https://github.com/shaka-project/shaka-player/issues/2333
+ - HLS support for AES-128 encryption
+   https://github.com/shaka-project/shaka-player/issues/850
+
+v4.1 - 2022 Q2
+ - HLS support for EXT-X-GAP
+   https://github.com/shaka-project/shaka-player/issues/1308
+ - Temporarily disable the active variant after `HTTP_ERROR`
+   https://github.com/shaka-project/shaka-player/issues/1542
+
+v4.0 - 2022 Q2
  - MSE support for FairPlay
    https://github.com/shaka-project/shaka-player/issues/3346
  - Support containerless formats
    https://github.com/shaka-project/shaka-player/issues/2337
 
-=====
-
 v3.3 - 2022 Q1
  - Common Media Client Data (CMCD) logging support
    https://github.com/shaka-project/shaka-player/issues/3619

package/test/cast/cast_receiver_integration.js

@@ -34,6 +34,8 @@ filterDescribe('CastReceiver', castReceiverIntegrationSupport, () => {
 
   /** @type {shaka.util.PublicPromise} */
   let messageWaitPromise;
+  /** @type {Array.<string>} */
+  let pendingMessages = null;
 
   /** @type {!Array.<function()>} */
   let toRestore;
@@ -91,6 +93,9 @@ filterDescribe('CastReceiver', castReceiverIntegrationSupport, () => {
     toRestore = [];
     pendingWaitWrapperCalls = 0;
 
+    messageWaitPromise = null;
+    pendingMessages = null;
+
     fakeInitState = {
       player: {
         configure: {},
@@ -118,6 +123,12 @@ filterDescribe('CastReceiver', castReceiverIntegrationSupport, () => {
     player = null;
     video = null;
     receiver = null;
+
+    if (messageWaitPromise) {
+      messageWaitPromise.resolve([]);
+    }
+    messageWaitPromise = null;
+    pendingMessages = null;
   });
 
   afterAll(() => {
@@ -128,6 +139,66 @@ filterDescribe('CastReceiver', castReceiverIntegrationSupport, () => {
     }
   });
 
+  describe('without drm', () => {
+    it('sends reasonably-sized updates', async () => {
+      // Use an unencrypted asset.
+      fakeInitState.manifest = 'test:sintel';
+
+      const p = waitForLoadedData();
+
+      // Start the process of loading by sending a fake init message.
+      fakeConnectedSenders(1);
+      fakeIncomingMessage({
+        type: 'init',
+        initState: fakeInitState,
+        appData: {},
+      }, mockShakaMessageBus);
+
+      await p;
+      // Wait for an update message.
+      const messages = await waitForUpdateMessages();
+      for (const message of messages) {
+        // Check that the update message is of a reasonable size. From previous
+        // testing we found that the socket would silently reject data that got
+        // too big. 6KB is safely below the limit.
+        expect(message.length).toBeLessThan(6000);
+      }
+    });
+
+    it('has reasonable average message size', async () => {
+      // Use an unencrypted asset.
+      fakeInitState.manifest = 'test:sintel';
+
+      const p = waitForLoadedData();
+
+      // Start the process of loading by sending a fake init message.
+      fakeConnectedSenders(1);
+      fakeIncomingMessage({
+        type: 'init',
+        initState: fakeInitState,
+        appData: {},
+      }, mockShakaMessageBus);
+
+      await p;
+
+      // Collect messages over 50 update cycles, and average their length.
+      // Not all properties are passed along on every update message, so
+      // the average length is expected to be lower than the length of the first
+      // update message.
+      let totalLength = 0;
+      let totalMessages = 0;
+      for (let i = 0; i < 50; i++) {
+        // eslint-disable-next-line no-await-in-loop
+        const messages = await waitForUpdateMessages();
+        for (const message of messages) {
+          totalLength += message.length;
+          totalMessages += 1;
+        }
+      }
+      expect(totalLength / totalMessages).toBeLessThan(2000);
+    });
+  });
+
   filterDescribe('with drm', () => support['com.widevine.alpha'], () => {
     drmIt('sends reasonably-sized updates', async () => {
       // Use an encrypted asset, to make sure DRM info doesn't balloon the size.
@@ -150,11 +221,13 @@ filterDescribe('CastReceiver', castReceiverIntegrationSupport, () => {
 
       await p;
       // Wait for an update message.
-      const message = await waitForUpdateMessage();
-      // Check that the update message is of a reasonable size. From previous
-      // testing we found that the socket would silently reject data that got
-      // too big. 6KB is safely below the limit.
-      expect(message.length).toBeLessThan(7 * 1024);
+      const messages = await waitForUpdateMessages();
+      for (const message of messages) {
+        // Check that the update message is of a reasonable size. From previous
+        // testing we found that the socket would silently reject data that got
+        // too big. 6KB is safely below the limit.
+        expect(message.length).toBeLessThan(6000);
+      }
     });
 
     drmIt('has reasonable average message size', async () => {
@@ -177,17 +250,22 @@ filterDescribe('CastReceiver', castReceiverIntegrationSupport, () => {
       }, mockShakaMessageBus);
 
       await p;
-      // Collect 50 update messages, and average their length.
+
+      // Collect messages over 50 update cycles, and average their length.
       // Not all properties are passed along on every update message, so
       // the average length is expected to be lower than the length of the first
       // update message.
       let totalLength = 0;
+      let totalMessages = 0;
       for (let i = 0; i < 50; i++) {
         // eslint-disable-next-line no-await-in-loop
-        const message = await waitForUpdateMessage();
-        totalLength += message.length;
+        const messages = await waitForUpdateMessages();
+        for (const message of messages) {
+          totalLength += message.length;
+          totalMessages += 1;
+        }
       }
-      expect(totalLength / 50).toBeLessThan(3000);
+      expect(totalLength / totalMessages).toBeLessThan(2000);
     });
   });
 
@@ -227,12 +305,12 @@ filterDescribe('CastReceiver', castReceiverIntegrationSupport, () => {
     expect(pendingWaitWrapperCalls).toBe(0);
 
     // Wait for a final update message before proceeding.
-    await waitForUpdateMessage();
+    await waitForUpdateMessages();
   });
 
   /**
    * Creates a wrapper around a method on a given prototype, which makes it
-   * wait on waitForUpdateMessage before returning, and registers that wrapper
+   * wait on waitForUpdateMessages before returning, and registers that wrapper
    * to be uninstalled afterwards.
    * The replaced method is expected to be a method that returns a promise.
    * @param {!Object} prototype
@@ -249,7 +327,7 @@ filterDescribe('CastReceiver', castReceiverIntegrationSupport, () => {
           'Waiting for update message before calling ' +
           name + '.' + methodName + '...');
       const originalArguments = Array.from(arguments);
-      await waitForUpdateMessage();
+      await waitForUpdateMessages();
       // eslint-disable-next-line no-restricted-syntax
       return original.apply(this, originalArguments);
     };
@@ -265,7 +343,8 @@ filterDescribe('CastReceiver', castReceiverIntegrationSupport, () => {
     });
   }
 
-  function waitForUpdateMessage() {
+  function waitForUpdateMessages() {
+    pendingMessages = [];
     messageWaitPromise = new shaka.util.PublicPromise();
     return messageWaitPromise;
   }
@@ -316,10 +395,12 @@ filterDescribe('CastReceiver', castReceiverIntegrationSupport, () => {
       bus.messages.push(CastUtils.deserialize(message));
       // Check to see if it's an update message.
       const parsed = CastUtils.deserialize(message);
-      if (parsed.type == 'update' && messageWaitPromise) {
+      if (parsed.type == 'update' && pendingMessages) {
         shaka.log.debug('Received update message. Proceeding...');
-        messageWaitPromise.resolve(message);
-        messageWaitPromise = null;
+        // The code waiting on this Promise will get an array of all of the
+        // messages processed within this tick.
+        pendingMessages.push(message);
+        messageWaitPromise.resolve(pendingMessages);
       }
     });
     const channel = {