Source: lib/media/adaptation_set.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.media.AdaptationSet');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.log');
  11. goog.require('shaka.util.MimeUtils');
  14. /**
  15.  * A set of variants that we want to adapt between.
  16.  *
  17.  * @final
  18.  */
  19. shaka.media.AdaptationSet = class {
  20.   /**
  21.    * @param {shaka.extern.Variant} root
  22.    *    The variant that all other variants will be tested against when being
  23.    *    added to the adaptation set. If a variant is not compatible with the
  24.    *    root, it will not be added.
  25.    * @param {!Iterable.<shaka.extern.Variant>=} candidates
  26.    *    Variants that may be compatible with the root and should be added if
  27.    *    compatible. If a candidate is not compatible, it will not end up in the
  28.    *    adaptation set.
  29.    * @param {boolean=} compareCodecs
  30.    * @param {boolean=} enableAudioGroups
  31.    */
  32.   constructor(root, candidates, compareCodecs = true,
  33.       enableAudioGroups = false) {
  34.     /** @private {shaka.extern.Variant} */
  35.     this.root_ = root;
  36.     /** @private {!Set.<shaka.extern.Variant>} */
  37.     this.variants_ = new Set([root]);
  39.     // Try to add all the candidates. If they cannot be added (because they
  40.     // are not compatible with the root, they will be rejected by |add|.
  41.     candidates = candidates || [];
  42.     for (const candidate of candidates) {
  43.       this.add(candidate, compareCodecs, enableAudioGroups);
  44.     }
  45.   }
  47.   /**
  48.    * @param {shaka.extern.Variant} variant
  49.    * @param {boolean} compareCodecs
  50.    * @param {boolean} enableAudioGroups
  51.    * @return {boolean}
  52.    */
  53.   add(variant, compareCodecs, enableAudioGroups) {
  54.     if (this.canInclude(variant, compareCodecs, enableAudioGroups)) {
  55.       this.variants_.add(variant);
  56.       return true;
  57.     }
  59.     // To be nice, issue a warning if someone is trying to add something that
  60.     // they shouldn't.
  61.     shaka.log.warning('Rejecting variant - not compatible with root.');
  62.     return false;
  63.   }
  65.   /**
  66.    * Check if |variant| can be included with the set. If |canInclude| returns
  67.    * |false|, calling |add| will result in it being ignored.
  68.    *
  69.    * @param {shaka.extern.Variant} variant
  70.    * @param {boolean=} compareCodecs
  71.    * @param {boolean=} enableAudioGroups
  72.    * @return {boolean}
  73.    */
  74.   canInclude(variant, compareCodecs = true, enableAudioGroups = false) {
  75.     return shaka.media.AdaptationSet
  76.         .areAdaptable(this.root_, variant, compareCodecs, enableAudioGroups);
  77.   }
  79.   /**
  80.    * @param {shaka.extern.Variant} a
  81.    * @param {shaka.extern.Variant} b
  82.    * @param {boolean} compareCodecs
  83.    * @param {boolean} enableAudioGroups
  84.    * @return {boolean}
  85.    */
  86.   static areAdaptable(a, b, compareCodecs, enableAudioGroups) {
  87.     const AdaptationSet = shaka.media.AdaptationSet;
  89.     // All variants should have audio or should all not have audio.
  90.     if (!!a.audio != !!b.audio) {
  91.       return false;
  92.     }
  94.     // All variants should have video or should all not have video.
  95.     if (!!a.video != !!b.video) {
  96.       return false;
  97.     }
  99.     // If the languages don't match, we should not adapt between them.
  100.     if (a.language != b.language) {
  101.       return false;
  102.     }
  104.     goog.asserts.assert(
  105.         !!a.audio == !!b.audio,
  106.         'Both should either have audio or not have audio.');
  107.     if (a.audio && b.audio && !AdaptationSet.areAudiosCompatible_(
  108.         a.audio, b.audio, compareCodecs, enableAudioGroups)) {
  109.       return false;
  110.     }
  112.     goog.asserts.assert(
  113.         !!a.video == !!b.video,
  114.         'Both should either have video or not have video.');
  115.     if (a.video && b.video &&
  116.         !AdaptationSet.areVideosCompatible_(a.video, b.video, compareCodecs)) {
  117.       return false;
  118.     }
  120.     return true;
  121.   }
  123.   /**
  124.    * @return {!Iterable.<shaka.extern.Variant>}
  125.    */
  126.   values() {
  127.     return this.variants_.values();
  128.   }
  130.   /**
  131.    * Check if we can switch between two audio streams.
  132.    *
  133.    * @param {shaka.extern.Stream} a
  134.    * @param {shaka.extern.Stream} b
  135.    * @param {boolean} compareCodecs
  136.    * @param {boolean} enableAudioGroups
  137.    * @return {boolean}
  138.    * @private
  139.    */
  140.   static areAudiosCompatible_(a, b, compareCodecs, enableAudioGroups) {
  141.     const AdaptationSet = shaka.media.AdaptationSet;
  143.     // Don't adapt between channel counts, which could annoy the user
  144.     // due to volume changes on downmixing.  An exception is made for
  145.     // stereo and mono, which should be fine to adapt between.
  146.     if (!a.channelsCount || !b.channelsCount ||
  147.         a.channelsCount > 2 || b.channelsCount > 2) {
  148.       if (a.channelsCount != b.channelsCount) {
  149.         return false;
  150.       }
  151.     }
  153.     // We can only adapt between base-codecs.
  154.     if (compareCodecs && !AdaptationSet.canTransitionBetween_(a, b)) {
  155.       return false;
  156.     }
  158.     // Audio roles must not change between adaptations.
  159.     if (!AdaptationSet.areRolesEqual_(a.roles, b.roles)) {
  160.       return false;
  161.     }
  163.     // We can only adapt between the same groupId.
  164.     if (enableAudioGroups && a.groupId !== b.groupId) {
  165.       return false;
  166.     }
  168.     return true;
  169.   }
  171.   /**
  172.    * Check if we can switch between two video streams.
  173.    *
  174.    * @param {shaka.extern.Stream} a
  175.    * @param {shaka.extern.Stream} b
  176.    * @param {boolean} compareCodecs
  177.    * @return {boolean}
  178.    * @private
  179.    */
  180.   static areVideosCompatible_(a, b, compareCodecs) {
  181.     const AdaptationSet = shaka.media.AdaptationSet;
  183.     // We can only adapt between base-codecs.
  184.     if (compareCodecs && !AdaptationSet.canTransitionBetween_(a, b)) {
  185.       return false;
  186.     }
  188.     // Video roles must not change between adaptations.
  189.     if (!AdaptationSet.areRolesEqual_(a.roles, b.roles)) {
  190.       return false;
  191.     }
  193.     return true;
  194.   }
  196.   /**
  197.    * Check if we can switch between two streams based on their codec and mime
  198.    * type.
  199.    *
  200.    * @param {shaka.extern.Stream} a
  201.    * @param {shaka.extern.Stream} b
  202.    * @return {boolean}
  203.    * @private
  204.    */
  205.   static canTransitionBetween_(a, b) {
  206.     if (a.mimeType != b.mimeType) {
  207.       return false;
  208.     }
  211.     // Get the base codec of each codec in each stream.
  212.     const codecsA = shaka.util.MimeUtils.splitCodecs(a.codecs).map((codec) => {
  213.       return shaka.util.MimeUtils.getCodecBase(codec);
  214.     });
  215.     const codecsB = shaka.util.MimeUtils.splitCodecs(b.codecs).map((codec) => {
  216.       return shaka.util.MimeUtils.getCodecBase(codec);
  217.     });
  219.     // We don't want to allow switching between transmuxed and non-transmuxed
  220.     // content so the number of codecs should be the same.
  221.     //
  222.     // To avoid the case where an codec is used for audio and video we will
  223.     // codecs using arrays (not sets). While at this time, there are no codecs
  224.     // that work for audio and video, it is possible for "raw" codecs to be
  225.     // which would share the same name.
  226.     if (codecsA.length != codecsB.length) {
  227.       return false;
  228.     }
  230.     // Sort them so that we can walk through them and compare them
  231.     // element-by-element.
  232.     codecsA.sort();
  233.     codecsB.sort();
  235.     for (let i = 0; i < codecsA.length; i++) {
  236.       if (codecsA[i] != codecsB[i]) {
  237.         return false;
  238.       }
  239.     }
  241.     return true;
  242.   }
  244.   /**
  245.    * Check if two role lists are the equal. This will take into account all
  246.    * unique behaviours when comparing roles.
  247.    *
  248.    * @param {!Iterable.<string>} a
  249.    * @param {!Iterable.<string>} b
  250.    * @return {boolean}
  251.    * @private
  252.    */
  253.   static areRolesEqual_(a, b) {
  254.     const aSet = new Set(a);
  255.     const bSet = new Set(b);
  257.     // Remove the main role from the role lists (we expect to see them only
  258.     // in dash manifests).
  259.     const mainRole = 'main';
  260.     aSet.delete(mainRole);
  261.     bSet.delete(mainRole);
  263.     // Make sure that we have the same number roles in each list. Make sure to
  264.     // do it after correcting for 'main'.
  265.     if (aSet.size != bSet.size) {
  266.       return false;
  267.     }
  269.     // Because we know the two sets are the same size, if any item is missing
  270.     // if means that they are not the same.
  271.     for (const x of aSet) {
  272.       if (!bSet.has(x)) {
  273.         return false;
  274.       }
  275.     }
  277.     return true;
  278.   }
  279. };