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.config.CodecSwitchingStrategy');
  12. goog.require('shaka.log');
  13. goog.require('shaka.media.AdaptationSet');
  14. goog.require('shaka.media.Capabilities');
  15. goog.require('shaka.util.LanguageUtils');
  18. /**
  19.  * An adaptation set criteria is a unit of logic that can take a set of
  20.  * variants and return a subset of variants that should (and can) be
  21.  * adapted between.
  22.  *
  23.  * @interface
  24.  */
  25. shaka.media.AdaptationSetCriteria = class {
  26.   /**
  27.    * Take a set of variants, and return a subset of variants that can be
  28.    * adapted between.
  29.    *
  30.    * @param {!Array.<shaka.extern.Variant>} variants
  31.    * @return {!shaka.media.AdaptationSet}
  32.    */
  33.   create(variants) {}
  34. };
  37. /**
  38.  * @implements {shaka.media.AdaptationSetCriteria}
  39.  * @final
  40.  */
  41. shaka.media.ExampleBasedCriteria = class {
  42.   /**
  43.    * @param {shaka.extern.Variant} example
  44.    * @param {shaka.config.CodecSwitchingStrategy} codecSwitchingStrategy
  45.    * @param {boolean} enableAudioGroups
  46.    */
  47.   constructor(example, codecSwitchingStrategy, enableAudioGroups) {
  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 audioLabel = '';
  52.     const videoLabel = '';
  53.     const hdrLevel = example.video && example.video.hdr ?
  54.         example.video.hdr : '';
  55.     const spatialAudio = example.audio && example.audio.spatialAudio ?
  56.         example.audio.spatialAudio : false;
  57.     const videoLayout = example.video && example.video.videoLayout ?
  58.         example.video.videoLayout : '';
  59.     const channelCount = example.audio && example.audio.channelsCount ?
  60.         example.audio.channelsCount : 0;
  61.     const audioCodec = example.audio && example.audio.codecs ?
  62.         example.audio.codecs : '';
  64.     /** @private {!shaka.media.AdaptationSetCriteria} */
  65.     this.preferenceBasedCriteria_ = new shaka.media.PreferenceBasedCriteria(
  66.         example.language, role, channelCount, hdrLevel, spatialAudio,
  67.         videoLayout, audioLabel, videoLabel,
  68.         codecSwitchingStrategy, enableAudioGroups, audioCodec);
  69.   }
  71.   /** @override */
  72.   create(variants) {
  73.     return this.preferenceBasedCriteria_.create(variants);
  74.   }
  75. };
  78. /**
  79.  * @implements {shaka.media.AdaptationSetCriteria}
  80.  * @final
  81.  */
  82. shaka.media.PreferenceBasedCriteria = class {
  83.   /**
  84.    * @param {string} language
  85.    * @param {string} role
  86.    * @param {number} channelCount
  87.    * @param {string} hdrLevel
  88.    * @param {boolean} spatialAudio
  89.    * @param {string} videoLayout
  90.    * @param {string} audioLabel
  91.    * @param {string} videoLabel
  92.    * @param {shaka.config.CodecSwitchingStrategy} codecSwitchingStrategy
  93.    * @param {boolean} enableAudioGroups
  94.    * @param {string} audioCodec
  95.    */
  96.   constructor(language, role, channelCount, hdrLevel, spatialAudio,
  97.       videoLayout, audioLabel, videoLabel, codecSwitchingStrategy,
  98.       enableAudioGroups, audioCodec) {
  99.     /** @private {string} */
  100.     this.language_ = language;
  101.     /** @private {string} */
  102.     this.role_ = role;
  103.     /** @private {number} */
  104.     this.channelCount_ = channelCount;
  105.     /** @private {string} */
  106.     this.hdrLevel_ = hdrLevel;
  107.     /** @private {boolean} */
  108.     this.spatialAudio_ = spatialAudio;
  109.     /** @private {string} */
  110.     this.videoLayout_ = videoLayout;
  111.     /** @private {string} */
  112.     this.audioLabel_ = audioLabel;
  113.     /** @private {string} */
  114.     this.videoLabel_ = videoLabel;
  115.     /** @private {shaka.config.CodecSwitchingStrategy} */
  116.     this.codecSwitchingStrategy_ = codecSwitchingStrategy;
  117.     /** @private {boolean} */
  118.     this.enableAudioGroups_ = enableAudioGroups;
  119.     /** @private {string} */
  120.     this.audioCodec_ = audioCodec;
  121.   }
  123.   /** @override */
  124.   create(variants) {
  125.     const Class = shaka.media.PreferenceBasedCriteria;
  127.     let current = [];
  129.     const byLanguage = Class.filterByLanguage_(variants, this.language_);
  130.     const byPrimary = variants.filter((variant) => variant.primary);
  132.     if (byLanguage.length) {
  133.       current = byLanguage;
  134.     } else if (byPrimary.length) {
  135.       current = byPrimary;
  136.     } else {
  137.       current = variants;
  138.     }
  140.     // Now refine the choice based on role preference.  Even the empty string
  141.     // works here, and will match variants without any roles.
  142.     const byRole = Class.filterVariantsByRole_(current, this.role_);
  143.     if (byRole.length) {
  144.       current = byRole;
  145.     } else {
  146.       shaka.log.warning('No exact match for variant role could be found.');
  147.     }
  149.     if (this.videoLayout_) {
  150.       const byVideoLayout = Class.filterVariantsByVideoLayout_(
  151.           current, this.videoLayout_);
  152.       if (byVideoLayout.length) {
  153.         current = byVideoLayout;
  154.       } else {
  155.         shaka.log.warning(
  156.             'No exact match for the video layout could be found.');
  157.       }
  158.     }
  160.     if (this.hdrLevel_) {
  161.       const byHdrLevel = Class.filterVariantsByHDRLevel_(
  162.           current, this.hdrLevel_);
  163.       if (byHdrLevel.length) {
  164.         current = byHdrLevel;
  165.       } else {
  166.         shaka.log.warning(
  167.             'No exact match for the hdr level could be found.');
  168.       }
  169.     }
  171.     if (this.channelCount_) {
  172.       const byChannel = Class.filterVariantsByAudioChannelCount_(
  173.           current, this.channelCount_);
  174.       if (byChannel.length) {
  175.         current = byChannel;
  176.       } else {
  177.         shaka.log.warning(
  178.             'No exact match for the channel count could be found.');
  179.       }
  180.     }
  182.     if (this.audioLabel_) {
  183.       const byLabel = Class.filterVariantsByAudioLabel_(
  184.           current, this.audioLabel_);
  185.       if (byLabel.length) {
  186.         current = byLabel;
  187.       } else {
  188.         shaka.log.warning('No exact match for audio label could be found.');
  189.       }
  190.     }
  192.     if (this.videoLabel_) {
  193.       const byLabel = Class.filterVariantsByVideoLabel_(
  194.           current, this.videoLabel_);
  195.       if (byLabel.length) {
  196.         current = byLabel;
  197.       } else {
  198.         shaka.log.warning('No exact match for video label could be found.');
  199.       }
  200.     }
  202.     const bySpatialAudio = Class.filterVariantsBySpatialAudio_(
  203.         current, this.spatialAudio_);
  204.     if (bySpatialAudio.length) {
  205.       current = bySpatialAudio;
  206.     } else {
  207.       shaka.log.warning('No exact match for spatial audio could be found.');
  208.     }
  210.     if (this.audioCodec_) {
  211.       const byAudioCodec = Class.filterVariantsByAudioCodec_(
  212.           current, this.audioCodec_);
  213.       if (byAudioCodec.length) {
  214.         current = byAudioCodec;
  215.       } else {
  216.         shaka.log.warning('No exact match for audio codec could be found.');
  217.       }
  218.     }
  220.     const supportsSmoothCodecTransitions = this.codecSwitchingStrategy_ ==
  221.       shaka.config.CodecSwitchingStrategy.SMOOTH &&
  222.         shaka.media.Capabilities.isChangeTypeSupported();
  224.     return new shaka.media.AdaptationSet(current[0], current,
  225.         !supportsSmoothCodecTransitions, this.enableAudioGroups_);
  226.   }
  228.   /**
  229.    * @param {!Array.<shaka.extern.Variant>} variants
  230.    * @param {string} preferredLanguage
  231.    * @return {!Array.<shaka.extern.Variant>}
  232.    * @private
  233.    */
  234.   static filterByLanguage_(variants, preferredLanguage) {
  235.     const LanguageUtils = shaka.util.LanguageUtils;
  237.     /** @type {string} */
  238.     const preferredLocale = LanguageUtils.normalize(preferredLanguage);
  240.     /** @type {?string} */
  241.     const closestLocale = LanguageUtils.findClosestLocale(
  242.         preferredLocale,
  243.         variants.map((variant) => LanguageUtils.getLocaleForVariant(variant)));
  245.     // There were no locales close to what we preferred.
  246.     if (!closestLocale) {
  247.       return [];
  248.     }
  250.     // Find the variants that use the closest variant.
  251.     return variants.filter((variant) => {
  252.       return closestLocale == LanguageUtils.getLocaleForVariant(variant);
  253.     });
  254.   }
  256.   /**
  257.    * Filter Variants by role.
  258.    *
  259.    * @param {!Array.<shaka.extern.Variant>} variants
  260.    * @param {string} preferredRole
  261.    * @return {!Array.<shaka.extern.Variant>}
  262.    * @private
  263.    */
  264.   static filterVariantsByRole_(variants, preferredRole) {
  265.     return variants.filter((variant) => {
  266.       if (!variant.audio) {
  267.         return false;
  268.       }
  270.       if (preferredRole) {
  271.         return variant.audio.roles.includes(preferredRole);
  272.       } else {
  273.         return variant.audio.roles.length == 0;
  274.       }
  275.     });
  276.   }
  278.   /**
  279.    * Filter Variants by audio label.
  280.    *
  281.    * @param {!Array.<shaka.extern.Variant>} variants
  282.    * @param {string} preferredLabel
  283.    * @return {!Array.<shaka.extern.Variant>}
  284.    * @private
  285.    */
  286.   static filterVariantsByAudioLabel_(variants, preferredLabel) {
  287.     return variants.filter((variant) => {
  288.       if (!variant.audio || !variant.audio.label) {
  289.         return false;
  290.       }
  292.       const label1 = variant.audio.label.toLowerCase();
  293.       const label2 = preferredLabel.toLowerCase();
  294.       return label1 == label2;
  295.     });
  296.   }
  298.   /**
  299.    * Filter Variants by video label.
  300.    *
  301.    * @param {!Array.<shaka.extern.Variant>} variants
  302.    * @param {string} preferredLabel
  303.    * @return {!Array.<shaka.extern.Variant>}
  304.    * @private
  305.    */
  306.   static filterVariantsByVideoLabel_(variants, preferredLabel) {
  307.     return variants.filter((variant) => {
  308.       if (!variant.video || !variant.video.label) {
  309.         return false;
  310.       }
  312.       const label1 = variant.video.label.toLowerCase();
  313.       const label2 = preferredLabel.toLowerCase();
  314.       return label1 == label2;
  315.     });
  316.   }
  318.   /**
  319.    * Filter Variants by channelCount.
  320.    *
  321.    * @param {!Array.<shaka.extern.Variant>} variants
  322.    * @param {number} channelCount
  323.    * @return {!Array.<shaka.extern.Variant>}
  324.    * @private
  325.    */
  326.   static filterVariantsByAudioChannelCount_(variants, channelCount) {
  327.     return variants.filter((variant) => {
  328.       if (variant.audio && variant.audio.channelsCount &&
  329.           variant.audio.channelsCount != channelCount) {
  330.         return false;
  331.       }
  332.       return true;
  333.     });
  334.   }
  336.   /**
  337.    * Filters variants according to the given hdr level config.
  338.    *
  339.    * @param {!Array.<shaka.extern.Variant>} variants
  340.    * @param {string} hdrLevel
  341.    * @private
  342.    */
  343.   static filterVariantsByHDRLevel_(variants, hdrLevel) {
  344.     if (hdrLevel == 'AUTO') {
  345.       // Auto detect the ideal HDR level.
  346.       if (window.matchMedia('(color-gamut: p3)').matches) {
  347.         const someHLG = variants.some((variant) => {
  348.           if (variant.video && variant.video.hdr &&
  349.               variant.video.hdr == 'HLG') {
  350.             return true;
  351.           }
  352.           return false;
  353.         });
  354.         hdrLevel = someHLG ? 'HLG' : 'PQ';
  355.       } else {
  356.         hdrLevel = 'SDR';
  357.       }
  358.     }
  359.     return variants.filter((variant) => {
  360.       if (variant.video && variant.video.hdr && variant.video.hdr != hdrLevel) {
  361.         return false;
  362.       }
  363.       return true;
  364.     });
  365.   }
  368.   /**
  369.    * Filters variants according to the given video layout config.
  370.    *
  371.    * @param {!Array.<shaka.extern.Variant>} variants
  372.    * @param {string} videoLayout
  373.    * @private
  374.    */
  375.   static filterVariantsByVideoLayout_(variants, videoLayout) {
  376.     return variants.filter((variant) => {
  377.       if (variant.video && variant.video.videoLayout &&
  378.           variant.video.videoLayout != videoLayout) {
  379.         return false;
  380.       }
  381.       return true;
  382.     });
  383.   }
  386.   /**
  387.    * Filters variants according to the given spatial audio config.
  388.    *
  389.    * @param {!Array.<shaka.extern.Variant>} variants
  390.    * @param {boolean} spatialAudio
  391.    * @private
  392.    */
  393.   static filterVariantsBySpatialAudio_(variants, spatialAudio) {
  394.     return variants.filter((variant) => {
  395.       if (variant.audio && variant.audio.spatialAudio != spatialAudio) {
  396.         return false;
  397.       }
  398.       return true;
  399.     });
  400.   }
  403.   /**
  404.    * Filters variants according to the given audio codec.
  405.    *
  406.    * @param {!Array<shaka.extern.Variant>} variants
  407.    * @param {string} audioCodec
  408.    * @private
  409.    */
  410.   static filterVariantsByAudioCodec_(variants, audioCodec) {
  411.     return variants.filter((variant) => {
  412.       if (variant.audio && variant.audio.codecs != audioCodec) {
  413.         return false;
  414.       }
  415.       return true;
  416.     });
  417.   }
  418. };