Source: lib/hls/manifest_text_parser.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.ManifestTextParser');
  20. goog.require('shaka.hls.Attribute');
  21. goog.require('shaka.hls.Playlist');
  22. goog.require('shaka.hls.PlaylistType');
  23. goog.require('shaka.hls.Segment');
  24. goog.require('shaka.hls.Tag');
  25. goog.require('shaka.hls.Utils');
  26. goog.require('shaka.util.Error');
  27. goog.require('shaka.util.StringUtils');
  28. goog.require('shaka.util.TextParser');
  31. /**
  32.  * Creates a new ManifestTextParser.
  33.  *
  34.  * @constructor
  35.  * @struct
  36.  */
  37. shaka.hls.ManifestTextParser = function() {
  38.   /** @private {number} */
  39.   this.globalId_ = 0;
  40. };
  43. /**
  44.  * @param {ArrayBuffer} data
  45.  * @param {string} absolutePlaylistUri An absolute, final URI after redirects.
  46.  * @return {!shaka.hls.Playlist}
  47.  * @throws {shaka.util.Error}
  48.  */
  49. shaka.hls.ManifestTextParser.prototype.parsePlaylist =
  50.     function(data, absolutePlaylistUri) {
  51.   const MEDIA_PLAYLIST_TAGS = shaka.hls.ManifestTextParser.MEDIA_PLAYLIST_TAGS;
  52.   const SEGMENT_TAGS = shaka.hls.ManifestTextParser.SEGMENT_TAGS;
  54.   // Get the input as a string.  Normalize newlines to \n.
  55.   let str = shaka.util.StringUtils.fromUTF8(data);
  56.   str = str.replace(/\r\n|\r(?=[^\n]|$)/gm, '\n').trim();
  58.   const lines = str.split(/\n+/m);
  60.   if (!/^#EXTM3U($|[ \t\n])/m.test(lines[0])) {
  61.     throw new shaka.util.Error(
  62.         shaka.util.Error.Severity.CRITICAL,
  63.         shaka.util.Error.Category.MANIFEST,
  64.         shaka.util.Error.Code.HLS_PLAYLIST_HEADER_MISSING);
  65.   }
  67.   /** shaka.hls.PlaylistType */
  68.   let playlistType = shaka.hls.PlaylistType.MASTER;
  70.   // First, look for media playlist tags, so that we know what the playlist
  71.   // type really is before we start parsing.
  72.   for (let i = 1; i < lines.length; i++) {
  73.     // Ignore comments.
  74.     if (!shaka.hls.Utils.isComment(lines[i])) {
  75.       const tag = this.parseTag_(lines[i]);
  76.       // These tags won't actually be used, so don't increment the global id.
  77.       this.globalId_ -= 1;
  79.       if (MEDIA_PLAYLIST_TAGS.includes(tag.name)) {
  80.         playlistType = shaka.hls.PlaylistType.MEDIA;
  81.         break;
  82.       } else if (tag.name == 'EXT-X-STREAM-INF') {
  83.         i += 1;
  84.       }
  85.     }
  86.   }
  88.   /** {Array.<shaka.hls.Tag>} */
  89.   const tags = [];
  90.   for (let i = 1; i < lines.length;) {
  91.     // Skip comments
  92.     if (shaka.hls.Utils.isComment(lines[i])) {
  93.       i += 1;
  94.       continue;
  95.     }
  97.     const tag = this.parseTag_(lines[i]);
  98.     if (SEGMENT_TAGS.includes(tag.name)) {
  99.       if (playlistType != shaka.hls.PlaylistType.MEDIA) {
  100.         // Only media playlists should contain segment tags
  101.         throw new shaka.util.Error(
  102.             shaka.util.Error.Severity.CRITICAL,
  103.             shaka.util.Error.Category.MANIFEST,
  104.             shaka.util.Error.Code.HLS_INVALID_PLAYLIST_HIERARCHY);
  105.       }
  107.       const segmentsData = lines.splice(i, lines.length - i);
  108.       const segments = this.parseSegments_(
  109.           absolutePlaylistUri, segmentsData, tags);
  110.       return new shaka.hls.Playlist(
  111.           absolutePlaylistUri, playlistType, tags, segments);
  112.     }
  114.     tags.push(tag);
  115.     i += 1;
  117.     // An EXT-X-STREAM-INF tag is followed by a URI of a media playlist.
  118.     // Add the URI to the tag object.
  119.     if (tag.name == 'EXT-X-STREAM-INF') {
  120.       const tagUri = new shaka.hls.Attribute('URI', lines[i]);
  121.       tag.addAttribute(tagUri);
  122.       i += 1;
  123.     }
  124.   }
  126.   return new shaka.hls.Playlist(absolutePlaylistUri, playlistType, tags);
  127. };
  130. /**
  131.  * Parses an array of strings into an array of HLS Segment objects.
  132.  *
  133.  * @param {string} absoluteMediaPlaylistUri
  134.  * @param {!Array.<string>} lines
  135.  * @param {!Array.<!shaka.hls.Tag>} playlistTags
  136.  * @return {!Array.<shaka.hls.Segment>}
  137.  * @private
  138.  * @throws {shaka.util.Error}
  139.  */
  140. shaka.hls.ManifestTextParser.prototype.parseSegments_ =
  141.     function(absoluteMediaPlaylistUri, lines, playlistTags) {
  142.   /** @type {!Array.<shaka.hls.Segment>} */
  143.   let segments = [];
  144.   /** @type {!Array.<shaka.hls.Tag>} */
  145.   let segmentTags = [];
  146.   lines.forEach((line) => {
  147.     if (/^(#EXT)/.test(line)) {
  148.       let tag = this.parseTag_(line);
  149.       if (shaka.hls.ManifestTextParser.MEDIA_PLAYLIST_TAGS.includes(tag.name)) {
  150.         playlistTags.push(tag);
  151.       } else {
  152.         segmentTags.push(tag);
  153.       }
  154.     } else if (shaka.hls.Utils.isComment(line)) {
  155.       // Skip comments.
  156.       return [];
  157.     } else {
  158.       const verbatimSegmentUri = line.trim();
  159.       const absoluteSegmentUri = shaka.hls.Utils.constructAbsoluteUri(
  160.           absoluteMediaPlaylistUri, verbatimSegmentUri);
  162.       // The URI appears after all of the tags describing the segment.
  163.       const segment = new shaka.hls.Segment(absoluteSegmentUri, segmentTags);
  164.       segments.push(segment);
  165.       segmentTags = [];
  166.     }
  167.   });
  168.   return segments;
  169. };
  172. /**
  173.  * Parses a string into an HLS Tag object while tracking what id to use next.
  174.  *
  175.  * @param {string} word
  176.  * @return {!shaka.hls.Tag}
  177.  * @throws {shaka.util.Error}
  178.  * @private
  179.  */
  180. shaka.hls.ManifestTextParser.prototype.parseTag_ = function(word) {
  181.   return shaka.hls.ManifestTextParser.parseTag(this.globalId_++, word);
  182. };
  185. /**
  186.  * Parses a string into an HLS Tag object.
  187.  *
  188.  * @param {number} id
  189.  * @param {string} word
  190.  * @return {!shaka.hls.Tag}
  191.  * @throws {shaka.util.Error}
  192.  */
  193. shaka.hls.ManifestTextParser.parseTag = function(id, word) {
  194.   /* HLS tags start with '#EXT'. A tag can have a set of attributes
  195.     (#EXT-<tagname>:<attribute list>) and/or a value (#EXT-<tagname>:<value>).
  196.     An attribute's format is 'AttributeName=AttributeValue'.
  197.     The parsing logic goes like this:
  198.      1. Everything before ':' is a name (we ignore '#').
  199.      2. Everything after ':' is a list of comma-seprated items,
  200.           2a. The first item might be a value, if it does not contain '='.
  201.           2b. Otherwise, items are attributes.
  202.      3. If there is no ":", it's a simple tag with no attributes and no value */
  203.   const blocks = word.match(/^#(EXT[^:]*)(?::(.*))?$/);
  204.   if (!blocks) {
  205.     throw new shaka.util.Error(
  206.         shaka.util.Error.Severity.CRITICAL,
  207.         shaka.util.Error.Category.MANIFEST,
  208.         shaka.util.Error.Code.INVALID_HLS_TAG,
  209.         word);
  210.   }
  211.   const name = blocks[1];
  212.   const data = blocks[2];
  213.   const attributes = [];
  214.   let value;
  216.   if (data) {
  217.     const parser = new shaka.util.TextParser(data);
  218.     let blockAttrs;
  220.     // Regex: any number of non-equals-sign characters at the beginning
  221.     // terminated by comma or end of line
  222.     const valueRegex = /^([^,=]+)(?:,|$)/g;
  224.     const blockValue = parser.readRegex(valueRegex);
  226.     if (blockValue) {
  227.       value = blockValue[1];
  228.     }
  230.     // Regex:
  231.     // 1. Key name ([1])
  232.     // 2. Equals sign
  233.     // 3. Either:
  234.     //   a. A quoted string (everything up to the next quote, [2])
  235.     //   b. An unquoted string
  236.     //    (everything up to the next comma or end of line, [3])
  237.     // 4. Either:
  238.     //   a. A comma
  239.     //   b. End of line
  240.     const attributeRegex = /([^=]+)=(?:"([^"]*)"|([^",]*))(?:,|$)/g;
  242.     while ((blockAttrs = parser.readRegex(attributeRegex))) {
  243.       const attrName = blockAttrs[1];
  244.       const attrValue = blockAttrs[2] || blockAttrs[3];
  245.       const attribute = new shaka.hls.Attribute(attrName, attrValue);
  246.       attributes.push(attribute);
  247.     }
  248.   }
  250.   return new shaka.hls.Tag(id, name, attributes, value);
  251. };
  254. /**
  255.  * HLS tags that only appear on Media Playlists.
  256.  * Used to determine a playlist type.
  257.  *
  258.  * @const {!Array.<string>}
  259.  */
  260. shaka.hls.ManifestTextParser.MEDIA_PLAYLIST_TAGS = [
  261.   'EXT-X-TARGETDURATION',
  262.   'EXT-X-MEDIA-SEQUENCE',
  263.   'EXT-X-DISCONTINUITY-SEQUENCE',
  264.   'EXT-X-PLAYLIST-TYPE',
  265.   'EXT-X-MAP',
  266.   'EXT-X-I-FRAMES-ONLY',
  267.   'EXT-X-ENDLIST',
  268. ];
  271. /**
  272.  * HLS tags that only appear on Segments in a Media Playlists.
  273.  * Used to determine the start of the segments info.
  274.  *
  275.  * @const {!Array.<string>}
  276.  */
  277. shaka.hls.ManifestTextParser.SEGMENT_TAGS = [
  278.   'EXTINF',
  279.   'EXT-X-BYTERANGE',
  280.   'EXT-X-DISCONTINUITY',
  281.   'EXT-X-PROGRAM-DATE-TIME',
  282.   'EXT-X-KEY',
  283.   'EXT-X-DATERANGE',
  284. ];