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.log');
  12. goog.require('shaka.media.AdaptationSet');
  13. goog.require('shaka.util.LanguageUtils');
  14. goog.require('shaka.util.StreamUtils');
  17. /**
  18.  * An adaptation set criteria is a unit of logic that can take a set of
  19.  * variants and return a subset of variants that should (and can) be
  20.  * adapted between.
  21.  *
  22.  * @interface
  23.  */
  24. shaka.media.AdaptationSetCriteria = class {
  25.   /**
  26.    * Take a set of variants, and return a subset of variants that can be
  27.    * adapted between.
  28.    *
  29.    * @param {!Array.<shaka.extern.Variant>} variants
  30.    * @return {!shaka.media.AdaptationSet}
  31.    */
  32.   create(variants) {}
  33. };
  36. /**
  37.  * @implements {shaka.media.AdaptationSetCriteria}
  38.  * @final
  39.  */
  40. shaka.media.ExampleBasedCriteria = class {
  41.   /**
  42.    * @param {shaka.extern.Variant} example
  43.    */
  44.   constructor(example) {
  45.     /** @private {shaka.extern.Variant} */
  46.     this.example_ = example;
  48.     // We can't know if role and label are really important, so we don't use
  49.     // role and label for this.
  50.     const role = '';
  51.     const label = '';
  52.     const channelCount = example.audio && example.audio.channelsCount ?
  53.                          example.audio.channelsCount :
  54.                          0;
  56.     /** @private {!shaka.media.AdaptationSetCriteria} */
  57.     this.fallback_ = new shaka.media.PreferenceBasedCriteria(
  58.         example.language, role, channelCount, label);
  59.   }
  61.   /** @override */
  62.   create(variants) {
  63.     // We can't assume that the example is in |variants| because it could
  64.     // actually be from another period.
  65.     const shortList = variants.filter((variant) => {
  66.       return shaka.media.AdaptationSet.areAdaptable(this.example_, variant);
  67.     });
  69.     if (shortList.length) {
  70.       // Use the first item in the short list as the root. It should not matter
  71.       // which element we use as all items in the short list should already be
  72.       // compatible.
  73.       return new shaka.media.AdaptationSet(shortList[0], shortList);
  74.     } else {
  75.       return this.fallback_.create(variants);
  76.     }
  77.   }
  78. };
  81. /**
  82.  * @implements {shaka.media.AdaptationSetCriteria}
  83.  * @final
  84.  */
  85. shaka.media.PreferenceBasedCriteria = class {
  86.   /**
  87.    * @param {string} language
  88.    * @param {string} role
  89.    * @param {number} channelCount
  90.    * @param {string=} label
  91.    */
  92.   constructor(language, role, channelCount, label = '') {
  93.     /** @private {string} */
  94.     this.language_ = language;
  95.     /** @private {string} */
  96.     this.role_ = role;
  97.     /** @private {number} */
  98.     this.channelCount_ = channelCount;
  99.     /** @private {string} */
  100.     this.label_ = label;
  101.   }
  103.   /** @override */
  104.   create(variants) {
  105.     const Class = shaka.media.PreferenceBasedCriteria;
  106.     const StreamUtils = shaka.util.StreamUtils;
  108.     let current = [];
  110.     const byLanguage = Class.filterByLanguage_(variants, this.language_);
  111.     const byPrimary = variants.filter((variant) => variant.primary);
  113.     if (byLanguage.length) {
  114.       current = byLanguage;
  115.     } else if (byPrimary.length) {
  116.       current = byPrimary;
  117.     } else {
  118.       current = variants;
  119.     }
  121.     // Now refine the choice based on role preference.  Even the empty string
  122.     // works here, and will match variants without any roles.
  123.     const byRole = Class.filterVariantsByRole_(current, this.role_);
  124.     if (byRole.length) {
  125.       current = byRole;
  126.     } else {
  127.       shaka.log.warning('No exact match for variant role could be found.');
  128.     }
  130.     if (this.channelCount_) {
  131.       const byChannel = StreamUtils.filterVariantsByAudioChannelCount(
  132.           current, this.channelCount_);
  133.       if (byChannel.length) {
  134.         current = byChannel;
  135.       } else {
  136.         shaka.log.warning(
  137.             'No exact match for the channel count could be found.');
  138.       }
  139.     }
  141.     if (this.label_) {
  142.       const byLabel = Class.filterVariantsByLabel_(current, this.label_);
  143.       if (byLabel.length) {
  144.         current = byLabel;
  145.       } else {
  146.         shaka.log.warning('No exact match for variant label could be found.');
  147.       }
  148.     }
  150.     // Make sure we only return a valid adaptation set.
  151.     const set = new shaka.media.AdaptationSet(current[0]);
  152.     for (const variant of current) {
  153.       if (set.canInclude(variant)) {
  154.         set.add(variant);
  155.       }
  156.     }
  158.     return set;
  159.   }
  161.   /**
  162.    * @param {!Array.<shaka.extern.Variant>} variants
  163.    * @param {string} preferredLanguage
  164.    * @return {!Array.<shaka.extern.Variant>}
  165.    * @private
  166.    */
  167.   static filterByLanguage_(variants, preferredLanguage) {
  168.     const LanguageUtils = shaka.util.LanguageUtils;
  170.     /** @type {string} */
  171.     const preferredLocale = LanguageUtils.normalize(preferredLanguage);
  173.     /** @type {?string} */
  174.     const closestLocale = LanguageUtils.findClosestLocale(
  175.         preferredLocale,
  176.         variants.map((variant) => LanguageUtils.getLocaleForVariant(variant)));
  178.     // There were no locales close to what we preferred.
  179.     if (!closestLocale) {
  180.       return [];
  181.     }
  183.     // Find the variants that use the closest variant.
  184.     return variants.filter((variant) => {
  185.       return closestLocale == LanguageUtils.getLocaleForVariant(variant);
  186.     });
  187.   }
  189.   /**
  190.    * Filter Variants by role.
  191.    *
  192.    * @param {!Array.<shaka.extern.Variant>} variants
  193.    * @param {string} preferredRole
  194.    * @return {!Array.<shaka.extern.Variant>}
  195.    * @private
  196.    */
  197.   static filterVariantsByRole_(variants, preferredRole) {
  198.     return variants.filter((variant) => {
  199.       if (!variant.audio) {
  200.         return false;
  201.       }
  203.       if (preferredRole) {
  204.         return variant.audio.roles.includes(preferredRole);
  205.       } else {
  206.         return variant.audio.roles.length == 0;
  207.       }
  208.     });
  209.   }
  211.   /**
  212.    * Filter Variants by label.
  213.    *
  214.    * @param {!Array.<shaka.extern.Variant>} variants
  215.    * @param {string} preferredLabel
  216.    * @return {!Array.<shaka.extern.Variant>}
  217.    * @private
  218.    */
  219.   static filterVariantsByLabel_(variants, preferredLabel) {
  220.     return variants.filter((variant) => {
  221.       if (!variant.audio) {
  222.         return false;
  223.       }
  225.       const label1 = variant.audio.label.toLowerCase();
  226.       const label2 = preferredLabel.toLowerCase();
  227.       return label1 == label2;
  228.     });
  229.   }
  230. };