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.     // Don't adapt between spatial and non spatial audio, which may
  154.     // annoy the user.
  155.     if (a.spatialAudio !== b.spatialAudio) {
  156.       return false;
  157.     }
  159.     // We can only adapt between base-codecs.
  160.     if (compareCodecs && !AdaptationSet.canTransitionBetween_(a, b)) {
  161.       return false;
  162.     }
  164.     // Audio roles must not change between adaptations.
  165.     if (!AdaptationSet.areRolesEqual_(a.roles, b.roles)) {
  166.       return false;
  167.     }
  169.     // We can only adapt between the same groupId.
  170.     if (enableAudioGroups && a.groupId !== b.groupId) {
  171.       return false;
  172.     }
  174.     return true;
  175.   }
  177.   /**
  178.    * Check if we can switch between two video streams.
  179.    *
  180.    * @param {shaka.extern.Stream} a
  181.    * @param {shaka.extern.Stream} b
  182.    * @param {boolean} compareCodecs
  183.    * @return {boolean}
  184.    * @private
  185.    */
  186.   static areVideosCompatible_(a, b, compareCodecs) {
  187.     const AdaptationSet = shaka.media.AdaptationSet;
  189.     // We can only adapt between base-codecs.
  190.     if (compareCodecs && !AdaptationSet.canTransitionBetween_(a, b)) {
  191.       return false;
  192.     }
  194.     // Video roles must not change between adaptations.
  195.     if (!AdaptationSet.areRolesEqual_(a.roles, b.roles)) {
  196.       return false;
  197.     }
  199.     return true;
  200.   }
  202.   /**
  203.    * Check if we can switch between two streams based on their codec and mime
  204.    * type.
  205.    *
  206.    * @param {shaka.extern.Stream} a
  207.    * @param {shaka.extern.Stream} b
  208.    * @return {boolean}
  209.    * @private
  210.    */
  211.   static canTransitionBetween_(a, b) {
  212.     if (a.mimeType != b.mimeType) {
  213.       return false;
  214.     }
  217.     // Get the base codec of each codec in each stream.
  218.     const codecsA = shaka.util.MimeUtils.splitCodecs(a.codecs).map((codec) => {
  219.       return shaka.util.MimeUtils.getCodecBase(codec);
  220.     });
  221.     const codecsB = shaka.util.MimeUtils.splitCodecs(b.codecs).map((codec) => {
  222.       return shaka.util.MimeUtils.getCodecBase(codec);
  223.     });
  225.     // We don't want to allow switching between transmuxed and non-transmuxed
  226.     // content so the number of codecs should be the same.
  227.     //
  228.     // To avoid the case where an codec is used for audio and video we will
  229.     // codecs using arrays (not sets). While at this time, there are no codecs
  230.     // that work for audio and video, it is possible for "raw" codecs to be
  231.     // which would share the same name.
  232.     if (codecsA.length != codecsB.length) {
  233.       return false;
  234.     }
  236.     // Sort them so that we can walk through them and compare them
  237.     // element-by-element.
  238.     codecsA.sort();
  239.     codecsB.sort();
  241.     for (let i = 0; i < codecsA.length; i++) {
  242.       if (codecsA[i] != codecsB[i]) {
  243.         return false;
  244.       }
  245.     }
  247.     return true;
  248.   }
  250.   /**
  251.    * Check if two role lists are the equal. This will take into account all
  252.    * unique behaviours when comparing roles.
  253.    *
  254.    * @param {!Iterable.<string>} a
  255.    * @param {!Iterable.<string>} b
  256.    * @return {boolean}
  257.    * @private
  258.    */
  259.   static areRolesEqual_(a, b) {
  260.     const aSet = new Set(a);
  261.     const bSet = new Set(b);
  263.     // Remove the main role from the role lists (we expect to see them only
  264.     // in dash manifests).
  265.     const mainRole = 'main';
  266.     aSet.delete(mainRole);
  267.     bSet.delete(mainRole);
  269.     // Make sure that we have the same number roles in each list. Make sure to
  270.     // do it after correcting for 'main'.
  271.     if (aSet.size != bSet.size) {
  272.       return false;
  273.     }
  275.     // Because we know the two sets are the same size, if any item is missing
  276.     // if means that they are not the same.
  277.     for (const x of aSet) {
  278.       if (!bSet.has(x)) {
  279.         return false;
  280.       }
  281.     }
  283.     return true;
  284.   }
  285. };