Source: lib/media/adaptation_set_criteria.js

  1. /**
  2.  * @license
  3.  * Copyright 2016 Google Inc.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  18. goog.provide('shaka.media.AdaptationSetCriteria');
  19. goog.provide('shaka.media.ExampleBasedCriteria');
  20. goog.provide('shaka.media.PreferenceBasedCriteria');
  22. goog.require('shaka.media.AdaptationSet');
  25. /**
  26.  * An adaptation set criteria is a unit of logic that can take a set of
  27.  * variants and return a subset of variants that should (and can) be
  28.  * adapted between.
  29.  *
  30.  * @interface
  31.  */
  32. shaka.media.AdaptationSetCriteria = class {
  33.   /**
  34.    * Take a set of variants, and return a subset of variants that can be
  35.    * adapted between.
  36.    *
  37.    * @param {!Array.<shaka.extern.Variant>} variants
  38.    * @return {!shaka.media.AdaptationSet}
  39.    */
  40.   create(variants) {}
  41. };
  44. /**
  45.  * @implements {shaka.media.AdaptationSetCriteria}
  46.  * @final
  47.  */
  48. shaka.media.ExampleBasedCriteria = class {
  49.   /**
  50.    * @param {shaka.extern.Variant} example
  51.    */
  52.   constructor(example) {
  53.     /** @private {shaka.extern.Variant} */
  54.     this.example_ = example;
  56.     // We can't know if role and label are really important, so we don't use
  57.     // role and label for this.
  58.     const role = '';
  59.     const label = '';
  60.     const channelCount = example.audio && example.audio.channelsCount ?
  61.                          example.audio.channelsCount :
  62.                          0;
  64.     /** @private {!shaka.media.AdaptationSetCriteria} */
  65.     this.fallback_ = new shaka.media.PreferenceBasedCriteria(
  66.         example.language, role, channelCount, label);
  67.   }
  69.   /** @override */
  70.   create(variants) {
  71.     // We can't assume that the example is in |variants| because it could
  72.     // actually be from another period.
  73.     const shortList = variants.filter((variant) => {
  74.       return shaka.media.AdaptationSet.areAdaptable(this.example_, variant);
  75.     });
  77.     if (shortList.length) {
  78.       // Use the first item in the short list as the root. It should not matter
  79.       // which element we use as all items in the short list should already be
  80.       // compatible.
  81.       return new shaka.media.AdaptationSet(shortList[0], shortList);
  82.     } else {
  83.       return this.fallback_.create(variants);
  84.     }
  85.   }
  86. };
  89. /**
  90.  * @implements {shaka.media.AdaptationSetCriteria}
  91.  * @final
  92.  */
  93. shaka.media.PreferenceBasedCriteria = class {
  94.   /**
  95.    * @param {string} language
  96.    * @param {string} role
  97.    * @param {number} channelCount
  98.    * @param {string=} label
  99.    */
  100.   constructor(language, role, channelCount, label = '') {
  101.     /** @private {string} */
  102.     this.language_ = language;
  103.     /** @private {string} */
  104.     this.role_ = role;
  105.     /** @private {number} */
  106.     this.channelCount_ = channelCount;
  107.     /** @private {string} */
  108.     this.label_ = label;
  109.   }
  111.   /** @override */
  112.   create(variants) {
  113.     const Class = shaka.media.PreferenceBasedCriteria;
  114.     const StreamUtils = shaka.util.StreamUtils;
  116.     let current = [];
  118.     const byLanguage = Class.filterByLanguage_(variants, this.language_);
  119.     const byPrimary = variants.filter((variant) => variant.primary);
  121.     if (byLanguage.length) {
  122.       current = byLanguage;
  123.     } else if (byPrimary.length) {
  124.       current = byPrimary;
  125.     } else {
  126.       current = variants;
  127.     }
  129.     // Now refine the choice based on role preference.  Even the empty string
  130.     // works here, and will match variants without any roles.
  131.     const byRole = Class.filterVariantsByRole_(current, this.role_);
  132.     if (byRole.length) {
  133.       current = byRole;
  134.     } else {
  135.       shaka.log.warning('No exact match for variant role could be found.');
  136.     }
  138.     if (this.channelCount_) {
  139.       const byChannel = StreamUtils.filterVariantsByAudioChannelCount(
  140.           current, this.channelCount_);
  141.       if (byChannel.length) {
  142.         current = byChannel;
  143.       } else {
  144.         shaka.log.warning(
  145.             'No exact match for the channel count could be found.');
  146.       }
  147.     }
  149.     if (this.label_) {
  150.       const byLabel = Class.filterVariantsByLabel_(current, this.label_);
  151.       if (byLabel.length) {
  152.         current = byLabel;
  153.       } else {
  154.         shaka.log.warning('No exact match for variant label could be found.');
  155.       }
  156.     }
  158.     // Make sure we only return a valid adaptation set.
  159.     const set = new shaka.media.AdaptationSet(current[0]);
  160.     for (const variant of current) {
  161.       if (set.canInclude(variant)) {
  162.         set.add(variant);
  163.       }
  164.     }
  166.     return set;
  167.   }
  169.   /**
  170.    * @param {!Array.<shaka.extern.Variant>} variants
  171.    * @param {string} preferredLanguage
  172.    * @return {!Array.<shaka.extern.Variant>}
  173.    * @private
  174.    */
  175.   static filterByLanguage_(variants, preferredLanguage) {
  176.     const LanguageUtils = shaka.util.LanguageUtils;
  178.     /** @type {string} */
  179.     const preferredLocale = LanguageUtils.normalize(preferredLanguage);
  181.     /** @type {?string} */
  182.     const closestLocale = LanguageUtils.findClosestLocale(
  183.         preferredLocale,
  184.         variants.map((variant) => LanguageUtils.getLocaleForVariant(variant)));
  186.     // There were no locales close to what we preferred.
  187.     if (!closestLocale) {
  188.       return [];
  189.     }
  191.     // Find the variants that use the closest variant.
  192.     return variants.filter((variant) => {
  193.       return closestLocale == LanguageUtils.getLocaleForVariant(variant);
  194.     });
  195.   }
  197.   /**
  198.    * Filter Variants by role.
  199.    *
  200.    * @param {!Array.<shaka.extern.Variant>} variants
  201.    * @param {string} preferredRole
  202.    * @return {!Array.<shaka.extern.Variant>}
  203.    * @private
  204.    */
  205.   static filterVariantsByRole_(variants, preferredRole) {
  206.     return variants.filter((variant) => {
  207.       if (!variant.audio) {
  208.         return false;
  209.       }
  211.       if (preferredRole) {
  212.         return variant.audio.roles.includes(preferredRole);
  213.       } else {
  214.         return variant.audio.roles.length == 0;
  215.       }
  216.     });
  217.   }
  219.   /**
  220.    * Filter Variants by label.
  221.    *
  222.    * @param {!Array.<shaka.extern.Variant>} variants
  223.    * @param {string} preferredLabel
  224.    * @return {!Array.<shaka.extern.Variant>}
  225.    * @private
  226.    */
  227.   static filterVariantsByLabel_(variants, preferredLabel) {
  228.     return variants.filter((variant) => {
  229.       if (!variant.audio) {
  230.         return false;
  231.       }
  233.       const label1 = variant.audio.label.toLowerCase();
  234.       const label2 = preferredLabel.toLowerCase();
  235.       return label1 == label2;
  236.     });
  237.   }
  238. };