shaka-player 4.9.24 → 4.9.26

package/lib/dash/dash_parser.js

@@ -29,6 +29,7 @@ goog.require('shaka.util.LanguageUtils');
 goog.require('shaka.util.ManifestParserUtils');
 goog.require('shaka.util.MimeUtils');
 goog.require('shaka.util.Networking');
+goog.require('shaka.util.ObjectUtils');
 goog.require('shaka.util.OperationManager');
 goog.require('shaka.util.PeriodCombiner');
 goog.require('shaka.util.PlayerConfiguration');
@@ -92,12 +93,19 @@ shaka.dash.DashParser = class {
 
     /**
      * A map of IDs to Stream objects.
-     * ID: Period@id,AdaptationSet@id,@Representation@id
-     * e.g.: '1,5,23'
+     * ID: Period@id,Representation@id
+     * e.g.: '1,23'
      * @private {!Object.<string, !shaka.extern.Stream>}
      */
     this.streamMap_ = {};
 
+    /**
+     * A map of Period IDs to Stream Map IDs.
+     * Use to have direct access to streamMap key.
+     * @private {!Object.<string, !Array<string>>}
+     */
+    this.indexStreamMap_ = {};
+
     /**
      * A map of period ids to their durations
      * @private {!Object.<string, number>}
@@ -235,6 +243,7 @@ shaka.dash.DashParser = class {
     this.manifestUris_ = [];
     this.manifest_ = null;
     this.streamMap_ = {};
+    this.indexStreamMap_ = {};
     this.contextCache_.clear();
     this.manifestPatchContext_ = {
       mpdId: '',
@@ -618,7 +627,7 @@ shaka.dash.DashParser = class {
     }
 
     this.manifestPatchContext_.type = mpdType;
-
+    this.cleanStreamMap_();
     /** @type {!shaka.media.PresentationTimeline} */
     let presentationTimeline;
     if (this.manifest_) {
@@ -697,7 +706,8 @@ shaka.dash.DashParser = class {
       profiles: profiles.split(','),
     };
 
-    const periodsAndDuration = this.parsePeriods_(context, getBaseUris, mpd);
+    const periodsAndDuration = this.parsePeriods_(
+        context, getBaseUris, mpd, /* newPeriod= */ false);
     const duration = periodsAndDuration.duration;
     const periods = periodsAndDuration.periods;
 
@@ -977,7 +987,7 @@ shaka.dash.DashParser = class {
     };
 
     const periodsAndDuration = this.parsePeriods_(context,
-        this.manifestPatchContext_.getBaseUris, periods);
+        this.manifestPatchContext_.getBaseUris, periods, /* newPeriod= */ true);
 
     return periodsAndDuration.periods;
   }
@@ -996,6 +1006,10 @@ shaka.dash.DashParser = class {
         this.contextCache_.delete(contextId);
       }
     }
+    const newPeriods = this.lastManifestUpdatePeriodIds_.filter((pID) => {
+      return pID !== periodId;
+    });
+    this.lastManifestUpdatePeriodIds_ = newPeriods;
   }
 
   /**
@@ -1237,6 +1251,7 @@ shaka.dash.DashParser = class {
    * @param {shaka.dash.DashParser.Context} context
    * @param {function():!Array.<string>} getBaseUris
    * @param {!shaka.extern.xml.Node} mpd
+   * @param {!boolean} newPeriod
    * @return {{
    *   periods: !Array.<shaka.extern.Period>,
    *   duration: ?number,
@@ -1244,7 +1259,7 @@ shaka.dash.DashParser = class {
    * }}
    * @private
    */
