Source: lib/media/region_timeline.js

  1. /**
  2.  * @license
  3.  * Copyright 2016 Google Inc.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  18. goog.provide('shaka.media.RegionTimeline');
  20. goog.require('shaka.util.IReleasable');
  21. goog.require('shaka.util.Timer');
  24. /**
  25.  * The region timeline is a set of unique timeline region info entries. When
  26.  * a new entry is added, the |onAddRegion| callback will be called.
  27.  *
  28.  * @implements {shaka.util.IReleasable}
  29.  * @final
  30.  */
  31. shaka.media.RegionTimeline = class {
  32.   /** Constructor */
  33.   constructor(getSeekRange) {
  34.     /** @private {function(shaka.extern.TimelineRegionInfo)} */
  35.     this.onAddRegion_ = (region) => {};
  36.     /** @private {!Set.<shaka.extern.TimelineRegionInfo>} */
  37.     this.regions_ = new Set();
  38.     /** @private {function():{start: number, end: number}} */
  39.     this.getSeekRange_ = getSeekRange;
  41.     /**
  42.      * Make sure all of the regions we're tracking are within the
  43.      * seek range or further in the future. We don't want to store
  44.      * regions that fall before the start of the seek range.
  45.      *
  46.      * @private {shaka.util.Timer}
  47.      */
  48.     this.filterTimer_ = new shaka.util.Timer(() => {
  49.       this.filterBySeekRange_();
  50.     }).tickEvery(
  51.         /* seconds= */ shaka.media.RegionTimeline.REGION_FILTER_INTERVAL);
  52.   }
  54.   /** @override */
  55.   release() {
  56.     // Prevent us from holding onto any external references via the callback.
  57.     this.onAddRegion_ = (region) => {};
  58.     this.regions_.clear();
  59.     this.filterTimer_.stop();
  60.   }
  62.   /**
  63.    * Set the callbacks for events. This will override any previous calls to
  64.    * |setListeners|.
  65.    *
  66.    * @param {function(shaka.extern.TimelineRegionInfo)} onAddRegion
  67.    *    Set the callback for when we add a new region. This callback will only
  68.    *    be called when a region is unique (we reject duplicate regions).
  69.    */
  70.   setListeners(onAddRegion) {
  71.     this.onAddRegion_ = onAddRegion;
  72.   }
  74.   /**
  75.    * @param {shaka.extern.TimelineRegionInfo} region
  76.    */
  77.   addRegion(region) {
  78.     const similarRegion = this.findSimilarRegion_(region);
  80.     // Make sure we don't add duplicate regions. We keep track of this here
  81.     // instead of making the parser track it.
  82.     if (similarRegion == null) {
  83.       this.regions_.add(region);
  84.       this.onAddRegion_(region);
  85.     }
  86.   }
  88.   /**
  89.    * @private
  90.    */
  91.   filterBySeekRange_() {
  92.     const seekRange = this.getSeekRange_();
  93.     for (const region of this.regions_) {
  94.       // Only consider the seek range start here.
  95.       // Future regions might become relevant eventually,
  96.       // but regions that are in the past and can't ever be
  97.       // seeked to will never come up again, and there's no
  98.       // reson to store or process them.
  99.       if (region.endTime < seekRange.start) {
  100.         this.regions_.delete(region);
  101.       }
  102.     }
  103.   }
  105.   /**
  106.    * Find a region in the timeline that has the same scheme id uri, event id,
  107.    * start time and end time. If these four parameters match, we assume it
  108.    * to be the same region. If no similar region can be found, |null| will be
  109.    * returned.
  110.    *
  111.    * @param {shaka.extern.TimelineRegionInfo} region
  112.    * @return {?shaka.extern.TimelineRegionInfo}
  113.    * @private
  114.    */
  115.   findSimilarRegion_(region) {
  116.     for (const existing of this.regions_) {
  117.       // The same scheme ID and time range means that it is similar-enough to
  118.       // be the same region.
  119.       const isSimilar = existing.schemeIdUri == region.schemeIdUri &&
  120.                         existing.id == region.id &&
  121.                         existing.startTime == region.startTime &&
  122.                         existing.endTime == region.endTime;
  124.       if (isSimilar) {
  125.         return existing;
  126.       }
  127.     }
  129.     return null;
  130.   }
  132.   /**
  133.    * Get an iterable for all the regions in the timeline. This will allow
  134.    * others to see what regions are in the timeline while not being able to
  135.    * change the collection.
  136.    *
  137.    * @return {!Iterable.<shaka.extern.TimelineRegionInfo>}
  138.    */
  139.   regions() {
  140.     return this.regions_;
  141.   }
  142. };
  144. /** @const {number} */
  145. shaka.media.RegionTimeline.REGION_FILTER_INTERVAL = 2; // in seconds