shaka-player 4.4.3 → 4.6.0

package/lib/util/stream_utils.js

@@ -31,110 +31,165 @@ shaka.util.StreamUtils = class {
    * @param {!shaka.extern.Manifest} manifest
    * @param {!Array.<string>} preferredVideoCodecs
    * @param {!Array.<string>} preferredAudioCodecs
-   * @param {number} preferredAudioChannelCount
    * @param {!Array.<string>} preferredDecodingAttributes
    */
   static chooseCodecsAndFilterManifest(manifest, preferredVideoCodecs,
-      preferredAudioCodecs, preferredAudioChannelCount,
-      preferredDecodingAttributes) {
+      preferredAudioCodecs, preferredDecodingAttributes) {
     const StreamUtils = shaka.util.StreamUtils;
+    const MimeUtils = shaka.util.MimeUtils;
 
     let variants = manifest.variants;
-
     // To start, choose the codecs based on configured preferences if available.
     if (preferredVideoCodecs.length || preferredAudioCodecs.length) {
       variants = StreamUtils.choosePreferredCodecs(variants,
           preferredVideoCodecs, preferredAudioCodecs);
     }
 
-    // Consider a subset of variants based on audio channel
-    // preferences.
-    // For some content (#1013), surround-sound variants will use a different
-    // codec than stereo variants, so it is important to choose codecs **after**
-    // considering the audio channel config.
-    variants = StreamUtils.filterVariantsByAudioChannelCount(
-        variants, preferredAudioChannelCount);
-
-    // Now organize variants into buckets by codecs.
-    /** @type {!shaka.util.MultiMap.<shaka.extern.Variant>} */
-    let variantsByCodecs = StreamUtils.getVariantsByCodecs_(variants);
-    variantsByCodecs = StreamUtils.filterVariantsByDensity_(variantsByCodecs);
-
-    const bestCodecs = StreamUtils.chooseCodecsByDecodingAttributes_(
-        variantsByCodecs, preferredDecodingAttributes);
+    if (preferredDecodingAttributes.length) {
+      // group variants by resolution and choose preferred variants only
+      /** @type {!shaka.util.MultiMap.<shaka.extern.Variant>} */
+      const variantsByResolutionMap = new shaka.util.MultiMap();
+      for (const variant of variants) {
+        variantsByResolutionMap
+            .push(String(variant.video.width || 0), variant);
+      }
+      const bestVariants = [];
+      variantsByResolutionMap.forEach((width, variantsByResolution) => {
+        let highestMatch = 0;
+        let matchingVariants = [];
+        for (const variant of variantsByResolution) {
+          const matchCount = preferredDecodingAttributes.filter(
+              (attribute) => variant.decodingInfos[0][attribute],
+          ).length;
+          if (matchCount > highestMatch) {
+            highestMatch = matchCount;
+            matchingVariants = [variant];
+          } else if (matchCount == highestMatch) {
+            matchingVariants.push(variant);
+          }
+        }
+        bestVariants.push(...matchingVariants);
+      });
+      variants = bestVariants;
+    }
 
-    // Filter out any variants that don't match, forcing AbrManager to choose
-    // from a single video codec and a single audio codec possible.
-    manifest.variants = manifest.variants.filter((variant) => {
-      const codecs = StreamUtils.getVariantCodecs_(variant);
-      if (codecs == bestCodecs) {
-        return true;
+    const audioStreamsSet = new Set();
+    const videoStreamsSet = new Set();
+    for (const variant of variants) {
+      if (variant.audio) {
+        audioStreamsSet.add(variant.audio);
+      }
+      if (variant.video) {
+        videoStreamsSet.add(variant.video);
       }
+    }
 
-      shaka.log.debug('Dropping Variant (better codec available)', variant);
-      return false;
+    const audioStreams = Array.from(audioStreamsSet).sort((v1, v2) => {
+      return v1.bandwidth - v2.bandwidth;
     });
-  }
-
-  /**
-  * Get variants by codecs.
-  *
-  * @param {!Array<shaka.extern.Variant>} variants
-  * @return {!shaka.util.MultiMap.<shaka.extern.Variant>}
-  * @private
-  */
-  static getVariantsByCodecs_(variants) {
-    const variantsByCodecs = new shaka.util.MultiMap();
-    for (const variant of variants) {
-      const variantCodecs = shaka.util.StreamUtils.getVariantCodecs_(variant);
-      variantsByCodecs.push(variantCodecs, variant);
+    const validAudioIds = [];
+    const validAudioStreamsMap = new Map();
+    const getAudioId = (stream) => {
+      return stream.language + (stream.channelsCount || 0) +
+        (stream.audioSamplingRate || 0) + stream.roles.join(',') +
+        stream.label + stream.groupId + stream.fastSwitching;
+    };
+    for (const stream of audioStreams) {
+      const groupId = getAudioId(stream);
+      const validAudioStreams = validAudioStreamsMap.get(groupId) || [];
+      if (!validAudioStreams.length) {
+        validAudioStreams.push(stream);
+        validAudioIds.push(stream.id);
+      } else {
+        const previousStream = validAudioStreams[validAudioStreams.length - 1];
+        const previousCodec =
+          MimeUtils.getNormalizedCodec(previousStream.codecs);
+        const currentCodec =
+          MimeUtils.getNormalizedCodec(stream.codecs);
+        if (previousCodec == currentCodec) {
+          if (stream.bandwidth > previousStream.bandwidth) {
+            validAudioStreams.push(stream);
+            validAudioIds.push(stream.id);
+          }
+        }
+      }
+      validAudioStreamsMap.set(groupId, validAudioStreams);
     }
 
-    return variantsByCodecs;
-  }
+    const videoStreams = Array.from(videoStreamsSet)
+        .sort((v1, v2) => {
+          if (!v1.bandwidth || !v2.bandwidth) {
+            return v1.width - v2.width;
+          }
+          return v1.bandwidth - v2.bandwidth;
+        });
 
-  /**
-  * Filters variants by density.
-  * Get variants by codecs map with the max density where all codecs are
-  * present.
-  *
-  * @param {!shaka.util.MultiMap.<shaka.extern.Variant>} variantsByCodecs
-  * @return {!shaka.util.MultiMap.<shaka.extern.Variant>}
-  * @private
-  */
-  static filterVariantsByDensity_(variantsByCodecs) {
-    let maxDensity = 0;
-    const codecGroupsByDensity = new Map();
-    const countCodecs = variantsByCodecs.size();
-
-    variantsByCodecs.forEach((codecs, variants) => {
-      for (const variant of variants) {
-        const video = variant.video;
-        if (!video || !video.width || !video.height) {
-          continue;
-        }
+    const isChangeTypeSupported =
+      shaka.media.Capabilities.isChangeTypeSupported();
 
-        const density = video.width * video.height * (video.frameRate || 1);
-        if (!codecGroupsByDensity.has(density)) {
-          codecGroupsByDensity.set(density, new shaka.util.MultiMap());
+    const validVideoIds = [];
+    const validVideoStreamsMap = new Map();
+    const getVideoGroupId = (stream) => {
+      return Math.round(stream.frameRate || 0) + (stream.hdr || '') +
+          stream.fastSwitching;
+    };
+    for (const stream of videoStreams) {
+      const groupId = getVideoGroupId(stream);
+      const validVideoStreams = validVideoStreamsMap.get(groupId) || [];
+      if (!validVideoStreams.length) {
+        validVideoStreams.push(stream);
+        validVideoIds.push(stream.id);
+      } else {
+        const previousStream = validVideoStreams[validVideoStreams.length - 1];
+        if (!isChangeTypeSupported) {
+          const previousCodec =
+            MimeUtils.getNormalizedCodec(previousStream.codecs);
+          const currentCodec =
+            MimeUtils.getNormalizedCodec(stream.codecs);
+          if (previousCodec !== currentCodec) {
+            continue;
+          }
+        }
+        if (stream.width > previousStream.width ||
+          stream.height > previousStream.height) {
+          validVideoStreams.push(stream);
+          validVideoIds.push(stream.id);
+        } else if (stream.width == previousStream.width &&
+          stream.height == previousStream.height) {
+          const previousCodec =
+            MimeUtils.getNormalizedCodec(previousStream.codecs);
+          const currentCodec =
+            MimeUtils.getNormalizedCodec(stream.codecs);
+          if (previousCodec == currentCodec) {
+            if (stream.bandwidth < previousStream.bandwidth) {
+              validVideoStreams.push(stream);
+              validVideoIds.push(stream.id);
+            }
+          }
         }
+      }
+      validVideoStreamsMap.set(groupId, validVideoStreams);
+    }
 
-        /** @type {!shaka.util.MultiMap.<shaka.extern.Variant>} */
-        const group = codecGroupsByDensity.get(density);
-        group.push(codecs, variant);
-
-        // We want to look at the groups in which all codecs are present.
-        // Take the max density from those groups where all codecs are present.
-        // Later, we will compare bandwidth numbers only within this group.
-        // Effectively, only the bandwidth differences in the highest-res and
-        // highest-framerate content will matter in choosing a codec.
-        if (group.size() === countCodecs) {
-          maxDensity = Math.max(maxDensity, density);
+    // Filter out any variants that don't match, forcing AbrManager to choose
+    // from a single video codec and a single audio codec possible.
+    manifest.variants = manifest.variants.filter((variant) => {
+      const audio = variant.audio;
+      const video = variant.video;
+      if (audio) {
+        if (!validAudioIds.includes(audio.id)) {
+          shaka.log.debug('Dropping Variant (better codec available)', variant);
+          return false;
         }
       }
+      if (video) {
+        if (!validVideoIds.includes(video.id)) {
+          shaka.log.debug('Dropping Variant (better codec available)', variant);
+          return false;
+        }
+      }
+      return true;
     });
-
-    return maxDensity ? codecGroupsByDensity.get(maxDensity) : variantsByCodecs;
   }
 
   /**
@@ -170,135 +225,6 @@ shaka.util.StreamUtils = class {
     return subset;
   }
 
-  /**
-   * Choose the codecs by configured preferred decoding attributes.
-   *
-   * @param {!shaka.util.MultiMap.<shaka.extern.Variant>} variantsByCodecs
-   * @param {!Array.<string>} attributes
-   * @return {string}
-   * @private
-   */
-  static chooseCodecsByDecodingAttributes_(variantsByCodecs, attributes) {
-    const StreamUtils = shaka.util.StreamUtils;
-
-    for (const attribute of attributes) {
-      if (attribute == StreamUtils.DecodingAttributes.SMOOTH ||
-          attribute == StreamUtils.DecodingAttributes.POWER) {
-        variantsByCodecs = StreamUtils.chooseCodecsByMediaCapabilitiesInfo_(
-            variantsByCodecs, attribute);
-        // If we only have one smooth or powerEfficient codecs, choose it as the
-        // best codecs.
-        if (variantsByCodecs.size() == 1) {
-          return variantsByCodecs.keys()[0];
-        }
-      } else if (attribute == StreamUtils.DecodingAttributes.BANDWIDTH) {
-        return StreamUtils.findCodecsByLowestBandwidth_(variantsByCodecs);
-      }
-    }
-    // If there's no configured decoding preferences, or we have multiple codecs
-    // that meets the configured decoding preferences, choose the one with
-    // the lowest bandwidth.
-    return StreamUtils.findCodecsByLowestBandwidth_(variantsByCodecs);
-  }
-
-  /**
-   * Choose the best codecs by configured preferred MediaCapabilitiesInfo
-   * attributes.
-   *
-   * @param {!shaka.util.MultiMap.<shaka.extern.Variant>} variantsByCodecs
-   * @param {string} attribute
-   * @return {!shaka.util.MultiMap.<shaka.extern.Variant>}
-   * @private
-   */
-  static chooseCodecsByMediaCapabilitiesInfo_(variantsByCodecs, attribute) {
-    let highestScore = 0;
-    const bestVariantsByCodecs = new shaka.util.MultiMap();
-    variantsByCodecs.forEach((codecs, variants) => {
-      let sum = 0;
-      let num = 0;
-
-      for (const variant of variants) {
-        if (variant.decodingInfos.length) {
-          sum += variant.decodingInfos[0][attribute] ? 1 : 0;
-          num++;
-        }
-      }
-
-      const averageScore = sum / num;
-      shaka.log.debug('codecs', codecs, 'avg', attribute, averageScore);
-
-      if (averageScore > highestScore) {
-        bestVariantsByCodecs.clear();
-        bestVariantsByCodecs.push(codecs, variants);
-        highestScore = averageScore;
-      } else if (averageScore == highestScore) {
-        bestVariantsByCodecs.push(codecs, variants);
-      }
-    });
-    return bestVariantsByCodecs;
-  }
-
-  /**
-   * Find the lowest-bandwidth (best) codecs.
-   * Compute the average bandwidth for each group of variants.
-   *
-   * @param {!shaka.util.MultiMap.<shaka.extern.Variant>} variantsByCodecs
-   * @return {string}
-   * @private
-   */
-  static findCodecsByLowestBandwidth_(variantsByCodecs) {
-    let bestCodecs = '';
-    let lowestAverageBandwidth = Infinity;
-
-    variantsByCodecs.forEach((codecs, variants) => {
-      let sum = 0;
-      let num = 0;
-      for (const variant of variants) {
-        sum += variant.bandwidth || 0;
-        ++num;
-      }
-
-      const averageBandwidth = sum / num;
-      shaka.log.debug('codecs', codecs, 'avg bandwidth', averageBandwidth);
-
-      if (averageBandwidth < lowestAverageBandwidth) {
-        bestCodecs = codecs;
-        lowestAverageBandwidth = averageBandwidth;
-      }
-    });
-
-    goog.asserts.assert(bestCodecs !== '', 'Should have chosen codecs!');
-    goog.asserts.assert(!isNaN(lowestAverageBandwidth),
-        'Bandwidth should be a number!');
-
-    return bestCodecs;
-  }
-
-  /**
-   * Get a string representing all codecs used in a variant.
-   *
-   * @param {!shaka.extern.Variant} variant
-   * @return {string}
-   * @private
-   */
-  static getVariantCodecs_(variant) {
-    // Only consider the base of the codec string.  For example, these should
-    // both be considered the same codec: avc1.42c01e, avc1.4d401f
-    let baseVideoCodec = '';
-    if (variant.video) {
-      baseVideoCodec =
-        shaka.util.MimeUtils.getNormalizedCodec(variant.video.codecs);
-    }
-
-    let baseAudioCodec = '';
-    if (variant.audio) {
-      baseAudioCodec =
-        shaka.util.MimeUtils.getNormalizedCodec(variant.audio.codecs);
-    }
-
-    return baseVideoCodec + '-' + baseAudioCodec;
-  }
-
   /**
    * Filter the variants in |manifest| to only include the variants that meet
    * the given restrictions.
@@ -402,14 +328,11 @@ shaka.util.StreamUtils = class {
    * Alters the given Manifest to filter out any unplayable streams.
    *
    * @param {shaka.media.DrmEngine} drmEngine
-   * @param {?shaka.extern.Variant} currentVariant
    * @param {shaka.extern.Manifest} manifest
    */
-  static async filterManifest(drmEngine, currentVariant, manifest) {
-    await shaka.util.StreamUtils.filterManifestByMediaCapabilities(manifest,
-        manifest.offlineSessionIds.length > 0);
-    shaka.util.StreamUtils.filterManifestByCurrentVariant(
-        currentVariant, manifest);
+  static async filterManifest(drmEngine, manifest) {
+    await shaka.util.StreamUtils.filterManifestByMediaCapabilities(
+        drmEngine, manifest, manifest.offlineSessionIds.length > 0);
     shaka.util.StreamUtils.filterTextStreams_(manifest);
     await shaka.util.StreamUtils.filterImageStreams_(manifest);
   }
@@ -419,30 +342,53 @@ shaka.util.StreamUtils = class {
    * Alters the given Manifest to filter out any streams unsupported by the
    * platform via MediaCapabilities.decodingInfo() API.
    *
+   * @param {shaka.media.DrmEngine} drmEngine
    * @param {shaka.extern.Manifest} manifest
    * @param {boolean} usePersistentLicenses
    */
   static async filterManifestByMediaCapabilities(
-      manifest, usePersistentLicenses) {
+      drmEngine, manifest, usePersistentLicenses) {
     goog.asserts.assert(navigator.mediaCapabilities,
         'MediaCapabilities should be valid.');
 
     await shaka.util.StreamUtils.getDecodingInfosForVariants(
         manifest.variants, usePersistentLicenses, /* srcEquals= */ false,
         /** preferredKeySystems= */ []);
+
+    let keySystem = null;
+    if (drmEngine) {
+      const drmInfo = drmEngine.getDrmInfo();
+      if (drmInfo) {
+        keySystem = drmInfo.keySystem;
+      }
+    }
+
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
+    const Capabilities = shaka.media.Capabilities;
+    const ManifestParserUtils = shaka.util.ManifestParserUtils;
+    const MimeUtils = shaka.util.MimeUtils;
+    const StreamUtils = shaka.util.StreamUtils;
+    const isXboxOne = shaka.util.Platform.isXboxOne();
+
     manifest.variants = manifest.variants.filter((variant) => {
       // See: https://github.com/shaka-project/shaka-player/issues/3860
       const video = variant.video;
+      const videoWidth = (video && video.width) || 0;
+      const videoHeight = (video && video.height) || 0;
 
-      const ContentType = shaka.util.ManifestParserUtils.ContentType;
-      const Capabilities = shaka.media.Capabilities;
-      const ManifestParserUtils = shaka.util.ManifestParserUtils;
-      const MimeUtils = shaka.util.MimeUtils;
-      const StreamUtils = shaka.util.StreamUtils;
+      // See: https://github.com/shaka-project/shaka-player/issues/3380
+      // Note: it makes sense to drop early
+      if (isXboxOne && video &&
+        (videoWidth > 1920 || videoHeight > 1080) &&
+        (video.codecs.includes('avc1.') || video.codecs.includes('avc3.'))
+      ) {
+        shaka.log.debug('Dropping variant - not compatible with platform',
+            StreamUtils.getVariantSummaryString_(variant));
+        return false;
+      }
 
       if (video) {
         let videoCodecs = StreamUtils.getCorrectVideoCodecs_(video.codecs);
-
         // For multiplexed streams. Here we must check the audio of the
         // stream to see if it is compatible.
         if (video.codecs.includes(',')) {
@@ -451,7 +397,6 @@ shaka.util.StreamUtils = class {
           videoCodecs = ManifestParserUtils.guessCodecs(
               ContentType.VIDEO, allCodecs);
           videoCodecs = StreamUtils.getCorrectVideoCodecs_(videoCodecs);
-
           let audioCodecs = ManifestParserUtils.guessCodecs(
               ContentType.AUDIO, allCodecs);
           audioCodecs = StreamUtils.getCorrectAudioCodecs_(audioCodecs);
@@ -493,19 +438,19 @@ shaka.util.StreamUtils = class {
         audio.codecs = codecs;
       }
 
-      // See: https://github.com/shaka-project/shaka-player/issues/3380
-      if (shaka.util.Platform.isXboxOne() && video &&
-          ((video.width && video.width > 1920) ||
-          (video.height && video.height > 1080)) &&
-          (video.codecs.includes('avc1.') ||
-          video.codecs.includes('avc3.'))) {
-        shaka.log.debug('Dropping variant - not compatible with platform',
-            StreamUtils.getVariantSummaryString_(variant));
-        return false;
-      }
-
       const supported = variant.decodingInfos.some((decodingInfo) => {
-        return decodingInfo.supported;
+        if (!decodingInfo.supported) {
+          return false;
+        }
+        if (keySystem) {
+          const keySystemAccess = decodingInfo.keySystemAccess;
+          if (keySystemAccess) {
+            if (keySystemAccess.keySystem != keySystem) {
+              return false;
+            }
+          }
+        }
+        return true;
       });
       // Filter out all unsupported variants.
       if (!supported) {
@@ -1013,7 +958,10 @@ shaka.util.StreamUtils = class {
   static async filterImageStreams_(manifest) {
     const imageStreams = [];
     for (const stream of manifest.imageStreams) {
-      const mimeType = stream.mimeType;
+      let mimeType = stream.mimeType;
+      if (mimeType == 'application/mp4' && stream.codecs == 'mjpg') {
+        mimeType = 'image/jpg';
+      }
       if (!shaka.util.StreamUtils.supportedImageMimeTypes_.has(mimeType)) {
         const minImage = shaka.util.StreamUtils.minImage_.get(mimeType);
         if (minImage) {
@@ -1163,6 +1111,7 @@ shaka.util.StreamUtils = class {
       frameRate: null,
       pixelAspectRatio: null,
       hdr: null,
+      videoLayout: null,
       mimeType: mimeType,
       audioMimeType: audioMimeType,
       videoMimeType: videoMimeType,
@@ -1198,6 +1147,7 @@ shaka.util.StreamUtils = class {
       track.pixelAspectRatio = video.pixelAspectRatio || null;
       track.videoBandwidth = video.bandwidth || null;
       track.hdr = video.hdr || null;
+      track.videoLayout = video.videoLayout || null;
     }
 
     if (audio) {
@@ -1238,6 +1188,7 @@ shaka.util.StreamUtils = class {
       frameRate: null,
       pixelAspectRatio: null,
       hdr: null,
+      videoLayout: null,
       mimeType: stream.mimeType,
       audioMimeType: null,
       videoMimeType: null,
@@ -1314,10 +1265,11 @@ shaka.util.StreamUtils = class {
       frameRate: null,
       pixelAspectRatio: null,
       hdr: null,
+      videoLayout: null,
       mimeType: stream.mimeType,
       audioMimeType: null,
       videoMimeType: null,
-      codecs: null,
+      codecs: stream.codecs || null,
       audioCodec: null,
       videoCodec: null,
       primary: false,
@@ -1441,6 +1393,7 @@ shaka.util.StreamUtils = class {
       frameRate: null,
       pixelAspectRatio: null,
       hdr: null,
+      videoLayout: null,
       mimeType: null,
       audioMimeType: null,
       videoMimeType: null,
@@ -1495,52 +1448,6 @@ shaka.util.StreamUtils = class {
   }
 
 
-  /**
-   * Filters variants according to the given audio channel count config.
-   *
-   * @param {!Array.<shaka.extern.Variant>} variants
-   * @param {number} preferredAudioChannelCount
-   * @return {!Array.<!shaka.extern.Variant>}
-   */
-  static filterVariantsByAudioChannelCount(
-      variants, preferredAudioChannelCount) {
-    // Group variants by their audio channel counts.
-    const variantsWithChannelCounts =
-        variants.filter((v) => v.audio && v.audio.channelsCount);
-
-    /** @type {!Map.<number, !Array.<shaka.extern.Variant>>} */
-    const variantsByChannelCount = new Map();
-    for (const variant of variantsWithChannelCounts) {
-      const count = variant.audio.channelsCount;
-      goog.asserts.assert(count != null, 'Must have count after filtering!');
-      if (!variantsByChannelCount.has(count)) {
-        variantsByChannelCount.set(count, []);
-      }
-      variantsByChannelCount.get(count).push(variant);
-    }
-
-    /** @type {!Array.<number>} */
-    const channelCounts = Array.from(variantsByChannelCount.keys());
-
-    // If no variant has audio channel count info, return the original variants.
-    if (channelCounts.length == 0) {
-      return variants;
-    }
-
-    // Choose the variants with the largest number of audio channels less than
-    // or equal to the configured number of audio channels.
-    const countLessThanOrEqualtoConfig =
-        channelCounts.filter((count) => count <= preferredAudioChannelCount);
-    if (countLessThanOrEqualtoConfig.length) {
-      return variantsByChannelCount.get(
-          Math.max(...countLessThanOrEqualtoConfig));
-    }
-
-    // If all variants have more audio channels than the config, choose the
-    // variants with the fewest audio channels.
-    return variantsByChannelCount.get(Math.min(...channelCounts));
-  }
-
   /**
    * Chooses streams according to the given config.
    * Works both for Stream and Track types due to their similarities.
@@ -1691,6 +1598,23 @@ shaka.util.StreamUtils = class {
   }
 
 
+  /**
+   * Indicates if some of the variant's streams are fastSwitching.
+   *
+   * @param {shaka.extern.Variant} variant
+   * @return {boolean}
+   */
+  static isFastSwitching(variant) {
+    if (variant.audio && variant.audio.fastSwitching) {
+      return true;
+    }
+    if (variant.video && variant.video.fastSwitching) {
+      return true;
+    }
+    return false;
+  }
+
+
   /**
    * Returns a string of a variant, with the attribute values of its audio
    * and/or video streams for log printing.
@@ -1762,7 +1686,6 @@ shaka.util.StreamUtils.nextTrackId_ = 0;
 shaka.util.StreamUtils.DecodingAttributes = {
   SMOOTH: 'smooth',
   POWER: 'powerEfficient',
-  BANDWIDTH: 'bandwidth',
 };
 
 /**