Source: lib/media/preference_based_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.PreferenceBasedCriteria');
  9. goog.require('shaka.config.CodecSwitchingStrategy');
  10. goog.require('shaka.log');
  11. goog.require('shaka.media.AdaptationSet');
  12. goog.require('shaka.media.AdaptationSetCriteria');
  13. goog.require('shaka.media.Capabilities');
  14. goog.require('shaka.util.LanguageUtils');
  17. /**
  18.  * @implements {shaka.media.AdaptationSetCriteria}
  19.  * @final
  20.  */
  21. shaka.media.PreferenceBasedCriteria = class {
  22.   /** */
  23.   constructor() {
  24.     /** @private {?shaka.media.AdaptationSetCriteria.Configuration} */
  25.     this.config_ = null;
  26.   }
  28.   /**
  29.    * @override
  30.    */
  31.   configure(config) {
  32.     this.config_ = config;
  33.   }
  35.   /**
  36.    * @override
  37.    */
  38.   create(variants) {
  39.     const Class = shaka.media.PreferenceBasedCriteria;
  41.     let current = [];
  43.     const byLanguage = Class.filterByLanguage_(variants, this.config_.language);
  44.     const byPrimary = variants.filter((variant) => variant.primary);
  46.     if (byLanguage.length) {
  47.       current = byLanguage;
  48.     } else if (byPrimary.length) {
  49.       current = byPrimary;
  50.     } else {
  51.       current = variants;
  52.     }
  54.     // Now refine the choice based on role preference.  Even the empty string
  55.     // works here, and will match variants without any roles.
  56.     const byRole = Class.filterVariantsByRole_(current, this.config_.role);
  57.     if (byRole.length) {
  58.       current = byRole;
  59.     } else {
  60.       shaka.log.warning('No exact match for variant role could be found.');
  61.     }
  63.     if (this.config_.videoLayout) {
  64.       const byVideoLayout = Class.filterVariantsByVideoLayout_(
  65.           current, this.config_.videoLayout);
  66.       if (byVideoLayout.length) {
  67.         current = byVideoLayout;
  68.       } else {
  69.         shaka.log.warning(
  70.             'No exact match for the video layout could be found.');
  71.       }
  72.     }
  74.     if (this.config_.hdrLevel) {
  75.       const byHdrLevel = Class.filterVariantsByHDRLevel_(
  76.           current, this.config_.hdrLevel);
  77.       if (byHdrLevel.length) {
  78.         current = byHdrLevel;
  79.       } else {
  80.         shaka.log.warning(
  81.             'No exact match for the hdr level could be found.');
  82.       }
  83.     }
  85.     if (this.config_.channelCount) {
  86.       const byChannel = Class.filterVariantsByAudioChannelCount_(
  87.           current, this.config_.channelCount);
  88.       if (byChannel.length) {
  89.         current = byChannel;
  90.       } else {
  91.         shaka.log.warning(
  92.             'No exact match for the channel count could be found.');
  93.       }
  94.     }
  96.     if (this.config_.audioLabel) {
  97.       const byLabel = Class.filterVariantsByAudioLabel_(
  98.           current, this.config_.audioLabel);
  99.       if (byLabel.length) {
  100.         current = byLabel;
  101.       } else {
  102.         shaka.log.warning('No exact match for audio label could be found.');
  103.       }
  104.     }
  106.     if (this.config_.videoLabel) {
  107.       const byLabel = Class.filterVariantsByVideoLabel_(
  108.           current, this.config_.videoLabel);
  109.       if (byLabel.length) {
  110.         current = byLabel;
  111.       } else {
  112.         shaka.log.warning('No exact match for video label could be found.');
  113.       }
  114.     }
  116.     const bySpatialAudio = Class.filterVariantsBySpatialAudio_(
  117.         current, this.config_.spatialAudio);
  118.     if (bySpatialAudio.length) {
  119.       current = bySpatialAudio;
  120.     } else {
  121.       shaka.log.warning('No exact match for spatial audio could be found.');
  122.     }
  124.     if (this.config_.audioCodec) {
  125.       const byAudioCodec = Class.filterVariantsByAudioCodec_(
  126.           current, this.config_.audioCodec);
  127.       if (byAudioCodec.length) {
  128.         current = byAudioCodec;
  129.       } else {
  130.         shaka.log.warning('No exact match for audio codec could be found.');
  131.       }
  132.     }
  134.     const supportsSmoothCodecTransitions =
  135.       this.config_.codecSwitchingStrategy ==
  136.       shaka.config.CodecSwitchingStrategy.SMOOTH &&
  137.         shaka.media.Capabilities.isChangeTypeSupported();
  139.     return new shaka.media.AdaptationSet(current[0], current,
  140.         !supportsSmoothCodecTransitions);
  141.   }
  143.   /**
  144.    * @param {!Array<shaka.extern.Variant>} variants
  145.    * @param {string} preferredLanguage
  146.    * @return {!Array<shaka.extern.Variant>}
  147.    * @private
  148.    */
  149.   static filterByLanguage_(variants, preferredLanguage) {
  150.     const LanguageUtils = shaka.util.LanguageUtils;
  152.     /** @type {string} */
  153.     const preferredLocale = LanguageUtils.normalize(preferredLanguage);
  155.     /** @type {?string} */
  156.     const closestLocale = LanguageUtils.findClosestLocale(
  157.         preferredLocale,
  158.         variants.map((variant) => LanguageUtils.getLocaleForVariant(variant)));
  160.     // There were no locales close to what we preferred.
  161.     if (!closestLocale) {
  162.       return [];
  163.     }
  165.     // Find the variants that use the closest variant.
  166.     return variants.filter((variant) => {
  167.       return closestLocale == LanguageUtils.getLocaleForVariant(variant);
  168.     });
  169.   }
  171.   /**
  172.    * Filter Variants by role.
  173.    *
  174.    * @param {!Array<shaka.extern.Variant>} variants
  175.    * @param {string} preferredRole
  176.    * @return {!Array<shaka.extern.Variant>}
  177.    * @private
  178.    */
  179.   static filterVariantsByRole_(variants, preferredRole) {
  180.     return variants.filter((variant) => {
  181.       if (!variant.audio) {
  182.         return false;
  183.       }
  185.       if (preferredRole) {
  186.         return variant.audio.roles.includes(preferredRole);
  187.       } else {
  188.         return variant.audio.roles.length == 0;
  189.       }
  190.     });
  191.   }
  193.   /**
  194.    * Filter Variants by audio label.
  195.    *
  196.    * @param {!Array<shaka.extern.Variant>} variants
  197.    * @param {string} preferredLabel
  198.    * @return {!Array<shaka.extern.Variant>}
  199.    * @private
  200.    */
  201.   static filterVariantsByAudioLabel_(variants, preferredLabel) {
  202.     return variants.filter((variant) => {
  203.       if (!variant.audio || !variant.audio.label) {
  204.         return false;
  205.       }
  207.       const label1 = variant.audio.label.toLowerCase();
  208.       const label2 = preferredLabel.toLowerCase();
  209.       return label1 == label2;
  210.     });
  211.   }
  213.   /**
  214.    * Filter Variants by video label.
  215.    *
  216.    * @param {!Array<shaka.extern.Variant>} variants
  217.    * @param {string} preferredLabel
  218.    * @return {!Array<shaka.extern.Variant>}
  219.    * @private
  220.    */
  221.   static filterVariantsByVideoLabel_(variants, preferredLabel) {
  222.     return variants.filter((variant) => {
  223.       if (!variant.video || !variant.video.label) {
  224.         return false;
  225.       }
  227.       const label1 = variant.video.label.toLowerCase();
  228.       const label2 = preferredLabel.toLowerCase();
  229.       return label1 == label2;
  230.     });
  231.   }
  233.   /**
  234.    * Filter Variants by channelCount.
  235.    *
  236.    * @param {!Array<shaka.extern.Variant>} variants
  237.    * @param {number} channelCount
  238.    * @return {!Array<shaka.extern.Variant>}
  239.    * @private
  240.    */
  241.   static filterVariantsByAudioChannelCount_(variants, channelCount) {
  242.     return variants.filter((variant) => {
  243.       if (variant.audio && variant.audio.channelsCount &&
  244.           variant.audio.channelsCount != channelCount) {
  245.         return false;
  246.       }
  247.       return true;
  248.     });
  249.   }
  251.   /**
  252.    * Filters variants according to the given hdr level config.
  253.    *
  254.    * @param {!Array<shaka.extern.Variant>} variants
  255.    * @param {string} hdrLevel
  256.    * @private
  257.    */
  258.   static filterVariantsByHDRLevel_(variants, hdrLevel) {
  259.     if (hdrLevel == 'AUTO') {
  260.       // Auto detect the ideal HDR level.
  261.       if (window.matchMedia('(color-gamut: p3)').matches) {
  262.         const someHLG = variants.some((variant) => {
  263.           if (variant.video && variant.video.hdr &&
  264.               variant.video.hdr == 'HLG') {
  265.             return true;
  266.           }
  267.           return false;
  268.         });
  269.         hdrLevel = someHLG ? 'HLG' : 'PQ';
  270.       } else {
  271.         hdrLevel = 'SDR';
  272.       }
  273.     }
  274.     return variants.filter((variant) => {
  275.       if (variant.video && variant.video.hdr && variant.video.hdr != hdrLevel) {
  276.         return false;
  277.       }
  278.       return true;
  279.     });
  280.   }
  283.   /**
  284.    * Filters variants according to the given video layout config.
  285.    *
  286.    * @param {!Array<shaka.extern.Variant>} variants
  287.    * @param {string} videoLayout
  288.    * @private
  289.    */
  290.   static filterVariantsByVideoLayout_(variants, videoLayout) {
  291.     return variants.filter((variant) => {
  292.       if (variant.video && variant.video.videoLayout &&
  293.           variant.video.videoLayout != videoLayout) {
  294.         return false;
  295.       }
  296.       return true;
  297.     });
  298.   }
  301.   /**
  302.    * Filters variants according to the given spatial audio config.
  303.    *
  304.    * @param {!Array<shaka.extern.Variant>} variants
  305.    * @param {boolean} spatialAudio
  306.    * @private
  307.    */
  308.   static filterVariantsBySpatialAudio_(variants, spatialAudio) {
  309.     return variants.filter((variant) => {
  310.       if (variant.audio && variant.audio.spatialAudio != spatialAudio) {
  311.         return false;
  312.       }
  313.       return true;
  314.     });
  315.   }
  318.   /**
  319.    * Filters variants according to the given audio codec.
  320.    *
  321.    * @param {!Array<shaka.extern.Variant>} variants
  322.    * @param {string} audioCodec
  323.    * @private
  324.    */
  325.   static filterVariantsByAudioCodec_(variants, audioCodec) {
  326.     return variants.filter((variant) => {
  327.       if (variant.audio && variant.audio.codecs != audioCodec) {
  328.         return false;
  329.       }
  330.       return true;
  331.     });
  332.   }
  333. };