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 {!Map<string, T>} */
  32.     this.regions_ = new Map();
  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_ = null;
  45.   }
  47.   /** @override */
  48.   release() {
  49.     this.regions_.clear();
  50.     this.releaseTimer_();
  51.     super.release();
  52.   }
  54.   /**
  55.    * @param {T} region
  56.    */
  57.   addRegion(region) {
  58.     const key = this.generateKey_(region);
  60.     // Make sure we don't add duplicate regions. We keep track of this here
  61.     // instead of making the parser track it.
  62.     if (!this.regions_.has(key)) {
  63.       this.regions_.set(key, region);
  64.       const event = new shaka.util.FakeEvent('regionadd', new Map([
  65.         ['region', region],
  66.       ]));
  67.       this.dispatchEvent(event);
  68.       this.setupTimer_();
  69.     }
  70.   }
  72.   /**
  73.    * @private
  74.    */
  75.   filterBySeekRange_() {
  76.     const seekRange = this.getSeekRange_();
  77.     for (const [key, region] of this.regions_) {
  78.       // Only consider the seek range start here.
  79.       // Future regions might become relevant eventually,
  80.       // but regions that are in the past and can't ever be
  81.       // seeked to will never come up again, and there's no
  82.       // reason to store or process them.
  83.       if (region.endTime < seekRange.start) {
  84.         this.regions_.delete(key);
  85.         const event = new shaka.util.FakeEvent('regionremove', new Map([
  86.           ['region', region],
  87.         ]));
  88.         this.dispatchEvent(event);
  89.       }
  90.     }
  91.     if (!this.regions_.size) {
  92.       this.releaseTimer_();
  93.     }
  94.   }
  96.   /** @private */
  97.   setupTimer_() {
  98.     if (this.filterTimer_) {
  99.       return;
  100.     }
  101.     this.filterTimer_ = new shaka.util.Timer(() => {
  102.       this.filterBySeekRange_();
  103.     }).tickEvery(
  104.         /* seconds= */ shaka.media.RegionTimeline.REGION_FILTER_INTERVAL);
  105.   }
  107.   /** @private */
  108.   releaseTimer_() {
  109.     if (this.filterTimer_) {
  110.       this.filterTimer_.stop();
  111.       this.filterTimer_ = null;
  112.     }
  113.   }
  115.   /**
  116.    * Get an iterable for all the regions in the timeline. This will allow
  117.    * others to see what regions are in the timeline while not being able to
  118.    * change the collection.
  119.    *
  120.    * @return {!Iterable<T>}
  121.    */
  122.   regions() {
  123.     return this.regions_.values();
  124.   }
  126.   /**
  127.    * @param {T} region
  128.    * @return {string}
  129.    * @private
  130.    */
  131.   generateKey_(region) {
  132.     return `${region.schemeIdUri}_${region.id}_` +
  133.       `${region.startTime.toFixed(1)}_${region.endTime.toFixed(1)}`;
  134.   }
  135. };
  137. /** @const {number} */
  138. shaka.media.RegionTimeline.REGION_FILTER_INTERVAL = 2; // in seconds