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.    */
  30.   constructor(root, candidates) {
  31.     /** @private {shaka.extern.Variant} */
  32.     this.root_ = root;
  33.     /** @private {!Set.<shaka.extern.Variant>} */
  34.     this.variants_ = new Set([root]);
  36.     // Try to add all the candidates. If they cannot be added (because they
  37.     // are not compatible with the root, they will be rejected by |add|.
  38.     candidates = candidates || [];
  39.     for (const candidate of candidates) {
  40.       this.add(candidate);
  41.     }
  42.   }
  44.   /**
  45.    * @param {shaka.extern.Variant} variant
  46.    * @return {boolean}
  47.    */
  48.   add(variant) {
  49.     if (this.canInclude(variant)) {
  50.       this.variants_.add(variant);
  51.       return true;
  52.     }
  54.     // To be nice, issue a warning if someone is trying to add something that
  55.     // they shouldn't.
  56.     shaka.log.warning('Rejecting variant - not compatible with root.');
  57.     return false;
  58.   }
  60.   /**
  61.    * Check if |variant| can be included with the set. If |canInclude| returns
  62.    * |false|, calling |add| will result in it being ignored.
  63.    *
  64.    * @param {shaka.extern.Variant} variant
  65.    * @return {boolean}
  66.    */
  67.   canInclude(variant) {
  68.     return shaka.media.AdaptationSet.areAdaptable(this.root_, variant);
  69.   }
  71.   /**
  72.    * @param {shaka.extern.Variant} a
  73.    * @param {shaka.extern.Variant} b
  74.    * @return {boolean}
  75.    */
  76.   static areAdaptable(a, b) {
  77.     const AdaptationSet = shaka.media.AdaptationSet;
  79.     // All variants should have audio or should all not have audio.
  80.     if (!!a.audio != !!b.audio) {
  81.       return false;
  82.     }
  84.     // All variants should have video or should all not have video.
  85.     if (!!a.video != !!b.video) {
  86.       return false;
  87.     }
  89.     // If the languages don't match, we should not adapt between them.
  90.     if (a.language != b.language) {
  91.       return false;
  92.     }
  94.     goog.asserts.assert(
  95.         !!a.audio == !!b.audio,
  96.         'Both should either have audio or not have audio.');
  97.     if (a.audio && b.audio &&
  98.         !AdaptationSet.areAudiosCompatible_(a.audio, b.audio)) {
  99.       return false;
  100.     }
  102.     goog.asserts.assert(
  103.         !!a.video == !!b.video,
  104.         'Both should either have video or not have video.');
  105.     if (a.video && b.video &&
  106.         !AdaptationSet.areVideosCompatible_(a.video, b.video)) {
  107.       return false;
  108.     }
  110.     return true;
  111.   }
  113.   /**
  114.    * @return {!Iterable.<shaka.extern.Variant>}
  115.    */
  116.   values() {
  117.     return this.variants_.values();
  118.   }
  120.   /**
  121.    * Check if we can switch between two audio streams.
  122.    *
  123.    * @param {shaka.extern.Stream} a
  124.    * @param {shaka.extern.Stream} b
  125.    * @return {boolean}
  126.    * @private
  127.    */
  128.   static areAudiosCompatible_(a, b) {
  129.     const AdaptationSet = shaka.media.AdaptationSet;
  131.     // Don't adapt between channel counts, which could annoy the user
  132.     // due to volume changes on downmixing.  An exception is made for
  133.     // stereo and mono, which should be fine to adapt between.
  134.     if (!a.channelsCount || !b.channelsCount ||
  135.         a.channelsCount > 2 || b.channelsCount > 2) {
  136.       if (a.channelsCount != b.channelsCount) {
  137.         return false;
  138.       }
  139.     }
  141.     // We can only adapt between base-codecs.
  142.     if (!AdaptationSet.canTransitionBetween_(a, b)) {
  143.       return false;
  144.     }
  146.     // Audio roles must not change between adaptations.
  147.     if (!AdaptationSet.areRolesEqual_(a.roles, b.roles)) {
  148.       return false;
  149.     }
  151.     return true;
  152.   }
  154.   /**
  155.    * Check if we can switch between two video streams.
  156.    *
  157.    * @param {shaka.extern.Stream} a
  158.    * @param {shaka.extern.Stream} b
  159.    * @return {boolean}
  160.    * @private
  161.    */
  162.   static areVideosCompatible_(a, b) {
  163.     const AdaptationSet = shaka.media.AdaptationSet;
  165.     // We can only adapt between base-codecs.
  166.     if (!AdaptationSet.canTransitionBetween_(a, b)) {
  167.       return false;
  168.     }
  170.     // Video roles must not change between adaptations.
  171.     if (!AdaptationSet.areRolesEqual_(a.roles, b.roles)) {
  172.       return false;
  173.     }
  175.     return true;
  176.   }
  178.   /**
  179.    * Check if we can switch between two streams based on their codec and mime
  180.    * type.
  181.    *
  182.    * @param {shaka.extern.Stream} a
  183.    * @param {shaka.extern.Stream} b
  184.    * @return {boolean}
  185.    * @private
  186.    */
  187.   static canTransitionBetween_(a, b) {
  188.     if (a.mimeType != b.mimeType) {
  189.       return false;
  190.     }
  193.     // Get the base codec of each codec in each stream.
  194.     const codecsA = shaka.util.MimeUtils.splitCodecs(a.codecs).map((codec) => {
  195.       return shaka.util.MimeUtils.getCodecBase(codec);
  196.     });
  197.     const codecsB = shaka.util.MimeUtils.splitCodecs(b.codecs).map((codec) => {
  198.       return shaka.util.MimeUtils.getCodecBase(codec);
  199.     });
  201.     // We don't want to allow switching between transmuxed and non-transmuxed
  202.     // content so the number of codecs should be the same.
  203.     //
  204.     // To avoid the case where an codec is used for audio and video we will
  205.     // codecs using arrays (not sets). While at this time, there are no codecs
  206.     // that work for audio and video, it is possible for "raw" codecs to be
  207.     // which would share the same name.
  208.     if (codecsA.length != codecsB.length) {
  209.       return false;
  210.     }
  212.     // Sort them so that we can walk through them and compare them
  213.     // element-by-element.
  214.     codecsA.sort();
  215.     codecsB.sort();
  217.     for (let i = 0; i < codecsA.length; i++) {
  218.       if (codecsA[i] != codecsB[i]) {
  219.         return false;
  220.       }
  221.     }
  223.     return true;
  224.   }
  226.   /**
  227.    * Check if two role lists are the equal. This will take into account all
  228.    * unique behaviours when comparing roles.
  229.    *
  230.    * @param {!Iterable.<string>} a
  231.    * @param {!Iterable.<string>} b
  232.    * @return {boolean}
  233.    * @private
  234.    */
  235.   static areRolesEqual_(a, b) {
  236.     const aSet = new Set(a);
  237.     const bSet = new Set(b);
  239.     // Remove the main role from the role lists (we expect to see them only
  240.     // in dash manifests).
  241.     const mainRole = 'main';
  242.     aSet.delete(mainRole);
  243.     bSet.delete(mainRole);
  245.     // Make sure that we have the same number roles in each list. Make sure to
  246.     // do it after correcting for 'main'.
  247.     if (aSet.size != bSet.size) {
  248.       return false;
  249.     }
  251.     // Because we know the two sets are the same size, if any item is missing
  252.     // if means that they are not the same.
  253.     for (const x of aSet) {
  254.       if (!bSet.has(x)) {
  255.         return false;
  256.       }
  257.     }
  259.     return true;
  260.   }
  261. };