Source: lib/util/periods.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.util.PeriodCombiner');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.drm.DrmUtils');
  11. goog.require('shaka.log');
  12. goog.require('shaka.media.MetaSegmentIndex');
  13. goog.require('shaka.media.SegmentIndex');
  14. goog.require('shaka.util.Error');
  15. goog.require('shaka.util.IReleasable');
  16. goog.require('shaka.util.LanguageUtils');
  17. goog.require('shaka.util.ManifestParserUtils');
  18. goog.require('shaka.util.MimeUtils');
  20. /**
  21.  * A utility to combine streams across periods.
  22.  *
  23.  * @implements {shaka.util.IReleasable}
  24.  * @final
  25.  * @export
  26.  */
  27. shaka.util.PeriodCombiner = class {
  28.   /** */
  29.   constructor() {
  30.     /** @private {!Array<shaka.extern.Variant>} */
  31.     this.variants_ = [];
  33.     /** @private {!Array<shaka.extern.Stream>} */
  34.     this.audioStreams_ = [];
  36.     /** @private {!Array<shaka.extern.Stream>} */
  37.     this.videoStreams_ = [];
  39.     /** @private {!Array<shaka.extern.Stream>} */
  40.     this.textStreams_ = [];
  42.     /** @private {!Array<shaka.extern.Stream>} */
  43.     this.imageStreams_ = [];
  45.     /** @private {boolean} */
  46.     this.multiTypeVariantsAllowed_ = false;
  48.     /** @private {boolean} */
  49.     this.useStreamOnce_ = false;
  51.     /**
  52.      * The IDs of the periods we have already used to generate streams.
  53.      * This helps us identify the periods which have been added when a live
  54.      * stream is updated.
  55.      *
  56.      * @private {!Set<string>}
  57.      */
  58.     this.usedPeriodIds_ = new Set();
  59.   }
  61.   /** @override */
  62.   release() {
  63.     const allStreams =
  64.         this.audioStreams_.concat(this.videoStreams_, this.textStreams_,
  65.             this.imageStreams_);
  67.     for (const stream of allStreams) {
  68.       if (stream.segmentIndex) {
  69.         stream.segmentIndex.release();
  70.       }
  71.     }
  73.     this.audioStreams_ = [];
  74.     this.videoStreams_ = [];
  75.     this.textStreams_ = [];
  76.     this.imageStreams_ = [];
  77.     this.variants_ = [];
  78.     this.multiTypeVariantsAllowed_ = false;
  79.     this.useStreamOnce_ = false;
  80.     this.usedPeriodIds_.clear();
  81.   }
  83.   /**
  84.    * @return {!Array<shaka.extern.Variant>}
  85.    *
  86.    * @export
  87.    */
  88.   getVariants() {
  89.     return this.variants_;
  90.   }
  92.   /**
  93.    * @return {!Array<shaka.extern.Stream>}
  94.    *
  95.    * @export
  96.    */
  97.   getTextStreams() {
  98.     // Return a copy of the array because makeTextStreamsForClosedCaptions
  99.     // may make changes to the contents of the array. Those changes should not
  100.     // propagate back to the PeriodCombiner.
  101.     return this.textStreams_.slice();
  102.   }
  104.   /**
  105.    * @return {!Array<shaka.extern.Stream>}
  106.    *
  107.    * @export
  108.    */
  109.   getImageStreams() {
  110.     return this.imageStreams_;
  111.   }
  113.   /**
  114.    * Deletes a stream from matchedStreams because it is no longer needed
  115.    *
  116.    * @param {?shaka.extern.Stream} stream
  117.    * @param {string} periodId
  118.    *
  119.    * @export
  120.    */
  121.   deleteStream(stream, periodId) {
  122.     if (!stream) {
  123.       return;
  124.     }
  125.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  126.     if (stream.type == ContentType.AUDIO) {
  127.       for (const audioStream of this.audioStreams_) {
  128.         audioStream.matchedStreams = audioStream.matchedStreams.filter((s) => {
  129.           return s !== stream;
  130.         });
  131.       }
  132.     } else if (stream.type == ContentType.VIDEO) {
  133.       for (const videoStream of this.videoStreams_) {
  134.         videoStream.matchedStreams = videoStream.matchedStreams.filter((s) => {
  135.           return s !== stream;
  136.         });
  137.         if (videoStream.trickModeVideo) {
  138.           videoStream.trickModeVideo.matchedStreams =
  139.             videoStream.trickModeVideo.matchedStreams.filter((s) => {
  140.               return s !== stream;
  141.             });
  142.         }
  143.         if (videoStream.dependencyStream) {
  144.           videoStream.dependencyStream.matchedStreams =
  145.             videoStream.dependencyStream.matchedStreams.filter((s) => {
  146.               return s !== stream;
  147.             });
  148.         }
  149.       }
  150.     } else if (stream.type == ContentType.TEXT) {
  151.       for (const textStream of this.textStreams_) {
  152.         textStream.matchedStreams = textStream.matchedStreams.filter((s) => {
  153.           return s !== stream;
  154.         });
  155.       }
  156.     } else if (stream.type == ContentType.IMAGE) {
  157.       for (const imageStream of this.imageStreams_) {
  158.         imageStream.matchedStreams = imageStream.matchedStreams.filter((s) => {
  159.           return s !== stream;
  160.         });
  161.       }
  162.     }
  163.     if (stream.segmentIndex) {
  164.       stream.closeSegmentIndex();
  165.     }
  166.     this.usedPeriodIds_.delete(periodId);
  167.   }
  169.   /**
  170.    * Returns an object that contains arrays of streams by type
  171.    * @param {!Array<shaka.extern.Period>} periods
  172.    * @param {boolean} addDummy
  173.    * @return {{
  174.    *  audioStreamsPerPeriod: !Array<!Map<string, shaka.extern.Stream>>,
  175.    *  videoStreamsPerPeriod: !Array<!Map<string, shaka.extern.Stream>>,
  176.    *  textStreamsPerPeriod: !Array<!Map<string, shaka.extern.Stream>>,
  177.    *  imageStreamsPerPeriod: !Array<!Map<string, shaka.extern.Stream>>
  178.    * }}
  179.    * @private
  180.    */
  181.   getStreamsPerPeriod_(periods, addDummy) {
  182.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  183.     const PeriodCombiner = shaka.util.PeriodCombiner;
  185.     const audioStreamsPerPeriod = [];
  186.     const videoStreamsPerPeriod = [];
  187.     const textStreamsPerPeriod = [];
  188.     const imageStreamsPerPeriod = [];
  190.     for (const period of periods) {
  191.       const audioMap = new Map(period.audioStreams.map((s) =>
  192.         [PeriodCombiner.generateAudioKey_(s), s]));
  193.       const videoMap = new Map(period.videoStreams.map((s) =>
  194.         [PeriodCombiner.generateVideoKey_(s), s]));
  195.       const textMap = new Map(period.textStreams.map((s) =>
  196.         [PeriodCombiner.generateTextKey_(s), s]));
  197.       const imageMap = new Map(period.imageStreams.map((s) =>
  198.         [PeriodCombiner.generateImageKey_(s), s]));
  200.       // It's okay to have a period with no text or images, but our algorithm
  201.       // fails on any period without matching streams.  So we add dummy streams
  202.       // to each period.  Since we combine text streams by language and image
  203.       // streams by resolution, we might need a dummy even in periods with these
  204.       // streams already.
  205.       if (addDummy) {
  206.         const dummyText = PeriodCombiner.dummyStream_(ContentType.TEXT);
  207.         textMap.set(PeriodCombiner.generateTextKey_(dummyText), dummyText);
  208.         const dummyImage = PeriodCombiner.dummyStream_(ContentType.IMAGE);
  209.         imageMap.set(PeriodCombiner.generateImageKey_(dummyImage), dummyImage);
  210.       }
  212.       audioStreamsPerPeriod.push(audioMap);
  213.       videoStreamsPerPeriod.push(videoMap);
  214.       textStreamsPerPeriod.push(textMap);
  215.       imageStreamsPerPeriod.push(imageMap);
  216.     }
  217.     return {
  218.       audioStreamsPerPeriod,
  219.       videoStreamsPerPeriod,
  220.       textStreamsPerPeriod,
  221.       imageStreamsPerPeriod,
  222.     };
  223.   }
  225.   /**
  226.    * @param {!Array<shaka.extern.Period>} periods
  227.    * @param {boolean} isDynamic
  228.    * @param {boolean=} isPatchUpdate
  229.    * @return {!Promise}
  230.    *
  231.    * @export
  232.    */
  233.   async combinePeriods(periods, isDynamic, isPatchUpdate = false) {
  234.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  236.     // Optimization: for single-period VOD, do nothing.  This makes sure
  237.     // single-period DASH content will be 100% accurately represented in the
  238.     // output.
  239.     if (!isDynamic && periods.length == 1) {
  240.       // We need to filter out duplicates, so call getStreamsPerPeriod()
  241.       // so it will do that by usage of Map.
  242.       const {
  243.         audioStreamsPerPeriod,
  244.         videoStreamsPerPeriod,
  245.         textStreamsPerPeriod,
  246.         imageStreamsPerPeriod,
  247.       } = this.getStreamsPerPeriod_(periods, /* addDummy= */ false);
  248.       this.audioStreams_ = Array.from(audioStreamsPerPeriod[0].values());
  249.       this.videoStreams_ = Array.from(videoStreamsPerPeriod[0].values());
  250.       this.textStreams_ = Array.from(textStreamsPerPeriod[0].values());
  251.       this.imageStreams_ = Array.from(imageStreamsPerPeriod[0].values());
  252.     } else {
  253.       // How many periods we've seen before which are not included in this call.
  254.       const periodsMissing = isPatchUpdate ? this.usedPeriodIds_.size : 0;
  255.       // Find the first period we haven't seen before.  Tag all the periods we
  256.       // see now as "used".
  257.       let firstNewPeriodIndex = -1;
  258.       for (let i = 0; i < periods.length; i++) {
  259.         const period = periods[i];
  260.         if (this.usedPeriodIds_.has(period.id)) {
  261.           // This isn't new.
  262.         } else {
  263.           // This one _is_ new.
  264.           this.usedPeriodIds_.add(period.id);
  266.           if (firstNewPeriodIndex == -1) {
  267.             // And it's the _first_ new one.
  268.             firstNewPeriodIndex = i;
  269.           }
  270.         }
  271.       }
  273.       if (firstNewPeriodIndex == -1) {
  274.         // Nothing new? Nothing to do.
  275.         return;
  276.       }
  278.       const {
  279.         audioStreamsPerPeriod,
  280.         videoStreamsPerPeriod,
  281.         textStreamsPerPeriod,
  282.         imageStreamsPerPeriod,
  283.       } = this.getStreamsPerPeriod_(periods, /* addDummy= */ true);
  285.       await Promise.all([
  286.         this.combine_(
  287.             this.audioStreams_,
  288.             audioStreamsPerPeriod,
  289.             firstNewPeriodIndex,
  290.             shaka.util.PeriodCombiner.cloneStream_,
  291.             shaka.util.PeriodCombiner.concatenateStreams_,
  292.             periodsMissing),
  293.         this.combine_(
  294.             this.videoStreams_,
  295.             videoStreamsPerPeriod,
  296.             firstNewPeriodIndex,
  297.             shaka.util.PeriodCombiner.cloneStream_,
  298.             shaka.util.PeriodCombiner.concatenateStreams_,
  299.             periodsMissing),
  300.         this.combine_(
  301.             this.textStreams_,
  302.             textStreamsPerPeriod,
  303.             firstNewPeriodIndex,
  304.             shaka.util.PeriodCombiner.cloneStream_,
  305.             shaka.util.PeriodCombiner.concatenateStreams_,
  306.             periodsMissing),
  307.         this.combine_(
  308.             this.imageStreams_,
  309.             imageStreamsPerPeriod,
  310.             firstNewPeriodIndex,
  311.             shaka.util.PeriodCombiner.cloneStream_,
  312.             shaka.util.PeriodCombiner.concatenateStreams_,
  313.             periodsMissing),
  314.       ]);
  315.     }
  317.     // Create variants for all audio/video combinations.
  318.     let nextVariantId = 0;
  319.     const variants = [];
  320.     if (!this.videoStreams_.length || !this.audioStreams_.length) {
  321.       // For audio-only or video-only content, just give each stream its own
  322.       // variant.
  323.       const streams = this.videoStreams_.length ? this.videoStreams_ :
  324.         this.audioStreams_;
  325.       for (const stream of streams) {
  326.         const id = nextVariantId++;
  327.         let bandwidth = stream.bandwidth || 0;
  328.         if (stream.dependencyStream) {
  329.           bandwidth += stream.dependencyStream.bandwidth || 0;
  330.         }
  331.         variants.push({
  332.           id,
  333.           language: stream.language,
  334.           disabledUntilTime: 0,
  335.           primary: stream.primary,
  336.           audio: stream.type == ContentType.AUDIO ? stream : null,
  337.           video: stream.type == ContentType.VIDEO ? stream : null,
  338.           bandwidth,
  339.           drmInfos: stream.drmInfos,
  340.           allowedByApplication: true,
  341.           allowedByKeySystem: true,
  342.           decodingInfos: [],
  343.         });
  344.       }
  345.     } else {
  346.       for (const audio of this.audioStreams_) {
  347.         for (const video of this.videoStreams_) {
  348.           const commonDrmInfos = shaka.drm.DrmUtils.getCommonDrmInfos(
  349.               audio.drmInfos, video.drmInfos);
  351.           if (audio.drmInfos.length && video.drmInfos.length &&
  352.               !commonDrmInfos.length) {
  353.             shaka.log.warning(
  354.                 'Incompatible DRM in audio & video, skipping variant creation.',
  355.                 audio, video);
  356.             continue;
  357.           }
  359.           let bandwidth = (audio.bandwidth || 0) + (video.bandwidth || 0);
  360.           if (audio.dependencyStream) {
  361.             bandwidth += audio.dependencyStream.bandwidth || 0;
  362.           }
  363.           if (video.dependencyStream) {
  364.             bandwidth += video.dependencyStream.bandwidth || 0;
  365.           }
  367.           const id = nextVariantId++;
  368.           variants.push({
  369.             id,
  370.             language: audio.language,
  371.             disabledUntilTime: 0,
  372.             primary: audio.primary,
  373.             audio,
  374.             video,
  375.             bandwidth,
  376.             drmInfos: commonDrmInfos,
  377.             allowedByApplication: true,
  378.             allowedByKeySystem: true,
  379.             decodingInfos: [],
  380.           });
  381.         }
  382.       }
  383.     }
  385.     this.variants_ = variants;
  386.   }
  389.   /**
  390.    * Stitch together DB streams across periods, taking a mix of stream types.
  391.    * The offline database does not separate these by type.
  392.    *
  393.    * Unlike the DASH case, this does not need to maintain any state for manifest
  394.    * updates.
  395.    *
  396.    * @param {!Array<!Array<shaka.extern.StreamDB>>} streamDbsPerPeriod
  397.    * @return {!Promise<!Array<shaka.extern.StreamDB>>}
  398.    */
  399.   static async combineDbStreams(streamDbsPerPeriod) {
  400.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  401.     const PeriodCombiner = shaka.util.PeriodCombiner;
  403.     // Optimization: for single-period content, do nothing.  This makes sure
  404.     // single-period DASH or any HLS content stored offline will be 100%
  405.     // accurately represented in the output.
  406.     if (streamDbsPerPeriod.length == 1) {
  407.       return streamDbsPerPeriod[0];
  408.     }
  410.     const audioStreamDbsPerPeriod = streamDbsPerPeriod.map(
  411.         (streams) => new Map(streams
  412.             .filter((s) => s.type === ContentType.AUDIO)
  413.             .map((s) => [PeriodCombiner.generateAudioKey_(s), s])));
  414.     const videoStreamDbsPerPeriod = streamDbsPerPeriod.map(
  415.         (streams) => new Map(streams
  416.             .filter((s) => s.type === ContentType.VIDEO)
  417.             .map((s) => [PeriodCombiner.generateVideoKey_(s), s])));
  418.     const textStreamDbsPerPeriod = streamDbsPerPeriod.map(
  419.         (streams) => new Map(streams
  420.             .filter((s) => s.type === ContentType.TEXT)
  421.             .map((s) => [PeriodCombiner.generateTextKey_(s), s])));
  422.     const imageStreamDbsPerPeriod = streamDbsPerPeriod.map(
  423.         (streams) => new Map(streams
  424.             .filter((s) => s.type === ContentType.IMAGE)
  425.             .map((s) => [PeriodCombiner.generateImageKey_(s), s])));
  427.     // It's okay to have a period with no text or images, but our algorithm
  428.     // fails on any period without matching streams.  So we add dummy streams to
  429.     // each period.  Since we combine text streams by language and image streams
  430.     // by resolution, we might need a dummy even in periods with these streams
  431.     // already.
  432.     for (const textStreams of textStreamDbsPerPeriod) {
  433.       const dummy = PeriodCombiner.dummyStreamDB_(ContentType.TEXT);
  434.       textStreams.set(PeriodCombiner.generateTextKey_(dummy), dummy);
  435.     }
  436.     for (const imageStreams of imageStreamDbsPerPeriod) {
  437.       const dummy = PeriodCombiner.dummyStreamDB_(ContentType.IMAGE);
  438.       imageStreams.set(PeriodCombiner.generateImageKey_(dummy), dummy);
  439.     }
  441.     const periodCombiner = new shaka.util.PeriodCombiner();
  443.     const combinedAudioStreamDbs = await periodCombiner.combine_(
  444.         /* outputStreams= */ [],
  445.         audioStreamDbsPerPeriod,
  446.         /* firstNewPeriodIndex= */ 0,
  447.         shaka.util.PeriodCombiner.cloneStreamDB_,
  448.         shaka.util.PeriodCombiner.concatenateStreamDBs_,
  449.         /* periodsMissing= */ 0);
  451.     const combinedVideoStreamDbs = await periodCombiner.combine_(
  452.         /* outputStreams= */ [],
  453.         videoStreamDbsPerPeriod,
  454.         /* firstNewPeriodIndex= */ 0,
  455.         shaka.util.PeriodCombiner.cloneStreamDB_,
  456.         shaka.util.PeriodCombiner.concatenateStreamDBs_,
  457.         /* periodsMissing= */ 0);
  459.     const combinedTextStreamDbs = await periodCombiner.combine_(
  460.         /* outputStreams= */ [],
  461.         textStreamDbsPerPeriod,
  462.         /* firstNewPeriodIndex= */ 0,
  463.         shaka.util.PeriodCombiner.cloneStreamDB_,
  464.         shaka.util.PeriodCombiner.concatenateStreamDBs_,
  465.         /* periodsMissing= */ 0);
  467.     const combinedImageStreamDbs = await periodCombiner.combine_(
  468.         /* outputStreams= */ [],
  469.         imageStreamDbsPerPeriod,
  470.         /* firstNewPeriodIndex= */ 0,
  471.         shaka.util.PeriodCombiner.cloneStreamDB_,
  472.         shaka.util.PeriodCombiner.concatenateStreamDBs_,
  473.         /* periodsMissing= */ 0);
  475.     // Recreate variantIds from scratch in the output.
  476.     // HLS content is always single-period, so the early return at the top of
  477.     // this method would catch all HLS content.  DASH content stored with v3.0
  478.     // will already be flattened before storage.  Therefore the only content
  479.     // that reaches this point is multi-period DASH content stored before v3.0.
  480.     // Such content always had variants generated from all combinations of audio
  481.     // and video, so we can simply do that now without loss of correctness.
  482.     let nextVariantId = 0;
  483.     if (!combinedVideoStreamDbs.length || !combinedAudioStreamDbs.length) {
  484.       // For audio-only or video-only content, just give each stream its own
  485.       // variant ID.
  486.       const combinedStreamDbs =
  487.           combinedVideoStreamDbs.concat(combinedAudioStreamDbs);
  488.       for (const stream of combinedStreamDbs) {
  489.         stream.variantIds = [nextVariantId++];
  490.       }
  491.     } else {
  492.       for (const audio of combinedAudioStreamDbs) {
  493.         for (const video of combinedVideoStreamDbs) {
  494.           const id = nextVariantId++;
  495.           video.variantIds.push(id);
  496.           audio.variantIds.push(id);
  497.         }
  498.       }
  499.     }
  501.     return combinedVideoStreamDbs
  502.         .concat(combinedAudioStreamDbs)
  503.         .concat(combinedTextStreamDbs)
  504.         .concat(combinedImageStreamDbs);
  505.   }
  507.   /**
  508.    * Combine input Streams per period into flat output Streams.
  509.    * Templatized to handle both DASH Streams and offline StreamDBs.
  510.    *
  511.    * @param {!Array<T>} outputStreams A list of existing output streams, to
  512.    *   facilitate updates for live DASH content.  Will be modified and returned.
  513.    * @param {!Array<!Map<string, T>>} streamsPerPeriod A list of maps of Streams
  514.    *   from each period.
  515.    * @param {number} firstNewPeriodIndex An index into streamsPerPeriod which
  516.    *   represents the first new period that hasn't been processed yet.
  517.    * @param {function(T):T} clone Make a clone of an input stream.
  518.    * @param {function(T, T)} concat Concatenate the second stream onto the end
  519.    *   of the first.
  520.    * @param {number} periodsMissing The number of periods missing
  521.    *
  522.    * @return {!Promise<!Array<T>>} The same array passed to outputStreams,
  523.    *   modified to include any newly-created streams.
  524.    *
  525.    * @template T
  526.    * Accepts either a StreamDB or Stream type.
  527.    *
  528.    * @private
  529.    */
  530.   async combine_(
  531.       outputStreams, streamsPerPeriod, firstNewPeriodIndex, clone, concat,
  532.       periodsMissing) {
  533.     const unusedStreamsPerPeriod = [];
  535.     for (let i = 0; i < streamsPerPeriod.length; i++) {
  536.       if (i >= firstNewPeriodIndex) {
  537.         // This periods streams are all new.
  538.         unusedStreamsPerPeriod.push(new Set(streamsPerPeriod[i].values()));
  539.       } else {
  540.         // This period's streams have all been used already.
  541.         unusedStreamsPerPeriod.push(new Set());
  542.       }
  543.     }
  545.     // First, extend all existing output Streams into the new periods.
  546.     for (const outputStream of outputStreams) {
  547.       // eslint-disable-next-line no-await-in-loop
  548.       const ok = await this.extendExistingOutputStream_(
  549.           outputStream, streamsPerPeriod, firstNewPeriodIndex, concat,
  550.           unusedStreamsPerPeriod, periodsMissing);
  551.       if (!ok) {
  552.         // This output Stream was not properly extended to include streams from
  553.         // the new period.  This is likely a bug in our algorithm, so throw an
  554.         // error.
  555.         throw new shaka.util.Error(
  556.             shaka.util.Error.Severity.CRITICAL,
  557.             shaka.util.Error.Category.MANIFEST,
  558.             shaka.util.Error.Code.PERIOD_FLATTENING_FAILED);
  559.       }
  561.       // This output stream is now complete with content from all known
  562.       // periods.
  563.     }  // for (const outputStream of outputStreams)
  565.     for (const unusedStreams of unusedStreamsPerPeriod) {
  566.       for (const stream of unusedStreams) {
  567.         // Create a new output stream which includes this input stream.
  568.         const outputStream = this.createNewOutputStream_(
  569.             stream, streamsPerPeriod, clone, concat,
  570.             unusedStreamsPerPeriod);
  571.         if (outputStream) {
  572.           outputStreams.push(outputStream);
  573.         } else {
  574.           // This is not a stream we can build output from, but it may become
  575.           // part of another output based on another period's stream.
  576.         }
  577.       }  // for (const stream of unusedStreams)
  578.     }  // for (const unusedStreams of unusedStreamsPerPeriod)
  580.     for (const unusedStreams of unusedStreamsPerPeriod) {
  581.       for (const stream of unusedStreams) {
  582.         if (shaka.util.PeriodCombiner.isDummy_(stream)) {
  583.           // This is one of our dummy streams, so ignore it.  We may not use
  584.           // them all, and that's fine.
  585.           continue;
  586.         }
  587.         // If this stream has a different codec/MIME than any other stream,
  588.         // then we can't play it.
  589.         const hasCodec = outputStreams.some((s) => {
  590.           return this.areAVStreamsCompatible_(stream, s);
  591.         });
  592.         if (!hasCodec) {
  593.           continue;
  594.         }
  596.         // Any other unused stream is likely a bug in our algorithm, so throw
  597.         // an error.
  598.         shaka.log.error('Unused stream in period-flattening!',
  599.             stream, outputStreams);
  600.         throw new shaka.util.Error(
  601.             shaka.util.Error.Severity.CRITICAL,
  602.             shaka.util.Error.Category.MANIFEST,
  603.             shaka.util.Error.Code.PERIOD_FLATTENING_FAILED);
  604.       }
  605.     }
  607.     return outputStreams;
  608.   }
  610.   /**
  611.    * @param {T} outputStream An existing output stream which needs to be
  612.    *   extended into new periods.
  613.    * @param {!Array<!Map<string, T>>} streamsPerPeriod A list of maps of Streams
  614.    *   from each period.
  615.    * @param {number} firstNewPeriodIndex An index into streamsPerPeriod which
  616.    *   represents the first new period that hasn't been processed yet.
  617.    * @param {function(T, T)} concat Concatenate the second stream onto the end
  618.    *   of the first.
  619.    * @param {!Array<!Set<T>>} unusedStreamsPerPeriod An array of sets of
  620.    *   unused streams from each period.
  621.    * @param {number} periodsMissing How many periods are missing in this update.
  622.    *
  623.    * @return {!Promise<boolean>}
  624.    *
  625.    * @template T
  626.    * Should only be called with a Stream type in practice, but has call sites
  627.    * from other templated functions that also accept a StreamDB.
  628.    *
  629.    * @private
  630.    */
  631.   async extendExistingOutputStream_(
  632.       outputStream, streamsPerPeriod, firstNewPeriodIndex, concat,
  633.       unusedStreamsPerPeriod, periodsMissing) {
  634.     this.findMatchesInAllPeriods_(streamsPerPeriod,
  635.         outputStream, periodsMissing > 0);
  637.     // This only exists where T == Stream, and this should only ever be called
  638.     // on Stream types.  StreamDB should not have pre-existing output streams.
  639.     goog.asserts.assert(outputStream.createSegmentIndex,
  640.         'outputStream should be a Stream type!');
  642.     if (!outputStream.matchedStreams) {
  643.       // We were unable to extend this output stream.
  644.       shaka.log.error('No matches extending output stream!',
  645.           outputStream, streamsPerPeriod);
  646.       return false;
  647.     }
  648.     // We need to create all the per-period segment indexes and append them to
  649.     // the output's MetaSegmentIndex.
  650.     if (outputStream.segmentIndex) {
  651.       await shaka.util.PeriodCombiner.extendOutputSegmentIndex_(outputStream,
  652.           firstNewPeriodIndex + periodsMissing);
  653.     }
  655.     shaka.util.PeriodCombiner.extendOutputStream_(outputStream,
  656.         firstNewPeriodIndex, concat, unusedStreamsPerPeriod, periodsMissing);
  657.     return true;
  658.   }
  660.   /**
  661.    * Creates the segment indexes for an array of input streams, and append them
  662.    * to the output stream's segment index.
  663.    *
  664.    * @param {shaka.extern.Stream} outputStream
  665.    * @param {number} firstNewPeriodIndex An index into streamsPerPeriod which
  666.    *   represents the first new period that hasn't been processed yet.
  667.    * @private
  668.    */
  669.   static async extendOutputSegmentIndex_(outputStream, firstNewPeriodIndex) {
  670.     const operations = [];
  671.     const streams = outputStream.matchedStreams;
  672.     goog.asserts.assert(streams, 'matched streams should be valid');
  674.     for (let i = firstNewPeriodIndex; i < streams.length; i++) {
  675.       const stream = streams[i];
  676.       operations.push(stream.createSegmentIndex());
  677.       if (stream.trickModeVideo && !stream.trickModeVideo.segmentIndex) {
  678.         operations.push(stream.trickModeVideo.createSegmentIndex());
  679.       }
  680.       if (stream.dependencyStream && !stream.dependencyStream.segmentIndex) {
  681.         operations.push(stream.dependencyStream.createSegmentIndex());
  682.       }
  683.     }
  684.     await Promise.all(operations);
  686.     // Concatenate the new matches onto the stream, starting at the first new
  687.     // period.
  688.     // Satisfy the compiler about the type.
  689.     // Also checks if the segmentIndex is still valid after the async
  690.     // operations, to make sure we stop if the active stream has changed.
  691.     if (outputStream.segmentIndex instanceof shaka.media.MetaSegmentIndex) {
  692.       for (let i = firstNewPeriodIndex; i < streams.length; i++) {
  693.         const match = streams[i];
  694.         goog.asserts.assert(match.segmentIndex,
  695.             'stream should have a segmentIndex.');
  696.         if (match.segmentIndex) {
  697.           outputStream.segmentIndex.appendSegmentIndex(match.segmentIndex);
  698.         }
  699.       }
  700.     }
  701.   }
  703.   /**
  704.    * Create a new output Stream based on a particular input Stream.  Locates
  705.    * matching Streams in all other periods and combines them into an output
  706.    * Stream.
  707.    * Templatized to handle both DASH Streams and offline StreamDBs.
  708.    *
  709.    * @param {T} stream An input stream on which to base the output stream.
  710.    * @param {!Array<!Map<string, T>>} streamsPerPeriod A list of maps of Streams
  711.    *   from each period.
  712.    * @param {function(T):T} clone Make a clone of an input stream.
  713.    * @param {function(T, T)} concat Concatenate the second stream onto the end
  714.    *   of the first.
  715.    * @param {!Array<!Set<T>>} unusedStreamsPerPeriod An array of sets of
  716.    *   unused streams from each period.
  717.    *
  718.    * @return {?T} A newly-created output Stream, or null if matches
  719.    *   could not be found.`
  720.    *
  721.    * @template T
  722.    * Accepts either a StreamDB or Stream type.
  723.    *
  724.    * @private
  725.    */
  726.   createNewOutputStream_(
  727.       stream, streamsPerPeriod, clone, concat, unusedStreamsPerPeriod) {
  728.     // Check do we want to create output stream from dummy stream
  729.     // and if so, return quickly.
  730.     if (shaka.util.PeriodCombiner.isDummy_(stream)) {
  731.       return null;
  732.     }
  733.     // Start by cloning the stream without segments, key IDs, etc.
  734.     const outputStream = clone(stream);
  736.     // Find best-matching streams in all periods.
  737.     this.findMatchesInAllPeriods_(streamsPerPeriod, outputStream);
  739.     // This only exists where T == Stream.
  740.     if (outputStream.createSegmentIndex) {
  741.       // Override the createSegmentIndex function of the outputStream.
  742.       outputStream.createSegmentIndex = async () => {
  743.         if (!outputStream.segmentIndex) {
  744.           outputStream.segmentIndex = new shaka.media.MetaSegmentIndex();
  745.           await shaka.util.PeriodCombiner.extendOutputSegmentIndex_(
  746.               outputStream, /* firstNewPeriodIndex= */ 0);
  747.         }
  748.       };
  749.       // For T == Stream, we need to create all the per-period segment indexes
  750.       // in advance.  concat() will add them to the output's MetaSegmentIndex.
  751.     }
  753.     if (!outputStream.matchedStreams || !outputStream.matchedStreams.length) {
  754.       // This is not a stream we can build output from, but it may become part
  755.       // of another output based on another period's stream.
  756.       return null;
  757.     }
  758.     shaka.util.PeriodCombiner.extendOutputStream_(outputStream,
  759.         /* firstNewPeriodIndex= */ 0, concat, unusedStreamsPerPeriod,
  760.         /* periodsMissing= */ 0);
  762.     return outputStream;
  763.   }
  765.   /**
  766.    * @param {T} outputStream An existing output stream which needs to be
  767.    *   extended into new periods.
  768.    * @param {number} firstNewPeriodIndex An index into streamsPerPeriod which
  769.    *   represents the first new period that hasn't been processed yet.
  770.    * @param {function(T, T)} concat Concatenate the second stream onto the end
  771.    *   of the first.
  772.    * @param {!Array<!Set<T>>} unusedStreamsPerPeriod An array of sets of
  773.    *   unused streams from each period.
  774.    * @param {number} periodsMissing How many periods are missing in this update
  775.    *
  776.    * @template T
  777.    * Accepts either a StreamDB or Stream type.
  778.    *
  779.    * @private
  780.    */
  781.   static extendOutputStream_(
  782.       outputStream, firstNewPeriodIndex, concat, unusedStreamsPerPeriod,
  783.       periodsMissing) {
  784.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  785.     const LanguageUtils = shaka.util.LanguageUtils;
  786.     const matches = outputStream.matchedStreams;
  788.     // Assure the compiler that matches didn't become null during the async
  789.     // operation before.
  790.     goog.asserts.assert(outputStream.matchedStreams,
  791.         'matchedStreams should be non-null');
  793.     // Concatenate the new matches onto the stream, starting at the first new
  794.     // period.
  795.     const start = firstNewPeriodIndex + periodsMissing;
  796.     for (let i = start; i < matches.length; i++) {
  797.       const match = matches[i];
  798.       concat(outputStream, match);
  800.       // We only consider an audio stream "used" if its language is related to
  801.       // the output language.  There are scenarios where we want to generate
  802.       // separate tracks for each language, even when we are forced to connect
  803.       // unrelated languages across periods.
  804.       let used = true;
  805.       if (outputStream.type == ContentType.AUDIO) {
  806.         const relatedness = LanguageUtils.relatedness(
  807.             outputStream.language, match.language);
  808.         if (relatedness == 0) {
  809.           used = false;
  810.         }
  811.       }
  813.       if (used) {
  814.         unusedStreamsPerPeriod[i - periodsMissing].delete(match);
  815.         // Add the full mimetypes to the stream.
  816.         if (match.fullMimeTypes) {
  817.           for (const fullMimeType of match.fullMimeTypes.values()) {
  818.             outputStream.fullMimeTypes.add(fullMimeType);
  819.           }
  820.         }
  821.       }
  822.     }
  823.   }
  825.   /**
  826.    * Clone a Stream to make an output Stream for combining others across
  827.    * periods.
  828.    *
  829.    * @param {shaka.extern.Stream} stream
  830.    * @return {shaka.extern.Stream}
  831.    * @private
  832.    */
  833.   static cloneStream_(stream) {
  834.     const clone = /** @type {shaka.extern.Stream} */(Object.assign({}, stream));
  836.     // These are wiped out now and rebuilt later from the various per-period
  837.     // streams that match this output.
  838.     clone.originalId = null;
  839.     clone.createSegmentIndex = () => Promise.resolve();
  840.     clone.closeSegmentIndex = () => {
  841.       if (clone.segmentIndex) {
  842.         clone.segmentIndex.release();
  843.         clone.segmentIndex = null;
  844.       }
  845.       // Close the segment index of the matched streams.
  846.       if (clone.matchedStreams) {
  847.         for (const match of clone.matchedStreams) {
  848.           if (match.segmentIndex) {
  849.             match.segmentIndex.release();
  850.             match.segmentIndex = null;
  851.           }
  852.         }
  853.       }
  854.     };
  856.     // Clone roles array so this output stream can own it.
  857.     clone.roles = clone.roles.slice();
  858.     clone.segmentIndex = null;
  859.     clone.emsgSchemeIdUris = [];
  860.     clone.keyIds = new Set(stream.keyIds);
  861.     clone.closedCaptions = stream.closedCaptions ?
  862.       new Map(stream.closedCaptions) : null;
  863.     clone.trickModeVideo = null;
  864.     clone.dependencyStream = null;
  866.     return clone;
  867.   }
  869.   /**
  870.    * Clone a StreamDB to make an output stream for combining others across
  871.    * periods.
  872.    *
  873.    * @param {shaka.extern.StreamDB} streamDb
  874.    * @return {shaka.extern.StreamDB}
  875.    * @private
  876.    */
  877.   static cloneStreamDB_(streamDb) {
  878.     const clone = /** @type {shaka.extern.StreamDB} */(Object.assign(
  879.         {}, streamDb));
  881.     // Clone roles array so this output stream can own it.
  882.     clone.roles = clone.roles.slice();
  883.     // These are wiped out now and rebuilt later from the various per-period
  884.     // streams that match this output.
  885.     clone.keyIds = new Set(streamDb.keyIds);
  886.     clone.segments = [];
  887.     clone.variantIds = [];
  888.     clone.closedCaptions = streamDb.closedCaptions ?
  889.       new Map(streamDb.closedCaptions) : null;
  891.     return clone;
  892.   }
  894.   /**
  895.    * Combine the various fields of the input Stream into the output.
  896.    *
  897.    * @param {shaka.extern.Stream} output
  898.    * @param {shaka.extern.Stream} input
  899.    * @private
  900.    */
  901.   static concatenateStreams_(output, input) {
  902.     // We keep the original stream's resolution, frame rate,
  903.     // sample rate, and channel count to ensure that it's properly
  904.     // matched with similar content in other periods further down
  905.     // the line.
  907.     // Combine arrays, keeping only the unique elements
  908.     const combineArrays = (output, input) => {
  909.       if (!output) {
  910.         output = [];
  911.       }
  912.       for (const item of input) {
  913.         if (!output.includes(item)) {
  914.           output.push(item);
  915.         }
  916.       }
  917.       return output;
  918.     };
  919.     output.roles = combineArrays(output.roles, input.roles);
  921.     if (input.emsgSchemeIdUris) {
  922.       output.emsgSchemeIdUris = combineArrays(
  923.           output.emsgSchemeIdUris, input.emsgSchemeIdUris);
  924.     }
  926.     for (const keyId of input.keyIds) {
  927.       output.keyIds.add(keyId);
  928.     }
  930.     if (output.originalId == null) {
  931.       output.originalId = input.originalId;
  932.     } else {
  933.       const newOriginalId = (input.originalId || '');
  934.       if (newOriginalId && !output.originalId.endsWith(newOriginalId)) {
  935.         output.originalId += ',' + newOriginalId;
  936.       }
  937.     }
  939.     const commonDrmInfos = shaka.drm.DrmUtils.getCommonDrmInfos(
  940.         output.drmInfos, input.drmInfos);
  941.     if (input.drmInfos.length && output.drmInfos.length &&
  942.         !commonDrmInfos.length) {
  943.       throw new shaka.util.Error(
  944.           shaka.util.Error.Severity.CRITICAL,
  945.           shaka.util.Error.Category.MANIFEST,
  946.           shaka.util.Error.Code.INCONSISTENT_DRM_ACROSS_PERIODS);
  947.     }
  948.     output.drmInfos = commonDrmInfos;
  950.     // The output is encrypted if any input was encrypted.
  951.     output.encrypted = output.encrypted || input.encrypted;
  953.     // Combine the closed captions maps.
  954.     if (input.closedCaptions) {
  955.       if (!output.closedCaptions) {
  956.         output.closedCaptions = new Map();
  957.       }
  958.       for (const [key, value] of input.closedCaptions) {
  959.         output.closedCaptions.set(key, value);
  960.       }
  961.     }
  963.     // Prioritize the highest bandwidth
  964.     if (output.bandwidth && input.bandwidth) {
  965.       output.bandwidth = Math.max(output.bandwidth, input.bandwidth);
  966.     }
  968.     // Combine trick-play video streams, if present.
  969.     if (input.trickModeVideo) {
  970.       if (!output.trickModeVideo) {
  971.         // Create a fresh output stream for trick-mode playback.
  972.         output.trickModeVideo = shaka.util.PeriodCombiner.cloneStream_(
  973.             input.trickModeVideo);
  974.         output.trickModeVideo.matchedStreams = [];
  975.         output.trickModeVideo.createSegmentIndex = () => {
  976.           if (output.trickModeVideo.segmentIndex) {
  977.             return Promise.resolve();
  978.           }
  979.           const segmentIndex = new shaka.media.MetaSegmentIndex();
  980.           goog.asserts.assert(output.trickModeVideo.matchedStreams,
  981.               'trickmode matched streams should exist');
  982.           for (const stream of output.trickModeVideo.matchedStreams) {
  983.             goog.asserts.assert(stream.segmentIndex,
  984.                 'trickmode segment index should exist');
  985.             segmentIndex.appendSegmentIndex(stream.segmentIndex);
  986.           }
  987.           output.trickModeVideo.segmentIndex = segmentIndex;
  989.           return Promise.resolve();
  990.         };
  991.       }
  993.       // Concatenate the trick mode input onto the trick mode output.
  994.       output.trickModeVideo.matchedStreams.push(input.trickModeVideo);
  995.       shaka.util.PeriodCombiner.concatenateStreams_(
  996.           output.trickModeVideo, input.trickModeVideo);
  997.     } else if (output.trickModeVideo) {
  998.       // We have a trick mode output, but no input from this Period.  Fill it in
  999.       // from the standard input Stream.
  1000.       output.trickModeVideo.matchedStreams.push(input);
  1001.       shaka.util.PeriodCombiner.concatenateStreams_(
  1002.           output.trickModeVideo, input);
  1003.     }
  1005.     // Combine dependency streams, if present.
  1006.     if (input.dependencyStream) {
  1007.       if (!output.dependencyStream) {
  1008.         // Create a fresh output stream for trick-mode playback.
  1009.         output.dependencyStream = shaka.util.PeriodCombiner.cloneStream_(
  1010.             input.dependencyStream);
  1011.         output.dependencyStream.matchedStreams = [];
  1012.         output.dependencyStream.createSegmentIndex = () => {
  1013.           if (output.dependencyStream.segmentIndex) {
  1014.             return Promise.resolve();
  1015.           }
  1016.           const segmentIndex = new shaka.media.MetaSegmentIndex();
  1017.           goog.asserts.assert(output.dependencyStream.matchedStreams,
  1018.               'dependency video matched streams should exist');
  1019.           for (const stream of output.dependencyStream.matchedStreams) {
  1020.             goog.asserts.assert(stream.segmentIndex,
  1021.                 'dependency video segment index should exist');
  1022.             segmentIndex.appendSegmentIndex(stream.segmentIndex);
  1023.           }
  1024.           output.dependencyStream.segmentIndex = segmentIndex;
  1026.           return Promise.resolve();
  1027.         };
  1028.       }
  1030.       // Concatenate the dependency input onto the dependency output.
  1031.       output.dependencyStream.matchedStreams.push(input.dependencyStream);
  1032.       shaka.util.PeriodCombiner.concatenateStreams_(
  1033.           output.dependencyStream, input.dependencyStream);
  1034.     } else if (output.dependencyStream) {
  1035.       // We have a dependency output, but no input from this Period.
  1036.       // Fill it in from the standard input Stream.
  1037.       output.dependencyStream.matchedStreams.push(input);
  1038.       shaka.util.PeriodCombiner.concatenateStreams_(
  1039.           output.dependencyStream, input);
  1040.     }
  1041.   }
  1043.   /**
  1044.    * Combine the various fields of the input StreamDB into the output.
  1045.    *
  1046.    * @param {shaka.extern.StreamDB} output
  1047.    * @param {shaka.extern.StreamDB} input
  1048.    * @private
  1049.    */
  1050.   static concatenateStreamDBs_(output, input) {
  1051.     // Combine arrays, keeping only the unique elements
  1052.     const combineArrays = (output, input) => {
  1053.       if (!output) {
  1054.         output = [];
  1055.       }
  1056.       for (const item of input) {
  1057.         if (!output.includes(item)) {
  1058.           output.push(item);
  1059.         }
  1060.       }
  1061.       return output;
  1062.     };
  1063.     output.roles = combineArrays(output.roles, input.roles);
  1065.     for (const keyId of input.keyIds) {
  1066.       output.keyIds.add(keyId);
  1067.     }
  1069.     // The output is encrypted if any input was encrypted.
  1070.     output.encrypted = output.encrypted && input.encrypted;
  1072.     // Concatenate segments without de-duping.
  1073.     output.segments.push(...input.segments);
  1075.     // Combine the closed captions maps.
  1076.     if (input.closedCaptions) {
  1077.       if (!output.closedCaptions) {
  1078.         output.closedCaptions = new Map();
  1079.       }
  1080.       for (const [key, value] of input.closedCaptions) {
  1081.         output.closedCaptions.set(key, value);
  1082.       }
  1083.     }
  1084.   }
  1086.   /**
  1087.    * Finds streams in all periods which match the output stream.
  1088.    *
  1089.    * @param {!Array<!Map<string, T>>} streamsPerPeriod
  1090.    * @param {T} outputStream
  1091.    * @param {boolean=} shouldAppend
  1092.    *
  1093.    * @template T
  1094.    * Accepts either a StreamDB or Stream type.
  1095.    *
  1096.    * @private
  1097.    */
  1098.   findMatchesInAllPeriods_(streamsPerPeriod, outputStream,
  1099.       shouldAppend = false) {
  1100.     const matches = shouldAppend ? outputStream.matchedStreams : [];
  1101.     for (const streams of streamsPerPeriod) {
  1102.       const match = this.findBestMatchInPeriod_(streams, outputStream);
  1103.       if (!match) {
  1104.         return;
  1105.       }
  1106.       matches.push(match);
  1107.     }
  1108.     outputStream.matchedStreams = matches;
  1109.   }
  1111.   /**
  1112.    * Find the best match for the output stream.
  1113.    *
  1114.    * @param {!Map<string, T>} streams
  1115.    * @param {T} outputStream
  1116.    * @return {?T}  Returns null if no match can be found.
  1117.    *
  1118.    * @template T
  1119.    * Accepts either a StreamDB or Stream type.
  1120.    *
  1121.    * @private
  1122.    */
  1123.   findBestMatchInPeriod_(streams, outputStream) {
  1124.     const getKey = {
  1125.       'audio': shaka.util.PeriodCombiner.generateAudioKey_,
  1126.       'video': shaka.util.PeriodCombiner.generateVideoKey_,
  1127.       'text': shaka.util.PeriodCombiner.generateTextKey_,
  1128.       'image': shaka.util.PeriodCombiner.generateImageKey_,
  1129.     }[outputStream.type];
  1131.     let best = null;
  1132.     const key = getKey(outputStream);
  1133.     if (streams.has(key)) {
  1134.       // We've found exact match by hashing.
  1135.       best = streams.get(key);
  1136.     } else {
  1137.       // We haven't found exact match, try to find the best one via
  1138.       // linear search.
  1139.       const areCompatible = {
  1140.         'audio': (os, s) => this.areAVStreamsCompatible_(os, s),
  1141.         'video': (os, s) => this.areAVStreamsCompatible_(os, s),
  1142.         'text': shaka.util.PeriodCombiner.areTextStreamsCompatible_,
  1143.         'image': shaka.util.PeriodCombiner.areImageStreamsCompatible_,
  1144.       }[outputStream.type];
  1145.       const isBetterMatch = {
  1146.         'audio': shaka.util.PeriodCombiner.isAudioStreamBetterMatch_,
  1147.         'video': shaka.util.PeriodCombiner.isVideoStreamBetterMatch_,
  1148.         'text': shaka.util.PeriodCombiner.isTextStreamBetterMatch_,
  1149.         'image': shaka.util.PeriodCombiner.isImageStreamBetterMatch_,
  1150.       }[outputStream.type];
  1152.       for (const stream of streams.values()) {
  1153.         if (!areCompatible(outputStream, stream)) {
  1154.           continue;
  1155.         }
  1157.         if (outputStream.fastSwitching != stream.fastSwitching) {
  1158.           continue;
  1159.         }
  1161.         if (!best || isBetterMatch(outputStream, best, stream)) {
  1162.           best = stream;
  1163.         }
  1164.       }
  1165.     }
  1167.     // Remove just found stream if configured to, so possible future linear
  1168.     // searches can be faster.
  1169.     if (this.useStreamOnce_ && !shaka.util.PeriodCombiner.isDummy_(best)) {
  1170.       streams.delete(getKey(best));
  1171.     }
  1173.     return best;
  1174.   }
  1176.   /**
  1177.    * @param {T} a
  1178.    * @param {T} b
  1179.    * @return {boolean}
  1180.    *
  1181.    * @template T
  1182.    * Accepts either a StreamDB or Stream type.
  1183.    *
  1184.    * @private
  1185.    */
  1186.   static areAVStreamsExactMatch_(a, b) {
  1187.     if (a.mimeType != b.mimeType) {
  1188.       return false;
  1189.     }
  1190.     return shaka.util.PeriodCombiner.getCodec_(a.codecs) ===
  1191.         shaka.util.PeriodCombiner.getCodec_(b.codecs);
  1192.   }
  1194.   /**
  1195.    * @param {boolean} allowed If set to true, multi-mimeType or multi-codec
  1196.    *   variants will be allowed.
  1197.    * @export
  1198.    */
  1199.   setAllowMultiTypeVariants(allowed) {
  1200.     this.multiTypeVariantsAllowed_ = allowed;
  1201.   }
  1203.   /**
  1204.    * @param {boolean} useOnce if true, stream will be used only once in period
  1205.    *   flattening algorithm.
  1206.    * @export
  1207.    */
  1208.   setUseStreamOnce(useOnce) {
  1209.     this.useStreamOnce_ = useOnce;
  1210.   }
  1212.   /**
  1213.    * @param {T} outputStream An audio or video output stream
  1214.    * @param {T} candidate A candidate stream to be combined with the output
  1215.    * @return {boolean} True if the candidate could be combined with the
  1216.    *   output stream
  1217.    *
  1218.    * @template T
  1219.    * Accepts either a StreamDB or Stream type.
  1220.    *
  1221.    * @private
  1222.    */
  1223.   areAVStreamsCompatible_(outputStream, candidate) {
  1224.     // Check for an exact match.
  1225.     if (!shaka.util.PeriodCombiner.areAVStreamsExactMatch_(
  1226.         outputStream, candidate)) {
  1227.       // It's not an exact match. See if we can do multi-codec or multi-mimeType
  1228.       // stream instead, using SourceBuffer.changeType.
  1229.       if (!this.multiTypeVariantsAllowed_) {
  1230.         return false;
  1231.       }
  1232.     }
  1234.     // This field is only available on Stream, not StreamDB.
  1235.     if (outputStream.drmInfos) {
  1236.       // Check for compatible DRM systems.  Note that clear streams are
  1237.       // implicitly compatible with any DRM and with each other.
  1238.       if (!shaka.drm.DrmUtils.areDrmCompatible(outputStream.drmInfos,
  1239.           candidate.drmInfos)) {
  1240.         return false;
  1241.       }
  1242.     }
  1244.     return true;
  1245.   }
  1247.   /**
  1248.    * @param {T} outputStream A text output stream
  1249.    * @param {T} candidate A candidate stream to be combined with the output
  1250.    * @return {boolean} True if the candidate could be combined with the
  1251.    *   output
  1252.    *
  1253.    * @template T
  1254.    * Accepts either a StreamDB or Stream type.
  1255.    *
  1256.    * @private
  1257.    */
  1258.   static areTextStreamsCompatible_(outputStream, candidate) {
  1259.     const LanguageUtils = shaka.util.LanguageUtils;
  1261.     // For text, we don't care about MIME type or codec.  We can always switch
  1262.     // between text types.
  1264.     // If the candidate is a dummy, then it is compatible, and we could use it
  1265.     // if nothing else matches.
  1266.     if (!candidate.language) {
  1267.       return true;
  1268.     }
  1270.     // Forced subtitles should be treated as unique streams
  1271.     if (outputStream.forced !== candidate.forced) {
  1272.       return false;
  1273.     }
  1275.     const languageRelatedness = LanguageUtils.relatedness(
  1276.         outputStream.language, candidate.language);
  1278.     // We will strictly avoid combining text across languages or "kinds"
  1279.     // (caption vs subtitle).
  1280.     if (languageRelatedness == 0 ||
  1281.         candidate.kind != outputStream.kind) {
  1282.       return false;
  1283.     }
  1285.     return true;
  1286.   }
  1288.   /**
  1289.    * @param {T} outputStream A image output stream
  1290.    * @param {T} candidate A candidate stream to be combined with the output
  1291.    * @return {boolean} True if the candidate could be combined with the
  1292.    *   output
  1293.    *
  1294.    * @template T
  1295.    * Accepts either a StreamDB or Stream type.
  1296.    *
  1297.    * @private
  1298.    */
  1299.   static areImageStreamsCompatible_(outputStream, candidate) {
  1300.     // For image, we don't care about MIME type.  We can always switch
  1301.     // between image types.
  1303.     return true;
  1304.   }
  1306.   /**
  1307.    * @param {T} outputStream An audio output stream
  1308.    * @param {T} best The best match so far for this period
  1309.    * @param {T} candidate A candidate stream which might be better
  1310.    * @return {boolean} True if the candidate is a better match
  1311.    *
  1312.    * @template T
  1313.    * Accepts either a StreamDB or Stream type.
  1314.    *
  1315.    * @private
  1316.    */
  1317.   static isAudioStreamBetterMatch_(outputStream, best, candidate) {
  1318.     const LanguageUtils = shaka.util.LanguageUtils;
  1319.     const {BETTER, EQUAL, WORSE} = shaka.util.PeriodCombiner.BetterOrWorse;
  1321.     // An exact match is better than a non-exact match.
  1322.     const bestIsExact = shaka.util.PeriodCombiner.areAVStreamsExactMatch_(
  1323.         outputStream, best);
  1324.     const candidateIsExact = shaka.util.PeriodCombiner.areAVStreamsExactMatch_(
  1325.         outputStream, candidate);
  1326.     if (bestIsExact && !candidateIsExact) {
  1327.       return false;
  1328.     }
  1329.     if (!bestIsExact && candidateIsExact) {
  1330.       return true;
  1331.     }
  1333.     // The most important thing is language.  In some cases, we will accept a
  1334.     // different language across periods when we must.
  1335.     const bestRelatedness = LanguageUtils.relatedness(
  1336.         outputStream.language, best.language);
  1337.     const candidateRelatedness = LanguageUtils.relatedness(
  1338.         outputStream.language, candidate.language);
  1340.     if (candidateRelatedness > bestRelatedness) {
  1341.       return true;
  1342.     }
  1343.     if (candidateRelatedness < bestRelatedness) {
  1344.       return false;
  1345.     }
  1347.     // If language-based differences haven't decided this, look at labels.
  1348.     // If available options differ, look does any matches with output stream.
  1349.     if (best.label !== candidate.label) {
  1350.       if (outputStream.label === best.label) {
  1351.         return false;
  1352.       }
  1353.       if (outputStream.label === candidate.label) {
  1354.         return true;
  1355.       }
  1356.     }
  1358.     // If label-based differences haven't decided this, look at roles.  If
  1359.     // the candidate has more roles in common with the output, upgrade to the
  1360.     // candidate.
  1361.     if (outputStream.roles.length) {
  1362.       const bestRoleMatches =
  1363.           best.roles.filter((role) => outputStream.roles.includes(role));
  1364.       const candidateRoleMatches =
  1365.           candidate.roles.filter((role) => outputStream.roles.includes(role));
  1366.       if (candidateRoleMatches.length > bestRoleMatches.length) {
  1367.         return true;
  1368.       } else if (candidateRoleMatches.length < bestRoleMatches.length) {
  1369.         return false;
  1370.       } else if (candidate.roles.length !== best.roles.length) {
  1371.         // Both streams have the same role overlap with the outputStream
  1372.         // If this is the case, choose the stream with the fewer roles overall.
  1373.         // Streams that match best together tend to be streams with the same
  1374.         // roles, e g stream1 with roles [r1, r2] is likely a better match
  1375.         // for stream2 with roles [r1, r2] vs stream3 with roles
  1376.         // [r1, r2, r3, r4].
  1377.         // If we match stream1 with stream3 due to the same role overlap,
  1378.         // stream2 is likely to be left unmatched and error out later.
  1379.         // See https://github.com/shaka-project/shaka-player/issues/2542 for
  1380.         // more details.
  1381.         return candidate.roles.length < best.roles.length;
  1382.       }
  1383.     } else if (!candidate.roles.length && best.roles.length) {
  1384.       // If outputStream has no roles, and only one of the streams has no roles,
  1385.       // choose the one with no roles.
  1386.       return true;
  1387.     } else if (candidate.roles.length && !best.roles.length) {
  1388.       return false;
  1389.     }
  1391.     // If the language doesn't match, but the candidate is the "primary"
  1392.     // language, then that should be preferred as a fallback.
  1393.     if (!best.primary && candidate.primary) {
  1394.       return true;
  1395.     }
  1396.     if (best.primary && !candidate.primary) {
  1397.       return false;
  1398.     }
  1400.     // If language-based and role-based features are equivalent, take the audio
  1401.     // with the closes channel count to the output.
  1402.     const channelsBetterOrWorse =
  1403.         shaka.util.PeriodCombiner.compareClosestPreferLower(
  1404.             outputStream.channelsCount,
  1405.             best.channelsCount,
  1406.             candidate.channelsCount);
  1407.     if (channelsBetterOrWorse == BETTER) {
  1408.       return true;
  1409.     } else if (channelsBetterOrWorse == WORSE) {
  1410.       return false;
  1411.     }
  1413.     // If channels are equal, take the closest sample rate to the output.
  1414.     const sampleRateBetterOrWorse =
  1415.         shaka.util.PeriodCombiner.compareClosestPreferLower(
  1416.             outputStream.audioSamplingRate,
  1417.             best.audioSamplingRate,
  1418.             candidate.audioSamplingRate);
  1419.     if (sampleRateBetterOrWorse == BETTER) {
  1420.       return true;
  1421.     } else if (sampleRateBetterOrWorse == WORSE) {
  1422.       return false;
  1423.     }
  1425.     if (outputStream.bandwidth) {
  1426.       // Take the audio with the closest bandwidth to the output.
  1427.       const bandwidthBetterOrWorse =
  1428.           shaka.util.PeriodCombiner.compareClosestPreferMinimalAbsDiff_(
  1429.               outputStream.bandwidth,
  1430.               best.bandwidth,
  1431.               candidate.bandwidth);
  1432.       if (bandwidthBetterOrWorse == BETTER) {
  1433.         return true;
  1434.       } else if (bandwidthBetterOrWorse == WORSE) {
  1435.         return false;
  1436.       }
  1437.     }
  1439.     // If the result of each comparison was inconclusive, default to false.
  1440.     return false;
  1441.   }
  1443.   /**
  1444.    * @param {T} outputStream A video output stream
  1445.    * @param {T} best The best match so far for this period
  1446.    * @param {T} candidate A candidate stream which might be better
  1447.    * @return {boolean} True if the candidate is a better match
  1448.    *
  1449.    * @template T
  1450.    * Accepts either a StreamDB or Stream type.
  1451.    *
  1452.    * @private
  1453.    */
  1454.   static isVideoStreamBetterMatch_(outputStream, best, candidate) {
  1455.     const {BETTER, EQUAL, WORSE} = shaka.util.PeriodCombiner.BetterOrWorse;
  1457.     // An exact match is better than a non-exact match.
  1458.     const bestIsExact = shaka.util.PeriodCombiner.areAVStreamsExactMatch_(
  1459.         outputStream, best);
  1460.     const candidateIsExact = shaka.util.PeriodCombiner.areAVStreamsExactMatch_(
  1461.         outputStream, candidate);
  1462.     if (bestIsExact && !candidateIsExact) {
  1463.       return false;
  1464.     }
  1465.     if (!bestIsExact && candidateIsExact) {
  1466.       return true;
  1467.     }
  1469.     // Take the video with the closest resolution to the output.
  1470.     const resolutionBetterOrWorse =
  1471.         shaka.util.PeriodCombiner.compareClosestPreferLower(
  1472.             outputStream.width * outputStream.height,
  1473.             best.width * best.height,
  1474.             candidate.width * candidate.height);
  1475.     if (resolutionBetterOrWorse == BETTER) {
  1476.       return true;
  1477.     } else if (resolutionBetterOrWorse == WORSE) {
  1478.       return false;
  1479.     }
  1481.     // We may not know the frame rate for the content, in which case this gets
  1482.     // skipped.
  1483.     if (outputStream.frameRate) {
  1484.       // Take the video with the closest frame rate to the output.
  1485.       const frameRateBetterOrWorse =
  1486.           shaka.util.PeriodCombiner.compareClosestPreferLower(
  1487.               outputStream.frameRate,
  1488.               best.frameRate,
  1489.               candidate.frameRate);
  1490.       if (frameRateBetterOrWorse == BETTER) {
  1491.         return true;
  1492.       } else if (frameRateBetterOrWorse == WORSE) {
  1493.         return false;
  1494.       }
  1495.     }
  1498.     if (outputStream.bandwidth) {
  1499.       // Take the video with the closest bandwidth to the output.
  1500.       const bandwidthBetterOrWorse =
  1501.           shaka.util.PeriodCombiner.compareClosestPreferMinimalAbsDiff_(
  1502.               outputStream.bandwidth,
  1503.               best.bandwidth,
  1504.               candidate.bandwidth);
  1505.       if (bandwidthBetterOrWorse == BETTER) {
  1506.         return true;
  1507.       } else if (bandwidthBetterOrWorse == WORSE) {
  1508.         return false;
  1509.       }
  1510.     }
  1512.     // If the result of each comparison was inconclusive, default to false.
  1513.     return false;
  1514.   }
  1516.   /**
  1517.    * @param {T} outputStream A text output stream
  1518.    * @param {T} best The best match so far for this period
  1519.    * @param {T} candidate A candidate stream which might be better
  1520.    * @return {boolean} True if the candidate is a better match
  1521.    *
  1522.    * @template T
  1523.    * Accepts either a StreamDB or Stream type.
  1524.    *
  1525.    * @private
  1526.    */
  1527.   static isTextStreamBetterMatch_(outputStream, best, candidate) {
  1528.     const LanguageUtils = shaka.util.LanguageUtils;
  1530.     // The most important thing is language.  In some cases, we will accept a
  1531.     // different language across periods when we must.
  1532.     const bestRelatedness = LanguageUtils.relatedness(
  1533.         outputStream.language, best.language);
  1534.     const candidateRelatedness = LanguageUtils.relatedness(
  1535.         outputStream.language, candidate.language);
  1537.     if (candidateRelatedness > bestRelatedness) {
  1538.       return true;
  1539.     }
  1540.     if (candidateRelatedness < bestRelatedness) {
  1541.       return false;
  1542.     }
  1544.     // If the language doesn't match, but the candidate is the "primary"
  1545.     // language, then that should be preferred as a fallback.
  1546.     if (!best.primary && candidate.primary) {
  1547.       return true;
  1548.     }
  1549.     if (best.primary && !candidate.primary) {
  1550.       return false;
  1551.     }
  1553.     // If language-based differences haven't decided this, look at labels.
  1554.     // If available options differ, look does any matches with output stream.
  1555.     if (best.label !== candidate.label) {
  1556.       if (outputStream.label === best.label) {
  1557.         return false;
  1558.       }
  1559.       if (outputStream.label === candidate.label) {
  1560.         return true;
  1561.       }
  1562.     }
  1564.     // If the candidate has more roles in common with the output, upgrade to the
  1565.     // candidate.
  1566.     if (outputStream.roles.length) {
  1567.       const bestRoleMatches =
  1568.           best.roles.filter((role) => outputStream.roles.includes(role));
  1569.       const candidateRoleMatches =
  1570.           candidate.roles.filter((role) => outputStream.roles.includes(role));
  1571.       if (candidateRoleMatches.length > bestRoleMatches.length) {
  1572.         return true;
  1573.       }
  1574.       if (candidateRoleMatches.length < bestRoleMatches.length) {
  1575.         return false;
  1576.       }
  1577.     } else if (!candidate.roles.length && best.roles.length) {
  1578.       // If outputStream has no roles, and only one of the streams has no roles,
  1579.       // choose the one with no roles.
  1580.       return true;
  1581.     } else if (candidate.roles.length && !best.roles.length) {
  1582.       return false;
  1583.     }
  1585.     // If the candidate has the same MIME type and codec, upgrade to the
  1586.     // candidate.  It's not required that text streams use the same format
  1587.     // across periods, but it's a helpful signal.  Some content in our demo app
  1588.     // contains the same languages repeated with two different text formats in
  1589.     // each period.  This condition ensures that all text streams are used.
  1590.     // Otherwise, we wind up with some one stream of each language left unused,
  1591.     // triggering a failure.
  1592.     if (candidate.mimeType == outputStream.mimeType &&
  1593.         candidate.codecs == outputStream.codecs &&
  1594.         (best.mimeType != outputStream.mimeType ||
  1595.          best.codecs != outputStream.codecs)) {
  1596.       return true;
  1597.     }
  1599.     // If the result of each comparison was inconclusive, default to false.
  1600.     return false;
  1601.   }
  1603.   /**
  1604.    * @param {T} outputStream A image output stream
  1605.    * @param {T} best The best match so far for this period
  1606.    * @param {T} candidate A candidate stream which might be better
  1607.    * @return {boolean} True if the candidate is a better match
  1608.    *
  1609.    * @template T
  1610.    * Accepts either a StreamDB or Stream type.
  1611.    *
  1612.    * @private
  1613.    */
  1614.   static isImageStreamBetterMatch_(outputStream, best, candidate) {
  1615.     const {BETTER, EQUAL, WORSE} = shaka.util.PeriodCombiner.BetterOrWorse;
  1617.     // Take the image with the closest resolution to the output.
  1618.     const resolutionBetterOrWorse =
  1619.         shaka.util.PeriodCombiner.compareClosestPreferLower(
  1620.             outputStream.width * outputStream.height,
  1621.             best.width * best.height,
  1622.             candidate.width * candidate.height);
  1623.     if (resolutionBetterOrWorse == BETTER) {
  1624.       return true;
  1625.     } else if (resolutionBetterOrWorse == WORSE) {
  1626.       return false;
  1627.     }
  1629.     // If the result of each comparison was inconclusive, default to false.
  1630.     return false;
  1631.   }
  1633.   /**
  1634.    * Create a dummy StreamDB to fill in periods that are missing a certain type,
  1635.    * to avoid failing the general flattening algorithm.  This won't be used for
  1636.    * audio or video, since those are strictly required in all periods if they
  1637.    * exist in any period.
  1638.    *
  1639.    * @param {shaka.util.ManifestParserUtils.ContentType} type
  1640.    * @return {shaka.extern.StreamDB}
  1641.    * @private
  1642.    */
  1643.   static dummyStreamDB_(type) {
  1644.     return {
  1645.       id: 0,
  1646.       originalId: '',
  1647.       groupId: null,
  1648.       primary: false,
  1649.       type,
  1650.       mimeType: '',
  1651.       codecs: '',
  1652.       language: '',
  1653.       originalLanguage: null,
  1654.       label: null,
  1655.       width: null,
  1656.       height: null,
  1657.       encrypted: false,
  1658.       keyIds: new Set(),
  1659.       segments: [],
  1660.       variantIds: [],
  1661.       roles: [],
  1662.       forced: false,
  1663.       channelsCount: null,
  1664.       audioSamplingRate: null,
  1665.       spatialAudio: false,
  1666.       closedCaptions: null,
  1667.       external: false,
  1668.       fastSwitching: false,
  1669.       isAudioMuxedInVideo: false,
  1670.       baseOriginalId: null,
  1671.     };
  1672.   }
  1674.   /**
  1675.    * Create a dummy Stream to fill in periods that are missing a certain type,
  1676.    * to avoid failing the general flattening algorithm.  This won't be used for
  1677.    * audio or video, since those are strictly required in all periods if they
  1678.    * exist in any period.
  1679.    *
  1680.    * @param {shaka.util.ManifestParserUtils.ContentType} type
  1681.    * @return {shaka.extern.Stream}
  1682.    * @private
  1683.    */
  1684.   static dummyStream_(type) {
  1685.     return {
  1686.       id: 0,
  1687.       originalId: '',
  1688.       groupId: null,
  1689.       createSegmentIndex: () => Promise.resolve(),
  1690.       segmentIndex: new shaka.media.SegmentIndex([]),
  1691.       mimeType: '',
  1692.       codecs: '',
  1693.       encrypted: false,
  1694.       drmInfos: [],
  1695.       keyIds: new Set(),
  1696.       language: '',
  1697.       originalLanguage: null,
  1698.       label: null,
  1699.       type,
  1700.       primary: false,
  1701.       trickModeVideo: null,
  1702.       dependencyStream: null,
  1703.       emsgSchemeIdUris: null,
  1704.       roles: [],
  1705.       forced: false,
  1706.       channelsCount: null,
  1707.       audioSamplingRate: null,
  1708.       spatialAudio: false,
  1709.       closedCaptions: null,
  1710.       accessibilityPurpose: null,
  1711.       external: false,
  1712.       fastSwitching: false,
  1713.       fullMimeTypes: new Set(),
  1714.       isAudioMuxedInVideo: false,
  1715.       baseOriginalId: null,
  1716.     };
  1717.   }
  1719.   /**
  1720.    * Compare the best value so far with the candidate value and the output
  1721.    * value.  Decide if the candidate is better, equal, or worse than the best
  1722.    * so far.  Any value less than or equal to the output is preferred over a
  1723.    * larger value, and closer to the output is better than farther.
  1724.    *
  1725.    * This provides us a generic way to choose things that should match as
  1726.    * closely as possible, like resolution, frame rate, audio channels, or
  1727.    * sample rate.  If we have to go higher to make a match, we will.  But if
  1728.    * the user selects 480p, for example, we don't want to surprise them with
  1729.    * 720p and waste bandwidth if there's another choice available to us.
  1730.    *
  1731.    * @param {number} outputValue
  1732.    * @param {number} bestValue
  1733.    * @param {number} candidateValue
  1734.    * @return {shaka.util.PeriodCombiner.BetterOrWorse}
  1735.    */
  1736.   static compareClosestPreferLower(outputValue, bestValue, candidateValue) {
  1737.     const {BETTER, EQUAL, WORSE} = shaka.util.PeriodCombiner.BetterOrWorse;
  1739.     // If one is the exact match for the output value, and the other isn't,
  1740.     // prefer the one that is the exact match.
  1741.     if (bestValue == outputValue && outputValue != candidateValue) {
  1742.       return WORSE;
  1743.     } else if (candidateValue == outputValue && outputValue != bestValue) {
  1744.       return BETTER;
  1745.     }
  1747.     if (bestValue > outputValue) {
  1748.       if (candidateValue <= outputValue) {
  1749.         // Any smaller-or-equal-to-output value is preferable to a
  1750.         // bigger-than-output value.
  1751.         return BETTER;
  1752.       }
  1754.       // Both "best" and "candidate" are greater than the output.  Take
  1755.       // whichever is closer.
  1756.       if (candidateValue - outputValue < bestValue - outputValue) {
  1757.         return BETTER;
  1758.       } else if (candidateValue - outputValue > bestValue - outputValue) {
  1759.         return WORSE;
  1760.       }
  1761.     } else {
  1762.       // The "best" so far is less than or equal to the output.  If the
  1763.       // candidate is bigger than the output, we don't want it.
  1764.       if (candidateValue > outputValue) {
  1765.         return WORSE;
  1766.       }
  1768.       // Both "best" and "candidate" are less than or equal to the output.
  1769.       // Take whichever is closer.
  1770.       if (outputValue - candidateValue < outputValue - bestValue) {
  1771.         return BETTER;
  1772.       } else if (outputValue - candidateValue > outputValue - bestValue) {
  1773.         return WORSE;
  1774.       }
  1775.     }
  1777.     return EQUAL;
  1778.   }
  1780.   /**
  1781.    * @param {number} outputValue
  1782.    * @param {number} bestValue
  1783.    * @param {number} candidateValue
  1784.    * @return {shaka.util.PeriodCombiner.BetterOrWorse}
  1785.    * @private
  1786.    */
  1787.   static compareClosestPreferMinimalAbsDiff_(
  1788.       outputValue, bestValue, candidateValue) {
  1789.     const {BETTER, EQUAL, WORSE} = shaka.util.PeriodCombiner.BetterOrWorse;
  1791.     const absDiffBest = Math.abs(outputValue - bestValue);
  1792.     const absDiffCandidate = Math.abs(outputValue - candidateValue);
  1793.     if (absDiffCandidate < absDiffBest) {
  1794.       return BETTER;
  1795.     } else if (absDiffBest < absDiffCandidate) {
  1796.       return WORSE;
  1797.     }
  1799.     return EQUAL;
  1800.   }
  1802.   /**
  1803.    * @param {T} stream
  1804.    * @return {boolean}
  1805.    * @template T
  1806.    * Accepts either a StreamDB or Stream type.
  1807.    * @private
  1808.    */
  1809.   static isDummy_(stream) {
  1810.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1811.     switch (stream.type) {
  1812.       case ContentType.TEXT:
  1813.         return !stream.language;
  1814.       case ContentType.IMAGE:
  1815.         return !stream.tilesLayout;
  1816.       default:
  1817.         return false;
  1818.     }
  1819.   }
  1821.   /**
  1822.    * @param {T} v
  1823.    * @return {string}
  1824.    * @template T
  1825.    * Accepts either a StreamDB or Stream type.
  1826.    * @private
  1827.    */
  1828.   static generateVideoKey_(v) {
  1829.     return shaka.util.PeriodCombiner.generateKey_([
  1830.       v.fastSwitching,
  1831.       v.width,
  1832.       v.frameRate,
  1833.       shaka.util.PeriodCombiner.getCodec_(v.codecs),
  1834.       v.mimeType,
  1835.       v.label,
  1836.       v.roles,
  1837.       v.closedCaptions ? Array.from(v.closedCaptions.entries()) : null,
  1838.       v.bandwidth,
  1839.       v.dependencyStream ? v.dependencyStream.baseOriginalId : null,
  1840.       Array.from(v.keyIds),
  1841.     ]);
  1842.   }
  1844.   /**
  1845.    * @param {T} a
  1846.    * @return {string}
  1847.    * @template T
  1848.    * Accepts either a StreamDB or Stream type.
  1849.    * @private
  1850.    */
  1851.   static generateAudioKey_(a) {
  1852.     return shaka.util.PeriodCombiner.generateKey_([
  1853.       a.fastSwitching,
  1854.       a.channelsCount,
  1855.       a.language,
  1856.       a.bandwidth,
  1857.       a.label,
  1858.       shaka.util.PeriodCombiner.getCodec_(a.codecs),
  1859.       a.mimeType,
  1860.       a.roles,
  1861.       a.audioSamplingRate,
  1862.       a.primary,
  1863.       a.dependencyStream ? a.dependencyStream.baseOriginalId : null,
  1864.       Array.from(a.keyIds),
  1865.     ]);
  1866.   }
  1868.   /**
  1869.    * @param {T} t
  1870.    * @return {string}
  1871.    * @template T
  1872.    * Accepts either a StreamDB or Stream type.
  1873.    * @private
  1874.    */
  1875.   static generateTextKey_(t) {
  1876.     return shaka.util.PeriodCombiner.generateKey_([
  1877.       t.language,
  1878.       t.label,
  1879.       t.codecs,
  1880.       t.mimeType,
  1881.       t.bandwidth,
  1882.       t.roles,
  1883.     ]);
  1884.   }
  1886.   /**
  1887.    * @param {T} i
  1888.    * @return {string}
  1889.    * @template T
  1890.    * Accepts either a StreamDB or Stream type.
  1891.    * @private
  1892.    */
  1893.   static generateImageKey_(i) {
  1894.     return shaka.util.PeriodCombiner.generateKey_([
  1895.       i.width,
  1896.       i.codecs,
  1897.       i.mimeType,
  1898.     ]);
  1899.   }
  1901.   /**
  1902.    * @param {!Array<*>} values
  1903.    * @return {string}
  1904.    * @private
  1905.    */
  1906.   static generateKey_(values) {
  1907.     return JSON.stringify(values);
  1908.   }
  1910.   /**
  1911.    * @param {string} codecs
  1912.    * @return {string}
  1913.    * @private
  1914.    */
  1915.   static getCodec_(codecs) {
  1916.     if (!shaka.util.PeriodCombiner.memoizedCodecs.has(codecs)) {
  1917.       const normalizedCodec = shaka.util.MimeUtils.getNormalizedCodec(codecs);
  1918.       shaka.util.PeriodCombiner.memoizedCodecs.set(codecs, normalizedCodec);
  1919.     }
  1920.     return shaka.util.PeriodCombiner.memoizedCodecs.get(codecs);
  1921.   }
  1922. };
  1924. /**
  1925.  * @enum {number}
  1926.  */
  1927. shaka.util.PeriodCombiner.BetterOrWorse = {
  1928.   BETTER: 1,
  1929.   EQUAL: 0,
  1930.   WORSE: -1,
  1931. };
  1933. /**
  1934.  * @private {Map<string, string>}
  1935.  */
  1936. shaka.util.PeriodCombiner.memoizedCodecs = new Map();