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');
  15. goog.require('shaka.util.Platform');
  18. /**
  19.  * @implements {shaka.media.AdaptationSetCriteria}
  20.  * @final
  21.  */
  22. shaka.media.PreferenceBasedCriteria = class {
  23.   /** */
  24.   constructor() {
  25.     /** @private {?shaka.media.AdaptationSetCriteria.Configuration} */
  26.     this.config_ = null;
  27.   }
  29.   /**
  30.    * @override
  31.    */
  32.   configure(config) {
  33.     this.config_ = config;
  34.   }
  36.   /**
  37.    * @override
  38.    */
  39.   create(variants) {
  40.     const Class = shaka.media.PreferenceBasedCriteria;
  42.     let current;
  44.     if (this.config_.language) {
  45.       const byLanguage = Class.filterByLanguage_(
  46.           variants, this.config_.language);
  47.       if (byLanguage.length) {
  48.         current = byLanguage;
  49.       }
  50.     }
  51.     if (!current) {
  52.       const byPrimary = variants.filter((variant) => variant.primary);
  53.       if (byPrimary.length) {
  54.         current = byPrimary;
  55.       } else {
  56.         current = variants;
  57.       }
  58.     }
  60.     // Now refine the choice based on role preference.  Even the empty string
  61.     // works here, and will match variants without any roles.
  62.     const byRole = Class.filterVariantsByRole_(current, this.config_.role);
  63.     if (byRole.length) {
  64.       current = byRole;
  65.     } else {
  66.       shaka.log.warning('No exact match for variant role could be found.');
  67.     }
  69.     if (this.config_.videoLayout) {
  70.       const byVideoLayout = Class.filterVariantsByVideoLayout_(
  71.           current, this.config_.videoLayout);
  72.       if (byVideoLayout.length) {
  73.         current = byVideoLayout;
  74.       } else {
  75.         shaka.log.warning(
  76.             'No exact match for the video layout could be found.');
  77.       }
  78.     }
  80.     if (this.config_.hdrLevel) {
  81.       const byHdrLevel = Class.filterVariantsByHDRLevel_(
  82.           current, this.config_.hdrLevel);
  83.       if (byHdrLevel.length) {
  84.         current = byHdrLevel;
  85.       } else {
  86.         shaka.log.warning(
  87.             'No exact match for the hdr level could be found.');
  88.       }
  89.     }
  91.     if (this.config_.channelCount) {
  92.       const byChannel = Class.filterVariantsByAudioChannelCount_(
  93.           current, this.config_.channelCount);
  94.       if (byChannel.length) {
  95.         current = byChannel;
  96.       } else {
  97.         shaka.log.warning(
  98.             'No exact match for the channel count could be found.');
  99.       }
  100.     }
  102.     if (this.config_.audioLabel) {
  103.       const byLabel = Class.filterVariantsByAudioLabel_(
  104.           current, this.config_.audioLabel);
  105.       if (byLabel.length) {
  106.         current = byLabel;
  107.       } else {
  108.         shaka.log.warning('No exact match for audio label could be found.');
  109.       }
  110.     }
  112.     if (this.config_.videoLabel) {
  113.       const byLabel = Class.filterVariantsByVideoLabel_(
  114.           current, this.config_.videoLabel);
  115.       if (byLabel.length) {
  116.         current = byLabel;
  117.       } else {
  118.         shaka.log.warning('No exact match for video label could be found.');
  119.       }
  120.     }
  122.     const bySpatialAudio = Class.filterVariantsBySpatialAudio_(
  123.         current, this.config_.spatialAudio);
  124.     if (bySpatialAudio.length) {
  125.       current = bySpatialAudio;
  126.     } else {
  127.       shaka.log.warning('No exact match for spatial audio could be found.');
  128.     }
  130.     if (this.config_.audioCodec) {
  131.       const byAudioCodec = Class.filterVariantsByAudioCodec_(
  132.           current, this.config_.audioCodec);
  133.       if (byAudioCodec.length) {
  134.         current = byAudioCodec;
  135.       } else {
  136.         shaka.log.warning('No exact match for audio codec could be found.');
  137.       }
  138.     }
  140.     const supportsSmoothCodecTransitions =
  141.       this.config_.codecSwitchingStrategy ==
  142.       shaka.config.CodecSwitchingStrategy.SMOOTH &&
  143.         shaka.media.Capabilities.isChangeTypeSupported();
  145.     return new shaka.media.AdaptationSet(current[0], current,
  146.         !supportsSmoothCodecTransitions);
  147.   }
  149.   /**
  150.    * @param {!Array<shaka.extern.Variant>} variants
  151.    * @param {string} preferredLanguage
  152.    * @return {!Array<shaka.extern.Variant>}
  153.    * @private
  154.    */
  155.   static filterByLanguage_(variants, preferredLanguage) {
  156.     const LanguageUtils = shaka.util.LanguageUtils;
  158.     /** @type {string} */
  159.     const preferredLocale = LanguageUtils.normalize(preferredLanguage);
  161.     /** @type {?string} */
  162.     const closestLocale = LanguageUtils.findClosestLocale(
  163.         preferredLocale,
  164.         variants.map((variant) => LanguageUtils.getLocaleForVariant(variant)));
  166.     // There were no locales close to what we preferred.
  167.     if (!closestLocale) {
  168.       return [];
  169.     }
  171.     // Find the variants that use the closest variant.
  172.     return variants.filter((variant) => {
  173.       return closestLocale == LanguageUtils.getLocaleForVariant(variant);
  174.     });
  175.   }
  177.   /**
  178.    * Filter Variants by role.
  179.    *
  180.    * @param {!Array<shaka.extern.Variant>} variants
  181.    * @param {string} preferredRole
  182.    * @return {!Array<shaka.extern.Variant>}
  183.    * @private
  184.    */
  185.   static filterVariantsByRole_(variants, preferredRole) {
  186.     return variants.filter((variant) => {
  187.       if (!variant.audio) {
  188.         return false;
  189.       }
  191.       if (preferredRole) {
  192.         return variant.audio.roles.includes(preferredRole);
  193.       } else {
  194.         return variant.audio.roles.length == 0;
  195.       }
  196.     });
  197.   }
  199.   /**
  200.    * Filter Variants by audio label.
  201.    *
  202.    * @param {!Array<shaka.extern.Variant>} variants
  203.    * @param {string} preferredLabel
  204.    * @return {!Array<shaka.extern.Variant>}
  205.    * @private
  206.    */
  207.   static filterVariantsByAudioLabel_(variants, preferredLabel) {
  208.     return variants.filter((variant) => {
  209.       if (!variant.audio || !variant.audio.label) {
  210.         return false;
  211.       }
  213.       const label1 = variant.audio.label.toLowerCase();
  214.       const label2 = preferredLabel.toLowerCase();
  215.       return label1 == label2;
  216.     });
  217.   }
  219.   /**
  220.    * Filter Variants by video label.
  221.    *
  222.    * @param {!Array<shaka.extern.Variant>} variants
  223.    * @param {string} preferredLabel
  224.    * @return {!Array<shaka.extern.Variant>}
  225.    * @private
  226.    */
  227.   static filterVariantsByVideoLabel_(variants, preferredLabel) {
  228.     return variants.filter((variant) => {
  229.       if (!variant.video || !variant.video.label) {
  230.         return false;
  231.       }
  233.       const label1 = variant.video.label.toLowerCase();
  234.       const label2 = preferredLabel.toLowerCase();
  235.       return label1 == label2;
  236.     });
  237.   }
  239.   /**
  240.    * Filter Variants by channelCount.
  241.    *
  242.    * @param {!Array<shaka.extern.Variant>} variants
  243.    * @param {number} channelCount
  244.    * @return {!Array<shaka.extern.Variant>}
  245.    * @private
  246.    */
  247.   static filterVariantsByAudioChannelCount_(variants, channelCount) {
  248.     return variants.filter((variant) => {
  249.       // Filter variants with channel count less than or equal to desired value.
  250.       if (variant.audio && variant.audio.channelsCount &&
  251.           variant.audio.channelsCount > channelCount) {
  252.         return false;
  253.       }
  254.       return true;
  255.     }).sort((v1, v2) => {
  256.       // We need to sort variants list by channels count, so the most close one
  257.       // to desired value will be first on the list. It's important for the call
  258.       // to shaka.media.AdaptationSet, which will base set of variants based on
  259.       // first variant.
  260.       if (!v1.audio && !v2.audio) {
  261.         return 0;
  262.       }
  263.       if (!v1.audio) {
  264.         return -1;
  265.       }
  266.       if (!v2.audio) {
  267.         return 1;
  268.       }
  269.       return (v2.audio.channelsCount || 0) - (v1.audio.channelsCount || 0);
  270.     });
  271.   }
  273.   /**
  274.    * Filters variants according to the given hdr level config.
  275.    *
  276.    * @param {!Array<shaka.extern.Variant>} variants
  277.    * @param {string} hdrLevel
  278.    * @private
  279.    */
  280.   static filterVariantsByHDRLevel_(variants, hdrLevel) {
  281.     if (hdrLevel == 'AUTO') {
  282.       const someHLG = variants.some((variant) => {
  283.         if (variant.video && variant.video.hdr &&
  284.             variant.video.hdr == 'HLG') {
  285.           return true;
  286.         }
  287.         return false;
  288.       });
  289.       hdrLevel = shaka.util.Platform.getHdrLevel(someHLG);
  290.     }
  291.     return variants.filter((variant) => {
  292.       if (variant.video && variant.video.hdr && variant.video.hdr != hdrLevel) {
  293.         return false;
  294.       }
  295.       return true;
  296.     });
  297.   }
  300.   /**
  301.    * Filters variants according to the given video layout config.
  302.    *
  303.    * @param {!Array<shaka.extern.Variant>} variants
  304.    * @param {string} videoLayout
  305.    * @private
  306.    */
  307.   static filterVariantsByVideoLayout_(variants, videoLayout) {
  308.     return variants.filter((variant) => {
  309.       if (variant.video && variant.video.videoLayout &&
  310.           variant.video.videoLayout != videoLayout) {
  311.         return false;
  312.       }
  313.       return true;
  314.     });
  315.   }
  318.   /**
  319.    * Filters variants according to the given spatial audio config.
  320.    *
  321.    * @param {!Array<shaka.extern.Variant>} variants
  322.    * @param {boolean} spatialAudio
  323.    * @private
  324.    */
  325.   static filterVariantsBySpatialAudio_(variants, spatialAudio) {
  326.     return variants.filter((variant) => {
  327.       if (variant.audio && variant.audio.spatialAudio != spatialAudio) {
  328.         return false;
  329.       }
  330.       return true;
  331.     });
  332.   }
  335.   /**
  336.    * Filters variants according to the given audio codec.
  337.    *
  338.    * @param {!Array<shaka.extern.Variant>} variants
  339.    * @param {string} audioCodec
  340.    * @private
  341.    */
  342.   static filterVariantsByAudioCodec_(variants, audioCodec) {
  343.     return variants.filter((variant) => {
  344.       if (variant.audio && variant.audio.codecs != audioCodec) {
  345.         return false;
  346.       }
  347.       return true;
  348.     });
  349.   }
  350. };