shaka-player 4.6.4 → 4.7.0

package/lib/util/cmsd_manager.js

@@ -0,0 +1,269 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+goog.provide('shaka.util.CmsdManager');
+
+goog.require('shaka.log');
+
+
+/**
+ * @summary
+ * A CmsdManager maintains CMSD state as well as a collection of utility
+ * functions.
+ * @export
+ */
+shaka.util.CmsdManager = class {
+  /**
+   * @param {shaka.extern.CmsdConfiguration} config
+   */
+  constructor(config) {
+    /** @private {shaka.extern.CmsdConfiguration} */
+    this.config_ = config;
+
+    /** @private {?Map.<string, (boolean|number|string)>} */
+    this.staticParams_ = null;
+
+    /** @private {?Map.<string, (boolean|number|string)>} */
+    this.dynamicParams_ = null;
+  }
+
+  /**
+   * Called by the Player to provide an updated configuration any time it
+   * changes.
+   *
+   * @param {shaka.extern.CmsdConfiguration} config
+   */
+  configure(config) {
+    this.config_ = config;
+  }
+
+
+  /**
+   * Resets the CmsdManager.
+   */
+  reset() {
+    this.staticParams_ = null;
+    this.dynamicParams_ = null;
+  }
+
+  /**
+   * Called by the Player to provide the headers of the latest request.
+   *
+   * @param {!Object.<string, string>} headers
+   */
+  processHeaders(headers) {
+    if (!this.config_.enabled) {
+      return;
+    }
+    const CmsdManager = shaka.util.CmsdManager;
+    const cmsdStatic = headers[CmsdManager.CMSD_STATIC_HEADER_NAME_];
+    if (cmsdStatic) {
+      const staticParams = this.parseCMSDStatic_(cmsdStatic);
+      if (staticParams) {
+        this.staticParams_ = staticParams;
+      }
+    }
+    const cmsdDynamic = headers[CmsdManager.CMSD_DYNAMIC_HEADER_NAME_];
+    if (cmsdDynamic) {
+      const dynamicParams = this.parseCMSDDynamic_(cmsdDynamic);
+      if (dynamicParams) {
+        this.dynamicParams_ = dynamicParams;
+      }
+    }
+  }
+
+  /**
+   * Returns the max bitrate in bits per second. If there is no max bitrate or
+   * it's not enabled, it returns null.
+   *
+   * @return {?number}
+   * @export
+   */
+  getMaxBitrate() {
+    const key = shaka.util.CmsdManager.KEYS_.MAX_SUGGESTED_BITRATE;
+    if (!this.config_.enabled || !this.config_.applyMaximumSuggestedBitrate ||
+        !this.dynamicParams_ || !this.dynamicParams_.has(key)) {
+      return null;
+    }
+    return /** @type {number} */(this.dynamicParams_.get(key)) * 1000;
+  }
+
+  /**
+   * Returns the estimated throughput in bits per second. If there is no
+   * estimated throughput or it's not enabled, it returns null.
+   *
+   * @return {?number}
+   * @export
+   */
+  getEstimatedThroughput() {
+    const key = shaka.util.CmsdManager.KEYS_.ESTIMATED_THROUGHPUT;
+    if (!this.config_.enabled || !this.dynamicParams_ ||
+        !this.dynamicParams_.has(key)) {
+      return null;
+    }
+    return /** @type {number} */(this.dynamicParams_.get(key)) * 1000;
+  }
+
+  /**
+   * Returns the response delay in milliseconds. If there is no response delay
+   * or it's not enabled, it returns null.
+   *
+   * @return {?number}
+   * @export
+   */
+  getResponseDelay() {
+    const key = shaka.util.CmsdManager.KEYS_.RESPONSE_DELAY;
+    if (!this.config_.enabled || !this.dynamicParams_ ||
+        !this.dynamicParams_.has(key)) {
+      return null;
+    }
+    return /** @type {number} */(this.dynamicParams_.get(key));
+  }
+
+  /**
+   * Returns the RTT in milliseconds. If there is no RTT or it's not enabled,
+   * it returns null.
+   *
+   * @return {?number}
+   * @export
+   */
+  getRoundTripTime() {
+    const key = shaka.util.CmsdManager.KEYS_.ROUND_TRIP_TIME;
+    if (!this.config_.enabled || !this.dynamicParams_ ||
+        !this.dynamicParams_.has(key)) {
+      return null;
+    }
+    return /** @type {number} */(this.dynamicParams_.get(key));
+  }
+
+  /**
+   * Gets the current bandwidth estimate.
+   *
+   * @param {number} defaultEstimate
+   * @return {number} The bandwidth estimate in bits per second.
+   * @export
+   */
+  getBandwidthEstimate(defaultEstimate) {
+    const estimatedThroughput = this.getEstimatedThroughput();
+    if (!estimatedThroughput) {
+      return defaultEstimate;
+    }
+    const etpWeightRatio = this.config_.estimatedThroughputWeightRatio;
+    if (etpWeightRatio > 0 && etpWeightRatio <= 1) {
+      return (defaultEstimate * (1 - etpWeightRatio)) +
+          (estimatedThroughput * etpWeightRatio);
+    }
+    return defaultEstimate;
+  }
+
+  /**
+   * @param {string} headerValue
+   * @return {?Map.<string, (boolean|number|string)>}
+   * @private
+   */
+  parseCMSDStatic_(headerValue) {
+    try {
+      const params = new Map();
+      const items = headerValue.split(',');
+      for (let i = 0; i < items.length; i++) {
+        // <key>=<value>
+        const substrs = items[i].split('=');
+        const key = substrs[0];
+        const value = this.parseParameterValue_(substrs[1]);
+        params.set(key, value);
+      }
+      return params;
+    } catch (e) {
+      shaka.log.warning(
+          'Failed to parse CMSD-Static response header value:', e);
+      return null;
+    }
+  }
+
+  /**
+   * @param {string} headerValue
+   * @return {?Map.<string, (boolean|number|string)>}
+   * @private
+   */
+  parseCMSDDynamic_(headerValue) {
+    try {
+      const params = new Map();
+      const items = headerValue.split(';');
+      // Server identifier as 1st item
+      for (let i = 1; i < items.length; i++) {
+        // <key>=<value>
+        const substrs = items[i].split('=');
+        const key = substrs[0];
+        const value = this.parseParameterValue_(substrs[1]);
+        params.set(key, value);
+      }
+      return params;
+    } catch (e) {
+      shaka.log.warning(
+          'Failed to parse CMSD-Dynamic response header value:', e);
+      return null;
+    }
+  }
+
+  /**
+   * @param {string} value
+   * @return {(boolean|number|string)}
+   * @private
+   */
+  parseParameterValue_(value) {
+    // If the value type is BOOLEAN and the value is TRUE, then the equals
+    // sign and the value are omitted
+    if (!value) {
+      return true;
+    }
+    // Check if boolean 'false'
+    if (value.toLowerCase() === 'false') {
+      return false;
+    }
+    // Check if a number
+    if (/^[-0-9]/.test(value)) {
+      return parseInt(value, 10);
+    }
+    // Value is a string, remove double quotes from string value
+    return value.replace(/["]+/g, '');
+  }
+};
+
+/**
+ * @const {string}
+ * @private
+ */
+shaka.util.CmsdManager.CMSD_STATIC_HEADER_NAME_ = 'cmsd-static';
+
+/**
+ * @const {string}
+ * @private
+ */
+shaka.util.CmsdManager.CMSD_DYNAMIC_HEADER_NAME_ = 'cmsd-dynamic';
+
+/**
+ * @enum {string}
+ * @private
+ */
+shaka.util.CmsdManager.KEYS_ = {
+  AVAILABILITY_TIME: 'at',
+  DURESS: 'du',
+  ENCODED_BITRATE: 'br',
+  ESTIMATED_THROUGHPUT: 'etp',
+  HELD_TIME: 'ht',
+  INTERMEDIARY_IDENTIFIER: 'n',
+  MAX_SUGGESTED_BITRATE: 'mb',
+  NEXT_OBJECT_RESPONSE: 'nor',
+  NEXT_RANGE_RESPONSE: 'nrr',
+  OBJECT_DURATION: 'd',
+  OBJECT_TYPE: 'ot',
+  RESPONSE_DELAY: 'rd',
+  ROUND_TRIP_TIME: 'rtt',
+  STARTUP: 'su',
+  STREAM_TYPE: 'st',
+  STREAMING_FORMAT: 'sf',
+  VERSION: 'v',
+};

package/lib/util/content_steering_manager.js

@@ -236,9 +236,10 @@ shaka.util.ContentSteeringManager = class {
    * Get the base locations ordered according the priority.
    *
    * @param {string|number} streamId
+   * @param {boolean=} ignoreBaseUrls
    * @return {!Array.<string>}
    */
-  getLocations(streamId) {
+  getLocations(streamId, ignoreBaseUrls = false) {
     const streamLocations = this.locations_.get(streamId) || new Map();
     /** @type {!Array.<!{pathwayId: string, location: string}>} */
     let locationsPathwayIdMap = [];
@@ -305,6 +306,9 @@ shaka.util.ContentSteeringManager = class {
         locations.push(location);
       }
     }
+    if (ignoreBaseUrls) {
+      return locations;
+    }
     return shaka.util.ManifestParserUtils.resolveUris(
         this.baseUris_, locations);
   }

package/lib/util/mime_utils.js

@@ -181,8 +181,12 @@ shaka.util.MimeUtils = class {
    * @return {string}
    */
   static getCodecBase(codecString) {
-    const parts = shaka.util.MimeUtils.getCodecParts_(codecString);
-    return parts[0];
+    const codecsBase = [];
+    for (const codec of codecString.split(',')) {
+      const parts = shaka.util.MimeUtils.getCodecParts_(codec);
+      codecsBase.push(parts[0]);
+    }
+    return codecsBase.sort().join(',');
   }
 
   /**

package/lib/util/periods.js

@@ -44,6 +44,9 @@ shaka.util.PeriodCombiner = class {
     /** @private {!Array.<shaka.extern.Stream>} */
     this.imageStreams_ = [];
 
+    /** @private {boolean} */
+    this.multiTypeVariantsAllowed_ = false;
+
     /**
      * The IDs of the periods we have already used to generate streams.
      * This helps us identify the periods which have been added when a live
@@ -201,25 +204,25 @@ shaka.util.PeriodCombiner = class {
       }
 
       await Promise.all([
-        shaka.util.PeriodCombiner.combine_(
+        this.combine_(
             this.audioStreams_,
             audioStreamsPerPeriod,
             firstNewPeriodIndex,
             shaka.util.PeriodCombiner.cloneStream_,
             shaka.util.PeriodCombiner.concatenateStreams_),
-        shaka.util.PeriodCombiner.combine_(
+        this.combine_(
             this.videoStreams_,
             videoStreamsPerPeriod,
             firstNewPeriodIndex,
             shaka.util.PeriodCombiner.cloneStream_,
             shaka.util.PeriodCombiner.concatenateStreams_),
-        shaka.util.PeriodCombiner.combine_(
+        this.combine_(
             this.textStreams_,
             textStreamsPerPeriod,
             firstNewPeriodIndex,
             shaka.util.PeriodCombiner.cloneStream_,
             shaka.util.PeriodCombiner.concatenateStreams_),
-        shaka.util.PeriodCombiner.combine_(
+        this.combine_(
             this.imageStreams_,
             imageStreamsPerPeriod,
             firstNewPeriodIndex,
@@ -417,28 +420,30 @@ shaka.util.PeriodCombiner = class {
           ContentType.IMAGE));
     }
 
-    const combinedAudioStreamDbs = await shaka.util.PeriodCombiner.combine_(
+    const periodCombiner = new shaka.util.PeriodCombiner();
+
+    const combinedAudioStreamDbs = await periodCombiner.combine_(
         /* outputStreams= */ [],
         audioStreamDbsPerPeriod,
         /* firstNewPeriodIndex= */ 0,
         shaka.util.PeriodCombiner.cloneStreamDB_,
         shaka.util.PeriodCombiner.concatenateStreamDBs_);
 
-    const combinedVideoStreamDbs = await shaka.util.PeriodCombiner.combine_(
+    const combinedVideoStreamDbs = await periodCombiner.combine_(
         /* outputStreams= */ [],
         videoStreamDbsPerPeriod,
         /* firstNewPeriodIndex= */ 0,
         shaka.util.PeriodCombiner.cloneStreamDB_,
         shaka.util.PeriodCombiner.concatenateStreamDBs_);
 
-    const combinedTextStreamDbs = await shaka.util.PeriodCombiner.combine_(
+    const combinedTextStreamDbs = await periodCombiner.combine_(
         /* outputStreams= */ [],
         textStreamDbsPerPeriod,
         /* firstNewPeriodIndex= */ 0,
         shaka.util.PeriodCombiner.cloneStreamDB_,
         shaka.util.PeriodCombiner.concatenateStreamDBs_);
 
-    const combinedImageStreamDbs = await shaka.util.PeriodCombiner.combine_(
+    const combinedImageStreamDbs = await periodCombiner.combine_(
         /* outputStreams= */ [],
         imageStreamDbsPerPeriod,
         /* firstNewPeriodIndex= */ 0,
@@ -499,7 +504,7 @@ shaka.util.PeriodCombiner = class {
    *
    * @private
    */
-  static async combine_(
+  async combine_(
       outputStreams, streamsPerPeriod, firstNewPeriodIndex, clone, concat) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
@@ -517,7 +522,7 @@ shaka.util.PeriodCombiner = class {
     // First, extend all existing output Streams into the new periods.
     for (const outputStream of outputStreams) {
       // eslint-disable-next-line no-await-in-loop
-      const ok = await shaka.util.PeriodCombiner.extendExistingOutputStream_(
+      const ok = await this.extendExistingOutputStream_(
           outputStream, streamsPerPeriod, firstNewPeriodIndex, concat,
           unusedStreamsPerPeriod);
       if (!ok) {
@@ -537,10 +542,9 @@ shaka.util.PeriodCombiner = class {
     for (const unusedStreams of unusedStreamsPerPeriod) {
       for (const stream of unusedStreams) {
         // Create a new output stream which includes this input stream.
-        const outputStream =
-            shaka.util.PeriodCombiner.createNewOutputStream_(
-                stream, streamsPerPeriod, clone, concat,
-                unusedStreamsPerPeriod);
+        const outputStream = this.createNewOutputStream_(
+            stream, streamsPerPeriod, clone, concat,
+            unusedStreamsPerPeriod);
         if (outputStream) {
           outputStreams.push(outputStream);
         } else {
@@ -562,11 +566,8 @@ shaka.util.PeriodCombiner = class {
         }
         // If this stream has a different codec/MIME than any other stream,
         // then we can't play it.
-        // TODO(#1528): Consider changing this when we support codec switching.
         const hasCodec = outputStreams.some((s) => {
-          return s.mimeType == stream.mimeType &&
-                shaka.util.MimeUtils.getNormalizedCodec(s.codecs) ==
-                    shaka.util.MimeUtils.getNormalizedCodec(stream.codecs);
+          return this.areAVStreamsCompatible_(stream, s);
         });
         if (!hasCodec) {
           continue;
@@ -606,11 +607,10 @@ shaka.util.PeriodCombiner = class {
    *
    * @private
    */
-  static async extendExistingOutputStream_(
+  async extendExistingOutputStream_(
       outputStream, streamsPerPeriod, firstNewPeriodIndex, concat,
       unusedStreamsPerPeriod) {
-    shaka.util.PeriodCombiner.findMatchesInAllPeriods_(streamsPerPeriod,
-        outputStream);
+    this.findMatchesInAllPeriods_(streamsPerPeriod, outputStream);
 
     // This only exists where T == Stream, and this should only ever be called
     // on Stream types.  StreamDB should not have pre-existing output streams.
@@ -668,6 +668,14 @@ shaka.util.PeriodCombiner = class {
         goog.asserts.assert(match.segmentIndex,
             'stream should have a segmentIndex.');
         if (match.segmentIndex) {
+          match.segmentIndex.forEachTopLevelReference((ref) => {
+            ref.codecs = match.codecs;
+            ref.mimeType = match.mimeType;
+            if (ref.initSegmentReference) {
+              ref.initSegmentReference.codecs = match.codecs;
+              ref.initSegmentReference.mimeType = match.mimeType;
+            }
+          });
           outputStream.segmentIndex.appendSegmentIndex(match.segmentIndex);
         }
       }
@@ -697,14 +705,13 @@ shaka.util.PeriodCombiner = class {
    *
    * @private
    */
-  static createNewOutputStream_(
+  createNewOutputStream_(
       stream, streamsPerPeriod, clone, concat, unusedStreamsPerPeriod) {
     // Start by cloning the stream without segments, key IDs, etc.
     const outputStream = clone(stream);
 
     // Find best-matching streams in all periods.
-    shaka.util.PeriodCombiner.findMatchesInAllPeriods_(streamsPerPeriod,
-        outputStream);
+    this.findMatchesInAllPeriods_(streamsPerPeriod, outputStream);
 
     // This only exists where T == Stream.
     if (outputStream.createSegmentIndex) {
@@ -778,6 +785,12 @@ shaka.util.PeriodCombiner = class {
 
       if (used) {
         unusedStreamsPerPeriod[i].delete(match);
+        // Add the codec of this stream to the output stream's codecs.
+        const codecs = new Set(outputStream.codecs.split(','));
+        for (const codec of match.codecs.split(',')) {
+          codecs.add(codec);
+        }
+        outputStream.codecs = Array.from(codecs).join(',');
       }
     }
   }
@@ -973,11 +986,10 @@ shaka.util.PeriodCombiner = class {
    *
    * @private
    */
-  static findMatchesInAllPeriods_(streamsPerPeriod, outputStream) {
+  findMatchesInAllPeriods_(streamsPerPeriod, outputStream) {
     const matches = [];
     for (const streams of streamsPerPeriod) {
-      const match = shaka.util.PeriodCombiner.findBestMatchInPeriod_(
-          streams, outputStream);
+      const match = this.findBestMatchInPeriod_(streams, outputStream);
       if (!match) {
         return;
       }
@@ -998,10 +1010,10 @@ shaka.util.PeriodCombiner = class {
    *
    * @private
    */
-  static findBestMatchInPeriod_(streams, outputStream) {
+  findBestMatchInPeriod_(streams, outputStream) {
     const areCompatible = {
-      'audio': shaka.util.PeriodCombiner.areAVStreamsCompatible_,
-      'video': shaka.util.PeriodCombiner.areAVStreamsCompatible_,
+      'audio': (os, s) => this.areAVStreamsCompatible_(os, s),
+      'video': (os, s) => this.areAVStreamsCompatible_(os, s),
       'text': shaka.util.PeriodCombiner.areTextStreamsCompatible_,
       'image': shaka.util.PeriodCombiner.areImageStreamsCompatible_,
     }[outputStream.type];
@@ -1029,17 +1041,23 @@ shaka.util.PeriodCombiner = class {
   }
 
   /**
-   * @param {T} outputStream An audio or video output stream
-   * @param {T} candidate A candidate stream to be combined with the output
-   * @return {boolean} True if the candidate could be combined with the
-   *   output stream
+   * @param {T} a
+   * @param {T} b
+   * @return {boolean}
    *
    * @template T
    * Accepts either a StreamDB or Stream type.
    *
    * @private
    */
-  static areAVStreamsCompatible_(outputStream, candidate) {
+  static areAVStreamsExactMatch_(a, b) {
+    if (a.mimeType != b.mimeType) {
+      return false;
+    }
+    /**
+     * @param {string} codecs
+     * @return {string}
+     */
     const getCodec = (codecs) => {
       if (!shaka.util.PeriodCombiner.memoizedCodecs.has(codecs)) {
         const normalizedCodec = shaka.util.MimeUtils.getNormalizedCodec(codecs);
@@ -1047,10 +1065,37 @@ shaka.util.PeriodCombiner = class {
       }
       return shaka.util.PeriodCombiner.memoizedCodecs.get(codecs);
     };
-    // Check MIME type and codecs, which should always be the same.
-    if (candidate.mimeType != outputStream.mimeType ||
-        getCodec(candidate.codecs) != getCodec(outputStream.codecs)) {
-      return false;
+    return getCodec(a.codecs) == getCodec(b.codecs);
+  }
+
+  /**
+   * @param {boolean} allowed If set to true, multi-mimeType or multi-codec
+   *   variants will be allowed.
+   */
+  setAllowMultiTypeVariants(allowed) {
+    this.multiTypeVariantsAllowed_ = allowed;
+  }
+
+  /**
+   * @param {T} outputStream An audio or video output stream
+   * @param {T} candidate A candidate stream to be combined with the output
+   * @return {boolean} True if the candidate could be combined with the
+   *   output stream
+   *
+   * @template T
+   * Accepts either a StreamDB or Stream type.
+   *
+   * @private
+   */
+  areAVStreamsCompatible_(outputStream, candidate) {
+    // Check for an exact match.
+    if (!shaka.util.PeriodCombiner.areAVStreamsExactMatch_(
+        outputStream, candidate)) {
+      // It's not an exact match. See if we can do multi-codec or multi-mimeType
+      // stream instead, using SourceBuffer.changeType.
+      if (!this.multiTypeVariantsAllowed_) {
+        return false;
+      }
     }
 
     // This field is only available on Stream, not StreamDB.
@@ -1158,6 +1203,18 @@ shaka.util.PeriodCombiner = class {
       return true;
     }
 
+    // An exact match is better than a non-exact match.
+    const bestIsExact = shaka.util.PeriodCombiner.areAVStreamsExactMatch_(
+        outputStream, best);
+    const candidateIsExact = shaka.util.PeriodCombiner.areAVStreamsExactMatch_(
+        outputStream, candidate);
+    if (bestIsExact && !candidateIsExact) {
+      return false;
+    }
+    if (!bestIsExact && candidateIsExact) {
+      return true;
+    }
+
     // Otherwise, compare the streams' characteristics to determine the best
     // match.
 
@@ -1281,6 +1338,18 @@ shaka.util.PeriodCombiner = class {
       return true;
     }
 
+    // An exact match is better than a non-exact match.
+    const bestIsExact = shaka.util.PeriodCombiner.areAVStreamsExactMatch_(
+        outputStream, best);
+    const candidateIsExact = shaka.util.PeriodCombiner.areAVStreamsExactMatch_(
+        outputStream, candidate);
+    if (bestIsExact && !candidateIsExact) {
+      return false;
+    }
+    if (!bestIsExact && candidateIsExact) {
+      return true;
+    }
+
     // Otherwise, compare the streams' characteristics to determine the best
     // match.
 

package/lib/util/player_configuration.js

@@ -94,6 +94,13 @@ shaka.util.PlayerConfiguration = class {
       ignoreDuplicateInitData: !shaka.util.Platform.isTizen2(),
     };
 
+    let codecSwitchingStrategy = shaka.config.CodecSwitchingStrategy.RELOAD;
+    let multiTypeVariantsAllowed = false;
+    if (shaka.util.Platform.supportsSmoothCodecSwitching()) {
+      codecSwitchingStrategy = shaka.config.CodecSwitchingStrategy.SMOOTH;
+      multiTypeVariantsAllowed = true;
+    }
+
     const manifest = {
       retryParameters: shaka.net.NetworkingEngine.defaultRetryParameters(),
       availabilityWindowOverride: NaN,
@@ -136,6 +143,7 @@ shaka.util.PlayerConfiguration = class {
         },
         sequenceMode: false,
         enableAudioGroups: false,
+        multiTypeVariantsAllowed,
       },
       hls: {
         ignoreTextStreamFailures: false,
@@ -220,6 +228,8 @@ shaka.util.PlayerConfiguration = class {
       liveSyncPlaybackRate: 1.1,
       liveSyncMinLatency: 0,
       liveSyncMinPlaybackRate: 1,
+      allowMediaSourceRecoveries: true,
+      minTimeBetweenRecoveries: 5,
     };
 
     // WebOS, Tizen, Chromecast and Hisense have long hardware pipelines
@@ -309,6 +319,12 @@ shaka.util.PlayerConfiguration = class {
       useHeaders: false,
     };
 
+    const cmsd = {
+      enabled: true,
+      applyMaximumSuggestedBitrate: true,
+      estimatedThroughputWeightRatio: 0.5,
+    };
+
     const lcevc = {
       enabled: false,
       dynamicPerformanceScaling: true,
@@ -316,11 +332,6 @@ shaka.util.PlayerConfiguration = class {
       drawLogo: false,
     };
 
-    let codecSwitchingStrategy = shaka.config.CodecSwitchingStrategy.RELOAD;
-    if (shaka.util.Platform.supportsSmoothCodecSwitching()) {
-      codecSwitchingStrategy = shaka.config.CodecSwitchingStrategy.SMOOTH;
-    }
-
     const mediaSource = {
       codecSwitchingStrategy: codecSwitchingStrategy,
       sourceBufferExtraFeatures: '',
@@ -352,9 +363,11 @@ shaka.util.PlayerConfiguration = class {
       preferredAudioChannelCount: 2,
       preferredVideoHdrLevel: 'AUTO',
       preferredVideoLayout: '',
+      preferredVideoLabel: '',
       preferredVideoCodecs: [],
       preferredAudioCodecs: [],
       preferForcedSubs: false,
+      preferSpatialAudio: false,
       preferredDecodingAttributes: [],
       restrictions: {
         minWidth: 0,
@@ -372,6 +385,7 @@ shaka.util.PlayerConfiguration = class {
       playRangeEnd: Infinity,
       textDisplayFactory: () => null,
       cmcd: cmcd,
+      cmsd: cmsd,
       lcevc: lcevc,
       ads: ads,
     };