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 audioLabel = '';
  62.     const videoLabel = '';
  63.     const hdrLevel = '';
  64.     const spatialAudio = false;
  65.     const videoLayout = '';
  66.     const channelCount = example.audio && example.audio.channelsCount ?
  67.                          example.audio.channelsCount :
  68.                          0;
  70.     /** @private {!shaka.media.AdaptationSetCriteria} */
  71.     this.fallback_ = new shaka.media.PreferenceBasedCriteria(
  72.         example.language, role, channelCount, hdrLevel, spatialAudio,
  73.         videoLayout, audioLabel, videoLabel,
  74.         codecSwitchingStrategy, enableAudioGroups);
  75.   }
  77.   /** @override */
  78.   create(variants) {
  79.     const supportsSmoothCodecTransitions = this.codecSwitchingStrategy_ ==
  80.       shaka.config.CodecSwitchingStrategy.SMOOTH &&
  81.         shaka.media.Capabilities.isChangeTypeSupported();
  82.     // We can't assume that the example is in |variants| because it could
  83.     // actually be from another period.
  84.     const shortList = variants.filter((variant) => {
  85.       return shaka.media.AdaptationSet.areAdaptable(this.example_, variant,
  86.           !supportsSmoothCodecTransitions, this.enableAudioGroups_);
  87.     });
  89.     if (shortList.length) {
  90.       // Use the first item in the short list as the root. It should not matter
  91.       // which element we use as all items in the short list should already be
  92.       // compatible.
  93.       return new shaka.media.AdaptationSet(shortList[0], shortList,
  94.           !supportsSmoothCodecTransitions, this.enableAudioGroups_);
  95.     } else {
  96.       return this.fallback_.create(variants);
  97.     }
  98.   }
  99. };
  102. /**
  103.  * @implements {shaka.media.AdaptationSetCriteria}
  104.  * @final
  105.  */
  106. shaka.media.PreferenceBasedCriteria = class {
  107.   /**
  108.    * @param {string} language
  109.    * @param {string} role
  110.    * @param {number} channelCount
  111.    * @param {string} hdrLevel
  112.    * @param {boolean} spatialAudio
  113.    * @param {string} videoLayout
  114.    * @param {string=} audioLabel
  115.    * @param {string=} videoLabel
  116.    * @param {shaka.config.CodecSwitchingStrategy=} codecSwitchingStrategy
  117.    * @param {boolean=} enableAudioGroups
  118.    * @param {string=} audioCodec
  119.    */
  120.   constructor(language, role, channelCount, hdrLevel, spatialAudio,
  121.       videoLayout, audioLabel = '', videoLabel = '',
  122.       codecSwitchingStrategy = shaka.config.CodecSwitchingStrategy.RELOAD,
  123.       enableAudioGroups = false, audioCodec = '') {
  124.     /** @private {string} */
  125.     this.language_ = language;
  126.     /** @private {string} */
  127.     this.role_ = role;
  128.     /** @private {number} */
  129.     this.channelCount_ = channelCount;
  130.     /** @private {string} */
  131.     this.hdrLevel_ = hdrLevel;
  132.     /** @private {boolean} */
  133.     this.spatialAudio_ = spatialAudio;
  134.     /** @private {string} */
  135.     this.videoLayout_ = videoLayout;
  136.     /** @private {string} */
  137.     this.audioLabel_ = audioLabel;
  138.     /** @private {string} */
  139.     this.videoLabel_ = videoLabel;
  140.     /** @private {shaka.config.CodecSwitchingStrategy} */
  141.     this.codecSwitchingStrategy_ = codecSwitchingStrategy;
  142.     /** @private {boolean} */
  143.     this.enableAudioGroups_ = enableAudioGroups;
  144.     /** @private {string} */
  145.     this.audioCodec_ = audioCodec;
  146.   }
  148.   /** @override */
  149.   create(variants) {
  150.     const Class = shaka.media.PreferenceBasedCriteria;
  152.     let current = [];
  154.     const byLanguage = Class.filterByLanguage_(variants, this.language_);
  155.     const byPrimary = variants.filter((variant) => variant.primary);
  157.     if (byLanguage.length) {
  158.       current = byLanguage;
  159.     } else if (byPrimary.length) {
  160.       current = byPrimary;
  161.     } else {
  162.       current = variants;
  163.     }
  165.     // Now refine the choice based on role preference.  Even the empty string
  166.     // works here, and will match variants without any roles.
  167.     const byRole = Class.filterVariantsByRole_(current, this.role_);
  168.     if (byRole.length) {
  169.       current = byRole;
  170.     } else {
  171.       shaka.log.warning('No exact match for variant role could be found.');
  172.     }
  174.     if (this.videoLayout_) {
  175.       const byVideoLayout = Class.filterVariantsByVideoLayout_(
  176.           current, this.videoLayout_);
  177.       if (byVideoLayout.length) {
  178.         current = byVideoLayout;
  179.       } else {
  180.         shaka.log.warning(
  181.             'No exact match for the video layout could be found.');
  182.       }
  183.     }
  185.     if (this.hdrLevel_) {
  186.       const byHdrLevel = Class.filterVariantsByHDRLevel_(
  187.           current, this.hdrLevel_);
  188.       if (byHdrLevel.length) {
  189.         current = byHdrLevel;
  190.       } else {
  191.         shaka.log.warning(
  192.             'No exact match for the hdr level could be found.');
  193.       }
  194.     }
  196.     if (this.channelCount_) {
  197.       const byChannel = Class.filterVariantsByAudioChannelCount_(
  198.           current, this.channelCount_);
  199.       if (byChannel.length) {
  200.         current = byChannel;
  201.       } else {
  202.         shaka.log.warning(
  203.             'No exact match for the channel count could be found.');
  204.       }
  205.     }
  207.     if (this.audioLabel_) {
  208.       const byLabel = Class.filterVariantsByAudioLabel_(
  209.           current, this.audioLabel_);
  210.       if (byLabel.length) {
  211.         current = byLabel;
  212.       } else {
  213.         shaka.log.warning('No exact match for audio label could be found.');
  214.       }
  215.     }
  217.     if (this.videoLabel_) {
  218.       const byLabel = Class.filterVariantsByVideoLabel_(
  219.           current, this.videoLabel_);
  220.       if (byLabel.length) {
  221.         current = byLabel;
  222.       } else {
  223.         shaka.log.warning('No exact match for video label could be found.');
  224.       }
  225.     }
  227.     const bySpatialAudio = Class.filterVariantsBySpatialAudio_(
  228.         current, this.spatialAudio_);
  229.     if (bySpatialAudio.length) {
  230.       current = bySpatialAudio;
  231.     } else {
  232.       shaka.log.warning('No exact match for spatial audio could be found.');
  233.     }
  235.     if (this.audioCodec_) {
  236.       const byAudioCodec = Class.filterVariantsByAudioCodec_(
  237.           current, this.audioCodec_);
  238.       if (byAudioCodec.length) {
  239.         current = byAudioCodec;
  240.       } else {
  241.         shaka.log.warning('No exact match for audio codec could be found.');
  242.       }
  243.     }
  245.     const supportsSmoothCodecTransitions = this.codecSwitchingStrategy_ ==
  246.       shaka.config.CodecSwitchingStrategy.SMOOTH &&
  247.         shaka.media.Capabilities.isChangeTypeSupported();
  249.     return new shaka.media.AdaptationSet(current[0], current,
  250.         !supportsSmoothCodecTransitions, this.enableAudioGroups_);
  251.   }
  253.   /**
  254.    * @param {!Array.<shaka.extern.Variant>} variants
  255.    * @param {string} preferredLanguage
  256.    * @return {!Array.<shaka.extern.Variant>}
  257.    * @private
  258.    */
  259.   static filterByLanguage_(variants, preferredLanguage) {
  260.     const LanguageUtils = shaka.util.LanguageUtils;
  262.     /** @type {string} */
  263.     const preferredLocale = LanguageUtils.normalize(preferredLanguage);
  265.     /** @type {?string} */
  266.     const closestLocale = LanguageUtils.findClosestLocale(
  267.         preferredLocale,
  268.         variants.map((variant) => LanguageUtils.getLocaleForVariant(variant)));
  270.     // There were no locales close to what we preferred.
  271.     if (!closestLocale) {
  272.       return [];
  273.     }
  275.     // Find the variants that use the closest variant.
  276.     return variants.filter((variant) => {
  277.       return closestLocale == LanguageUtils.getLocaleForVariant(variant);
  278.     });
  279.   }
  281.   /**
  282.    * Filter Variants by role.
  283.    *
  284.    * @param {!Array.<shaka.extern.Variant>} variants
  285.    * @param {string} preferredRole
  286.    * @return {!Array.<shaka.extern.Variant>}
  287.    * @private
  288.    */
  289.   static filterVariantsByRole_(variants, preferredRole) {
  290.     return variants.filter((variant) => {
  291.       if (!variant.audio) {
  292.         return false;
  293.       }
  295.       if (preferredRole) {
  296.         return variant.audio.roles.includes(preferredRole);
  297.       } else {
  298.         return variant.audio.roles.length == 0;
  299.       }
  300.     });
  301.   }
  303.   /**
  304.    * Filter Variants by audio label.
  305.    *
  306.    * @param {!Array.<shaka.extern.Variant>} variants
  307.    * @param {string} preferredLabel
  308.    * @return {!Array.<shaka.extern.Variant>}
  309.    * @private
  310.    */
  311.   static filterVariantsByAudioLabel_(variants, preferredLabel) {
  312.     return variants.filter((variant) => {
  313.       if (!variant.audio || !variant.audio.label) {
  314.         return false;
  315.       }
  317.       const label1 = variant.audio.label.toLowerCase();
  318.       const label2 = preferredLabel.toLowerCase();
  319.       return label1 == label2;
  320.     });
  321.   }
  323.   /**
  324.    * Filter Variants by video label.
  325.    *
  326.    * @param {!Array.<shaka.extern.Variant>} variants
  327.    * @param {string} preferredLabel
  328.    * @return {!Array.<shaka.extern.Variant>}
  329.    * @private
  330.    */
  331.   static filterVariantsByVideoLabel_(variants, preferredLabel) {
  332.     return variants.filter((variant) => {
  333.       if (!variant.video || !variant.video.label) {
  334.         return false;
  335.       }
  337.       const label1 = variant.video.label.toLowerCase();
  338.       const label2 = preferredLabel.toLowerCase();
  339.       return label1 == label2;
  340.     });
  341.   }
  343.   /**
  344.    * Filter Variants by channelCount.
  345.    *
  346.    * @param {!Array.<shaka.extern.Variant>} variants
  347.    * @param {number} channelCount
  348.    * @return {!Array.<shaka.extern.Variant>}
  349.    * @private
  350.    */
  351.   static filterVariantsByAudioChannelCount_(variants, channelCount) {
  352.     return variants.filter((variant) => {
  353.       if (variant.audio && variant.audio.channelsCount &&
  354.           variant.audio.channelsCount != channelCount) {
  355.         return false;
  356.       }
  357.       return true;
  358.     });
  359.   }
  361.   /**
  362.    * Filters variants according to the given hdr level config.
  363.    *
  364.    * @param {!Array.<shaka.extern.Variant>} variants
  365.    * @param {string} hdrLevel
  366.    * @private
  367.    */
  368.   static filterVariantsByHDRLevel_(variants, hdrLevel) {
  369.     if (hdrLevel == 'AUTO') {
  370.       // Auto detect the ideal HDR level.
  371.       if (window.matchMedia('(color-gamut: p3)').matches) {
  372.         hdrLevel = 'PQ';
  373.       } else {
  374.         hdrLevel = 'SDR';
  375.       }
  376.     }
  377.     return variants.filter((variant) => {
  378.       if (variant.video && variant.video.hdr && variant.video.hdr != hdrLevel) {
  379.         return false;
  380.       }
  381.       return true;
  382.     });
  383.   }
  386.   /**
  387.    * Filters variants according to the given video layout config.
  388.    *
  389.    * @param {!Array.<shaka.extern.Variant>} variants
  390.    * @param {string} videoLayout
  391.    * @private
  392.    */
  393.   static filterVariantsByVideoLayout_(variants, videoLayout) {
  394.     return variants.filter((variant) => {
  395.       if (variant.video && variant.video.videoLayout &&
  396.           variant.video.videoLayout != videoLayout) {
  397.         return false;
  398.       }
  399.       return true;
  400.     });
  401.   }
  404.   /**
  405.    * Filters variants according to the given spatial audio config.
  406.    *
  407.    * @param {!Array.<shaka.extern.Variant>} variants
  408.    * @param {boolean} spatialAudio
  409.    * @private
  410.    */
  411.   static filterVariantsBySpatialAudio_(variants, spatialAudio) {
  412.     return variants.filter((variant) => {
  413.       if (variant.audio && variant.audio.spatialAudio != spatialAudio) {
  414.         return false;
  415.       }
  416.       return true;
  417.     });
  418.   }
  421.   /**
  422.    * Filters variants according to the given audio codec.
  423.    *
  424.    * @param {!Array<shaka.extern.Variant>} variants
  425.    * @param {string} audioCodec
  426.    * @private
  427.    */
  428.   static filterVariantsByAudioCodec_(variants, audioCodec) {
  429.     return variants.filter((variant) => {
  430.       if (variant.audio && variant.audio.codecs != audioCodec) {
  431.         return false;
  432.       }
  433.       return true;
  434.     });
  435.   }
  436. };