Source: lib/hls/manifest_text_parser.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.hls.ManifestTextParser');
  9. goog.require('shaka.hls.Attribute');
  10. goog.require('shaka.hls.Playlist');
  11. goog.require('shaka.hls.PlaylistType');
  12. goog.require('shaka.hls.Segment');
  13. goog.require('shaka.hls.Tag');
  14. goog.require('shaka.hls.Utils');
  15. goog.require('shaka.util.Error');
  16. goog.require('shaka.util.StringUtils');
  17. goog.require('shaka.util.TextParser');
  20. /**
  21.  * HlS manifest text parser.
  22.  */
  23. shaka.hls.ManifestTextParser = class {
  24.   /** */
  25.   constructor() {
  26.     /** @private {number} */
  27.     this.globalId_ = 0;
  28.   }
  30.   /**
  31.    * @param {BufferSource} data
  32.    * @param {string} absolutePlaylistUri An absolute, final URI after redirects.
  33.    * @return {!shaka.hls.Playlist}
  34.    */
  35.   parsePlaylist(data, absolutePlaylistUri) {
  36.     const MEDIA_PLAYLIST_TAGS =
  37.         shaka.hls.ManifestTextParser.MEDIA_PLAYLIST_TAGS;
  38.     const SEGMENT_TAGS = shaka.hls.ManifestTextParser.SEGMENT_TAGS;
  40.     // Get the input as a string.  Normalize newlines to \n.
  41.     let str = shaka.util.StringUtils.fromUTF8(data);
  42.     str = str.replace(/\r\n|\r(?=[^\n]|$)/gm, '\n').trim();
  44.     const lines = str.split(/\n+/m);
  46.     if (!/^#EXTM3U($|[ \t\n])/m.test(lines[0])) {
  47.       throw new shaka.util.Error(
  48.           shaka.util.Error.Severity.CRITICAL,
  49.           shaka.util.Error.Category.MANIFEST,
  50.           shaka.util.Error.Code.HLS_PLAYLIST_HEADER_MISSING);
  51.     }
  53.     /** shaka.hls.PlaylistType */
  54.     let playlistType = shaka.hls.PlaylistType.MASTER;
  56.     // First, look for media playlist tags, so that we know what the playlist
  57.     // type really is before we start parsing.
  58.     // TODO: refactor the for loop for better readability.
  59.     // Whether to skip the next element; initialize to true to skip first elem.
  60.     let skip = true;
  61.     for (const line of lines) {
  62.       // Ignore comments.
  63.       if (shaka.hls.Utils.isComment(line) || skip) {
  64.         skip = false;
  65.         continue;
  66.       }
  67.       const tag = this.parseTag_(line);
  68.       // These tags won't actually be used, so don't increment the global
  69.       // id.
  70.       this.globalId_ -= 1;
  72.       if (MEDIA_PLAYLIST_TAGS.includes(tag.name)) {
  73.         playlistType = shaka.hls.PlaylistType.MEDIA;
  74.         break;
  75.       } else if (tag.name == 'EXT-X-STREAM-INF') {
  76.         skip = true;
  77.       }
  78.     }
  80.     /** {Array.<shaka.hls.Tag>} */
  81.     const tags = [];
  82.     // Initialize to "true" to skip the first element.
  83.     skip = true;
  84.     for (let i = 0; i < lines.length; i++) {
  85.       const line = lines[i];
  86.       const next = lines[i + 1];
  87.       // Skip comments
  88.       if (shaka.hls.Utils.isComment(line) || skip) {
  89.         skip = false;
  90.         continue;
  91.       }
  93.       const tag = this.parseTag_(line);
  94.       if (SEGMENT_TAGS.includes(tag.name)) {
  95.         if (playlistType != shaka.hls.PlaylistType.MEDIA) {
  96.           // Only media playlists should contain segment tags
  97.           throw new shaka.util.Error(
  98.               shaka.util.Error.Severity.CRITICAL,
  99.               shaka.util.Error.Category.MANIFEST,
  100.               shaka.util.Error.Code.HLS_INVALID_PLAYLIST_HIERARCHY);
  101.         }
  103.         const segmentsData = lines.splice(i, lines.length - i);
  104.         const segments = this.parseSegments_(
  105.             absolutePlaylistUri, segmentsData, tags);
  106.         return new shaka.hls.Playlist(
  107.             absolutePlaylistUri, playlistType, tags, segments);
  108.       }
  110.       tags.push(tag);
  112.       // An EXT-X-STREAM-INF tag is followed by a URI of a media playlist.
  113.       // Add the URI to the tag object.
  114.       if (tag.name == 'EXT-X-STREAM-INF') {
  115.         const tagUri = new shaka.hls.Attribute('URI', next);
  116.         tag.addAttribute(tagUri);
  117.         skip = true;
  118.       }
  119.     }
  121.     return new shaka.hls.Playlist(absolutePlaylistUri, playlistType, tags);
  122.   }
  124.   /**
  125.    * Parses an array of strings into an array of HLS Segment objects.
  126.    *
  127.    * @param {string} absoluteMediaPlaylistUri
  128.    * @param {!Array.<string>} lines
  129.    * @param {!Array.<!shaka.hls.Tag>} playlistTags
  130.    * @return {!Array.<shaka.hls.Segment>}
  131.    * @private
  132.    */
  133.   parseSegments_(absoluteMediaPlaylistUri, lines, playlistTags) {
  134.     /** @type {!Array.<shaka.hls.Segment>} */
  135.     const segments = [];
  136.     /** @type {!Array.<shaka.hls.Tag>} */
  137.     let segmentTags = [];
  139.     /** @type {!Array.<shaka.hls.Tag>} */
  140.     let partialSegmentTags = [];
  142.     // The last parsed EXT-X-MAP tag.
  143.     /** @type {?shaka.hls.Tag} */
  144.     let currentMapTag = null;
  146.     for (const line of lines) {
  147.       if (/^(#EXT)/.test(line)) {
  148.         const tag = this.parseTag_(line);
  149.         if (shaka.hls.ManifestTextParser.MEDIA_PLAYLIST_TAGS.includes(
  150.             tag.name)) {
  151.           playlistTags.push(tag);
  152.         } else {
  153.           // Mark the the EXT-X-MAP tag, and add it to the segment tags
  154.           // following it later.
  155.           if (tag.name == 'EXT-X-MAP') {
  156.             currentMapTag = tag;
  157.           } else if (tag.name == 'EXT-X-PART') {
  158.             partialSegmentTags.push(tag);
  159.           } else if (tag.name == 'EXT-X-PRELOAD-HINT') {
  160.             if (tag.getAttributeValue('TYPE') == 'PART') {
  161.               partialSegmentTags.push(tag);
  162.             } else if (tag.getAttributeValue('TYPE') == 'MAP') {
  163.               // Rename the Preload Hint tag to be a Map tag.
  164.               tag.setName('EXT-X-MAP');
  165.               currentMapTag = tag;
  166.             }
  167.           } else {
  168.             segmentTags.push(tag);
  169.           }
  170.         }
  171.       } else if (shaka.hls.Utils.isComment(line)) {
  172.         // Skip comments.
  173.       } else {
  174.         const verbatimSegmentUri = line.trim();
  175.         const absoluteSegmentUri = shaka.hls.Utils.constructAbsoluteUri(
  176.             absoluteMediaPlaylistUri, verbatimSegmentUri);
  177.         // Attach the last parsed EXT-X-MAP tag to the segment.
  178.         if (currentMapTag) {
  179.           segmentTags.push(currentMapTag);
  180.         }
  181.         // The URI appears after all of the tags describing the segment.
  182.         const segment =
  183.             new shaka.hls.Segment(absoluteSegmentUri, segmentTags,
  184.                 partialSegmentTags);
  185.         segments.push(segment);
  186.         segmentTags = [];
  187.         partialSegmentTags = [];
  188.       }
  189.     }
  190.     // After all the partial segments of a regular segment is published,
  191.     // a EXTINF tag and Uri for a regular segment containing the same media
  192.     // content will get published at last.
  193.     // If no EXTINF tag follows the list of partial segment tags at the end,
  194.     // create a segment to wrap the partial segment tags.
  195.     if (partialSegmentTags.length) {
  196.       if (currentMapTag) {
  197.         segmentTags.push(currentMapTag);
  198.       }
  199.       const segment = new shaka.hls.Segment('', segmentTags,
  200.           partialSegmentTags);
  201.       segments.push(segment);
  202.     }
  204.     return segments;
  205.   }
  207.   /**
  208.    * Parses a string into an HLS Tag object while tracking what id to use next.
  209.    *
  210.    * @param {string} word
  211.    * @return {!shaka.hls.Tag}
  212.    * @private
  213.    */
  214.   parseTag_(word) {
  215.     return shaka.hls.ManifestTextParser.parseTag(this.globalId_++, word);
  216.   }
  218.   /**
  219.    * Parses a string into an HLS Tag object.
  220.    *
  221.    * @param {number} id
  222.    * @param {string} word
  223.    * @return {!shaka.hls.Tag}
  224.    */
  225.   static parseTag(id, word) {
  226.     /* HLS tags start with '#EXT'. A tag can have a set of attributes
  227.       (#EXT-<tagname>:<attribute list>) and/or a value (#EXT-<tagname>:<value>).
  228.       An attribute's format is 'AttributeName=AttributeValue'.
  229.       The parsing logic goes like this:
  230.        1. Everything before ':' is a name (we ignore '#').
  231.        2. Everything after ':' is a list of comma-seprated items,
  232.             2a. The first item might be a value, if it does not contain '='.
  233.             2b. Otherwise, items are attributes.
  234.        3. If there is no ":", it's a simple tag with no attributes and no value.
  235.     */
  236.     const blocks = word.match(/^#(EXT[^:]*)(?::(.*))?$/);
  237.     if (!blocks) {
  238.       throw new shaka.util.Error(
  239.           shaka.util.Error.Severity.CRITICAL,
  240.           shaka.util.Error.Category.MANIFEST,
  241.           shaka.util.Error.Code.INVALID_HLS_TAG,
  242.           word);
  243.     }
  244.     const name = blocks[1];
  245.     const data = blocks[2];
  246.     const attributes = [];
  247.     let value;
  249.     if (data) {
  250.       const parser = new shaka.util.TextParser(data);
  251.       let blockAttrs;
  253.       // Regex: any number of non-equals-sign characters at the beginning
  254.       // terminated by comma or end of line
  255.       const valueRegex = /^([^,=]+)(?:,|$)/g;
  257.       const blockValue = parser.readRegex(valueRegex);
  259.       if (blockValue) {
  260.         value = blockValue[1];
  261.       }
  263.       // Regex:
  264.       // 1. Key name ([1])
  265.       // 2. Equals sign
  266.       // 3. Either:
  267.       //   a. A quoted string (everything up to the next quote, [2])
  268.       //   b. An unquoted string
  269.       //    (everything up to the next comma or end of line, [3])
  270.       // 4. Either:
  271.       //   a. A comma
  272.       //   b. End of line
  273.       const attributeRegex = /([^=]+)=(?:"([^"]*)"|([^",]*))(?:,|$)/g;
  275.       while ((blockAttrs = parser.readRegex(attributeRegex))) {
  276.         const attrName = blockAttrs[1];
  277.         const attrValue = blockAttrs[2] || blockAttrs[3];
  278.         const attribute = new shaka.hls.Attribute(attrName, attrValue);
  279.         attributes.push(attribute);
  280.         parser.skipWhitespace();
  281.       }
  282.     }
  284.     return new shaka.hls.Tag(id, name, attributes, value);
  285.   }
  286. };
  289. /**
  290.  * HLS tags that only appear on Media Playlists.
  291.  * Used to determine a playlist type.
  292.  *
  293.  * @const {!Array.<string>}
  294.  */
  295. shaka.hls.ManifestTextParser.MEDIA_PLAYLIST_TAGS = [
  296.   'EXT-X-TARGETDURATION',
  297.   'EXT-X-MEDIA-SEQUENCE',
  298.   'EXT-X-DISCONTINUITY-SEQUENCE',
  299.   'EXT-X-PLAYLIST-TYPE',
  300.   'EXT-X-I-FRAMES-ONLY',
  301.   'EXT-X-ENDLIST',
  302.   'EXT-X-SERVER-CONTROL',
  303.   'EXT-X-SKIP',
  304. ];
  307. /**
  308.  * HLS tags that only appear on Segments in a Media Playlists.
  309.  * Used to determine the start of the segments info.
  310.  *
  311.  * @const {!Array.<string>}
  312.  */
  313. shaka.hls.ManifestTextParser.SEGMENT_TAGS = [
  314.   'EXTINF',
  315.   'EXT-X-BYTERANGE',
  316.   'EXT-X-DISCONTINUITY',
  317.   'EXT-X-PROGRAM-DATE-TIME',
  318.   'EXT-X-KEY',
  319.   'EXT-X-DATERANGE',
  320.   'EXT-X-MAP',
  321. ];