shaka-player 4.10.11 → 4.10.13

package/lib/cea/mp4_cea_parser.js

@@ -105,14 +105,16 @@ shaka.cea.Mp4CeaParser = class {
         // These are the various boxes that signal a codec.
         .box('avc1', codecBoxParser)
         .box('avc3', codecBoxParser)
-        .box('hev1', codecBoxParser)
-        .box('hvc1', codecBoxParser)
         .box('dvav', codecBoxParser)
         .box('dva1', codecBoxParser)
+        .box('hev1', codecBoxParser)
+        .box('hvc1', codecBoxParser)
         .box('dvh1', codecBoxParser)
         .box('dvhe', codecBoxParser)
         .box('vvc1', codecBoxParser)
         .box('vvi1', codecBoxParser)
+        .box('dvc1', codecBoxParser)
+        .box('dvi1', codecBoxParser)
 
         // This signals an encrypted sample, which we can go inside of to find
         // the codec used.
@@ -406,18 +408,21 @@ shaka.cea.Mp4CeaParser.CodecBitstreamMap_ = {
   // AVC
   'avc1': shaka.cea.Mp4CeaParser.BitstreamFormat.H264,
   'avc3': shaka.cea.Mp4CeaParser.BitstreamFormat.H264,
-  // HEVC
-  'hev1': shaka.cea.Mp4CeaParser.BitstreamFormat.H265,
-  'hvc1': shaka.cea.Mp4CeaParser.BitstreamFormat.H265,
   // Dolby Vision based in AVC
   'dvav': shaka.cea.Mp4CeaParser.BitstreamFormat.H264,
   'dva1': shaka.cea.Mp4CeaParser.BitstreamFormat.H264,
+  // HEVC
+  'hev1': shaka.cea.Mp4CeaParser.BitstreamFormat.H265,
+  'hvc1': shaka.cea.Mp4CeaParser.BitstreamFormat.H265,
   // Dolby Vision based in HEVC
   'dvh1': shaka.cea.Mp4CeaParser.BitstreamFormat.H265,
   'dvhe': shaka.cea.Mp4CeaParser.BitstreamFormat.H265,
   // VVC
   'vvc1': shaka.cea.Mp4CeaParser.BitstreamFormat.H266,
   'vvi1': shaka.cea.Mp4CeaParser.BitstreamFormat.H266,
+  // Dolby Vision based in VVC
+  'dvc1': shaka.cea.Mp4CeaParser.BitstreamFormat.H266,
+  'dvi1': shaka.cea.Mp4CeaParser.BitstreamFormat.H266,
 };
 
 /**

package/lib/config/codec_switching_strategy.js

@@ -11,14 +11,18 @@ goog.provide('shaka.config.CodecSwitchingStrategy');
  * @export
  */
 shaka.config.CodecSwitchingStrategy = {
-  // Allow codec switching which will always involve reloading the
-  // `MediaSource`.
-  RELOAD: 'reload',
-  // Allow codec switching; determine if `SourceBuffer.changeType` is available
-  // and attempt to use this first, but fall back to reloading `MediaSource` if
-  // not available.
-  //
-  // Note: Some devices that support `SourceBuffer.changeType` can become stuck
-  // in a pause state.
-  SMOOTH: 'smooth',
+  /**
+   * Allow codec switching which will always involve reloading
+   * the <code<MediaSource</code>.
+   */
+  'RELOAD': 'reload',
+  /**
+   * Allow codec switching; determine if <code>SourceBuffer.changeType</code>
+   * is available and attempt to use this first, but fall back to reloading
+   * <code>MediaSource</code> if not available.
+   * <br>
+   * Note: Some devices that support <code>SourceBuffer.changeType</code> can
+   * become stuck in a pause state.
+   */
+  'SMOOTH': 'smooth',
 };

package/lib/dash/dash_parser.js

@@ -30,6 +30,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');
@@ -93,12 +94,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>}
@@ -256,6 +264,7 @@ shaka.dash.DashParser = class {
     this.manifestUris_ = [];
     this.manifest_ = null;
     this.streamMap_ = {};
+    this.indexStreamMap_ = {};
     this.contextCache_.clear();
     this.manifestPatchContext_ = {
       mpdId: '',
@@ -653,7 +662,7 @@ shaka.dash.DashParser = class {
     }
 
     this.manifestPatchContext_.type = mpdType;
-
+    this.cleanStreamMap_();
     /** @type {!shaka.media.PresentationTimeline} */
     let presentationTimeline;
     if (this.manifest_) {
@@ -734,7 +743,8 @@ shaka.dash.DashParser = class {
     };
 
     this.gapCount_ = 0;
-    const periodsAndDuration = this.parsePeriods_(context, getBaseUris, mpd);
+    const periodsAndDuration = this.parsePeriods_(
+        context, getBaseUris, mpd, /* newPeriod= */ false);
     const duration = periodsAndDuration.duration;
     const periods = periodsAndDuration.periods;
 
@@ -1013,7 +1023,7 @@ shaka.dash.DashParser = class {
     };
 
     const periodsAndDuration = this.parsePeriods_(context,
-        this.manifestPatchContext_.getBaseUris, periods);
+        this.manifestPatchContext_.getBaseUris, periods, /* newPeriod= */ true);
 
     return periodsAndDuration.periods;
   }
@@ -1033,6 +1043,10 @@ shaka.dash.DashParser = class {
         this.contextCache_.delete(contextId);
       }
     }
