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