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