shaka-player 4.10.11 → 4.10.13

package/lib/util/periods.js

@@ -890,26 +890,33 @@ shaka.util.PeriodCombiner = class {
         // Create a fresh output stream for trick-mode playback.
         output.trickModeVideo = shaka.util.PeriodCombiner.cloneStream_(
             input.trickModeVideo);
-        // TODO: fix the createSegmentIndex function for trickModeVideo.
-        // The trick-mode tracks in multi-period content should have trick-mode
-        // segment indexes whenever available, rather than only regular-mode
-        // segment indexes.
+        output.trickModeVideo.matchedStreams = [];
         output.trickModeVideo.createSegmentIndex = () => {
-          // Satisfy the compiler about the type.
-          goog.asserts.assert(
-              output.segmentIndex instanceof shaka.media.MetaSegmentIndex,
-              'The stream should have a MetaSegmentIndex.');
-          output.trickModeVideo.segmentIndex = output.segmentIndex.clone();
+          if (output.trickModeVideo.segmentIndex) {
+            return Promise.resolve();
+          }
+          const segmentIndex = new shaka.media.MetaSegmentIndex();
+          goog.asserts.assert(output.trickModeVideo.matchedStreams,
+              'trickmode matched streams should exist');
+          for (const stream of output.trickModeVideo.matchedStreams) {
+            goog.asserts.assert(stream.segmentIndex,
+                'trickmode segment index should exist');
+            segmentIndex.appendSegmentIndex(stream.segmentIndex);
+          }
+          output.trickModeVideo.segmentIndex = segmentIndex;
+
           return Promise.resolve();
         };
       }
 
       // Concatenate the trick mode input onto the trick mode output.
+      output.trickModeVideo.matchedStreams.push(input.trickModeVideo);
       shaka.util.PeriodCombiner.concatenateStreams_(
           output.trickModeVideo, input.trickModeVideo);
     } else if (output.trickModeVideo) {
       // We have a trick mode output, but no input from this Period.  Fill it in
       // from the standard input Stream.
+      output.trickModeVideo.matchedStreams.push(input);
       shaka.util.PeriodCombiner.concatenateStreams_(
           output.trickModeVideo, input);
     }

package/lib/util/stream_utils.js

@@ -418,6 +418,8 @@ shaka.util.StreamUtils = class {
       'dva1': 'avc1',
       'dvhe': 'hev1',
       'dvh1': 'hvc1',
+      'dvc1': 'vvc1',
+      'dvi1': 'vvi1',
     };
     /** @type {!Set<!shaka.extern.Stream>} */
     const streams = new Set();

package/lib/util/tXml.js

@@ -6,6 +6,7 @@
 
 goog.provide('shaka.util.TXml');
 
+goog.require('shaka.util.ObjectUtils');
 goog.require('shaka.util.StringUtils');
 goog.require('shaka.log');
 
@@ -71,24 +72,37 @@ shaka.util.TXml = class {
   }
 
   /**
-   * Parse some data
+   * Get namespace based on schema
    * @param {string} schema
    * @return {string}
    */
   static getKnownNameSpace(schema) {
-    if (shaka.util.TXml.knownNameSpaces_.has(schema)) {
-      return shaka.util.TXml.knownNameSpaces_.get(schema);
+    if (shaka.util.TXml.uriToNameSpace_.has(schema)) {
+      return shaka.util.TXml.uriToNameSpace_.get(schema);
     }
     return '';
   }
 
   /**
-   * Parse some data
+   * Get schema based on namespace
+   * @param {string} NS
+   * @return {string}
+   */
+  static getKnownSchema(NS) {
+    if (shaka.util.TXml.nameSpaceToUri_.has(NS)) {
+      return shaka.util.TXml.nameSpaceToUri_.get(NS);
+    }
+    return '';
+  }
+
+  /**
+   * Sets NS <-> schema bidirectional mapping
    * @param {string} schema
    * @param {string} NS
    */
   static setKnownNameSpace(schema, NS) {
-    shaka.util.TXml.knownNameSpaces_.set(schema, NS);
+    shaka.util.TXml.uriToNameSpace_.set(schema, NS);
+    shaka.util.TXml.nameSpaceToUri_.set(NS, schema);
   }
 
   /**
@@ -869,43 +883,69 @@ shaka.util.TXml = class {
   /**
    * Converts a tXml node to DOM element.
    * @param {shaka.extern.xml.Node} node
-   * @param {boolean=} doParents
-   * @param {boolean=} doChildren
    * @return {!Element}
    */
-  static txmlNodeToDomElement(node, doParents = true, doChildren = true) {
+  static txmlNodeToDomElement(node) {
     const TXml = shaka.util.TXml;
-    const element = document.createElement(node.tagName);
+    let namespace = '';
+    const parts = node.tagName.split(':');
+    if (parts.length > 0) {
+      namespace = TXml.getKnownSchema(parts[0]);
+    }
+    const element = document.createElementNS(namespace, node.tagName);
 
     for (const k in node.attributes) {
       const v = node.attributes[k];
       element.setAttribute(k, v);
     }
 
-    if (doParents && node.parent && node.parent.tagName != '?xml') {
-      const parentElement = TXml.txmlNodeToDomElement(
-          node.parent, /* doParents= */ true, /* doChildren= */ false);
-      parentElement.appendChild(element);
-    }
-
-    if (doChildren) {
-      for (const child of node.children) {
-        let childElement;
-        if (typeof child == 'string') {
-          childElement = new Text(child);
-        } else {
-          childElement = TXml.txmlNodeToDomElement(
-              child, /* doParents= */ false, /* doChildren= */ true);
-        }
-        element.appendChild(childElement);
+    for (const child of node.children) {
+      let childElement;
+      if (typeof child == 'string') {
+        childElement = new Text(child);
+      } else {
+        childElement = TXml.txmlNodeToDomElement(child);
       }
+      element.appendChild(childElement);
     }
 
     return element;
   }
+
+  /**
+   * Clones node and its children recursively. Skips parent.
+   * @param {?shaka.extern.xml.Node} node
+   * @return {?shaka.extern.xml.Node}
+   */
+  static cloneNode(node) {
+    if (!node) {
+      return null;
+    }
+    /** @type {!shaka.extern.xml.Node} */
+    const clone = {
+      tagName: node.tagName,
+      attributes: shaka.util.ObjectUtils.shallowCloneObject(node.attributes),
+      children: [],
+      parent: null,
+    };
+    for (const child of node.children) {
+      if (typeof child === 'string') {
+        clone.children.push(child);
+      } else {
+        const clonedChild = shaka.util.TXml.cloneNode(child);
+        clonedChild.parent = clone;
+        clone.children.push(clonedChild);
+      }
+    }
+    return clone;
+  }
 };
 
-shaka.util.TXml.knownNameSpaces_ = new Map([]);
+/** @private {!Map<string, string>} */
+shaka.util.TXml.uriToNameSpace_ = new Map();
+
+/** @private {!Map<string, string>} */
+shaka.util.TXml.nameSpaceToUri_ = new Map();
 
 
 /**

package/package.json

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