Source: lib/media/segment_reference.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.InitSegmentReference');
  19. goog.provide('shaka.media.SegmentReference');
  21. goog.require('goog.asserts');
  25. /**
  26.  * Creates an InitSegmentReference, which provides the location to an
  27.  * initialization segment.
  28.  *
  29.  * @param {function():!Array.<string>} uris A function that creates the URIs of
  30.  *   the resource containing the segment.
  31.  * @param {number} startByte The offset from the start of the resource to the
  32.  *   start of the segment.
  33.  * @param {?number} endByte The offset from the start of the resource to the
  34.  *   end of the segment, inclusive.  A value of null indicates that the segment
  35.  *   extends to the end of the resource.
  36.  *
  37.  * @constructor
  38.  * @struct
  39.  * @export
  40.  */
  41. shaka.media.InitSegmentReference = function(uris, startByte, endByte) {
  42.   /** @type {function():!Array.<string>} */
  43.   this.getUris = uris;
  45.   /** @const {number} */
  46.   this.startByte = startByte;
  48.   /** @const {?number} */
  49.   this.endByte = endByte;
  50. };
  53. /**
  54.  * Creates the URIs of the resource containing the segment.
  55.  *
  56.  * @return {!Array.<string>}
  57.  * @export
  58.  */
  59. shaka.media.InitSegmentReference.prototype.createUris = function() {
  60.   return this.getUris();
  61. };
  64. /**
  65.  * Returns the offset from the start of the resource to the
  66.  * start of the segment.
  67.  *
  68.  * @return {number}
  69.  * @export
  70.  */
  71. shaka.media.InitSegmentReference.prototype.getStartByte = function() {
  72.   return this.startByte;
  73. };
  76. /**
  77.  * Returns the offset from the start of the resource to the end of the segment,
  78.  * inclusive.  A value of null indicates that the segment extends to the end of
  79.  * the resource.
  80.  *
  81.  * @return {?number}
  82.  * @export
  83.  */
  84. shaka.media.InitSegmentReference.prototype.getEndByte = function() {
  85.   return this.endByte;
  86. };
  90. /**
  91.  * Creates a SegmentReference, which provides the start time, end time, and
  92.  * location to a media segment.
  93.  *
  94.  * @param {number} position The segment's position within a particular Period.
  95.  *   The following should hold true between any two SegmentReferences from the
  96.  *   same Period, r1 and r2:
  97.  *   IF r2.position > r1.position THEN
  98.  *     [ (r2.startTime > r1.startTime) OR
  99.  *       (r2.startTime == r1.startTime AND r2.endTime >= r1.endTime) ]
  100.  * @param {number} startTime The segment's start time in seconds, relative to
  101.  *   the start of a particular Period.
  102.  * @param {number} endTime The segment's end time in seconds, relative to
  103.  *   the start of a particular Period.  The segment ends the instant before
  104.  *   this time, so |endTime| must be strictly greater than |startTime|.
  105.  * @param {function():!Array.<string>} uris
  106.  *   A function that creates the URIs of the resource containing the segment.
  107.  * @param {number} startByte The offset from the start of the resource to the
  108.  *   start of the segment.
  109.  * @param {?number} endByte The offset from the start of the resource to the
  110.  *   end of the segment, inclusive.  A value of null indicates that the segment
  111.  *   extends to the end of the resource.
  112.  *
  113.  * @constructor
  114.  * @struct
  115.  * @export
  116.  */
  117. shaka.media.SegmentReference = function(
  118.     position, startTime, endTime, uris, startByte, endByte) {
  119.   goog.asserts.assert(startTime < endTime,
  120.                       'startTime must be less than endTime');
  121.   goog.asserts.assert((startByte < endByte) || (endByte == null),
  122.                       'startByte must be < endByte');
  123.   /** @const {number} */
  124.   this.position = position;
  126.   /** @type {number} */
  127.   this.startTime = startTime;
  129.   /** @type {number} */
  130.   this.endTime = endTime;
  132.   /** @type {function():!Array.<string>} */
  133.   this.getUris = uris;
  135.   /** @const {number} */
  136.   this.startByte = startByte;
  138.   /** @const {?number} */
  139.   this.endByte = endByte;
  140. };
  143. /**
  144.  * Returns the segment's position within a particular Period.
  145.  *
  146.  * @return {number} The segment's position.
  147.  * @export
  148.  */
  149. shaka.media.SegmentReference.prototype.getPosition = function() {
  150.   return this.position;
  151. };
  154. /**
  155.  * Returns the segment's start time in seconds, relative to
  156.  * the start of a particular Period.
  157.  *
  158.  * @return {number}
  159.  * @export
  160.  */
  161. shaka.media.SegmentReference.prototype.getStartTime = function() {
  162.   return this.startTime;
  163. };
  166. /**
  167.  * Returns the segment's end time in seconds, relative to
  168.  * the start of a particular Period.
  169.  *
  170.  * @return {number}
  171.  * @export
  172.  */
  173. shaka.media.SegmentReference.prototype.getEndTime = function() {
  174.   return this.endTime;
  175. };
  178. /**
  179.  * Creates the URIs of the resource containing the segment.
  180.  *
  181.  * @return {!Array.<string>}
  182.  * @export
  183.  */
  184. shaka.media.SegmentReference.prototype.createUris = function() {
  185.   return this.getUris();
  186. };
  189. /**
  190.  * Returns the offset from the start of the resource to the
  191.  * start of the segment.
  192.  *
  193.  * @return {number}
  194.  * @export
  195.  */
  196. shaka.media.SegmentReference.prototype.getStartByte = function() {
  197.   return this.startByte;
  198. };
  201. /**
  202.  * Returns the offset from the start of the resource to the end of the segment,
  203.  * inclusive.  A value of null indicates that the segment extends to the end of
  204.  * the resource.
  205.  *
  206.  * @return {?number}
  207.  * @export
  208.  */
  209. shaka.media.SegmentReference.prototype.getEndByte = function() {
  210.   return this.endByte;
  211. };
  214. /**
  215.  * A convenient typedef for when either type of reference is acceptable.
  216.  *
  217.  * @typedef {shaka.media.InitSegmentReference|shaka.media.SegmentReference}
  218.  */
  219. shaka.media.AnySegmentReference;