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