+    const newPeriods = this.lastManifestUpdatePeriodIds_.filter((pID) => {
+      return pID !== periodId;
+    });
+    this.lastManifestUpdatePeriodIds_ = newPeriods;
   }
 
   /**
@@ -1274,6 +1288,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,
@@ -1281,7 +1296,7 @@ shaka.dash.DashParser = class {
    * }}
    * @private
    */
-  parsePeriods_(context, getBaseUris, mpd) {
+  parsePeriods_(context, getBaseUris, mpd, newPeriod) {
     const TXml = shaka.util.TXml;
     let presentationDuration = context.mediaPresentationDuration;
 
@@ -1413,8 +1428,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) {
@@ -1442,6 +1467,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
@@ -1458,6 +1503,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;
@@ -2221,7 +2267,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;
@@ -2235,45 +2286,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;
@@ -3137,7 +3172,7 @@ shaka.dash.DashParser.Context;
  * @typedef {{
  *   start: number,
  *   duration: ?number,
- *   node: !shaka.extern.xml.Node,
+ *   node: ?shaka.extern.xml.Node,
  *   isLastPeriod: boolean
  * }}
  *
@@ -3149,7 +3184,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/hls/hls_parser.js

@@ -736,6 +736,9 @@ shaka.hls.HlsParser = class {
         // also start 6 seconds apart in presentation time.
 
         const segment0 = segmentIndex.earliestReference();
+        if (!segment0) {
+          continue;
+        }
         if (segment0.syncTime == null) {
           shaka.log.alwaysError('Missing EXT-X-PROGRAM-DATE-TIME for stream',
               streamInfo.getUris(),

package/lib/media/content_workarounds.js

@@ -95,6 +95,18 @@ shaka.media.ContentWorkarounds = class {
             newType: ContentWorkarounds.BOX_TYPE_ENCV_,
           });
         })
+        .fullBox('dvc1', (box) => {
+          boxesToModify.push({
+            box,
+            newType: ContentWorkarounds.BOX_TYPE_ENCV_,
+          });
+        })
+        .fullBox('dvi1', (box) => {
+          boxesToModify.push({
+            box,
+            newType: ContentWorkarounds.BOX_TYPE_ENCV_,
+          });
+        })
         .fullBox('hev1', (box) => {
           boxesToModify.push({
             box,

package/lib/media/segment_utils.js

@@ -493,9 +493,13 @@ shaka.media.SegmentUtils = class {
       return codecs;
     }
     const dolbyVision = codecs.find((codec) => {
-      return codec.startsWith('dvh1.') ||
+      return codec.startsWith('dvav.') ||
+          codec.startsWith('dva1.') ||
+          codec.startsWith('dvh1.') ||
           codec.startsWith('dvhe.') ||
-          codec.startsWith('dav1.');
+          codec.startsWith('dav1.') ||
+          codec.startsWith('dvc1.') ||
+          codec.startsWith('dvi1.');
     });
     if (!dolbyVision) {
       return codecs;

package/lib/media/streaming_engine.js

@@ -15,10 +15,9 @@ goog.require('shaka.log');
 goog.require('shaka.media.InitSegmentReference');
 goog.require('shaka.media.ManifestParser');
 goog.require('shaka.media.MediaSourceEngine');
-goog.require('shaka.media.SegmentIndex');
 goog.require('shaka.media.SegmentIterator');
-goog.require('shaka.media.SegmentPrefetch');
 goog.require('shaka.media.SegmentReference');
+goog.require('shaka.media.SegmentPrefetch');
 goog.require('shaka.media.SegmentUtils');
 goog.require('shaka.net.Backoff');
 goog.require('shaka.net.NetworkingEngine');
@@ -75,16 +74,9 @@ shaka.media.StreamingEngine = class {
     this.config_ = null;
 
     /**
-     * Retains deferred SegmentIndex objects for streams which were switched
-     * away from during an ongoing fetchAndAppend_().
-     * They are released and cleared from this map when the next onUpdate_() for
-     * a stream's content type occurs.
-     * This is because at that point, it is guaranteed no logic is actively
-     * using information for these old streams.
-     *
-     * Lastly, the operations are stored in arrays in the off chance multiple
-     * ABR switches happen during an ongoing fetchAndAppend_().
-     * @private {!Map.<string, !Array.<?shaka.media.SegmentIndex>>}
+     * 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();
 
@@ -176,7 +168,6 @@ shaka.media.StreamingEngine = class {
         state.segmentPrefetch.clearAll();
         state.segmentPrefetch = null;
       }
-      this.handleDeferredCloseSegmentIndexes_(state);
     }
     for (const prefetch of this.audioPrefetchMap_.values()) {
       prefetch.clearAll();
@@ -186,7 +177,6 @@ shaka.media.StreamingEngine = class {
 
     this.mediaStates_.clear();
     this.audioPrefetchMap_.clear();
-    this.deferredCloseSegmentIndex_.clear();
 
     this.playerInterface_ = null;
     this.manifest_ = null;
@@ -530,14 +520,9 @@ shaka.media.StreamingEngine = class {
   handleDeferredCloseSegmentIndexes_(mediaState) {
     for (const [key, value] of this.deferredCloseSegmentIndex_.entries()) {
       const streamId = /** @type {string} */ (key);
-      const segmentIndexArray =
-      /** @type {!Array.<?shaka.media.SegmentIndex>} */ (value);
+      const closeSegmentIndex = /** @type {!function()} */ (value);
       if (streamId.includes(mediaState.type)) {
-        for (const segmentIndex of segmentIndexArray) {
-          if (segmentIndex) {
-            segmentIndex.release();
-          }
-        }
+        closeSegmentIndex();
         this.deferredCloseSegmentIndex_.delete(streamId);
       }
     }
@@ -612,26 +597,23 @@ shaka.media.StreamingEngine = class {
           fullMimeType, this.manifest_.sequenceMode, stream.external);
     }
 
-    // Releases the segmentIndex of the old stream if safe to do so.
+    // Releases the segmentIndex of the old stream.
     // Do not close segment indexes we are prefetching.
     if (!this.audioPrefetchMap_.has(mediaState.stream)) {
       if (mediaState.stream.closeSegmentIndex) {
         if (mediaState.performingUpdate) {
           const oldStreamTag =
               shaka.media.StreamingEngine.logPrefix_(mediaState);
-          // 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.
-          // onUpdate_() will resume the closeSegmentIndex() operation for the
-          // old stream when the update has finished.
           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.segmentIndex]);
-          } else {
-            // We switched from stream A -> B -> back to A.
-            this.deferredCloseSegmentIndex_.get(oldStreamTag).push(
-                mediaState.stream.segmentIndex);
+                oldStreamTag, mediaState.stream.closeSegmentIndex);
           }
         } else {
           mediaState.stream.closeSegmentIndex();
@@ -643,8 +625,8 @@ shaka.media.StreamingEngine = class {
     mediaState.segmentIterator = null;
     mediaState.adaptation = !!adaptation;
 
-    const newStreamTag = shaka.media.StreamingEngine.logPrefix_(mediaState);
-    shaka.log.debug('switch: switching to Stream ' + newStreamTag);
+    const streamTag = shaka.media.StreamingEngine.logPrefix_(mediaState);
+    shaka.log.debug('switch: switching to Stream ' + streamTag);
 
     if (clearBuffer) {
       if (mediaState.clearingBuffer) {
@@ -1228,6 +1210,11 @@ 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.
@@ -1546,7 +1533,8 @@ shaka.media.StreamingEngine = class {
       // If there's positive drift then we need to adjust the lookup time, and
       // may wind up requesting the previous segment to be safe.
       // inaccurateManifestTolerance should be 0 for low latency streaming.
-      const inaccurateTolerance = this.config_.inaccurateManifestTolerance;
+      const inaccurateTolerance = this.manifest_.sequenceMode ?
+        0 : this.config_.inaccurateManifestTolerance;
       const lookupTime = Math.max(presentationTime - inaccurateTolerance, 0);
 
       shaka.log.v1(logPrefix, 'looking up segment',
@@ -2086,6 +2074,8 @@ shaka.media.StreamingEngine = class {
                 .box('dva1', Mp4Parser.visualSampleEntry)
                 .box('dvh1', Mp4Parser.visualSampleEntry)
                 .box('dvhe', Mp4Parser.visualSampleEntry)
+                .box('dvc1', Mp4Parser.visualSampleEntry)
+                .box('dvi1', Mp4Parser.visualSampleEntry)
                 .box('vexu', Mp4Parser.children)
                 .box('proj', Mp4Parser.children)
                 .fullBox('prji', (box) => {
@@ -2810,6 +2800,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

@@ -4454,9 +4454,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * beginning or end of the seekable range for the content.
    *
    * @param {number} rate
+   * @param {boolean=} useTrickPlayTrack
    * @export
    */
-  trickPlay(rate) {
+  trickPlay(rate, useTrickPlayTrack = true) {
     // A playbackRate of 0 is used internally when we are in a buffering state,
     // and doesn't make sense for trick play.  If you set a rate of 0 for trick
     // play, we will reject it and issue a warning.  If it happens during a
@@ -4478,7 +4479,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
 
     if (this.loadMode_ == shaka.Player.LoadMode.MEDIA_SOURCE) {
       this.abrManager_.playbackRateChanged(rate);
-      this.streamingEngine_.setTrickPlay(Math.abs(rate) > 1);
+      this.streamingEngine_.setTrickPlay(
+          useTrickPlayTrack && Math.abs(rate) > 1);
     }
     if (this.isLive()) {
       this.trickPlayEventManager_.listen(this.video_, 'timeupdate', () => {
@@ -5561,6 +5563,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);
@@ -6502,7 +6505,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           shaka.log.debug('Buffer fullness ratio (' + bufferFullness + ') ' +
             'is less than the vodDynamicPlaybackRateBufferRatio (' +
             bufferThreshold + '). Updating playbackRate to ' + minPlaybackRate);
-          this.trickPlay(minPlaybackRate);
+          this.trickPlay(minPlaybackRate, /* useTrickPlayTrack= */ false);
         }
       } else if (bufferFullness == 1) {
         if (playbackRate !== this.playRateController_.getDefaultRate()) {
@@ -6629,7 +6632,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           timeSinceLastRebuffer + 's) ' +
           'is less than the live sync panicThreshold (' + panicThreshold +
           's). Updating playbackRate to ' + minPlaybackRate);
-        this.trickPlay(minPlaybackRate);
+        this.trickPlay(minPlaybackRate, /* useTrickPlayTrack= */ false);
       }
     } else if (maxLatency && maxPlaybackRate &&
       (latency - offset) > maxLatency) {
@@ -6637,7 +6640,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         shaka.log.debug('Latency (' + latency + 's) is greater than ' +
           'live sync maxLatency (' + maxLatency + 's). ' +
           'Updating playbackRate to ' + maxPlaybackRate);
-        this.trickPlay(maxPlaybackRate);
+        this.trickPlay(maxPlaybackRate, /* useTrickPlayTrack= */ false);
       }
       this.targetLatencyReached_ = null;
     } else if (minLatency && minPlaybackRate &&
@@ -6646,7 +6649,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         shaka.log.debug('Latency (' + latency + 's) is smaller than ' +
           'live sync minLatency (' + minLatency + 's). ' +
           'Updating playbackRate to ' + minPlaybackRate);
-        this.trickPlay(minPlaybackRate);
+        this.trickPlay(minPlaybackRate, /* useTrickPlayTrack= */ false);
       }
       this.targetLatencyReached_ = null;
     } else if (playbackRate !== this.playRateController_.getDefaultRate()) {
@@ -7257,19 +7260,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);
@@ -7832,7 +7848,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @export
  */
 // eslint-disable-next-line no-useless-concat
-shaka.Player.version = 'v4.10.11' + '-uncompiled';  // x-release-please-version
+shaka.Player.version = 'v4.10.13' + '-uncompiled';  // x-release-please-version
 
 // Initialize the deprecation system using the version string we just set
 // on the player.

package/lib/util/mime_utils.js

@@ -172,6 +172,9 @@ shaka.util.MimeUtils = class {
       case base === 'hvc1':
       case base === 'hev1':
         return 'hevc'; // H265
+      case base === 'vvc1':
+      case base === 'vvi1':
+        return 'vvc'; // H266
       case base === 'dvh1':
       case base === 'dvhe':
         return 'dovi-hevc'; // Dolby Vision based in HEVC
@@ -180,6 +183,9 @@ shaka.util.MimeUtils = class {
         return 'dovi-avc'; // Dolby Vision based in AVC
       case base === 'dav1':
         return 'dovi-av1'; // Dolby Vision based in AV1
+      case base === 'dvc1':
+      case base === 'dvi1':
+        return 'dovi-vvc'; // Dolby Vision based in VVC
     }
     return base;
   }