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.device.DeviceFactory');
  11. goog.require('shaka.log');
  12. goog.require('shaka.media.AdaptationSet');
  13. goog.require('shaka.media.AdaptationSetCriteria');
  14. goog.require('shaka.media.Capabilities');
  15. goog.require('shaka.util.LanguageUtils');
  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.   getConfiguration() {
  40.     return this.config_;
  41.   }
  43.   /**
  44.    * @override
  45.    */
  46.   create(variants) {
  47.     const Class = shaka.media.PreferenceBasedCriteria;
  49.     let current;
  51.     if (this.config_.language) {
  52.       const byLanguage = Class.filterByLanguage_(
  53.           variants, this.config_.language);
  54.       if (byLanguage.length) {
  55.         current = byLanguage;
  56.       }
  57.     }
  58.     if (!current) {
  59.       const byPrimary = variants.filter((variant) => variant.primary);
  60.       if (byPrimary.length) {
  61.         current = byPrimary;
  62.       } else {
  63.         current = variants;
  64.       }
  65.     }
  67.     // Now refine the choice based on role preference.  Even the empty string
  68.     // works here, and will match variants without any roles.
  69.     const byRole = Class.filterVariantsByRole_(current, this.config_.role);
  70.     if (byRole.length) {
  71.       current = byRole;
  72.     } else {
  73.       shaka.log.warning('No exact match for variant role could be found.');
  74.     }
  76.     if (this.config_.videoLayout) {
  77.       const byVideoLayout = Class.filterVariantsByVideoLayout_(
  78.           current, this.config_.videoLayout);
  79.       if (byVideoLayout.length) {
  80.         current = byVideoLayout;
  81.       } else {
  82.         shaka.log.warning(
  83.             'No exact match for the video layout could be found.');
  84.       }
  85.     }
  87.     if (this.config_.hdrLevel) {
  88.       const byHdrLevel = Class.filterVariantsByHDRLevel_(
  89.           current, this.config_.hdrLevel);
  90.       if (byHdrLevel.length) {
  91.         current = byHdrLevel;
  92.       } else {
  93.         shaka.log.warning(
  94.             'No exact match for the hdr level could be found.');
  95.       }
  96.     }
  99.     const channelCounts = [
  100.       this.config_.channelCount,
  101.       this.config_.preferredAudioChannelCount,
  102.     ];
  104.     // Remove duplicates and empty values
  105.     const filteredChannelCounts =
  106.       channelCounts.filter(
  107.           (count, pos) => count && channelCounts.indexOf(count) === pos);
  109.     if (filteredChannelCounts.length) {
  110.       for (const channelCount of filteredChannelCounts) {
  111.         const byChannel = Class.filterVariantsByAudioChannelCount_(
  112.             current, channelCount);
  113.         if (byChannel.length) {
  114.           current = byChannel;
  115.           break;
  116.         } else {
  117.           shaka.log.warning(
  118.               'No exact match for the channel count could be found.');
  119.         }
  120.       }
  121.     }
  123.     if (this.config_.audioLabel) {
  124.       const byLabel = Class.filterVariantsByAudioLabel_(
  125.           current, this.config_.audioLabel);
  126.       if (byLabel.length) {
  127.         current = byLabel;
  128.       } else {
  129.         shaka.log.warning('No exact match for audio label could be found.');
  130.       }
  131.     }
  133.     if (this.config_.videoLabel) {
  134.       const byLabel = Class.filterVariantsByVideoLabel_(
  135.           current, this.config_.videoLabel);
  136.       if (byLabel.length) {
  137.         current = byLabel;
  138.       } else {
  139.         shaka.log.warning('No exact match for video label could be found.');
  140.       }
  141.     }
  143.     const bySpatialAudio = Class.filterVariantsBySpatialAudio_(
  144.         current, this.config_.spatialAudio);
  145.     if (bySpatialAudio.length) {
  146.       current = bySpatialAudio;
  147.     } else {
  148.       shaka.log.warning('No exact match for spatial audio could be found.');
  149.     }
  151.     const audioCodecs = [
  152.       this.config_.audioCodec,
  153.       this.config_.activeAudioCodec,
  154.       ...this.config_.preferredAudioCodecs,
  155.     ];
  157.     // Remove duplicates and empty values
  158.     const filteredAudioCodecs =
  159.       audioCodecs.filter(
  160.           (codec, pos) => codec && audioCodecs.indexOf(codec) === pos);
  162.     if (filteredAudioCodecs.length) {
  163.       for (const audioCodec of filteredAudioCodecs) {
  164.         const byAudioCodec = Class.filterVariantsByAudioCodec_(
  165.             current, audioCodec);
  166.         if (byAudioCodec.length) {
  167.           current = byAudioCodec;
  168.           break;
  169.         } else {
  170.           shaka.log.warning('No exact match for audio codec could be found.');
  171.         }
  172.       }
  173.     }
  175.     const supportsSmoothCodecTransitions =
  176.       this.config_.codecSwitchingStrategy ==
  177.       shaka.config.CodecSwitchingStrategy.SMOOTH &&
  178.         shaka.media.Capabilities.isChangeTypeSupported();
  180.     return new shaka.media.AdaptationSet(current[0], current,
  181.         !supportsSmoothCodecTransitions);
  182.   }
  184.   /**
  185.    * @param {!Array<shaka.extern.Variant>} variants
  186.    * @param {string} preferredLanguage
  187.    * @return {!Array<shaka.extern.Variant>}
  188.    * @private
  189.    */
  190.   static filterByLanguage_(variants, preferredLanguage) {
  191.     const LanguageUtils = shaka.util.LanguageUtils;
  193.     /** @type {string} */
  194.     const preferredLocale = LanguageUtils.normalize(preferredLanguage);
  196.     /** @type {?string} */
  197.     const closestLocale = LanguageUtils.findClosestLocale(
  198.         preferredLocale,
  199.         variants.map((variant) => LanguageUtils.getLocaleForVariant(variant)));
  201.     // There were no locales close to what we preferred.
  202.     if (!closestLocale) {
  203.       return [];
  204.     }
  206.     // Find the variants that use the closest variant.
  207.     return variants.filter((variant) => {
  208.       return closestLocale == LanguageUtils.getLocaleForVariant(variant);
  209.     });
  210.   }
  212.   /**
  213.    * Filter Variants by role.
  214.    *
  215.    * @param {!Array<shaka.extern.Variant>} variants
  216.    * @param {string} preferredRole
  217.    * @return {!Array<shaka.extern.Variant>}
  218.    * @private
  219.    */
  220.   static filterVariantsByRole_(variants, preferredRole) {
  221.     return variants.filter((variant) => {
  222.       if (!variant.audio) {
  223.         return false;
  224.       }
  226.       if (preferredRole) {
  227.         return variant.audio.roles.includes(preferredRole);
  228.       } else {
  229.         return variant.audio.roles.length == 0;
  230.       }
  231.     });
  232.   }
  234.   /**
  235.    * Filter Variants by audio label.
  236.    *
  237.    * @param {!Array<shaka.extern.Variant>} variants
  238.    * @param {string} preferredLabel
  239.    * @return {!Array<shaka.extern.Variant>}
  240.    * @private
  241.    */
  242.   static filterVariantsByAudioLabel_(variants, preferredLabel) {
  243.     return variants.filter((variant) => {
  244.       if (!variant.audio || !variant.audio.label) {
  245.         return false;
  246.       }
  248.       const label1 = variant.audio.label.toLowerCase();
  249.       const label2 = preferredLabel.toLowerCase();
  250.       return label1 == label2;
  251.     });
  252.   }
  254.   /**
  255.    * Filter Variants by video label.
  256.    *
  257.    * @param {!Array<shaka.extern.Variant>} variants
  258.    * @param {string} preferredLabel
  259.    * @return {!Array<shaka.extern.Variant>}
  260.    * @private
  261.    */
  262.   static filterVariantsByVideoLabel_(variants, preferredLabel) {
  263.     return variants.filter((variant) => {
  264.       if (!variant.video || !variant.video.label) {
  265.         return false;
  266.       }
  268.       const label1 = variant.video.label.toLowerCase();
  269.       const label2 = preferredLabel.toLowerCase();
  270.       return label1 == label2;
  271.     });
  272.   }
  274.   /**
  275.    * Filter Variants by channelCount.
  276.    *
  277.    * @param {!Array<shaka.extern.Variant>} variants
  278.    * @param {number} channelCount
  279.    * @return {!Array<shaka.extern.Variant>}
  280.    * @private
  281.    */
  282.   static filterVariantsByAudioChannelCount_(variants, channelCount) {
  283.     return variants.filter((variant) => {
  284.       // Filter variants with channel count less than or equal to desired value.
  285.       if (variant.audio && variant.audio.channelsCount &&
  286.           variant.audio.channelsCount > channelCount) {
  287.         return false;
  288.       }
  289.       return true;
  290.     }).sort((v1, v2) => {
  291.       // We need to sort variants list by channels count, so the most close one
  292.       // to desired value will be first on the list. It's important for the call
  293.       // to shaka.media.AdaptationSet, which will base set of variants based on
  294.       // first variant.
  295.       if (!v1.audio && !v2.audio) {
  296.         return 0;
  297.       }
  298.       if (!v1.audio) {
  299.         return -1;
  300.       }
  301.       if (!v2.audio) {
  302.         return 1;
  303.       }
  304.       return (v2.audio.channelsCount || 0) - (v1.audio.channelsCount || 0);
  305.     });
  306.   }
  308.   /**
  309.    * Filters variants according to the given hdr level config.
  310.    *
  311.    * @param {!Array<shaka.extern.Variant>} variants
  312.    * @param {string} hdrLevel
  313.    * @private
  314.    */
  315.   static filterVariantsByHDRLevel_(variants, hdrLevel) {
  316.     if (hdrLevel == 'AUTO') {
  317.       const someHLG = variants.some((variant) => {
  318.         if (variant.video && variant.video.hdr &&
  319.             variant.video.hdr == 'HLG') {
  320.           return true;
  321.         }
  322.         return false;
  323.       });
  324.       const device = shaka.device.DeviceFactory.getDevice();
  325.       hdrLevel = device.getHdrLevel(someHLG);
  326.     }
  327.     return variants.filter((variant) => {
  328.       if (variant.video && variant.video.hdr && variant.video.hdr != hdrLevel) {
  329.         return false;
  330.       }
  331.       return true;
  332.     });
  333.   }
  336.   /**
  337.    * Filters variants according to the given video layout config.
  338.    *
  339.    * @param {!Array<shaka.extern.Variant>} variants
  340.    * @param {string} videoLayout
  341.    * @private
  342.    */
  343.   static filterVariantsByVideoLayout_(variants, videoLayout) {
  344.     return variants.filter((variant) => {
  345.       if (variant.video && variant.video.videoLayout &&
  346.           variant.video.videoLayout != videoLayout) {
  347.         return false;
  348.       }
  349.       return true;
  350.     });
  351.   }
  354.   /**
  355.    * Filters variants according to the given spatial audio config.
  356.    *
  357.    * @param {!Array<shaka.extern.Variant>} variants
  358.    * @param {boolean} spatialAudio
  359.    * @private
  360.    */
  361.   static filterVariantsBySpatialAudio_(variants, spatialAudio) {
  362.     return variants.filter((variant) => {
  363.       if (variant.audio && variant.audio.spatialAudio != spatialAudio) {
  364.         return false;
  365.       }
  366.       return true;
  367.     });
  368.   }
  371.   /**
  372.    * Filters variants according to the given audio codec.
  373.    *
  374.    * @param {!Array<shaka.extern.Variant>} variants
  375.    * @param {string} audioCodec
  376.    * @private
  377.    */
  378.   static filterVariantsByAudioCodec_(variants, audioCodec) {
  379.     return variants.filter((variant) => {
  380.       if (variant.audio && variant.audio.codecs != audioCodec) {
  381.         return false;
  382.       }
  383.       return true;
  384.     });
  385.   }
  386. };