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.    */
  119.   constructor(language, role, channelCount, hdrLevel, spatialAudio,
  120.       videoLayout, audioLabel = '', videoLabel = '',
  121.       codecSwitchingStrategy = shaka.config.CodecSwitchingStrategy.RELOAD,
  122.       enableAudioGroups = false) {
  123.     /** @private {string} */
  124.     this.language_ = language;
  125.     /** @private {string} */
  126.     this.role_ = role;
  127.     /** @private {number} */
  128.     this.channelCount_ = channelCount;
  129.     /** @private {string} */
  130.     this.hdrLevel_ = hdrLevel;
  131.     /** @private {boolean} */
  132.     this.spatialAudio_ = spatialAudio;
  133.     /** @private {string} */
  134.     this.videoLayout_ = videoLayout;
  135.     /** @private {string} */
  136.     this.audioLabel_ = audioLabel;
  137.     /** @private {string} */
  138.     this.videoLabel_ = videoLabel;
  139.     /** @private {shaka.config.CodecSwitchingStrategy} */
  140.     this.codecSwitchingStrategy_ = codecSwitchingStrategy;
  141.     /** @private {boolean} */
  142.     this.enableAudioGroups_ = enableAudioGroups;
  143.   }
  145.   /** @override */
  146.   create(variants) {
  147.     const Class = shaka.media.PreferenceBasedCriteria;
  149.     let current = [];
  151.     const byLanguage = Class.filterByLanguage_(variants, this.language_);
  152.     const byPrimary = variants.filter((variant) => variant.primary);
  154.     if (byLanguage.length) {
  155.       current = byLanguage;
  156.     } else if (byPrimary.length) {
  157.       current = byPrimary;
  158.     } else {
  159.       current = variants;
  160.     }
  162.     // Now refine the choice based on role preference.  Even the empty string
  163.     // works here, and will match variants without any roles.
  164.     const byRole = Class.filterVariantsByRole_(current, this.role_);
  165.     if (byRole.length) {
  166.       current = byRole;
  167.     } else {
  168.       shaka.log.warning('No exact match for variant role could be found.');
  169.     }
  171.     if (this.videoLayout_) {
  172.       const byVideoLayout = Class.filterVariantsByVideoLayout_(
  173.           current, this.videoLayout_);
  174.       if (byVideoLayout.length) {
  175.         current = byVideoLayout;
  176.       } else {
  177.         shaka.log.warning(
  178.             'No exact match for the video layout could be found.');
  179.       }
  180.     }
  182.     if (this.hdrLevel_) {
  183.       const byHdrLevel = Class.filterVariantsByHDRLevel_(
  184.           current, this.hdrLevel_);
  185.       if (byHdrLevel.length) {
  186.         current = byHdrLevel;
  187.       } else {
  188.         shaka.log.warning(
  189.             'No exact match for the hdr level could be found.');
  190.       }
  191.     }
  193.     if (this.channelCount_) {
  194.       const byChannel = Class.filterVariantsByAudioChannelCount_(
  195.           current, this.channelCount_);
  196.       if (byChannel.length) {
  197.         current = byChannel;
  198.       } else {
  199.         shaka.log.warning(
  200.             'No exact match for the channel count could be found.');
  201.       }
  202.     }
  204.     if (this.audioLabel_) {
  205.       const byLabel = Class.filterVariantsByAudioLabel_(
  206.           current, this.audioLabel_);
  207.       if (byLabel.length) {
  208.         current = byLabel;
  209.       } else {
  210.         shaka.log.warning('No exact match for audio label could be found.');
  211.       }
  212.     }
  214.     if (this.videoLabel_) {
  215.       const byLabel = Class.filterVariantsByVideoLabel_(
  216.           current, this.videoLabel_);
  217.       if (byLabel.length) {
  218.         current = byLabel;
  219.       } else {
  220.         shaka.log.warning('No exact match for video label could be found.');
  221.       }
  222.     }
  224.     const bySpatialAudio = Class.filterVariantsBySpatialAudio_(
  225.         current, this.spatialAudio_);
  226.     if (bySpatialAudio.length) {
  227.       current = bySpatialAudio;
  228.     } else {
  229.       shaka.log.warning('No exact match for spatial audio could be found.');
  230.     }
  232.     const supportsSmoothCodecTransitions = this.codecSwitchingStrategy_ ==
  233.       shaka.config.CodecSwitchingStrategy.SMOOTH &&
  234.         shaka.media.Capabilities.isChangeTypeSupported();
  236.     return new shaka.media.AdaptationSet(current[0], current,
  237.         !supportsSmoothCodecTransitions, this.enableAudioGroups_);
  238.   }
  240.   /**
  241.    * @param {!Array.<shaka.extern.Variant>} variants
  242.    * @param {string} preferredLanguage
  243.    * @return {!Array.<shaka.extern.Variant>}
  244.    * @private
  245.    */
  246.   static filterByLanguage_(variants, preferredLanguage) {
  247.     const LanguageUtils = shaka.util.LanguageUtils;
  249.     /** @type {string} */
  250.     const preferredLocale = LanguageUtils.normalize(preferredLanguage);
  252.     /** @type {?string} */
  253.     const closestLocale = LanguageUtils.findClosestLocale(
  254.         preferredLocale,
  255.         variants.map((variant) => LanguageUtils.getLocaleForVariant(variant)));
  257.     // There were no locales close to what we preferred.
  258.     if (!closestLocale) {
  259.       return [];
  260.     }
  262.     // Find the variants that use the closest variant.
  263.     return variants.filter((variant) => {
  264.       return closestLocale == LanguageUtils.getLocaleForVariant(variant);
  265.     });
  266.   }
  268.   /**
  269.    * Filter Variants by role.
  270.    *
  271.    * @param {!Array.<shaka.extern.Variant>} variants
  272.    * @param {string} preferredRole
  273.    * @return {!Array.<shaka.extern.Variant>}
  274.    * @private
  275.    */
  276.   static filterVariantsByRole_(variants, preferredRole) {
  277.     return variants.filter((variant) => {
  278.       if (!variant.audio) {
  279.         return false;
  280.       }
  282.       if (preferredRole) {
  283.         return variant.audio.roles.includes(preferredRole);
  284.       } else {
  285.         return variant.audio.roles.length == 0;
  286.       }
  287.     });
  288.   }
  290.   /**
  291.    * Filter Variants by audio label.
  292.    *
  293.    * @param {!Array.<shaka.extern.Variant>} variants
  294.    * @param {string} preferredLabel
  295.    * @return {!Array.<shaka.extern.Variant>}
  296.    * @private
  297.    */
  298.   static filterVariantsByAudioLabel_(variants, preferredLabel) {
  299.     return variants.filter((variant) => {
  300.       if (!variant.audio || !variant.audio.label) {
  301.         return false;
  302.       }
  304.       const label1 = variant.audio.label.toLowerCase();
  305.       const label2 = preferredLabel.toLowerCase();
  306.       return label1 == label2;
  307.     });
  308.   }
  310.   /**
  311.    * Filter Variants by video label.
  312.    *
  313.    * @param {!Array.<shaka.extern.Variant>} variants
  314.    * @param {string} preferredLabel
  315.    * @return {!Array.<shaka.extern.Variant>}
  316.    * @private
  317.    */
  318.   static filterVariantsByVideoLabel_(variants, preferredLabel) {
  319.     return variants.filter((variant) => {
  320.       if (!variant.video || !variant.video.label) {
  321.         return false;
  322.       }
  324.       const label1 = variant.video.label.toLowerCase();
  325.       const label2 = preferredLabel.toLowerCase();
  326.       return label1 == label2;
  327.     });
  328.   }
  330.   /**
  331.    * Filter Variants by channelCount.
  332.    *
  333.    * @param {!Array.<shaka.extern.Variant>} variants
  334.    * @param {number} channelCount
  335.    * @return {!Array.<shaka.extern.Variant>}
  336.    * @private
  337.    */
  338.   static filterVariantsByAudioChannelCount_(variants, channelCount) {
  339.     return variants.filter((variant) => {
  340.       if (variant.audio && variant.audio.channelsCount &&
  341.           variant.audio.channelsCount != channelCount) {
  342.         return false;
  343.       }
  344.       return true;
  345.     });
  346.   }
  348.   /**
  349.    * Filters variants according to the given hdr level config.
  350.    *
  351.    * @param {!Array.<shaka.extern.Variant>} variants
  352.    * @param {string} hdrLevel
  353.    * @private
  354.    */
  355.   static filterVariantsByHDRLevel_(variants, hdrLevel) {
  356.     if (hdrLevel == 'AUTO') {
  357.       // Auto detect the ideal HDR level.
  358.       if (window.matchMedia('(color-gamut: p3)').matches) {
  359.         hdrLevel = 'PQ';
  360.       } else {
  361.         hdrLevel = 'SDR';
  362.       }
  363.     }
  364.     return variants.filter((variant) => {
  365.       if (variant.video && variant.video.hdr && variant.video.hdr != hdrLevel) {
  366.         return false;
  367.       }
  368.       return true;
  369.     });
  370.   }
  373.   /**
  374.    * Filters variants according to the given video layout config.
  375.    *
  376.    * @param {!Array.<shaka.extern.Variant>} variants
  377.    * @param {string} videoLayout
  378.    * @private
  379.    */
  380.   static filterVariantsByVideoLayout_(variants, videoLayout) {
  381.     return variants.filter((variant) => {
  382.       if (variant.video && variant.video.videoLayout &&
  383.           variant.video.videoLayout != videoLayout) {
  384.         return false;
  385.       }
  386.       return true;
  387.     });
  388.   }
  391.   /**
  392.    * Filters variants according to the given spatial audio config.
  393.    *
  394.    * @param {!Array.<shaka.extern.Variant>} variants
  395.    * @param {boolean} spatialAudio
  396.    * @private
  397.    */
  398.   static filterVariantsBySpatialAudio_(variants, spatialAudio) {
  399.     return variants.filter((variant) => {
  400.       if (variant.audio && variant.audio.spatialAudio != spatialAudio) {
  401.         return false;
  402.       }
  403.       return true;
  404.     });
  405.   }
  406. };