Source: lib/hls/hls_classes.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.hls.Attribute');
  19. goog.provide('shaka.hls.Playlist');
  20. goog.provide('shaka.hls.PlaylistType');
  21. goog.provide('shaka.hls.Segment');
  22. goog.provide('shaka.hls.Tag');
  24. goog.require('goog.asserts');
  28. /**
  29.  * Creates an HLS playlist object.
  30.  *
  31.  * @param {!string} uri
  32.  * @param {!shaka.hls.PlaylistType} type
  33.  * @param {!Array.<shaka.hls.Tag>} tags
  34.  * @param {!Array.<shaka.hls.Segment>=} opt_segments
  35.  *
  36.  * @constructor
  37.  * @struct
  38.  */
  39. shaka.hls.Playlist = function(uri, type, tags, opt_segments) {
  40.   /** @const {!string} */
  41.   this.uri = uri;
  43.   /** @const {shaka.hls.PlaylistType} */
  44.   this.type = type;
  46.   /** @const {!Array.<!shaka.hls.Tag>} */
  47.   this.tags = tags;
  49.   /** @const {Array.<!shaka.hls.Segment>} */
  50.   this.segments = opt_segments || null;
  51. };
  54. /**
  55.  * @enum {number}
  56.  */
  57. shaka.hls.PlaylistType = {
  58.   MASTER: 0,
  59.   MEDIA: 1
  60. };
  64. /**
  65.  * Creates an HLS tag object.
  66.  *
  67.  * @param {number} id
  68.  * @param {!string} name
  69.  * @param {!Array.<shaka.hls.Attribute>} attributes
  70.  * @param {?string=} opt_value
  71.  *
  72.  * @constructor
  73.  * @struct
  74.  */
  75. shaka.hls.Tag = function(id, name, attributes, opt_value) {
  77.   goog.asserts.assert(
  78.       (attributes.length == 0 && opt_value) ||
  79.       (attributes.length > 0 && !opt_value) ||
  80.       (attributes.length == 0 && !opt_value),
  81.       'Tags can only take the form ' +
  82.       '(1) <NAME>:<VALUE> ' +
  83.       '(2) <NAME>:<ATTRIBUTE_LIST> ' +
  84.       ' (3) <NAME>');
  86.   /** @const {number} */
  87.   this.id = id;
  89.   /** @const {!string} */
  90.   this.name = name;
  92.   /** @const {Array.<shaka.hls.Attribute>} */
  93.   this.attributes = attributes;
  95.   /** @const {?string} */
  96.   this.value = opt_value || null;
  97. };
  100. /**
  101.  * Create the string representation of the tag.
  102.  *
  103.  * For the DRM system - the full tag needs to be passed down to the CDM. There
  104.  * are two ways of doing this (1) save the original tag or (2) recreate the tag.
  105.  * As with some cases (like in tests) the tag never existed in string form, it
  106.  * is far easier to recreate the tag from the parsed form.
  107.  *
  108.  * @return {string}
  109.  * @override
  110.  */
  111. shaka.hls.Tag.prototype.toString = function() {
  113.   /**
  114.    * @param {shaka.hls.Attribute} attr
  115.    * @return {!string}
  116.    */
  117.   var attr_to_str = function(attr) {
  118.     return attr.name + '="' + attr.value + '"';
  119.   };
  122.   // A valid tag can only follow 1 of 3 patterns.
  123.   //  1) <NAME>:<VALUE>
  124.   //  2) <NAME>:<ATTRIBUTE LIST>
  125.   //  3) <NAME>
  127.   if (this.value) {
  128.     return '#' + this.name + ':' + this.value;
  129.   }
  131.   if (this.attributes.length > 0) {
  132.     return '#' + this.name + ':' + this.attributes.map(attr_to_str).join(',');
  133.   }
  135.   return '#' + this.name;
  136. };
  140. /**
  141.  * Creates an HLS attribute object.
  142.  *
  143.  * @param {!string} name
  144.  * @param {!string} value
  145.  *
  146.  * @constructor
  147.  * @struct
  148.  */
  149. shaka.hls.Attribute = function(name, value) {
  150.   /** @const {!string} */
  151.   this.name = name;
  153.   /** @const {!string} */
  154.   this.value = value;
  155. };
  158. /**
  159.  * Adds an attribute to an HLS Tag.
  160.  *
  161.  * @param {!shaka.hls.Attribute} attribute
  162.  */
  163. shaka.hls.Tag.prototype.addAttribute = function(attribute) {
  164.   this.attributes.push(attribute);
  165. };
  168. /**
  169.  * Gets the first attribute of the tag with a specified name.
  170.  *
  171.  * @param {!string} name
  172.  * @return {?shaka.hls.Attribute} attribute
  173.  */
  174. shaka.hls.Tag.prototype.getAttribute = function(name) {
  175.   var attributes = this.attributes.filter(function(attr) {
  176.     return attr.name == name;
  177.   });
  179.   goog.asserts.assert(attributes.length < 2,
  180.                       'A tag should not have multiple attributes ' +
  181.                       'with the same name!');
  183.   if (attributes.length)
  184.     return attributes[0];
  185.   else
  186.     return null;
  187. };
  190. /**
  191.  * Gets the value of the first attribute of the tag with a specified name.
  192.  * If not found, returns an optional default value.
  193.  *
  194.  * @param {!string} name
  195.  * @param {string=} opt_defaultValue
  196.  * @return {?string}
  197.  */
  198. shaka.hls.Tag.prototype.getAttributeValue = function(name, opt_defaultValue) {
  199.   var defaultValue = opt_defaultValue || null;
  200.   var attribute = this.getAttribute(name);
  201.   return attribute ? attribute.value : defaultValue;
  202. };
  206. /**
  207.  * Creates an HLS segment object.
  208.  *
  209.  * @param {!string} uri
  210.  * @param {!Array.<shaka.hls.Tag>} tags
  211.  *
  212.  * @constructor
  213.  * @struct
  214.  */
  215. shaka.hls.Segment = function(uri, tags) {
  216.   /** @const {!Array.<shaka.hls.Tag>} */
  217.   this.tags = tags;
  219.   /** @const {!string} */
  220.   this.uri = uri;
  221. };