shaka-player 4.6.4 → 4.7.0

package/lib/media/adaptation_set_criteria.js

@@ -58,8 +58,10 @@ shaka.media.ExampleBasedCriteria = class {
     // We can't know if role and label are really important, so we don't use
     // role and label for this.
     const role = '';
-    const label = '';
+    const audioLabel = '';
+    const videoLabel = '';
     const hdrLevel = '';
+    const spatialAudio = false;
     const videoLayout = '';
     const channelCount = example.audio && example.audio.channelsCount ?
                          example.audio.channelsCount :
@@ -67,7 +69,8 @@ shaka.media.ExampleBasedCriteria = class {
 
     /** @private {!shaka.media.AdaptationSetCriteria} */
     this.fallback_ = new shaka.media.PreferenceBasedCriteria(
-        example.language, role, channelCount, hdrLevel, videoLayout, label,
+        example.language, role, channelCount, hdrLevel, spatialAudio,
+        videoLayout, audioLabel, videoLabel,
         codecSwitchingStrategy, enableAudioGroups);
   }
 
@@ -106,12 +109,15 @@ shaka.media.PreferenceBasedCriteria = class {
    * @param {string} role
    * @param {number} channelCount
    * @param {string} hdrLevel
+   * @param {boolean} spatialAudio
    * @param {string} videoLayout
-   * @param {string=} label
+   * @param {string=} audioLabel
+   * @param {string=} videoLabel
    * @param {shaka.config.CodecSwitchingStrategy=} codecSwitchingStrategy
    * @param {boolean=} enableAudioGroups
    */
-  constructor(language, role, channelCount, hdrLevel, videoLayout, label = '',
+  constructor(language, role, channelCount, hdrLevel, spatialAudio,
+      videoLayout, audioLabel = '', videoLabel = '',
       codecSwitchingStrategy = shaka.config.CodecSwitchingStrategy.RELOAD,
       enableAudioGroups = false) {
     /** @private {string} */
@@ -122,10 +128,14 @@ shaka.media.PreferenceBasedCriteria = class {
     this.channelCount_ = channelCount;
     /** @private {string} */
     this.hdrLevel_ = hdrLevel;
+    /** @private {boolean} */
+    this.spatialAudio_ = spatialAudio;
     /** @private {string} */
     this.videoLayout_ = videoLayout;
     /** @private {string} */
-    this.label_ = label;
+    this.audioLabel_ = audioLabel;
+    /** @private {string} */
+    this.videoLabel_ = videoLabel;
     /** @private {shaka.config.CodecSwitchingStrategy} */
     this.codecSwitchingStrategy_ = codecSwitchingStrategy;
     /** @private {boolean} */
@@ -191,15 +201,34 @@ shaka.media.PreferenceBasedCriteria = class {
       }
     }
 
-    if (this.label_) {
-      const byLabel = Class.filterVariantsByLabel_(current, this.label_);
+    if (this.audioLabel_) {
+      const byLabel = Class.filterVariantsByAudioLabel_(
+          current, this.audioLabel_);
+      if (byLabel.length) {
+        current = byLabel;
+      } else {
+        shaka.log.warning('No exact match for audio label could be found.');
+      }
+    }
+
+    if (this.videoLabel_) {
+      const byLabel = Class.filterVariantsByVideoLabel_(
+          current, this.videoLabel_);
       if (byLabel.length) {
         current = byLabel;
       } else {
-        shaka.log.warning('No exact match for variant label could be found.');
+        shaka.log.warning('No exact match for video label could be found.');
       }
     }
 
+    const bySpatialAudio = Class.filterVariantsBySpatialAudio_(
+        current, this.spatialAudio_);
+    if (bySpatialAudio.length) {
+      current = bySpatialAudio;
+    } else {
+      shaka.log.warning('No exact match for spatial audio could be found.');
+    }
+
     const supportsSmoothCodecTransitions = this.codecSwitchingStrategy_ ==
       shaka.config.CodecSwitchingStrategy.SMOOTH &&
         shaka.media.Capabilities.isChangeTypeSupported();
@@ -259,14 +288,14 @@ shaka.media.PreferenceBasedCriteria = class {
   }
 
   /**
-   * Filter Variants by label.
+   * Filter Variants by audio label.
    *
    * @param {!Array.<shaka.extern.Variant>} variants
    * @param {string} preferredLabel
    * @return {!Array.<shaka.extern.Variant>}
    * @private
    */
-  static filterVariantsByLabel_(variants, preferredLabel) {
+  static filterVariantsByAudioLabel_(variants, preferredLabel) {
     return variants.filter((variant) => {
       if (!variant.audio || !variant.audio.label) {
         return false;
@@ -278,6 +307,26 @@ shaka.media.PreferenceBasedCriteria = class {
     });
   }
 
+  /**
+   * Filter Variants by video label.
+   *
+   * @param {!Array.<shaka.extern.Variant>} variants
+   * @param {string} preferredLabel
+   * @return {!Array.<shaka.extern.Variant>}
+   * @private
+   */
+  static filterVariantsByVideoLabel_(variants, preferredLabel) {
+    return variants.filter((variant) => {
+      if (!variant.video || !variant.video.label) {
+        return false;
+      }
+
+      const label1 = variant.video.label.toLowerCase();
+      const label2 = preferredLabel.toLowerCase();
+      return label1 == label2;
+    });
+  }
+
   /**
    * Filter Variants by channelCount.
    *
@@ -337,4 +386,21 @@ shaka.media.PreferenceBasedCriteria = class {
       return true;
     });
   }
+
+
+  /**
+   * Filters variants according to the given spatial audio config.
+   *
+   * @param {!Array.<shaka.extern.Variant>} variants
+   * @param {boolean} spatialAudio
+   * @private
+   */
+  static filterVariantsBySpatialAudio_(variants, spatialAudio) {
+    return variants.filter((variant) => {
+      if (variant.audio && variant.audio.spatialAudio != spatialAudio) {
+        return false;
+      }
+      return true;
+    });
+  }
 };

package/lib/media/media_source_engine.js

@@ -148,6 +148,9 @@ shaka.media.MediaSourceEngine = class {
 
     /** @private {boolean} */
     this.streamingAllowed_ = true;
+
+    /** @private {?number} */
+    this.lastDuration_ = null;
   }
 
   /**
@@ -1088,7 +1091,8 @@ shaka.media.MediaSourceEngine = class {
    *   value will be dropped.
    * @param {boolean} ignoreTimestampOffset  If true, the timestampOffset will
    *   not be applied in this step.
-   * @param {shaka.extern.Stream} stream The current stream.
+   * @param {string} mimeType
+   * @param {string} codecs
    * @param {!Map.<shaka.util.ManifestParserUtils.ContentType,
    *               shaka.extern.Stream>} streamsByType
    *   A map of content types to streams.  All streams must be supported
@@ -1098,7 +1102,7 @@ shaka.media.MediaSourceEngine = class {
    */
   async setStreamProperties(
       contentType, timestampOffset, appendWindowStart, appendWindowEnd,
-      ignoreTimestampOffset, stream, streamsByType) {
+      ignoreTimestampOffset, mimeType, codecs, streamsByType) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     if (contentType == ContentType.TEXT) {
       if (!ignoreTimestampOffset) {
@@ -1109,8 +1113,8 @@ shaka.media.MediaSourceEngine = class {
     }
     const operations = [];
 
-    const hasChangedCodecs =
-        await this.codecSwitchIfNecessary_(contentType, stream, streamsByType);
+    const hasChangedCodecs = await this.codecSwitchIfNecessary_(
+        contentType, mimeType, codecs, streamsByType);
 
     if (!hasChangedCodecs) {
       // Queue an abort() to help MSE splice together overlapping segments.
@@ -1241,6 +1245,7 @@ shaka.media.MediaSourceEngine = class {
       }
 
       this.mediaSource_.duration = duration;
+      this.lastDuration_ = duration;
     });
   }
 
@@ -1758,7 +1763,11 @@ shaka.media.MediaSourceEngine = class {
       this.mediaSourceOpen_ = new shaka.util.PublicPromise();
       this.mediaSource_ = this.createMediaSource(this.mediaSourceOpen_);
       await this.mediaSourceOpen_;
-      this.mediaSource_.duration = previousDuration;
+      if (!isNaN(previousDuration) && previousDuration) {
+        this.mediaSource_.duration = previousDuration;
+      } else if (!isNaN(this.lastDuration_) && this.lastDuration_) {
+        this.mediaSource_.duration = this.lastDuration_;
+      }
 
       const sourceBufferAdded = new shaka.util.PublicPromise();
       const sourceBuffers =
@@ -1819,15 +1828,17 @@ shaka.media.MediaSourceEngine = class {
    * Codec switch if necessary, this will not resolve until the codec
    * switch is over.
    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
-   * @param {shaka.extern.Stream} stream
+   * @param {string} mimeType
+   * @param {string} codecs
    * @param {!Map.<shaka.util.ManifestParserUtils.ContentType,
    *               shaka.extern.Stream>} streamsByType
    * @return {!Promise.<boolean>} true if there was a codec switch,
    *                              false otherwise.
    * @private
    */
-  async codecSwitchIfNecessary_(contentType, stream, streamsByType) {
-    if (contentType == shaka.util.ManifestParserUtils.ContentType.TEXT) {
+  async codecSwitchIfNecessary_(contentType, mimeType, codecs, streamsByType) {
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
+    if (contentType == ContentType.TEXT) {
       return false;
     }
     const MimeUtils = shaka.util.MimeUtils;
@@ -1838,30 +1849,43 @@ shaka.media.MediaSourceEngine = class {
 
     /** @type {?shaka.extern.Transmuxer} */
     let transmuxer;
-    let newMimeType = shaka.util.MimeUtils.getFullType(
-        stream.mimeType, stream.codecs);
+    let transmuxerMuxed = false;
+    let newMimeType = shaka.util.MimeUtils.getFullType(mimeType, codecs);
     let needTransmux = this.config_.forceTransmux;
     if (!shaka.media.Capabilities.isTypeSupported(newMimeType) ||
         (!this.sequenceMode_ &&
         shaka.util.MimeUtils.RAW_FORMATS.includes(newMimeType))) {
       needTransmux = true;
     }
-    const newMimeTypeWithAllCodecs =
-        shaka.util.MimeUtils.getFullTypeWithAllCodecs(
-            stream.mimeType, stream.codecs);
     const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
     if (needTransmux) {
+      const newMimeTypeWithAllCodecs =
+          shaka.util.MimeUtils.getFullTypeWithAllCodecs(mimeType, codecs);
       const transmuxerPlugin =
           TransmuxerEngine.findTransmuxer(newMimeTypeWithAllCodecs);
       if (transmuxerPlugin) {
         transmuxer = transmuxerPlugin();
-        newMimeType =
-            transmuxer.convertCodecs(contentType, newMimeTypeWithAllCodecs);
+        const audioCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
+            ContentType.AUDIO, (codecs || '').split(','));
+        const videoCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
+            ContentType.VIDEO, (codecs || '').split(','));
+        if (audioCodec && videoCodec) {
+          transmuxerMuxed = true;
+          let codec = videoCodec;
+          if (contentType == ContentType.AUDIO) {
+            codec = audioCodec;
+          }
+          newMimeType = transmuxer.convertCodecs(contentType,
+              shaka.util.MimeUtils.getFullTypeWithAllCodecs(mimeType, codec));
+        } else {
+          newMimeType =
+              transmuxer.convertCodecs(contentType, newMimeTypeWithAllCodecs);
+        }
       }
     }
 
-    const newAllCodecs = MimeUtils.getCodecs(newMimeType);
-    const newCodec = MimeUtils.getCodecBase(newAllCodecs);
+    const newCodec = MimeUtils.getCodecBase(
+        MimeUtils.getCodecs(newMimeType));
     const newBasicType = MimeUtils.getBasicType(newMimeType);
 
     // Current/new codecs base and basic type match then no need to switch
@@ -1870,7 +1894,7 @@ shaka.media.MediaSourceEngine = class {
     }
 
     let allowChangeType = true;
-    if (this.needSplitMuxedContent_ || (newAllCodecs.split(',').length &&
+    if (this.needSplitMuxedContent_ || (transmuxerMuxed &&
         transmuxer && !this.transmuxers_[contentType])) {
       allowChangeType = false;
     }

package/lib/media/segment_reference.js

@@ -57,6 +57,12 @@ shaka.media.InitSegmentReference = class {
 
     /** @type {?shaka.extern.aes128Key} */
     this.aes128Key = aes128Key;
+
+    /** @type {?string} */
+    this.codecs = null;
+
+    /** @type {?string} */
+    this.mimeType = null;
   }
 
   /**
@@ -305,6 +311,12 @@ shaka.media.SegmentReference = class {
           this.partialReferences[this.partialReferences.length - 1];
       lastPartial.markAsLastPartial();
     }
+
+    /** @type {?string} */
+    this.codecs = null;
+
+    /** @type {?string} */
+    this.mimeType = null;
   }
 
   /**

package/lib/media/streaming_engine.js

@@ -119,6 +119,9 @@ shaka.media.StreamingEngine = class {
 
     /** @private {!shaka.util.Destroyer} */
     this.destroyer_ = new shaka.util.Destroyer(() => this.doDestroy_());
+
+    /** @private {number} */
+    this.lastMediaSourceReset_ = 0;
   }
 
   /** @override */
@@ -1090,8 +1093,8 @@ shaka.media.StreamingEngine = class {
         this.config_.rebufferingGoal,
         this.config_.bufferingGoal);
 
-    const scaledBufferingGoal =
-        unscaledBufferingGoal * this.bufferingGoalScale_;
+    const scaledBufferingGoal = Math.max(1,
+        unscaledBufferingGoal * this.bufferingGoalScale_);
 
     // Check if we've buffered to the end of the presentation.
     const timeUntilEnd =
@@ -1636,6 +1639,13 @@ shaka.media.StreamingEngine = class {
     });
 
     if (!waitingForAnotherStreamToRecover) {
+      if (this.config_.maxDisabledTime > 0) {
+        const handled = this.playerInterface_.disableStream(
+            mediaState.stream, this.config_.maxDisabledTime);
+        if (handled) {
+          return;
+        }
+      }
       // Reduction schedule: 80%, 60%, 40%, 20%, 16%, 12%, 8%, 4%, fail.
       // Note: percentages are used for comparisons to avoid rounding errors.
       const percentBefore = Math.round(100 * this.bufferingGoalScale_);
@@ -1761,7 +1771,8 @@ shaka.media.StreamingEngine = class {
           await this.playerInterface_.mediaSourceEngine.setStreamProperties(
               mediaState.type, timestampOffset, appendWindowStart,
               appendWindowEnd, ignoreTimestampOffset,
-              mediaState.stream, streamsByType);
+              reference.mimeType || mediaState.stream.mimeType,
+              reference.codecs || mediaState.stream.codecs, streamsByType);
           if (isResetMediaSourceNecessary) {
             let otherState = null;
             if (mediaState.type === ContentType.VIDEO) {
@@ -2453,6 +2464,47 @@ shaka.media.StreamingEngine = class {
     return this.config_.maxDisabledTime;
   }
 
+  /**
+   * Reset Media Source
+   *
+   * @return {!Promise.<boolean>}
+   */
+  async resetMediaSource() {
+    const now = (Date.now() / 1000);
+    const minTimeBetweenRecoveries = this.config_.minTimeBetweenRecoveries;
+    if (!this.config_.allowMediaSourceRecoveries ||
+        (now - this.lastMediaSourceReset_) < minTimeBetweenRecoveries) {
+      return false;
+    }
+    this.lastMediaSourceReset_ = now;
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
+    const audioMediaState = this.mediaStates_.get(ContentType.AUDIO);
+    if (audioMediaState) {
+      audioMediaState.lastInitSegmentReference = null;
+      this.forceClearBuffer_(audioMediaState);
+      this.abortOperations_(audioMediaState).catch(() => {});
+    }
+    const videoMediaState = this.mediaStates_.get(ContentType.VIDEO);
+    if (videoMediaState) {
+      videoMediaState.lastInitSegmentReference = null;
+      this.forceClearBuffer_(videoMediaState);
+      this.abortOperations_(videoMediaState).catch(() => {});
+    }
+    /**
+     * @type {!Map.<shaka.util.ManifestParserUtils.ContentType,
+     *              shaka.extern.Stream>}
+     */
+    const streamsByType = new Map();
+    if (this.currentVariant_.audio) {
+      streamsByType.set(ContentType.AUDIO, this.currentVariant_.audio);
+    }
+    if (this.currentVariant_.video) {
+      streamsByType.set(ContentType.VIDEO, this.currentVariant_.video);
+    }
+    await this.playerInterface_.mediaSourceEngine.reset(streamsByType);
+    return true;
+  }
+
   /**
    * @param {shaka.media.StreamingEngine.MediaState_} mediaState
    * @return {string} A log prefix of the form ($CONTENT_TYPE:$STREAM_ID), e.g.,

package/lib/player.js

@@ -39,6 +39,7 @@ goog.require('shaka.text.UITextDisplayer');
 goog.require('shaka.text.WebVttGenerator');
 goog.require('shaka.util.BufferUtils');
 goog.require('shaka.util.CmcdManager');
+goog.require('shaka.util.CmsdManager');
 goog.require('shaka.util.ConfigUtils');
 goog.require('shaka.util.Dom');
 goog.require('shaka.util.Error');
@@ -598,6 +599,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     /** @private {shaka.util.CmcdManager} */
     this.cmcdManager_ = null;
 
+    /** @private {shaka.util.CmsdManager} */
+    this.cmsdManager_ = null;
+
     // This is the canvas element that will be used for rendering LCEVC
     // enhanced frames.
     /** @private {?HTMLCanvasElement} */
@@ -676,8 +680,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
             this.config_.preferredVariantRole,
             this.config_.preferredAudioChannelCount,
             this.config_.preferredVideoHdrLevel,
+            this.config_.preferSpatialAudio,
             this.config_.preferredVideoLayout,
             this.config_.preferredAudioLabel,
+            this.config_.preferredVideoLabel,
             this.config_.mediaSource.codecSwitchingStrategy,
             this.config_.manifest.dash.enableAudioGroups);
 
@@ -701,6 +707,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     // Create the CMCD manager so client data can be attached to all requests
     this.cmcdManager_ = this.createCmcd_();
 
+    this.cmsdManager_ = this.createCmsd_();
+
     this.networkingEngine_ = this.createNetworkingEngine();
     this.networkingEngine_.setForceHTTPS(this.config_.streaming.forceHTTPS);
 
@@ -846,6 +854,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     this.stats_ = null;
     this.videoContainer_ = null;
     this.cmcdManager_ = null;
+    this.cmsdManager_ = null;
 
     if (this.networkingEngine_) {
       await this.networkingEngine_.destroy();
@@ -1217,6 +1226,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.adManager_.onAssetUnload();
       }
 
+      if (this.cmsdManager_) {
+        this.cmsdManager_.reset();
+      }
+
       if (this.video_) {
         // Remove all track nodes
         shaka.util.Dom.removeAllChildren(this.video_);
@@ -1576,6 +1589,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     goog.asserts.assert(
         this.cmcdManager_,
         'Need CMCD manager to populate manifest request data.');
+    goog.asserts.assert(
+        this.cmsdManager_,
+        'Need CMSD manager to process response headers.');
     goog.asserts.assert(
         this.config_,
         'Need player config when initializing the parser.');
@@ -1825,6 +1841,12 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
             'Please use an AbrManager with setMediaElement function.');
         this.abrManager_.setMediaElement = () => {};
       }
+      if (typeof this.abrManager_.setCmsdManager != 'function') {
+        shaka.Deprecate.deprecateFeature(5,
+            'AbrManager',
+            'Please use an AbrManager with setCmsdManager function.');
+        this.abrManager_.setCmsdManager = () => {};
+      }
       this.abrManager_.configure(this.config_.abr);
     }
 
@@ -1836,8 +1858,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
             this.config_.preferredVariantRole,
             this.config_.preferredAudioChannelCount,
             this.config_.preferredVideoHdrLevel,
+            this.config_.preferSpatialAudio,
             this.config_.preferredVideoLayout,
             this.config_.preferredAudioLabel,
+            this.config_.preferredVideoLabel,
             this.config_.mediaSource.codecSwitchingStrategy,
             this.config_.manifest.dash.enableAudioGroups);
 
@@ -1853,6 +1877,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       return this.switch_(variant, clearBuffer, safeMargin);
     });
     this.abrManager_.setMediaElement(mediaElement);
+    this.abrManager_.setCmsdManager(this.cmsdManager_);
 
     // If the content is multi-codec and the browser can play more than one of
     // them, choose codecs now before we initialize streaming.
@@ -2607,6 +2632,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
           .set('request', request)
           .set('requestType', requestType);
       this.dispatchEvent(this.makeEvent_(name, data));
+      if (this.cmsdManager_) {
+        this.cmsdManager_.processHeaders(headers);
+      }
     };
     /** @type {shaka.net.NetworkingEngine.OnDownloadFailed} */
     const onDownloadFailed_ = (request, error, httpResponseCode, aborted) => {
@@ -2847,6 +2875,15 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     return new shaka.util.CmcdManager(playerInterface, this.config_.cmcd);
   }
 
+  /**
+   * Create a new CMSD manager.
+   *
+   * @private
+   */
+  createCmsd_() {
+    return new shaka.util.CmsdManager(this.config_.cmsd);
+  }
+
   /**
    * Creates a new instance of StreamingEngine.  This can be replaced by tests
    * to create fake instances instead.
@@ -2947,9 +2984,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     }
 
     // If lowLatencyMode is enabled, and inaccurateManifestTolerance and
-    // rebufferingGoal and segmentPrefetchLimit are not specified, set
-    // inaccurateManifestTolerance to 0 and rebufferingGoal to 0.01 and
-    // segmentPrefetchLimit to 2 by default for low latency streaming.
+    // rebufferingGoal and segmentPrefetchLimit and baseDelay are not
+    // specified, set inaccurateManifestTolerance to 0 and rebufferingGoal
+    // to 0.01 and segmentPrefetchLimit to 2 and baseDelay to 100 by default
+    // for low latency streaming.
     if (config['streaming'] && config['streaming']['lowLatencyMode']) {
       if (config['streaming']['inaccurateManifestTolerance'] == undefined) {
         config['streaming']['inaccurateManifestTolerance'] = 0;
@@ -2960,6 +2998,30 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       if (config['streaming']['segmentPrefetchLimit'] == undefined) {
         config['streaming']['segmentPrefetchLimit'] = 2;
       }
+      if (config['streaming']['retryParameters'] == undefined) {
+        config['streaming']['retryParameters'] = {};
+      }
+      if (config['streaming']['retryParameters']['baseDelay'] == undefined) {
+        config['streaming']['retryParameters']['baseDelay'] = 100;
+      }
+      if (config['manifest'] == undefined) {
+        config['manifest'] = {};
+      }
+      if (config['manifest']['retryParameters'] == undefined) {
+        config['manifest']['retryParameters'] = {};
+      }
+      if (config['manifest']['retryParameters']['baseDelay'] == undefined) {
+        config['manifest']['retryParameters']['baseDelay'] = 100;
+      }
+      if (config['drm'] == undefined) {
+        config['drm'] = {};
+      }
+      if (config['drm']['retryParameters'] == undefined) {
+        config['drm']['retryParameters'] = {};
+      }
+      if (config['drm']['retryParameters']['baseDelay'] == undefined) {
+        config['drm']['retryParameters']['baseDelay'] = 100;
+      }
     }
     const ret = shaka.util.PlayerConfiguration.mergeConfigObjects(
         this.config_, config, this.defaultConfig_());
@@ -3065,6 +3127,9 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
     if (this.cmcdManager_) {
       this.cmcdManager_.configure(this.config_.cmcd);
     }
+    if (this.cmsdManager_) {
+      this.cmsdManager_.configure(this.config_.cmsd);
+    }
   }
 
   /**
@@ -4001,8 +4066,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
               role || '',
               channelsCount,
               /* hdrLevel= */ '',
+              /* spatialAudio= */ false,
               /* videoLayout= */ '',
-              /* label= */ '',
+              /* audioLabel= */ '',
+              /* videoLabel= */ '',
               this.config_.mediaSource.codecSwitchingStrategy,
               this.config_.manifest.dash.enableAudioGroups);
 
@@ -4125,8 +4192,10 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
               /* role= */ '',
               /* channelCount= */ 0,
               /* hdrLevel= */ '',
+              /* spatialAudio= */ false,
               /* videoLayout= */ '',
               label,
+              /* videoLabel= */ '',
               this.config_.mediaSource.codecSwitchingStrategy,
               this.config_.manifest.dash.enableAudioGroups);
 
@@ -6188,7 +6257,7 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
    * @param {!shaka.util.Error} error
    * @private
    */
-  onError_(error) {
+  async onError_(error) {
     goog.asserts.assert(error instanceof shaka.util.Error, 'Wrong error type!');
 
     // Errors dispatched after |destroy| is called are not meaningful and should
@@ -6197,6 +6266,23 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
       return;
     }
 
+    let fireError = true;
+    if (this.fullyLoaded_ && this.manifest_ && this.streamingEngine_ &&
+        (error.code == shaka.util.Error.Code.VIDEO_ERROR ||
+        error.code == shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_FAILED ||
+        error.code == shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_THREW ||
+        error.code == shaka.util.Error.Code.TRANSMUXING_FAILED)) {
+      try {
+        const ret = await this.streamingEngine_.resetMediaSource();
+        fireError = !ret;
+      } catch (e) {
+        fireError = true;
+      }
+    }
+    if (!fireError) {
+      return;
+    }
+
     // Restore disabled variant if the player experienced a critical error.
     if (error.severity === shaka.util.Error.Severity.CRITICAL) {
       this.restoreDisabledVariants_(/* updateAbrManager= */ false);
@@ -6779,7 +6865,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @export
  */
 // eslint-disable-next-line no-useless-concat
-shaka.Player.version = 'v4.6.4' + '-uncompiled';  // x-release-please-version
+shaka.Player.version = 'v4.7.0' + '-uncompiled';  // x-release-please-version
 
 // Initialize the deprecation system using the version string we just set
 // on the player.