Source: lib/media/segment_index.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.SegmentIndex');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.log');
  22. goog.require('shaka.media.SegmentReference');
  23. goog.require('shaka.util.IDestroyable');
  27. /**
  28.  * Creates a SegmentIndex.
  29.  *
  30.  * @param {!Array.<!shaka.media.SegmentReference>} references The list of
  31.  *   SegmentReferences, which must be sorted first by their start times
  32.  *   (ascending) and second by their end times (ascending).  They must have
  33.  *   continuous, increasing positions.
  34.  *
  35.  * @constructor
  36.  * @struct
  37.  * @implements {shaka.util.IDestroyable}
  38.  * @export
  39.  */
  40. shaka.media.SegmentIndex = function(references) {
  41.   if (goog.DEBUG) {
  42.     shaka.media.SegmentIndex.assertCorrectReferences_(references);
  43.   }
  45.   /** @private {Array.<!shaka.media.SegmentReference>} */
  46.   this.references_ = references;
  47. };
  50. /**
  51.  * @override
  52.  * @export
  53.  */
  54. shaka.media.SegmentIndex.prototype.destroy = function() {
  55.   this.references_ = null;
  56.   return Promise.resolve();
  57. };
  60. /**
  61.  * Finds the position of the segment for the given time, in seconds, relative
  62.  * to the start of a particular Period.  Returns the position of the segment
  63.  * with the largest end time if more than one segment is known for the given
  64.  * time.
  65.  *
  66.  * @param {number} time
  67.  * @return {?number} The position of the segment, or null
  68.  *   if the position of the segment could not be determined.
  69.  * @export
  70.  */
  71. shaka.media.SegmentIndex.prototype.find = function(time) {
  72.   // For live streams, searching from the end is faster.  For VOD, it balances
  73.   // out either way.  In both cases, references_.length is small enough that the
  74.   // difference isn't huge.
  75.   for (let i = this.references_.length - 1; i >= 0; --i) {
  76.     let r = this.references_[i];
  77.     // Note that a segment ends immediately before the end time.
  78.     if ((time >= r.startTime) && (time < r.endTime)) {
  79.       return r.position;
  80.     }
  81.   }
  82.   if (this.references_.length && time < this.references_[0].startTime) {
  83.     return this.references_[0].position;
  84.   }
  86.   return null;
  87. };
  90. /**
  91.  * Gets the SegmentReference for the segment at the given position.
  92.  *
  93.  * @param {number} position The position of the segment.
  94.  * @return {shaka.media.SegmentReference} The SegmentReference, or null if
  95.  *   no such SegmentReference exists.
  96.  * @export
  97.  */
  98. shaka.media.SegmentIndex.prototype.get = function(position) {
  99.   if (this.references_.length == 0) {
  100.     return null;
  101.   }
  103.   let index = position - this.references_[0].position;
  104.   if (index < 0 || index >= this.references_.length) {
  105.     return null;
  106.   }
  108.   return this.references_[index];
  109. };
  112. /**
  113.  * Offset all segment references by a fixed amount.
  114.  *
  115.  * @param {number} offset The amount to add to each segment's start and end
  116.  *   times.
  117.  * @export
  118.  */
  119. shaka.media.SegmentIndex.prototype.offset = function(offset) {
  120.   for (let i = 0; i < this.references_.length; ++i) {
  121.     this.references_[i].startTime += offset;
  122.     this.references_[i].endTime += offset;
  123.   }
  124. };
  127. /**
  128.  * Merges the given SegmentReferences.  Supports extending the original
  129.  * references only.  Will not replace old references or interleave new ones.
  130.  *
  131.  * @param {!Array.<!shaka.media.SegmentReference>} references The list of
  132.  *   SegmentReferences, which must be sorted first by their start times
  133.  *   (ascending) and second by their end times (ascending).  They must have
  134.  *   continuous, increasing positions.
  135.  * @export
  136.  */
  137. shaka.media.SegmentIndex.prototype.merge = function(references) {
  138.   if (goog.DEBUG) {
  139.     shaka.media.SegmentIndex.assertCorrectReferences_(references);
  140.   }
  142.   let newReferences = [];
  143.   let i = 0;
  144.   let j = 0;
  146.   while ((i < this.references_.length) && (j < references.length)) {
  147.     let r1 = this.references_[i];
  148.     let r2 = references[j];
  150.     if (r1.startTime < r2.startTime) {
  151.       newReferences.push(r1);
  152.       i++;
  153.     } else if (r1.startTime > r2.startTime) {
  154.       if (i == 0) {
  155.         // If the reference appears before any existing reference, it may have
  156.         // been evicted before; in this case, simply add it back and it will be
  157.         // evicted again later.
  158.         newReferences.push(r2);
  159.       } else {
  160.         // Drop the new reference if it would have to be interleaved with the
  161.         // old one.  Issue a warning, since this is not a supported update.
  162.         shaka.log.warning('Refusing to rewrite original references on update!');
  163.       }
  164.       j++;
  165.     } else {
  166.       // When period is changed, fit() will expand the last segment to the start
  167.       // of the next period.  So, it is valid to have end time updated to the
  168.       // last segment reference in a period.
  169.       if (Math.abs(r1.endTime - r2.endTime) > 0.1) {
  170.         goog.asserts.assert(r2.endTime > r1.endTime &&
  171.             i == this.references_.length - 1 &&
  172.             j == references.length - 1,
  173.             'This should be an update of the last segment in a period');
  174.         let r = new shaka.media.SegmentReference(r1.position,
  175.             r2.startTime, r2.endTime, r2.getUris, r2.startByte, r2.endByte);
  176.         newReferences.push(r);
  177.       } else {
  178.         // Drop the new reference if there's an old reference with the
  179.         // same time.
  180.         newReferences.push(r1);
  181.       }
  182.       i++;
  183.       j++;
  184.     }
  185.   }
  187.   while (i < this.references_.length) {
  188.     newReferences.push(this.references_[i++]);
  189.   }
  191.   if (newReferences.length) {
  192.     // The rest of these references may need to be renumbered.
  193.     let nextPosition = newReferences[newReferences.length - 1].position + 1;
  194.     while (j < references.length) {
  195.       let r = references[j++];
  196.       let r2 = new shaka.media.SegmentReference(nextPosition++,
  197.           r.startTime, r.endTime, r.getUris, r.startByte, r.endByte);
  198.       newReferences.push(r2);
  199.     }
  200.   } else {
  201.     newReferences = references;
  202.   }
  204.   if (goog.DEBUG) {
  205.     shaka.media.SegmentIndex.assertCorrectReferences_(newReferences);
  206.   }
  208.   this.references_ = newReferences;
  209. };
  212. /**
  213.  * Replace existing references with new ones, without merging.
  214.  *
  215.  * @param {!Array.<!shaka.media.SegmentReference>} newReferences
  216.  */
  217. shaka.media.SegmentIndex.prototype.replace = function(newReferences) {
  218.   if (goog.DEBUG) {
  219.     shaka.media.SegmentIndex.assertCorrectReferences_(newReferences);
  220.   }
  221.   this.references_ = newReferences;
  222. };
  225. /**
  226.  * Removes all SegmentReferences that end before the given time.
  227.  *
  228.  * @param {number} time The time in seconds.
  229.  * @export
  230.  */
  231. shaka.media.SegmentIndex.prototype.evict = function(time) {
  232.   for (let i = 0; i < this.references_.length; ++i) {
  233.     if (this.references_[i].endTime > time) {
  234.       this.references_.splice(0, i);
  235.       return;
  236.     }
  237.   }
  238.   this.references_ = [];
  239. };
  242. /**
  243.  * Expands the first SegmentReference so it begins at the start of its Period
  244.  * if it already begins close to the start of its Period.
  245.  *
  246.  * Also expands or contracts the last SegmentReference so it ends at the end of
  247.  * its Period.
  248.  *
  249.  * Do not call on the last period of a live presentation (unknown duration).
  250.  * It is okay to call on the other periods of a live presentation, where the
  251.  * duration is known and another period has been added.
  252.  *
  253.  * @param {?number} periodDuration
  254.  */
  255. shaka.media.SegmentIndex.prototype.fit = function(periodDuration) {
  256.   goog.asserts.assert(periodDuration != null,
  257.                       'Period duration must be known for static content!');
  258.   goog.asserts.assert(periodDuration != Infinity,
  259.                       'Period duration must be finite for static content!');
  261.   // Trim out references we will never use.
  262.   while (this.references_.length) {
  263.     let lastReference = this.references_[this.references_.length - 1];
  264.     if (lastReference.startTime >= periodDuration) {
  265.       this.references_.pop();
  266.     } else {
  267.       break;
  268.     }
  269.   }
  270.   while (this.references_.length) {
  271.     let firstReference = this.references_[0];
  272.     if (firstReference.endTime <= 0) {
  273.       this.references_.shift();
  274.     } else {
  275.       break;
  276.     }
  277.   }
  279.   if (this.references_.length == 0) {
  280.     return;
  281.   }
  283.   // Adjust the last SegmentReference.
  284.   let lastReference = this.references_[this.references_.length - 1];
  285.   this.references_[this.references_.length - 1] =
  286.       new shaka.media.SegmentReference(
  287.           lastReference.position,
  288.           lastReference.startTime,
  289.           /* endTime */ periodDuration,
  290.           lastReference.getUris,
  291.           lastReference.startByte,
  292.           lastReference.endByte);
  293. };
  296. if (goog.DEBUG) {
  297.   /**
  298.    * Asserts that the given SegmentReferences are sorted and have continuous,
  299.    * increasing positions.
  300.    *
  301.    * @param {!Array.<shaka.media.SegmentReference>} references
  302.    * @private
  303.    */
  304.   shaka.media.SegmentIndex.assertCorrectReferences_ = function(references) {
  305.     goog.asserts.assert(references.every(function(r2, i) {
  306.       if (i == 0) return true;
  307.       let r1 = references[i - 1];
  308.       if (r2.position != r1.position + 1) return false;
  309.       if (r1.startTime < r2.startTime) {
  310.         return true;
  311.       } else if (r1.startTime > r2.startTime) {
  312.         return false;
  313.       } else {
  314.         if (r1.endTime <= r2.endTime) {
  315.           return true;
  316.         } else {
  317.           return false;
  318.         }
  319.       }
  320.     }), 'SegmentReferences are incorrect');
  321.   };
  322. }