Source: lib/media/adaptation_set_criteria.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.media.AdaptationSetCriteria');
  8. goog.provide('shaka.media.ExampleBasedCriteria');
  9. goog.provide('shaka.media.PreferenceBasedCriteria');
  11. goog.require('shaka.config.CodecSwitchingStrategy');
  12. goog.require('shaka.log');
  13. goog.require('shaka.media.AdaptationSet');
  14. goog.require('shaka.media.Capabilities');
  15. goog.require('shaka.util.LanguageUtils');
  18. /**
  19.  * An adaptation set criteria is a unit of logic that can take a set of
  20.  * variants and return a subset of variants that should (and can) be
  21.  * adapted between.
  22.  *
  23.  * @interface
  24.  */
  25. shaka.media.AdaptationSetCriteria = class {
  26.   /**
  27.    * Take a set of variants, and return a subset of variants that can be
  28.    * adapted between.
  29.    *
  30.    * @param {!Array.<shaka.extern.Variant>} variants
  31.    * @return {!shaka.media.AdaptationSet}
  32.    */
  33.   create(variants) {}
  34. };
  37. /**
  38.  * @implements {shaka.media.AdaptationSetCriteria}
  39.  * @final
  40.  */
  41. shaka.media.ExampleBasedCriteria = class {
  42.   /**
  43.    * @param {shaka.extern.Variant} example
  44.    * @param {shaka.config.CodecSwitchingStrategy=} codecSwitchingStrategy
  45.    * @param {boolean=} enableAudioGroups
  46.    */
  47.   constructor(example,
  48.       codecSwitchingStrategy = shaka.config.CodecSwitchingStrategy.RELOAD,
  49.       enableAudioGroups = false) {
  50.     /** @private {shaka.extern.Variant} */
  51.     this.example_ = example;
  52.     /** @private {shaka.config.CodecSwitchingStrategy} */
  53.     this.codecSwitchingStrategy_ = codecSwitchingStrategy;
  54.     /** @private {boolean} */
  55.     this.enableAudioGroups_ = enableAudioGroups;
  58.     // We can't know if role and label are really important, so we don't use
  59.     // role and label for this.
  60.     const role = '';
  61.     const label = '';
  62.     const hdrLevel = '';
  63.     const videoLayout = '';
  64.     const channelCount = example.audio && example.audio.channelsCount ?
  65.                          example.audio.channelsCount :
  66.                          0;
  68.     /** @private {!shaka.media.AdaptationSetCriteria} */
  69.     this.fallback_ = new shaka.media.PreferenceBasedCriteria(
  70.         example.language, role, channelCount, hdrLevel, videoLayout, label,
  71.         codecSwitchingStrategy, enableAudioGroups);
  72.   }
  74.   /** @override */
  75.   create(variants) {
  76.     const supportsSmoothCodecTransitions = this.codecSwitchingStrategy_ ==
  77.       shaka.config.CodecSwitchingStrategy.SMOOTH &&
  78.         shaka.media.Capabilities.isChangeTypeSupported();
  79.     // We can't assume that the example is in |variants| because it could
  80.     // actually be from another period.
  81.     const shortList = variants.filter((variant) => {
  82.       return shaka.media.AdaptationSet.areAdaptable(this.example_, variant,
  83.           !supportsSmoothCodecTransitions, this.enableAudioGroups_);
  84.     });
  86.     if (shortList.length) {
  87.       // Use the first item in the short list as the root. It should not matter
  88.       // which element we use as all items in the short list should already be
  89.       // compatible.
  90.       return new shaka.media.AdaptationSet(shortList[0], shortList,
  91.           !supportsSmoothCodecTransitions, this.enableAudioGroups_);
  92.     } else {
  93.       return this.fallback_.create(variants);
  94.     }
  95.   }
  96. };
  99. /**
  100.  * @implements {shaka.media.AdaptationSetCriteria}
  101.  * @final
  102.  */
  103. shaka.media.PreferenceBasedCriteria = class {
  104.   /**
  105.    * @param {string} language
  106.    * @param {string} role
  107.    * @param {number} channelCount
  108.    * @param {string} hdrLevel
  109.    * @param {string} videoLayout
  110.    * @param {string=} label
  111.    * @param {shaka.config.CodecSwitchingStrategy=} codecSwitchingStrategy
  112.    * @param {boolean=} enableAudioGroups
  113.    */
  114.   constructor(language, role, channelCount, hdrLevel, videoLayout, label = '',
  115.       codecSwitchingStrategy = shaka.config.CodecSwitchingStrategy.RELOAD,
  116.       enableAudioGroups = false) {
  117.     /** @private {string} */
  118.     this.language_ = language;
  119.     /** @private {string} */
  120.     this.role_ = role;
  121.     /** @private {number} */
  122.     this.channelCount_ = channelCount;
  123.     /** @private {string} */
  124.     this.hdrLevel_ = hdrLevel;
  125.     /** @private {string} */
  126.     this.videoLayout_ = videoLayout;
  127.     /** @private {string} */
  128.     this.label_ = label;
  129.     /** @private {shaka.config.CodecSwitchingStrategy} */
  130.     this.codecSwitchingStrategy_ = codecSwitchingStrategy;
  131.     /** @private {boolean} */
  132.     this.enableAudioGroups_ = enableAudioGroups;
  133.   }
  135.   /** @override */
  136.   create(variants) {
  137.     const Class = shaka.media.PreferenceBasedCriteria;
  139.     let current = [];
  141.     const byLanguage = Class.filterByLanguage_(variants, this.language_);
  142.     const byPrimary = variants.filter((variant) => variant.primary);
  144.     if (byLanguage.length) {
  145.       current = byLanguage;
  146.     } else if (byPrimary.length) {
  147.       current = byPrimary;
  148.     } else {
  149.       current = variants;
  150.     }
  152.     // Now refine the choice based on role preference.  Even the empty string
  153.     // works here, and will match variants without any roles.
  154.     const byRole = Class.filterVariantsByRole_(current, this.role_);
  155.     if (byRole.length) {
  156.       current = byRole;
  157.     } else {
  158.       shaka.log.warning('No exact match for variant role could be found.');
  159.     }
  161.     if (this.videoLayout_) {
  162.       const byVideoLayout = Class.filterVariantsByVideoLayout_(
  163.           current, this.videoLayout_);
  164.       if (byVideoLayout.length) {
  165.         current = byVideoLayout;
  166.       } else {
  167.         shaka.log.warning(
  168.             'No exact match for the video layout could be found.');
  169.       }
  170.     }
  172.     if (this.hdrLevel_) {
  173.       const byHdrLevel = Class.filterVariantsByHDRLevel_(
  174.           current, this.hdrLevel_);
  175.       if (byHdrLevel.length) {
  176.         current = byHdrLevel;
  177.       } else {
  178.         shaka.log.warning(
  179.             'No exact match for the hdr level could be found.');
  180.       }
  181.     }
  183.     if (this.channelCount_) {
  184.       const byChannel = Class.filterVariantsByAudioChannelCount_(
  185.           current, this.channelCount_);
  186.       if (byChannel.length) {
  187.         current = byChannel;
  188.       } else {
  189.         shaka.log.warning(
  190.             'No exact match for the channel count could be found.');
  191.       }
  192.     }
  194.     if (this.label_) {
  195.       const byLabel = Class.filterVariantsByLabel_(current, this.label_);
  196.       if (byLabel.length) {
  197.         current = byLabel;
  198.       } else {
  199.         shaka.log.warning('No exact match for variant label could be found.');
  200.       }
  201.     }
  203.     const supportsSmoothCodecTransitions = this.codecSwitchingStrategy_ ==
  204.       shaka.config.CodecSwitchingStrategy.SMOOTH &&
  205.         shaka.media.Capabilities.isChangeTypeSupported();
  207.     return new shaka.media.AdaptationSet(current[0], current,
  208.         !supportsSmoothCodecTransitions, this.enableAudioGroups_);
  209.   }
  211.   /**
  212.    * @param {!Array.<shaka.extern.Variant>} variants
  213.    * @param {string} preferredLanguage
  214.    * @return {!Array.<shaka.extern.Variant>}
  215.    * @private
  216.    */
  217.   static filterByLanguage_(variants, preferredLanguage) {
  218.     const LanguageUtils = shaka.util.LanguageUtils;
  220.     /** @type {string} */
  221.     const preferredLocale = LanguageUtils.normalize(preferredLanguage);
  223.     /** @type {?string} */
  224.     const closestLocale = LanguageUtils.findClosestLocale(
  225.         preferredLocale,
  226.         variants.map((variant) => LanguageUtils.getLocaleForVariant(variant)));
  228.     // There were no locales close to what we preferred.
  229.     if (!closestLocale) {
  230.       return [];
  231.     }
  233.     // Find the variants that use the closest variant.
  234.     return variants.filter((variant) => {
  235.       return closestLocale == LanguageUtils.getLocaleForVariant(variant);
  236.     });
  237.   }
  239.   /**
  240.    * Filter Variants by role.
  241.    *
  242.    * @param {!Array.<shaka.extern.Variant>} variants
  243.    * @param {string} preferredRole
  244.    * @return {!Array.<shaka.extern.Variant>}
  245.    * @private
  246.    */
  247.   static filterVariantsByRole_(variants, preferredRole) {
  248.     return variants.filter((variant) => {
  249.       if (!variant.audio) {
  250.         return false;
  251.       }
  253.       if (preferredRole) {
  254.         return variant.audio.roles.includes(preferredRole);
  255.       } else {
  256.         return variant.audio.roles.length == 0;
  257.       }
  258.     });
  259.   }
  261.   /**
  262.    * Filter Variants by label.
  263.    *
  264.    * @param {!Array.<shaka.extern.Variant>} variants
  265.    * @param {string} preferredLabel
  266.    * @return {!Array.<shaka.extern.Variant>}
  267.    * @private
  268.    */
  269.   static filterVariantsByLabel_(variants, preferredLabel) {
  270.     return variants.filter((variant) => {
  271.       if (!variant.audio || !variant.audio.label) {
  272.         return false;
  273.       }
  275.       const label1 = variant.audio.label.toLowerCase();
  276.       const label2 = preferredLabel.toLowerCase();
  277.       return label1 == label2;
  278.     });
  279.   }
  281.   /**
  282.    * Filter Variants by channelCount.
  283.    *
  284.    * @param {!Array.<shaka.extern.Variant>} variants
  285.    * @param {number} channelCount
  286.    * @return {!Array.<shaka.extern.Variant>}
  287.    * @private
  288.    */
  289.   static filterVariantsByAudioChannelCount_(variants, channelCount) {
  290.     return variants.filter((variant) => {
  291.       if (variant.audio && variant.audio.channelsCount &&
  292.           variant.audio.channelsCount != channelCount) {
  293.         return false;
  294.       }
  295.       return true;
  296.     });
  297.   }
  299.   /**
  300.    * Filters variants according to the given hdr level config.
  301.    *
  302.    * @param {!Array.<shaka.extern.Variant>} variants
  303.    * @param {string} hdrLevel
  304.    * @private
  305.    */
  306.   static filterVariantsByHDRLevel_(variants, hdrLevel) {
  307.     if (hdrLevel == 'AUTO') {
  308.       // Auto detect the ideal HDR level.
  309.       if (window.matchMedia('(color-gamut: p3)').matches) {
  310.         hdrLevel = 'PQ';
  311.       } else {
  312.         hdrLevel = 'SDR';
  313.       }
  314.     }
  315.     return variants.filter((variant) => {
  316.       if (variant.video && variant.video.hdr && variant.video.hdr != hdrLevel) {
  317.         return false;
  318.       }
  319.       return true;
  320.     });
  321.   }
  324.   /**
  325.    * Filters variants according to the given video layout config.
  326.    *
  327.    * @param {!Array.<shaka.extern.Variant>} variants
  328.    * @param {string} videoLayout
  329.    * @private
  330.    */
  331.   static filterVariantsByVideoLayout_(variants, videoLayout) {
  332.     return variants.filter((variant) => {
  333.       if (variant.video && variant.video.videoLayout &&
  334.           variant.video.videoLayout != videoLayout) {
  335.         return false;
  336.       }
  337.       return true;
  338.     });
  339.   }
  340. };