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.  * @final
  22.  */
  23. shaka.media.RegionTimeline = class extends shaka.util.FakeEventTarget {
  24.   /**
  25.    * @param {!function():{start: number, end: number}} getSeekRange
  26.    */
  27.   constructor(getSeekRange) {
  28.     super();
  30.     /** @private {!Set.<shaka.extern.TimelineRegionInfo>} */
  31.     this.regions_ = new Set();
  33.     /** @private {!function():{start: number, end: number}} */
  34.     this.getSeekRange_ = getSeekRange;
  36.     /**
  37.      * Make sure all of the regions we're tracking are within the
  38.      * seek range or further in the future. We don't want to store
  39.      * regions that fall before the start of the seek range.
  40.      *
  41.      * @private {shaka.util.Timer}
  42.      */
  43.     this.filterTimer_ = new shaka.util.Timer(() => {
  44.       this.filterBySeekRange_();
  45.     }).tickEvery(
  46.         /* seconds= */ shaka.media.RegionTimeline.REGION_FILTER_INTERVAL);
  47.   }
  49.   /** @override */
  50.   release() {
  51.     this.regions_.clear();
  52.     this.filterTimer_.stop();
  53.     super.release();
  54.   }
  56.   /**
  57.    * @param {shaka.extern.TimelineRegionInfo} region
  58.    */
  59.   addRegion(region) {
  60.     const similarRegion = this.findSimilarRegion_(region);
  62.     // Make sure we don't add duplicate regions. We keep track of this here
  63.     // instead of making the parser track it.
  64.     if (similarRegion == null) {
  65.       this.regions_.add(region);
  66.       const event = new shaka.util.FakeEvent('regionadd', new Map([
  67.         ['region', region],
  68.       ]));
  69.       this.dispatchEvent(event);
  70.     }
  71.   }
  73.   /**
  74.    * @private
  75.    */
  76.   filterBySeekRange_() {
  77.     const seekRange = this.getSeekRange_();
  78.     for (const region of this.regions_) {
  79.       // Only consider the seek range start here.
  80.       // Future regions might become relevant eventually,
  81.       // but regions that are in the past and can't ever be
  82.       // seeked to will never come up again, and there's no
  83.       // reson to store or process them.
  84.       if (region.endTime < seekRange.start) {
  85.         this.regions_.delete(region);
  86.         const event = new shaka.util.FakeEvent('regionremove', new Map([
  87.           ['region', region],
  88.         ]));
  89.         this.dispatchEvent(event);
  90.       }
  91.     }
  92.   }
  94.   /**
  95.    * Find a region in the timeline that has the same scheme id uri, event id,
  96.    * start time and end time. If these four parameters match, we assume it
  97.    * to be the same region. If no similar region can be found, |null| will be
  98.    * returned.
  99.    *
  100.    * @param {shaka.extern.TimelineRegionInfo} region
  101.    * @return {?shaka.extern.TimelineRegionInfo}
  102.    * @private
  103.    */
  104.   findSimilarRegion_(region) {
  105.     const isDiffNegligible = (a, b) => Math.abs(a - b) < 0.1;
  106.     for (const existing of this.regions_) {
  107.       // The same scheme ID and time range means that it is similar-enough to
  108.       // be the same region.
  109.       const isSimilar = existing.schemeIdUri == region.schemeIdUri &&
  110.           existing.id == region.id &&
  111.           isDiffNegligible(existing.startTime, region.startTime) &&
  112.           isDiffNegligible(existing.endTime, region.endTime);
  114.       if (isSimilar) {
  115.         return existing;
  116.       }
  117.     }
  119.     return null;
  120.   }
  122.   /**
  123.    * Get an iterable for all the regions in the timeline. This will allow
  124.    * others to see what regions are in the timeline while not being able to
  125.    * change the collection.
  126.    *
  127.    * @return {!Iterable.<shaka.extern.TimelineRegionInfo>}
  128.    */
  129.   regions() {
  130.     return this.regions_;
  131.   }
  132. };
  134. /** @const {number} */
  135. shaka.media.RegionTimeline.REGION_FILTER_INTERVAL = 2; // in seconds