Source: lib/media/time_ranges_utils.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.TimeRangesUtils');
  20. goog.require('shaka.util.Platform');
  23. /**
  24.  * @namespace shaka.media.TimeRangesUtils
  25.  * @summary A set of utility functions for dealing with TimeRanges objects.
  26.  */
  29. /**
  30.  * Gets the first timestamp in the buffer.
  31.  *
  32.  * @param {TimeRanges} b
  33.  * @return {?number} The first buffered timestamp, in seconds, if |buffered|
  34.  *   is non-empty; otherwise, return null.
  35.  */
  36. shaka.media.TimeRangesUtils.bufferStart = function(b) {
  37.   if (!b) return null;
  38.   // Workaround Safari bug: https://bit.ly/2trx6O8
  39.   if (b.length == 1 && b.end(0) - b.start(0) < 1e-6) return null;
  40.   // Workaround Edge bug: https://bit.ly/2JYLPeB
  41.   if (b.length == 1 && b.start(0) < 0) return 0;
  42.   return b.length ? b.start(0) : null;
  43. };
  46. /**
  47.  * Gets the last timestamp in the buffer.
  48.  *
  49.  * @param {TimeRanges} b
  50.  * @return {?number} The last buffered timestamp, in seconds, if |buffered|
  51.  *   is non-empty; otherwise, return null.
  52.  */
  53. shaka.media.TimeRangesUtils.bufferEnd = function(b) {
  54.   if (!b) return null;
  55.   // Workaround Safari bug: https://bit.ly/2trx6O8
  56.   if (b.length == 1 && b.end(0) - b.start(0) < 1e-6) return null;
  57.   return b.length ? b.end(b.length - 1) : null;
  58. };
  61. /**
  62.  * Determines if the given time is inside a buffered range.  This includes gaps,
  63.  * meaning that if the playhead is in a gap, it is considered buffered. If there
  64.  * is a small gap between the playhead and buffer start, consider it as
  65.  * buffered.
  66.  *
  67.  * @param {TimeRanges} b
  68.  * @param {number} time Playhead time
  69.  * @param {number=} smallGapLimit Set in configuration
  70.  * @return {boolean}
  71.  */
  72. shaka.media.TimeRangesUtils.isBuffered = function(b, time, smallGapLimit = 0) {
  73.   if (!b || !b.length) return false;
  74.   // Workaround Safari bug: https://bit.ly/2trx6O8
  75.   if (b.length == 1 && b.end(0) - b.start(0) < 1e-6) return false;
  77.   if (time > b.end(b.length - 1)) {
  78.     return false;
  79.   }
  80.   // Push the time forward by the gap limit so that it is more likely to be in
  81.   // the range.
  82.   return (time + smallGapLimit >= b.start(0));
  83. };
  86. /**
  87.  * Computes how far ahead of the given timestamp is buffered.  To provide smooth
  88.  * playback while jumping gaps, we don't include the gaps when 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. shaka.media.TimeRangesUtils.bufferedAheadOf = function(b, time) {
  97.   if (!b || !b.length) return 0;
  98.   // Workaround Safari bug: https://bit.ly/2trx6O8
  99.   if (b.length == 1 && b.end(0) - b.start(0) < 1e-6) return 0;
  101.   // NOTE: On IE11, buffered ranges may show appended data before the associated
  102.   // append operation is complete.
  104.   // We calculate the buffered amount by ONLY accounting for the content
  105.   // buffered (i.e. we ignore the times of the gaps).  We also buffer through
  106.   // all gaps.
  107.   // Therefore, we start at the end and add up all buffers until |time|.
  108.   let result = 0;
  109.   for (let i = b.length - 1; i >= 0 && b.end(i) > time; --i) {
  110.     result += b.end(i) - Math.max(b.start(i), time);
  111.   }
  113.   return result;
  114. };
  117. /**
  118.  * Determines if the given time is inside a gap between buffered ranges.  If it
  119.  * is, this returns the index of the buffer that is *ahead* of the gap.
  120.  *
  121.  * @param {TimeRanges} b
  122.  * @param {number} time
  123.  * @return {?number} The index of the buffer after the gap, or null if not in a
  124.  *   gap.
  125.  */
  126. shaka.media.TimeRangesUtils.getGapIndex = function(b, time) {
  127.   const Platform = shaka.util.Platform;
  129.   if (!b || !b.length) return null;
  130.   // Workaround Safari bug: https://bit.ly/2trx6O8
  131.   if (b.length == 1 && b.end(0) - b.start(0) < 1e-6) return null;
  133.   // Some browsers will stop earlier than others before a gap (e.g. IE/Edge
  134.   // stops 0.5 seconds before a gap). So for some browsers we need to use a
  135.   // larger threshold. See: https://bit.ly/2K5xmJO
  136.   const useLargeThreshold = Platform.isLegacyEdge() ||
  137.                             Platform.isIE() ||
  138.                             Platform.isTizen() ||
  139.                             Platform.isChromecast();
  141.   const threshold = useLargeThreshold ? 0.5 : 0.1;
  143.   for (let i = 0; i < b.length; i++) {
  144.     if (b.start(i) > time && (i == 0 || b.end(i - 1) - time <= threshold)) {
  145.       return i;
  146.     }
  147.   }
  149.   return null;
  150. };
  153. /**
  154.  * @param {TimeRanges} b
  155.  * @return {!Array.<shaka.extern.BufferedRange>}
  156.  */
  157. shaka.media.TimeRangesUtils.getBufferedInfo = function(b) {
  158.   if (!b) return [];
  159.   let ret = [];
  160.   for (let i = 0; i < b.length; i++) {
  161.     ret.push({start: b.start(i), end: b.end(i)});
  162.   }
  163.   return ret;
  164. };