Source: lib/media/region_timeline.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.media.RegionTimeline');
  9. goog.require('shaka.util.FakeEvent');
  10. goog.require('shaka.util.FakeEventTarget');
  11. goog.require('shaka.util.IReleasable');
  12. goog.require('shaka.util.Timer');
  15. /**
  16.  * The region timeline is a set of unique timeline region info entries. When
  17.  * a new entry is added, the 'regionadd' event will be fired.  When an entry is
  18.  * deleted, the 'regionremove' event will be fired.
  19.  *
  20.  * @implements {shaka.util.IReleasable}
  21.  * @template T
  22.  * @final
  23.  */
  24. shaka.media.RegionTimeline = class extends shaka.util.FakeEventTarget {
  25.   /**
  26.    * @param {!function():{start: number, end: number}} getSeekRange
  27.    */
  28.   constructor(getSeekRange) {
  29.     super();
  31.     /** @private {!Set<T>} */
  32.     this.regions_ = new Set();
  34.     /** @private {!function():{start: number, end: number}} */
  35.     this.getSeekRange_ = getSeekRange;
  37.     /**
  38.      * Make sure all of the regions we're tracking are within the
  39.      * seek range or further in the future. We don't want to store
  40.      * regions that fall before the start of the seek range.
  41.      *
  42.      * @private {shaka.util.Timer}
  43.      */
  44.     this.filterTimer_ = new shaka.util.Timer(() => {
  45.       this.filterBySeekRange_();
  46.     }).tickEvery(
  47.         /* seconds= */ shaka.media.RegionTimeline.REGION_FILTER_INTERVAL);
  48.   }
  50.   /** @override */
  51.   release() {
  52.     this.regions_.clear();
  53.     this.filterTimer_.stop();
  54.     super.release();
  55.   }
  57.   /**
  58.    * @param {T} region
  59.    */
  60.   addRegion(region) {
  61.     const similarRegion = this.findSimilarRegion_(region);
  63.     // Make sure we don't add duplicate regions. We keep track of this here
  64.     // instead of making the parser track it.
  65.     if (similarRegion == null) {
  66.       this.regions_.add(region);
  67.       const event = new shaka.util.FakeEvent('regionadd', new Map([
  68.         ['region', region],
  69.       ]));
  70.       this.dispatchEvent(event);
  71.     }
  72.   }
  74.   /**
  75.    * @private
  76.    */
  77.   filterBySeekRange_() {
  78.     const seekRange = this.getSeekRange_();
  79.     for (const region of this.regions_) {
  80.       // Only consider the seek range start here.
  81.       // Future regions might become relevant eventually,
  82.       // but regions that are in the past and can't ever be
  83.       // seeked to will never come up again, and there's no
  84.       // reason to store or process them.
  85.       if (region.endTime < seekRange.start) {
  86.         this.regions_.delete(region);
  87.         const event = new shaka.util.FakeEvent('regionremove', new Map([
  88.           ['region', region],
  89.         ]));
  90.         this.dispatchEvent(event);
  91.       }
  92.     }
  93.   }
  95.   /**
  96.    * Find a region in the timeline that has the same scheme id uri, event id,
  97.    * start time and end time. If these four parameters match, we assume it
  98.    * to be the same region. If no similar region can be found, |null| will be
  99.    * returned.
  100.    *
  101.    * @param {T} region
  102.    * @return {?T}
  103.    * @private
  104.    */
  105.   findSimilarRegion_(region) {
  106.     const isDiffNegligible = (a, b) => Math.abs(a - b) < 0.1;
  107.     for (const existing of this.regions_) {
  108.       // The same scheme ID and time range means that it is similar-enough to
  109.       // be the same region.
  110.       const isSimilar = existing.schemeIdUri == region.schemeIdUri &&
  111.           existing.id == region.id &&
  112.           isDiffNegligible(existing.startTime, region.startTime) &&
  113.           isDiffNegligible(existing.endTime, region.endTime);
  115.       if (isSimilar) {
  116.         return existing;
  117.       }
  118.     }
  120.     return null;
  121.   }
  123.   /**
  124.    * Get an iterable for all the regions in the timeline. This will allow
  125.    * others to see what regions are in the timeline while not being able to
  126.    * change the collection.
  127.    *
  128.    * @return {!Iterable<T>}
  129.    */
  130.   regions() {
  131.     return this.regions_;
  132.   }
  133. };
  135. /** @const {number} */
  136. shaka.media.RegionTimeline.REGION_FILTER_INTERVAL = 2; // in seconds