Source: lib/media/segment_index.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.media.MetaSegmentIndex');
  8. goog.provide('shaka.media.SegmentIndex');
  9. goog.provide('shaka.media.SegmentIterator');
  11. goog.require('goog.asserts');
  12. goog.require('shaka.log');
  13. goog.require('shaka.media.SegmentReference');
  14. goog.require('shaka.util.IReleasable');
  15. goog.require('shaka.util.Timer');
  18. /**
  19.  * SegmentIndex.
  20.  *
  21.  * @implements {shaka.extern.SegmentIndex}
  22.  * @implements {shaka.util.IReleasable}
  23.  * @implements {Iterable<!shaka.media.SegmentReference>}
  24.  * @export
  25.  */
  26. shaka.media.SegmentIndex = class {
  27.   /**
  28.    * @param {!Array<!shaka.media.SegmentReference>} references The list of
  29.    *   SegmentReferences, which must be sorted first by their start times
  30.    *   (ascending) and second by their end times (ascending).
  31.    */
  32.   constructor(references) {
  33.     if (goog.DEBUG) {
  34.       shaka.media.SegmentIndex.assertCorrectReferences_(references);
  35.     }
  37.     /** @protected {!Array<!shaka.media.SegmentReference>} */
  38.     this.references = references;
  40.     /** @private {shaka.util.Timer} */
  41.     this.timer_ = null;
  43.     /**
  44.      * The number of references that have been removed from the front of the
  45.      * array.  Used to create stable positions in the find/get APIs.
  46.      *
  47.      * @protected {number}
  48.      */
  49.     this.numEvicted_ = 0;
  51.     /** @private {boolean} */
  52.     this.immutable_ = false;
  53.   }
  55.   /**
  56.    * Get immutability
  57.    *
  58.    * @return {boolean}
  59.    */
  60.   getIsImmutable() {
  61.     return this.immutable_;
  62.   }
  64.   /**
  65.    * @override
  66.    * @export
  67.    */
  68.   getNumReferences() {
  69.     return this.references.length;
  70.   }
  72.   /**
  73.    * @override
  74.    * @export
  75.    */
  76.   getNumEvicted() {
  77.     return this.numEvicted_;
  78.   }
  80.   /**
  81.    * @override
  82.    * @export
  83.    */
  84.   release() {
  85.     if (this.immutable_) {
  86.       return;
  87.     }
  89.     this.references = [];
  91.     if (this.timer_) {
  92.       this.timer_.stop();
  93.     }
  94.     this.timer_ = null;
  95.   }
  98.   /**
  99.    * Marks the index as immutable.  Segments cannot be added or removed after
  100.    * this point.  This doesn't affect the references themselves.  This also
  101.    * makes the destroy/release methods do nothing.
  102.    *
  103.    * This is mainly for testing.
  104.    *
  105.    * @export
  106.    */
  107.   markImmutable() {
  108.     this.immutable_ = true;
  109.   }
  112.   /**
  113.    * Iterates over all top-level segment references in this segment index.
  114.    * @param {function(!shaka.media.SegmentReference)} fn
  115.    */
  116.   forEachTopLevelReference(fn) {
  117.     for (const reference of this.references) {
  118.       fn(reference);
  119.     }
  120.   }
  123.   /**
  124.    * Return the earliest reference, or null if empty.
  125.    * @return {shaka.media.SegmentReference}
  126.    */
  127.   earliestReference() {
  128.     return this.references[0] || null;
  129.   }
  132.   /**
  133.    * Drop the first N references.
  134.    * Used in early HLS synchronization, and does not count as eviction.
  135.    * @param {number} n
  136.    */
  137.   dropFirstReferences(n) {
  138.     this.references.splice(0, n);
  139.   }
  142.   /**
  143.    * @override
  144.    * @export
  145.    */
  146.   find(time) {
  147.     // For live streams, searching from the end is faster.  For VOD, it balances
  148.     // out either way.  In both cases, references.length is small enough that
  149.     // the difference isn't huge.
  150.     const lastReferenceIndex = this.references.length - 1;
  151.     for (let i = lastReferenceIndex; i >= 0; --i) {
  152.       const r = this.references[i];
  153.       const start = r.startTime;
  154.       // A rounding error can cause /time/ to equal e.endTime or fall in between
  155.       // the references by a fraction of a second. To account for this, we use
  156.       // the start of the next segment as /end/, unless this is the last
  157.       // reference, in which case we use its end time as /end/.
  158.       const end = i < lastReferenceIndex ?
  159.         this.references[i + 1].startTime : r.endTime;
  160.       // Note that a segment ends immediately before the end time.
  161.       if ((time >= start) && (time < end)) {
  162.         return i + this.numEvicted_;
  163.       }
  164.     }
  165.     if (this.references.length && time < this.references[0].startTime) {
  166.       return this.numEvicted_;
  167.     }
  169.     return null;
  170.   }
  173.   /**
  174.    * @override
  175.    * @export
  176.    */
  177.   get(position) {
  178.     if (this.references.length == 0) {
  179.       return null;
  180.     }
  182.     const index = position - this.numEvicted_;
  183.     if (index < 0 || index >= this.references.length) {
  184.       return null;
  185.     }
  187.     return this.references[index];
  188.   }
  191.   /**
  192.    * Offset all segment references by a fixed amount.
  193.    *
  194.    * @param {number} offset The amount to add to each segment's start and end
  195.    *   times.
  196.    * @export
  197.    */
  198.   offset(offset) {
  199.     if (!this.immutable_) {
  200.       for (const ref of this.references) {
  201.         ref.offset(offset);
  202.       }
  203.     }
  204.   }
  207.   /**
  208.    * Merges the given SegmentReferences.  Supports extending the original
  209.    * references only.  Will replace old references with equivalent new ones, and
  210.    * keep any unique old ones.
  211.    *
  212.    * Used, for example, by the DASH and HLS parser, where manifests may not list
  213.    * all available references, so we must keep available references in memory to
  214.    * fill the availability window.
  215.    *
  216.    * @param {!Array<!shaka.media.SegmentReference>} references The list of
  217.    *   SegmentReferences, which must be sorted first by their start times
  218.    *   (ascending) and second by their end times (ascending).
  219.    */
  220.   merge(references) {
  221.     if (goog.DEBUG) {
  222.       shaka.media.SegmentIndex.assertCorrectReferences_(references);
  223.     }
  224.     if (this.immutable_) {
  225.       return;
  226.     }
  228.     if (!references.length) {
  229.       return;
  230.     }
  232.     // Partial segments are used for live edge, and should be removed when they
  233.     // get older. Remove the old SegmentReferences after the first new
  234.     // reference's start time.
  235.     // Use times rounded to the millisecond for filtering purposes, so that
  236.     // tiny rounding errors will not result in duplicate segments in the index.
  237.     const firstStartTime = Math.round(references[0].startTime * 1000) / 1000;
  238.     this.references = this.references.filter((r) => {
  239.       return (Math.round(r.startTime * 1000) / 1000) < firstStartTime;
  240.     });
  242.     this.references.push(...references);
  244.     if (goog.DEBUG) {
  245.       shaka.media.SegmentIndex.assertCorrectReferences_(this.references);
  246.     }
  247.   }
  249.   /**
  250.    * Merges the given SegmentReferences and evicts the ones that end before the
  251.    * given time.  Supports extending the original references only.
  252.    * Will not replace old references or interleave new ones.
  253.    * Used, for example, by the DASH and HLS parser, where manifests may not list
  254.    * all available references, so we must keep available references in memory to
  255.    * fill the availability window.
  256.    *
  257.    * @param {!Array<!shaka.media.SegmentReference>} references The list of
  258.    *   SegmentReferences, which must be sorted first by their start times
  259.    *   (ascending) and second by their end times (ascending).
  260.    * @param {number} windowStart The start of the availability window to filter
  261.    *   out the references that are no longer available.
  262.    * @export
  263.    */
  264.   mergeAndEvict(references, windowStart) {
  265.     // Filter out the references that are no longer available to avoid
  266.     // repeatedly evicting them and messing up eviction count.
  267.     references = references.filter((r) => {
  268.       return r.endTime > windowStart &&
  269.           (this.references.length == 0 ||
  270.            r.endTime > this.references[0].startTime);
  271.     });
  273.     const oldFirstRef = this.references[0];
  274.     this.merge(references);
  275.     const newFirstRef = this.references[0];
  277.     if (oldFirstRef) {
  278.       // We don't compare the actual ref, since the object could legitimately be
  279.       // replaced with an equivalent.  Even the URIs could change due to
  280.       // load-balancing actions taken by the server.  However, if the time
  281.       // changes, its not an equivalent reference.
  282.       goog.asserts.assert(oldFirstRef.startTime == newFirstRef.startTime,
  283.           'SegmentIndex.merge should not change the first reference time!');
  284.     }
  286.     this.evict(windowStart);
  287.   }
  289.   /**
  290.    * Removes all SegmentReferences that end before the given time.
  291.    *
  292.    * @param {number} time The time in seconds.
  293.    * @export
  294.    */
  295.   evict(time) {
  296.     if (this.immutable_) {
  297.       return;
  298.     }
  300.     const oldSize = this.references.length;
  302.     this.references = this.references.filter((ref) => ref.endTime > time);
  304.     const newSize = this.references.length;
  305.     const diff = oldSize - newSize;
  306.     // Tracking the number of evicted refs will keep their "positions" stable
  307.     // for the caller.
  308.     this.numEvicted_ += diff;
  309.   }
  312.   /**
  313.    * Drops references that start after windowEnd, or end before windowStart,
  314.    * and contracts the last reference so that it ends at windowEnd.
  315.    *
  316.    * Do not call on the last period of a live presentation (unknown duration).
  317.    * It is okay to call on the other periods of a live presentation, where the
  318.    * duration is known and another period has been added.
  319.    *
  320.    * @param {number} windowStart
  321.    * @param {?number} windowEnd
  322.    * @param {boolean=} isNew Whether this is a new SegmentIndex and we shouldn't
  323.    *   update the number of evicted elements.
  324.    * @export
  325.    */
  326.   fit(windowStart, windowEnd, isNew = false) {
  327.     goog.asserts.assert(windowEnd != null,
  328.         'Content duration must be known for static content!');
  329.     goog.asserts.assert(windowEnd != Infinity,
  330.         'Content duration must be finite for static content!');
  331.     if (this.immutable_) {
  332.       return;
  333.     }
  335.     // Trim out references we will never use.
  336.     while (this.references.length) {
  337.       const lastReference = this.references[this.references.length - 1];
  338.       if (lastReference.startTime >= windowEnd) {
  339.         this.references.pop();
  340.       } else {
  341.         break;
  342.       }
  343.     }
  345.     while (this.references.length) {
  346.       const firstReference = this.references[0];
  347.       if (firstReference.endTime <= windowStart) {
  348.         this.references.shift();
  349.         if (!isNew) {
  350.           this.numEvicted_++;
  351.         }
  352.       } else {
  353.         break;
  354.       }
  355.     }
  357.     if (this.references.length == 0) {
  358.       return;
  359.     }
  361.     // Adjust the last SegmentReference.
  362.     const lastReference = this.references[this.references.length - 1];
  363.     const newReference = new shaka.media.SegmentReference(
  364.         lastReference.startTime,
  365.         /* endTime= */ windowEnd,
  366.         lastReference.getUrisInner,
  367.         lastReference.startByte,
  368.         lastReference.endByte,
  369.         lastReference.initSegmentReference,
  370.         lastReference.timestampOffset,
  371.         lastReference.appendWindowStart,
  372.         lastReference.appendWindowEnd,
  373.         lastReference.partialReferences,
  374.         lastReference.tilesLayout,
  375.         lastReference.tileDuration,
  376.         lastReference.syncTime,
  377.         lastReference.status,
  378.         lastReference.aesKey,
  379.     );
  380.     newReference.mimeType = lastReference.mimeType;
  381.     newReference.codecs = lastReference.codecs;
  382.     newReference.discontinuitySequence = lastReference.discontinuitySequence;
  383.     this.references[this.references.length - 1] = newReference;
  384.   }
  387.   /**
  388.    * Updates the references every so often.  Stops when the references list
  389.    * returned by the callback is null.
  390.    *
  391.    * @param {number} interval The interval in seconds.
  392.    * @param {function(): Array<shaka.media.SegmentReference>} updateCallback
  393.    * @export
  394.    */
  395.   updateEvery(interval, updateCallback) {
  396.     goog.asserts.assert(!this.timer_, 'SegmentIndex timer already started!');
  397.     if (this.immutable_) {
  398.       return;
  399.     }
  400.     if (this.timer_) {
  401.       this.timer_.stop();
  402.     }
  404.     this.timer_ = new shaka.util.Timer(() => {
  405.       const references = updateCallback();
  406.       if (references) {
  407.         this.references.push(...references);
  408.       } else {
  409.         this.timer_.stop();
  410.         this.timer_ = null;
  411.       }
  412.     });
  413.     this.timer_.tickEvery(interval);
  414.   }
  417.   /** @return {!shaka.media.SegmentIterator} */
  418.   [Symbol.iterator]() {
  419.     const iter = this.getIteratorForTime(0);
  420.     goog.asserts.assert(iter != null, 'Iterator for 0 should never be null!');
  421.     return iter;
  422.   }
  424.   /**
  425.    * Returns a new iterator that initially points to the segment that contains
  426.    * the given time, or the nearest independent segment before it.
  427.    *
  428.    * Like the normal iterator, next() must be called first to get to the first
  429.    * element. Returns null if we do not find a segment at the
  430.    * requested time.
  431.    *
  432.    * The first segment returned by the iterator _MUST_ be an independent
  433.    * segment.  Assumes that only partial references can be dependent, based on
  434.    * RFC 8216 rev 13, section 8.1: "Each (non-Partial) Media Segment in a Media
  435.    * Playlist will contain at least one independent frame."
  436.    *
  437.    * @param {number} time
  438.    * @param {boolean=} allowNonIndependent
  439.    * @param {boolean=} reverse
  440.    * @return {?shaka.media.SegmentIterator}
  441.    * @export
  442.    */
  443.   getIteratorForTime(time, allowNonIndependent = false, reverse = false) {
  444.     let index = this.find(time);
  445.     if (index == null) {
  446.       return null;
  447.     }
  449.     const ref = this.get(index);
  451.     // Adjust index to point to previous or next index (if reversed), so first
  452.     // next() call will traverse in proper direction.
  453.     if (!reverse) {
  454.       index--;
  455.     } else {
  456.       index++;
  457.     }
  459.     let partialSegmentIndex = -1;
  460.     if (ref && ref.hasPartialSegments()) {
  461.       // Look for a partial SegmentReference.
  462.       for (let i = ref.partialReferences.length - 1; i >= 0; --i) {
  463.         let r = ref.partialReferences[i];
  464.         // Note that a segment ends immediately before the end time.
  465.         if ((time >= r.startTime) && (time < r.endTime)) {
  466.           if (!allowNonIndependent) {
  467.             // Find an independent partial segment by moving backwards.
  468.             while (i && (!r.isIndependent())) {
  469.               i--;
  470.               r = ref.partialReferences[i];
  471.             }
  472.             if (!r.isIndependent()) {
  473.               shaka.log.alwaysError('No independent partial segment found!');
  474.               return null;
  475.             }
  476.           }
  477.           // Call to next() should move the partial segment, not the full
  478.           // segment.
  479.           if (reverse) {
  480.             index--;
  481.           } else {
  482.             index++;
  483.           }
  484.           partialSegmentIndex = i - 1;
  485.           break;
  486.         }
  487.       }
  488.     }
  489.     return new shaka.media.SegmentIterator(
  490.         this, index, partialSegmentIndex, reverse);
  491.   }
  493.   /**
  494.    * @return {boolean}
  495.    */
  496.   isEmpty() {
  497.     return this.getNumReferences() == 0;
  498.   }
  500.   /**
  501.    * Create a SegmentIndex for a single segment of the given start time and
  502.    * duration at the given URIs.
  503.    *
  504.    * @param {number} startTime
  505.    * @param {number} duration
  506.    * @param {!Array<string>} uris
  507.    * @return {!shaka.media.SegmentIndex}
  508.    * @export
  509.    */
  510.   static forSingleSegment(startTime, duration, uris) {
  511.     const reference = new shaka.media.SegmentReference(
  512.         /* startTime= */ startTime,
  513.         /* endTime= */ startTime + duration,
  514.         /* getUris= */ () => uris,
  515.         /* startByte= */ 0,
  516.         /* endByte= */ null,
  517.         /* initSegmentReference= */ null,
  518.         /* presentationTimeOffset= */ startTime,
  519.         /* appendWindowStart= */ startTime,
  520.         /* appendWindowEnd= */ startTime + duration);
  521.     return new shaka.media.SegmentIndex([reference]);
  522.   }
  523. };
  526. if (goog.DEBUG) {
  527.   /**
  528.    * Asserts that the given SegmentReferences are sorted.
  529.    *
  530.    * @param {!Array<shaka.media.SegmentReference>} references
  531.    * @private
  532.    */
  533.   shaka.media.SegmentIndex.assertCorrectReferences_ = (references) => {
  534.     goog.asserts.assert(references.every((r2, i) => {
  535.       if (i == 0) {
  536.         return true;
  537.       }
  538.       const r1 = references[i - 1];
  539.       if (r1.startTime < r2.startTime) {
  540.         return true;
  541.       } else if (r1.startTime > r2.startTime) {
  542.         return false;
  543.       } else {
  544.         if (r1.endTime <= r2.endTime) {
  545.           return true;
  546.         } else {
  547.           return false;
  548.         }
  549.       }
  550.     }), 'SegmentReferences are incorrect');
  551.   };
  552. }
  555. /**
  556.  * An iterator over a SegmentIndex's references.
  557.  *
  558.  * @implements {Iterator<shaka.media.SegmentReference>}
  559.  * @export
  560.  */
  561. shaka.media.SegmentIterator = class {
  562.   /**
  563.    * @param {shaka.media.SegmentIndex} segmentIndex
  564.    * @param {number} index
  565.    * @param {number} partialSegmentIndex
  566.    * @param {boolean} reverse
  567.    */
  568.   constructor(segmentIndex, index, partialSegmentIndex, reverse) {
  569.     /** @private {shaka.media.SegmentIndex} */
  570.     this.segmentIndex_ = segmentIndex;
  572.     /** @private {number} */
  573.     this.currentPosition_ = index;
  575.     /** @private {number} */
  576.     this.currentPartialPosition_ = partialSegmentIndex;
  578.     /** @private {boolean} */
  579.     this.reverse = reverse;
  580.   }
  582.   /**
  583.    * @param {boolean} reverse
  584.    * @export
  585.    */
  586.   setReverse(reverse) {
  587.     this.reverse = reverse;
  588.   }
  590.   /**
  591.    * @return {number}
  592.    * @export
  593.    */
  594.   currentPosition() {
  595.     return this.currentPosition_;
  596.   }
  598.   /**
  599.    * @return {shaka.media.SegmentReference}
  600.    * @export
  601.    */
  602.   current() {
  603.     let ref = this.segmentIndex_.get(this.currentPosition_);
  605.     // When we advance past the end of partial references in next(), then add
  606.     // new references in merge(), the pointers may not make sense any more.
  607.     // This adjusts the invalid pointer values to point to the next newly added
  608.     // segment or partial segment.
  609.     if (ref && ref.hasPartialSegments() && ref.hasAllPartialSegments() &&
  610.         this.currentPartialPosition_ >= ref.partialReferences.length) {
  611.       this.currentPosition_++;
  612.       this.currentPartialPosition_ = 0;
  613.       ref = this.segmentIndex_.get(this.currentPosition_);
  614.     }
  616.     // If the regular segment contains partial segments, get the current
  617.     // partial SegmentReference.
  618.     if (ref && ref.hasPartialSegments()) {
  619.       const partial = ref.partialReferences[this.currentPartialPosition_];
  620.       return partial;
  621.     }
  622.     return ref;
  623.   }
  625.   /**
  626.    * @override
  627.    * @export
  628.    */
  629.   next() {
  630.     const ref = this.segmentIndex_.get(this.currentPosition_);
  632.     if (!this.reverse) {
  633.       if (ref && ref.hasPartialSegments()) {
  634.         // If the regular segment contains partial segments, move to the next
  635.         // partial SegmentReference.
  636.         this.currentPartialPosition_++;
  637.         // If the current regular segment has been published completely, and
  638.         // we've reached the end of its partial segments list, move to the next
  639.         // regular segment.
  640.         // If the Partial Segments list is still on the fly, do not move to
  641.         // the next regular segment.
  642.         if (ref.hasAllPartialSegments() &&
  643.             this.currentPartialPosition_ == ref.partialReferences.length) {
  644.           this.currentPosition_++;
  645.           this.currentPartialPosition_ = 0;
  646.         }
  647.       } else {
  648.         // If the regular segment doesn't contain partial segments, move to the
  649.         // next regular segment.
  650.         this.currentPosition_++;
  651.         this.currentPartialPosition_ = 0;
  652.       }
  653.     } else {
  654.       if (ref && ref.hasPartialSegments()) {
  655.         // If the regular segment contains partial segments, move to the
  656.         // previous partial SegmentReference.
  657.         this.currentPartialPosition_--;
  658.         if (this.currentPartialPosition_ < 0) {
  659.           this.currentPosition_--;
  660.           const prevRef = this.segmentIndex_.get(this.currentPosition_);
  661.           if (prevRef && prevRef.hasPartialSegments()) {
  662.             this.currentPartialPosition_ = prevRef.partialReferences.length - 1;
  663.           } else {
  664.             this.currentPartialPosition_ = 0;
  665.           }
  666.         }
  667.       } else {
  668.         // If the regular segment doesn't contain partial segments, move to the
  669.         // previous regular segment.
  670.         this.currentPosition_--;
  671.         this.currentPartialPosition_ = 0;
  672.       }
  673.     }
  675.     const res = this.current();
  677.     return {
  678.       'value': res,
  679.       'done': !res,
  680.     };
  681.   }
  683.   /**
  684.    * @export
  685.    */
  686.   resetToLastIndependent() {
  687.     const current = this.current();
  688.     if (current.isPartial() && !current.isIndependent()) {
  689.       const ref = this.segmentIndex_.get(this.currentPosition_);
  690.       if (ref && ref.hasPartialSegments()) {
  691.         let partial = ref.partialReferences[this.currentPartialPosition_];
  692.         while (partial.isIndependent()) {
  693.           if (this.currentPartialPosition_ <= 0) {
  694.             break;
  695.           }
  696.           this.currentPartialPosition_--;
  697.           partial = ref.partialReferences[this.currentPartialPosition_];
  698.         }
  699.       }
  700.     }
  701.   }
  702. };
  705. /**
  706.  * A meta-SegmentIndex composed of multiple other SegmentIndexes.
  707.  * Used in constructing multi-Period Streams for DASH.
  708.  *
  709.  * @extends shaka.media.SegmentIndex
  710.  * @implements {shaka.util.IReleasable}
  711.  * @implements {Iterable<!shaka.media.SegmentReference>}
  712.  * @export
  713.  */
  714. shaka.media.MetaSegmentIndex = class extends shaka.media.SegmentIndex {
  715.   /** */
  716.   constructor() {
  717.     super([]);
  719.     /** @private {!Array<!shaka.media.SegmentIndex>} */
  720.     this.indexes_ = [];
  721.   }
  723.   /** Evicts all old SegmentIndexes in this MetaSegmentIndex that are empty. */
  724.   evictEmpty() {
  725.     while (this.indexes_.length > 1 && this.indexes_[0].isEmpty()) {
  726.       const index = this.indexes_.shift();
  727.       // In the case of this class, this.numEvicted_ represents the evicted
  728.       // segments that were in indexes that were entirely evicted.
  729.       this.numEvicted_ += index.getNumEvicted();
  730.       index.release();
  731.     }
  732.   }
  734.   /**
  735.    * Append a SegmentIndex to this MetaSegmentIndex.  This effectively stitches
  736.    * the underlying Stream onto the end of the multi-Period Stream represented
  737.    * by this MetaSegmentIndex.
  738.    *
  739.    * @param {!shaka.media.SegmentIndex} segmentIndex
  740.    */
  741.   appendSegmentIndex(segmentIndex) {
  742.     goog.asserts.assert(
  743.         this.indexes_.length == 0 || segmentIndex.getNumEvicted() == 0,
  744.         'Should not append a new segment index with already-evicted segments');
  745.     this.indexes_.push(segmentIndex);
  746.   }
  748.   /**
  749.    * Create a clone of this MetaSegmentIndex containing all the same indexes.
  750.    *
  751.    * @return {!shaka.media.MetaSegmentIndex}
  752.    */
  753.   clone() {
  754.     const clone = new shaka.media.MetaSegmentIndex();
  755.     // Be careful to clone the Array.  We don't want to share the reference with
  756.     // our clone and affect each other accidentally.
  757.     clone.indexes_ = this.indexes_.slice();
  758.     clone.numEvicted_ = this.numEvicted_;
  759.     return clone;
  760.   }
  762.   /**
  763.    * @override
  764.    * @export
  765.    */
  766.   release() {
  767.     for (const index of this.indexes_) {
  768.       index.release();
  769.     }
  771.     this.indexes_ = [];
  772.   }
  774.   /**
  775.    * @override
  776.    * @export
  777.    */
  778.   forEachTopLevelReference(fn) {
  779.     for (const index of this.indexes_) {
  780.       index.forEachTopLevelReference(fn);
  781.     }
  782.   }
  784.   /**
  785.    * @override
  786.    * @export
  787.    */
  788.   find(time) {
  789.     let numPassedInEarlierIndexes = this.numEvicted_;
  791.     for (const index of this.indexes_) {
  792.       const position = index.find(time);
  794.       if (position != null) {
  795.         return position + numPassedInEarlierIndexes;
  796.       }
  798.       numPassedInEarlierIndexes += index.getNumEvicted() +
  799.         index.getNumReferences();
  800.     }
  802.     return null;
  803.   }
  805.   /**
  806.    * @override
  807.    * @export
  808.    */
  809.   get(position) {
  810.     let numPassedInEarlierIndexes = this.numEvicted_;
  811.     let sawSegments = false;
  813.     for (const index of this.indexes_) {
  814.       goog.asserts.assert(
  815.           !sawSegments || index.getNumEvicted() == 0,
  816.           'Should not see evicted segments after available segments');
  817.       const reference = index.get(position - numPassedInEarlierIndexes);
  819.       if (reference) {
  820.         return reference;
  821.       }
  823.       const num = index.getNumReferences();
  824.       numPassedInEarlierIndexes += index.getNumEvicted() + num;
  825.       sawSegments = sawSegments || num != 0;
  826.     }
  828.     return null;
  829.   }
  831.   /**
  832.    * @override
  833.    * @export
  834.    */
  835.   offset(offset) {
  836.     // offset() is only used by HLS, and MetaSegmentIndex is only used for DASH.
  837.     goog.asserts.assert(
  838.         false, 'offset() should not be used in MetaSegmentIndex!');
  839.   }
  841.   /**
  842.    * @override
  843.    * @export
  844.    */
  845.   merge(references) {
  846.     // merge() is only used internally by the DASH and HLS parser on
  847.     // SegmentIndexes, but never on MetaSegmentIndex.
  848.     goog.asserts.assert(
  849.         false, 'merge() should not be used in MetaSegmentIndex!');
  850.   }
  852.   /**
  853.    * @override
  854.    * @export
  855.    */
  856.   evict(time) {
  857.     for (const index of this.indexes_) {
  858.       index.evict(time);
  859.     }
  860.     this.evictEmpty();
  861.   }
  863.   /**
  864.    * @override
  865.    * @export
  866.    */
  867.   mergeAndEvict(references, windowStart) {
  868.     // mergeAndEvict() is only used internally by the DASH and HLS parser on
  869.     // SegmentIndexes, but never on MetaSegmentIndex.
  870.     goog.asserts.assert(
  871.         false, 'mergeAndEvict() should not be used in MetaSegmentIndex!');
  872.   }
  874.   /**
  875.    * @override
  876.    * @export
  877.    */
  878.   fit(windowStart, windowEnd) {
  879.     // fit() is only used internally by manifest parsers on SegmentIndexes, but
  880.     // never on MetaSegmentIndex.
  881.     goog.asserts.assert(false, 'fit() should not be used in MetaSegmentIndex!');
  882.   }
  884.   /**
  885.    * @override
  886.    * @export
  887.    */
  888.   updateEvery(interval, updateCallback) {
  889.     // updateEvery() is only used internally by the DASH parser on
  890.     // SegmentIndexes, but never on MetaSegmentIndex.
  891.     goog.asserts.assert(
  892.         false, 'updateEvery() should not be used in MetaSegmentIndex!');
  893.   }
  894. };