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