-  parsePeriods_(context, getBaseUris, mpd) {
+  parsePeriods_(context, getBaseUris, mpd, newPeriod) {
     const TXml = shaka.util.TXml;
     let presentationDuration = context.mediaPresentationDuration;
 
@@ -1370,8 +1385,18 @@ shaka.dash.DashParser = class {
       prevEnd = start + periodDuration;
     } // end of period parsing loop
 
-    // Replace previous seen periods with the current one.
-    this.lastManifestUpdatePeriodIds_ = periods.map((el) => el.id);
+    if (newPeriod) {
+      // append new period from the patch manifest
+      for (const el of periods) {
+        const periodID = el.id;
+        if (!this.lastManifestUpdatePeriodIds_.includes(periodID)) {
+          this.lastManifestUpdatePeriodIds_.push(periodID);
+        }
+      }
+    } else {
+      // Replace previous seen periods with the current one.
+      this.lastManifestUpdatePeriodIds_ = periods.map((el) => el.id);
+    }
 
     if (presentationDuration != null) {
       if (prevEnd != null) {
@@ -1399,6 +1424,26 @@ shaka.dash.DashParser = class {
     }
   }
 
+  /**
+   * Clean StreamMap Object to remove reference of deleted Stream Object
+   * @private
+   */
+  cleanStreamMap_() {
+    const oldPeriodIds = Object.keys(this.indexStreamMap_);
+    if (oldPeriodIds.length === this.lastManifestUpdatePeriodIds_.length) {
+      return;
+    }
+    const diffPeriodsIDs = oldPeriodIds.filter((pId) => {
+      return !this.lastManifestUpdatePeriodIds_.includes(pId);
+    });
+    for (const pId of diffPeriodsIDs) {
+      for (const contextId of this.indexStreamMap_[pId]) {
+        delete this.streamMap_[contextId];
+      }
+      delete this.indexStreamMap_[pId];
+    }
+  }
+
   /**
    * Parses a Period XML element.  Unlike the other parse methods, this is not
    * given the Node; it is given a PeriodInfo structure.  Also, partial parsing
@@ -1415,6 +1460,7 @@ shaka.dash.DashParser = class {
     const TXml = shaka.util.TXml;
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
+    goog.asserts.assert(periodInfo.node, 'periodInfo.node should exist');
     context.period = this.createFrame_(periodInfo.node, null, getBaseUris);
     context.periodInfo = periodInfo;
     context.period.availabilityTimeOffset = context.availabilityTimeOffset;
@@ -2184,7 +2230,12 @@ shaka.dash.DashParser = class {
     };
 
     if (contextId && context.dynamic && !this.streamMap_[contextId]) {
+      const periodId = context.period.id || '';
+      if (!this.indexStreamMap_[periodId]) {
+        this.indexStreamMap_[periodId] = [];
+      }
       this.streamMap_[contextId] = stream;
+      this.indexStreamMap_[periodId].push(contextId);
     }
 
     return stream;
@@ -2198,45 +2249,29 @@ shaka.dash.DashParser = class {
    * @private
    */
   cloneContext_(context) {
-    const contextClone = /** @type {!shaka.dash.DashParser.Context} */({});
-
-    for (const k of Object.keys(context)) {
-      if (['period', 'adaptationSet', 'representation'].includes(k)) {
-        /** @type {shaka.dash.DashParser.InheritanceFrame} */
-        const frameRef = context[k];
-        contextClone[k] = {
-          segmentBase: null,
-          segmentList: null,
-          segmentTemplate: frameRef.segmentTemplate,
-          getBaseUris: frameRef.getBaseUris,
-          width: frameRef.width,
-          height: frameRef.height,
-          contentType: frameRef.contentType,
-          mimeType: frameRef.mimeType,
-          language: frameRef.language,
-          codecs: frameRef.codecs,
-          frameRate: frameRef.frameRate,
-          pixelAspectRatio: frameRef.pixelAspectRatio,
-          emsgSchemeIdUris: frameRef.emsgSchemeIdUris,
-          id: frameRef.id,
-          position: frameRef.position,
-          numChannels: frameRef.numChannels,
-          audioSamplingRate: frameRef.audioSamplingRate,
-          availabilityTimeOffset: frameRef.availabilityTimeOffset,
-          initialization: frameRef.initialization,
-        };
-      } else if (k == 'periodInfo') {
-        /** @type {shaka.dash.DashParser.PeriodInfo} */
-        const frameRef = context[k];
-        contextClone[k] = {
-          start: frameRef.start,
-          duration: frameRef.duration,
-          node: null,
-          isLastPeriod: frameRef.isLastPeriod,
-        };
-      } else {
-        contextClone[k] = context[k];
+    /**
+     * @param {?shaka.dash.DashParser.InheritanceFrame} frame
+     * @return {?shaka.dash.DashParser.InheritanceFrame}
+     */
+    const cloneFrame = (frame) => {
+      if (!frame) {
+        return null;
       }
+      const clone = shaka.util.ObjectUtils.shallowCloneObject(frame);
+      clone.segmentBase = null;
+      clone.segmentList = null;
+      clone.segmentTemplate = shaka.util.TXml.cloneNode(clone.segmentTemplate);
+      return clone;
+    };
+    const contextClone = shaka.util.ObjectUtils.shallowCloneObject(context);
+    contextClone.period = cloneFrame(contextClone.period);
+    contextClone.adaptationSet = cloneFrame(contextClone.adaptationSet);
+    contextClone.representation = cloneFrame(contextClone.representation);
+
+    if (contextClone.periodInfo) {
+      contextClone.periodInfo =
+        shaka.util.ObjectUtils.shallowCloneObject(contextClone.periodInfo);
+      contextClone.periodInfo.node = null;
     }
 
     return contextClone;
@@ -3082,7 +3117,7 @@ shaka.dash.DashParser.Context;
  * @typedef {{
  *   start: number,
  *   duration: ?number,
- *   node: !shaka.extern.xml.Node,
+ *   node: ?shaka.extern.xml.Node,
  *   isLastPeriod: boolean
  * }}
  *
@@ -3094,7 +3129,7 @@ shaka.dash.DashParser.Context;
  * @property {?number} duration
  *   The duration of the period; or null if the duration is not given.  This
  *   will be non-null for all periods except the last.
- * @property {!shaka.extern.xml.Node} node
+ * @property {?shaka.extern.xml.Node} node
  *   The XML Node for the Period.
  * @property {boolean} isLastPeriod
  *   Whether this Period is the last one in the manifest.

package/lib/media/streaming_engine.js

@@ -73,6 +73,13 @@ shaka.media.StreamingEngine = class {
     /** @private {?shaka.extern.StreamingConfiguration} */
     this.config_ = null;
 
+    /**
+     * Retains a reference to the function used to close SegmentIndex objects
+     * for streams which were switched away from during an ongoing update_().
+     * @private {!Map.<string, !function()>}
+     */
+    this.deferredCloseSegmentIndex_ = new Map();
+
     /** @private {number} */
     this.bufferingGoalScale_ = 1;
 
@@ -504,6 +511,24 @@ shaka.media.StreamingEngine = class {
   }
 
 
+  /**
+   * Handles deferred releases of old SegmentIndexes for the mediaState's
+   * content type from a previous update.
+   * @param {!shaka.media.StreamingEngine.MediaState_} mediaState
+   * @private
+   */
+  handleDeferredCloseSegmentIndexes_(mediaState) {
+    for (const [key, value] of this.deferredCloseSegmentIndex_.entries()) {
+      const streamId = /** @type {string} */ (key);
+      const closeSegmentIndex = /** @type {!function()} */ (value);
+      if (streamId.includes(mediaState.type)) {
+        closeSegmentIndex();
+        this.deferredCloseSegmentIndex_.delete(streamId);
+      }
+    }
+  }
+
+
   /**
    * Switches to the given Stream. |stream| may be from any Variant.
    *
@@ -576,7 +601,23 @@ shaka.media.StreamingEngine = class {
     // Do not close segment indexes we are prefetching.
     if (!this.audioPrefetchMap_.has(mediaState.stream)) {
       if (mediaState.stream.closeSegmentIndex) {
-        mediaState.stream.closeSegmentIndex();
+        if (mediaState.performingUpdate) {
+          const oldStreamTag =
+              shaka.media.StreamingEngine.logPrefix_(mediaState);
+          if (!this.deferredCloseSegmentIndex_.has(oldStreamTag)) {
+            // The ongoing update is still using the old stream's segment
+            // reference information.
+            // If we close the old stream now, the update will not complete
+            // correctly.
+            // The next onUpdate_() for this content type will resume the
+            // closeSegmentIndex() operation for the old stream once the ongoing
+            // update has finished, then immediately create a new segment index.
+            this.deferredCloseSegmentIndex_.set(
+                oldStreamTag, mediaState.stream.closeSegmentIndex);
+          }
+        } else {
+          mediaState.stream.closeSegmentIndex();
+        }
       }
     }
 
@@ -1169,6 +1210,13 @@ shaka.media.StreamingEngine = class {
       return;
     }
 
+    // If stream switches happened during the previous update_() for this
+    // content type, close out the old streams that were switched away from.
+    // Even if we had switched away from the active stream 'A' during the
+    // update_(), e.g. (A -> B -> A), closing 'A' is permissible here since we
+    // will immediately re-create it in the logic below.
+    this.handleDeferredCloseSegmentIndexes_(mediaState);
+
     // Make sure the segment index exists. If not, create the segment index.
     if (!mediaState.stream.segmentIndex) {
       const thisStream = mediaState.stream;
@@ -1450,14 +1498,11 @@ shaka.media.StreamingEngine = class {
         mediaState.stream.segmentIndex,
         'segment index should have been generated already');
 
-    const currentSegment = mediaState.segmentIterator ?
-        mediaState.segmentIterator.current() : null;
-
-    if (currentSegment) {
+    if (mediaState.segmentIterator) {
       // Something is buffered from the same Stream.  Use the current position
       // in the segment index.  This is updated via next() after each segment is
       // appended.
-      return currentSegment;
+      return mediaState.segmentIterator.current();
     } else if (mediaState.lastSegmentReference || bufferEnd) {
       // Something is buffered from another Stream.
       const time = mediaState.lastSegmentReference ?
@@ -1955,8 +2000,8 @@ shaka.media.StreamingEngine = class {
         reference.startTime <= appendWindowEnd,
         logPrefix + ' segment should start before append window end');
 
-    const codecs = MimeUtils.getCodecBase(
-        reference.codecs || mediaState.stream.codecs);
+    const fullCodecs = (reference.codecs || mediaState.stream.codecs);
+    const codecs = MimeUtils.getCodecBase(fullCodecs);
     const mimeType = MimeUtils.getBasicType(
         reference.mimeType || mediaState.stream.mimeType);
     const timestampOffset = reference.timestampOffset;
@@ -1974,7 +2019,7 @@ shaka.media.StreamingEngine = class {
       const isResetMediaSourceNecessary =
           mediaState.lastCodecs && mediaState.lastMimeType &&
           this.playerInterface_.mediaSourceEngine.isResetMediaSourceNecessary(
-              mediaState.type, mediaState.stream, mimeType, codecs);
+              mediaState.type, mediaState.stream, mimeType, fullCodecs);
       if (isResetMediaSourceNecessary) {
         let otherState = null;
         if (mediaState.type === ContentType.VIDEO) {
@@ -2717,6 +2762,10 @@ shaka.media.StreamingEngine = class {
     this.destroyer_.ensureNotDestroyed();
     // Try to recover from network errors
     if (error.category === shaka.util.Error.Category.NETWORK) {
+      if (mediaState.restoreStreamAfterTrickPlay) {
+        this.setTrickPlay(/* on= */ false);
+        return;
+      }
       const maxDisabledTime = this.getDisabledTime_(error);
       error.handled = this.playerInterface_.disableStream(
           mediaState.stream, maxDisabledTime);

package/lib/player.js

@@ -5297,6 +5297,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
 
     if (this.loadMode_ == shaka.Player.LoadMode.SRC_EQUALS) {
+      this.stats_.addBytesDownloaded(NaN);
       this.stats_.setResolution(
           /* width= */ element.videoWidth || NaN,
           /* height= */ element.videoHeight || NaN);
@@ -6942,19 +6943,32 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     if (hasAltStream) {
       let didDisableStream = false;
 
+      let isTrickModeVideo = false;
+
       for (const variant of this.manifest_.variants) {
         const candidate = variant[stream.type];
 
-        if (candidate && candidate.id === stream.id) {
+        if (!candidate) {
+          continue;
+        }
+
+        if (candidate.id === stream.id) {
           variant.disabledUntilTime = (Date.now() / 1000) + disableTime;
           didDisableStream = true;
 
           shaka.log.v2(
               'Disabled stream ' + stream.type + ':' + stream.id +
               ' for ' + disableTime + ' seconds...');
+        } else if (candidate.trickModeVideo &&
+            candidate.trickModeVideo.id == stream.id) {
+          isTrickModeVideo = true;
         }
       }
 
+      if (!didDisableStream && isTrickModeVideo) {
+        return false;
+      }
+
       goog.asserts.assert(didDisableStream, 'Must have disabled stream');
 
       this.checkVariantsTimer_.tickEvery(1);
@@ -7504,7 +7518,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @export
  */
 // eslint-disable-next-line no-useless-concat
-shaka.Player.version = 'v4.9.24' + '-uncompiled';  // x-release-please-version
+shaka.Player.version = 'v4.9.26' + '-uncompiled';  // x-release-please-version
 
 // Initialize the deprecation system using the version string we just set
 // on the player.

package/lib/text/ui_text_displayer.js

@@ -710,10 +710,6 @@ shaka.text.UITextDisplayer = class {
           // Only do this for the text itself.
           elem.style.backgroundColor = 'rgba(0, 0, 0, 0.8)';
         }
-        const fontFamily = inherit((c) => c.fontFamily);
-        if (fontFamily) {
-          elem.style.fontFamily = fontFamily;
-        }
       }
       if (text) {
         elem.textContent = text;

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/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);
   }
 
   /**
@@ -873,7 +887,12 @@ shaka.util.TXml = class {
    */
   static txmlNodeToDomElement(node) {
     const TXml = shaka.util.TXml;
-    const element = document.createElementNS('', 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];
@@ -892,9 +911,41 @@ shaka.util.TXml = class {
 
     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.9.24",
+  "version": "4.9.26",
   "homepage": "https://github.com/shaka-project/shaka-player",
   "author": "Google",
   "maintainers": [

package/ui/less/containers.less

@@ -22,10 +22,9 @@
   }
 
   /* Set the fonts for all other content. */
-  * {
-    font-family: Roboto-Regular, Roboto, sans-serif, TengwarTelcontar;
-    -webkit-font-smoothing: antialiased;
-  }
+  font-family: Roboto, sans-serif, TengwarTelcontar;
+  font-weight: normal;
+  -webkit-font-smoothing: antialiased;
 }
 
 /* Each browser has a different prefixed pseudo-class for fullscreened elements.

package/ui/less/tooltip.less

@@ -47,7 +47,7 @@
       content: attr(aria-label);
 
       /* Override .material-icons-round text styling */
-      font-family: Roboto-Regular, Roboto, sans-serif;
+      font-family: Roboto, sans-serif;
       line-height: calc(@material-icons-width / 2);
       white-space: nowrap;
       font-size: 13px;