Source: lib/media/time_ranges_utils.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.media.TimeRangesUtils');
  10. /**
  11.  * @summary A set of utility functions for dealing with TimeRanges objects.
  12.  */
  13. shaka.media.TimeRangesUtils = class {
  14.   /**
  15.    * Gets the first timestamp in the buffer.
  16.    *
  17.    * @param {TimeRanges} b
  18.    * @return {?number} The first buffered timestamp, in seconds, if |buffered|
  19.    *   is non-empty; otherwise, return null.
  20.    */
  21.   static bufferStart(b) {
  22.     if (!b) {
  23.       return null;
  24.     }
  25.     // Workaround Safari bug: https://bit.ly/2trx6O8
  26.     if (b.length == 1 && b.end(0) - b.start(0) < 1e-6) {
  27.       return null;
  28.     }
  29.     // Workaround Edge bug: https://bit.ly/2JYLPeB
  30.     if (b.length == 1 && b.start(0) < 0) {
  31.       return 0;
  32.     }
  33.     return b.length ? b.start(0) : null;
  34.   }
  37.   /**
  38.    * Gets the last timestamp in the buffer.
  39.    *
  40.    * @param {TimeRanges} b
  41.    * @return {?number} The last buffered timestamp, in seconds, if |buffered|
  42.    *   is non-empty; otherwise, return null.
  43.    */
  44.   static bufferEnd(b) {
  45.     if (!b) {
  46.       return null;
  47.     }
  48.     // Workaround Safari bug: https://bit.ly/2trx6O8
  49.     if (b.length == 1 && b.end(0) - b.start(0) < 1e-6) {
  50.       return null;
  51.     }
  52.     return b.length ? b.end(b.length - 1) : null;
  53.   }
  56.   /**
  57.    * Determines if the given time is inside a buffered range.  This includes
  58.    * gaps, meaning that if the playhead is in a gap, it is considered buffered.
  59.    * If there is a small gap between the playhead and buffer start, consider it
  60.    * as buffered.
  61.    *
  62.    * @param {TimeRanges} b
  63.    * @param {number} time Playhead time
  64.    * @param {number=} smallGapLimit Set in configuration
  65.    * @return {boolean}
  66.    */
  67.   static isBuffered(b, time, smallGapLimit = 0) {
  68.     if (!b || !b.length) {
  69.       return false;
  70.     }
  71.     // Workaround Safari bug: https://bit.ly/2trx6O8
  72.     if (b.length == 1 && b.end(0) - b.start(0) < 1e-6) {
  73.       return false;
  74.     }
  76.     if (time > b.end(b.length - 1)) {
  77.       return false;
  78.     }
  79.     // Push the time forward by the gap limit so that it is more likely to be in
  80.     // the range.
  81.     return (time + smallGapLimit >= b.start(0));
  82.   }
  85.   /**
  86.    * Computes how far ahead of the given timestamp is buffered.  To provide
  87.    * smooth playback while jumping gaps, we don't include the gaps when
  88.    * calculating this.
  89.    * This only includes the amount of content that is buffered.
  90.    *
  91.    * @param {TimeRanges} b
  92.    * @param {number} time
  93.    * @return {number} The number of seconds buffered, in seconds, ahead of the
  94.    *   given time.
  95.    */
  96.   static bufferedAheadOf(b, time) {
  97.     if (!b || !b.length) {
  98.       return 0;
  99.     }
  100.     // Workaround Safari bug: https://bit.ly/2trx6O8
  101.     if (b.length == 1 && b.end(0) - b.start(0) < 1e-6) {
  102.       return 0;
  103.     }
  105.     // We calculate the buffered amount by ONLY accounting for the content
  106.     // buffered (i.e. we ignore the times of the gaps).  We also buffer through
  107.     // all gaps.
  108.     // Therefore, we start at the end and add up all buffers until |time|.
  109.     let result = 0;
  110.     for (const {start, end} of shaka.media.TimeRangesUtils.getBufferedInfo(b)) {
  111.       if (end > time) {
  112.         result += end - Math.max(start, time);
  113.       }
  114.     }
  116.     return result;
  117.   }
  120.   /**
  121.    * Determines if the given time is inside a gap between buffered ranges.  If
  122.    * it is, this returns the index of the buffer that is *ahead* of the gap.
  123.    *
  124.    * @param {TimeRanges} b
  125.    * @param {number} time
  126.    * @param {number} threshold
  127.    * @return {?number} The index of the buffer after the gap, or null if not in
  128.    *   a gap.
  129.    */
  130.   static getGapIndex(b, time, threshold) {
  131.     const TimeRangesUtils = shaka.media.TimeRangesUtils;
  133.     if (!b || !b.length) {
  134.       return null;
  135.     }
  136.     // Workaround Safari bug: https://bit.ly/2trx6O8
  137.     if (b.length == 1 && b.end(0) - b.start(0) < 1e-6) {
  138.       return null;
  139.     }
  141.     const idx = TimeRangesUtils.getBufferedInfo(b).findIndex((item, i, arr) => {
  142.       return item.start > time &&
  143.           (i == 0 || arr[i - 1].end - time <= threshold);
  144.     });
  145.     return idx >= 0 ? idx : null;
  146.   }
  149.   /**
  150.    * @param {TimeRanges} b
  151.    * @return {!Array.<shaka.extern.BufferedRange>}
  152.    */
  153.   static getBufferedInfo(b) {
  154.     if (!b) {
  155.       return [];
  156.     }
  157.     const ret = [];
  158.     for (let i = 0; i < b.length; i++) {
  159.       ret.push({start: b.start(i), end: b.end(i)});
  160.     }
  161.     return ret;
  162.   }
  163. };