Source: lib/text/vtt_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.text.VttTextParser');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.log');
  22. goog.require('shaka.text.Cue');
  23. goog.require('shaka.text.CueRegion');
  24. goog.require('shaka.text.TextEngine');
  25. goog.require('shaka.util.Error');
  26. goog.require('shaka.util.StringUtils');
  27. goog.require('shaka.util.TextParser');
  31. /**
  32.  * @constructor
  33.  * @implements {shakaExtern.TextParser}
  34.  */
  35. shaka.text.VttTextParser = function() {};
  38. /** @override */
  39. shaka.text.VttTextParser.prototype.parseInit = function(data) {
  40.   goog.asserts.assert(false, 'VTT does not have init segments');
  41. };
  44. /**
  45.  * @override
  46.  * @throws {shaka.util.Error}
  47.  */
  48. shaka.text.VttTextParser.prototype.parseMedia = function(data, time) {
  49.   const VttTextParser = shaka.text.VttTextParser;
  50.   // Get the input as a string.  Normalize newlines to \n.
  51.   let str = shaka.util.StringUtils.fromUTF8(data);
  52.   str = str.replace(/\r\n|\r(?=[^\n]|$)/gm, '\n');
  53.   let blocks = str.split(/\n{2,}/m);
  55.   if (!/^WEBVTT($|[ \t\n])/m.test(blocks[0])) {
  56.     throw new shaka.util.Error(
  57.         shaka.util.Error.Severity.CRITICAL,
  58.         shaka.util.Error.Category.TEXT,
  59.         shaka.util.Error.Code.INVALID_TEXT_HEADER);
  60.   }
  62.   let offset = time.segmentStart;
  63.   if (offset == null) {
  64.     // This is a probe, such as the HLS parser makes.  We don't know the segment
  65.     // start time, so we will use the X-TIMESTAMP-MAP header, if present, to get
  66.     // the segment start time.  By only doing this when segmentStart == null, we
  67.     // protect against rollover in the MPEGTS field.
  69.     // In case the attempt below doesn't work out, assume an offset of 0.
  70.     offset = 0;
  72.     if (blocks[0].indexOf('X-TIMESTAMP-MAP') >= 0) {
  73.       // https://goo.gl/m7eVn9
  74.       // The 'X-TIMESTAMP-MAP' header is used in HLS to align text with
  75.       // the rest of the media.
  76.       // The header format is 'X-TIMESTAMP-MAP=MPEGTS:n,LOCAL:m'
  77.       // (the attributes can go in any order)
  78.       // where n is MPEG-2 time and m is cue time it maps to.
  79.       // For example 'X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000'
  80.       // means an offset of 10 seconds
  81.       // 900000/MPEG_TIMESCALE - cue time.
  82.       let cueTimeMatch =
  83.           blocks[0].match(/LOCAL:((?:(\d{1,}):)?(\d{2}):(\d{2})\.(\d{3}))/m);
  85.       let mpegTimeMatch = blocks[0].match(/MPEGTS:(\d+)/m);
  86.       if (cueTimeMatch && mpegTimeMatch) {
  87.         let parser = new shaka.util.TextParser(cueTimeMatch[1]);
  88.         let cueTime = shaka.text.VttTextParser.parseTime_(parser);
  89.         let mpegTime = Number(mpegTimeMatch[1]);
  90.         const mpegTimescale = shaka.text.VttTextParser.MPEG_TIMESCALE_;
  91.         // Apple-encoded HLS content uses absolute timestamps, so assume the
  92.         // presence of the map tag means the content uses absolute timestamps.
  93.         offset = time.periodStart + (mpegTime / mpegTimescale - cueTime);
  94.       }
  95.     }
  96.   }
  98.   // Parse VTT regions.
  99.   /* !Array.<!shakaExtern.CueRegion> */
  100.   let regions = [];
  101.   let lines = blocks[0].split('\n');
  102.   for (let i = 1; i < lines.length; i++) {
  103.     if (/^Region:/.test(lines[i])) {
  104.       let region = VttTextParser.parseRegion_(lines[i]);
  105.       regions.push(region);
  106.     }
  107.   }
  109.   // Parse cues.
  110.   let ret = [];
  111.   for (let i = 1; i < blocks.length; i++) {
  112.     lines = blocks[i].split('\n');
  113.     let cue = VttTextParser.parseCue_(lines, offset, regions);
  114.     if (cue) {
  115.       ret.push(cue);
  116.     }
  117.     }
  119.   return ret;
  120. };
  123. /**
  124.  * Parses a string into a Region object.
  125.  *
  126.  * @param {string} text
  127.  * @return {!shakaExtern.CueRegion}
  128.  * @private
  129.  */
  130. shaka.text.VttTextParser.parseRegion_ = function(text) {
  131.   const VttTextParser = shaka.text.VttTextParser;
  132.   let parser = new shaka.util.TextParser(text);
  133.   // The region string looks like this:
  134.   // Region: id=fred width=50% lines=3 regionanchor=0%,100%
  135.   //         viewportanchor=10%,90% scroll=up
  136.   let region = new shaka.text.CueRegion();
  138.   // Skip 'Region:'
  139.   parser.readWord();
  140.   parser.skipWhitespace();
  142.   let word = parser.readWord();
  143.   while (word) {
  144.     if (!VttTextParser.parseRegionSetting_(region, word)) {
  145.       shaka.log.warning('VTT parser encountered an invalid VTTRegion setting: ',
  146.                         word,
  147.                         ' The setting will be ignored.');
  148.     }
  149.     parser.skipWhitespace();
  150.     word = parser.readWord();
  151.   }
  153.   return region;
  154. };
  157. /**
  158.  * Parses a text block into a Cue object.
  159.  *
  160.  * @param {!Array.<string>} text
  161.  * @param {number} timeOffset
  162.  * @param {!Array.<!shakaExtern.CueRegion>} regions
  163.  * @return {shaka.text.Cue}
  164.  * @private
  165.  */
  166. shaka.text.VttTextParser.parseCue_ = function(text, timeOffset, regions) {
  167.   const VttTextParser = shaka.text.VttTextParser;
  169.   // Skip empty blocks.
  170.   if (text.length == 1 && !text[0]) {
  171.     return null;
  172.   }
  174.   // Skip comment blocks.
  175.   if (/^NOTE($|[ \t])/.test(text[0])) {
  176.     return null;
  177.   }
  179.   // Skip style blocks.
  180.   if (text[0] == 'STYLE') {
  181.     return null;
  182.   }
  184.   let id = null;
  185.   let index = text[0].indexOf('-->');
  186.   if (index < 0) {
  187.     id = text[0];
  188.     text.splice(0, 1);
  189.   }
  191.   // Parse the times.
  192.   let parser = new shaka.util.TextParser(text[0]);
  193.   let start = VttTextParser.parseTime_(parser);
  194.   let expect = parser.readRegex(/[ \t]+-->[ \t]+/g);
  195.   let end = VttTextParser.parseTime_(parser);
  197.   if (start == null || expect == null || end == null) {
  198.     throw new shaka.util.Error(
  199.         shaka.util.Error.Severity.CRITICAL,
  200.         shaka.util.Error.Category.TEXT,
  201.         shaka.util.Error.Code.INVALID_TEXT_CUE);
  202.   }
  204.   start += timeOffset;
  205.   end += timeOffset;
  207.   // Get the payload.
  208.   let payload = text.slice(1).join('\n').trim();
  210.   let cue = new shaka.text.Cue(start, end, payload);
  212.   // Parse optional settings.
  213.   parser.skipWhitespace();
  214.   let word = parser.readWord();
  215.   while (word) {
  216.     if (!VttTextParser.parseCueSetting(cue, word, regions)) {
  217.       shaka.log.warning('VTT parser encountered an invalid VTT setting: ',
  218.                         word,
  219.                         ' The setting will be ignored.');
  220.     }
  221.     parser.skipWhitespace();
  222.     word = parser.readWord();
  223.   }
  225.   if (id != null) {
  226.     cue.id = id;
  227.   }
  228.   return cue;
  229. };
  232. /**
  233.  * Parses a WebVTT setting from the given word.
  234.  *
  235.  * @param {!shaka.text.Cue} cue
  236.  * @param {string} word
  237.  * @param {!Array.<!shaka.text.CueRegion>} regions
  238.  * @return {boolean} True on success.
  239.  */
  240. shaka.text.VttTextParser.parseCueSetting = function(cue, word, regions) {
  241.   const VttTextParser = shaka.text.VttTextParser;
  242.   let results = null;
  243.   if ((results = /^align:(start|middle|center|end|left|right)$/.exec(word))) {
  244.     VttTextParser.setTextAlign_(cue, results[1]);
  245.   } else if ((results = /^vertical:(lr|rl)$/.exec(word))) {
  246.     VttTextParser.setVerticalWritingDirection_(cue, results[1]);
  247.   } else if ((results = /^size:([\d.]+)%$/.exec(word))) {
  248.     cue.size = Number(results[1]);
  249.   } else if ((results =
  250.       /^position:([\d.]+)%(?:,(line-left|line-right|center|start|end))?$/
  251.       .exec(word))) {
  252.     cue.position = Number(results[1]);
  253.     if (results[2]) {
  254.       VttTextParser.setPositionAlign_(cue, results[2]);
  255.     }
  256.   } else if ((results = /^region:(.*)$/.exec(word))) {
  257.     let region = VttTextParser.getRegionById_(regions, results[1]);
  258.     if (region) {
  259.       cue.region = region;
  260.     }
  261.   } else {
  262.     return VttTextParser.parsedLineValueAndInterpretation_(cue, word);
  263.   }
  265.   return true;
  266. };
  269. /**
  270.  *
  271.  * @param {!Array.<!shaka.text.CueRegion>} regions
  272.  * @param {string} id
  273.  * @return {?shaka.text.CueRegion}
  274.  * @private
  275.  */
  276. shaka.text.VttTextParser.getRegionById_ = function(regions, id) {
  277.   let regionsWithId = regions.filter(function(region) {
  278.     return region.id == id;
  279.   });
  280.   if (!regionsWithId.length) {
  281.     shaka.log.warning('VTT parser could not find a region with id: ',
  282.                   id,
  283.                   ' The region will be ignored.');
  284.     return null;
  285.   }
  286.   goog.asserts.assert(regionsWithId.length == 1,
  287.                       'VTTRegion ids should be unique!');
  289.   return regionsWithId[0];
  290. };
  293. /**
  294.  * Parses a WebVTTRegion setting from the given word.
  295.  *
  296.  * @param {!shaka.text.CueRegion} region
  297.  * @param {string} word
  298.  * @return {boolean} True on success.
  299.  * @private
  300.  */
  301. shaka.text.VttTextParser.parseRegionSetting_ = function(region, word) {
  302.   let results = null;
  303.   if ((results = /^id=(.*)$/.exec(word))) {
  304.     region.id = results[1];
  305.   } else if ((results = /^width=(\d{1,2}|100)%$/.exec(word))) {
  306.     region.width = Number(results[1]);
  307.   } else if ((results = /^lines=(\d+)$/.exec(word))) {
  308.     region.height = Number(results[1]);
  309.     region.heightUnits = shaka.text.CueRegion.units.LINES;
  310.   } else if ((results = /^regionanchor=(\d{1,2}|100)%,(\d{1,2}|100)%$/
  311.             .exec(word))) {
  312.     region.regionAnchorX = Number(results[1]);
  313.     region.regionAnchorY = Number(results[2]);
  314.   } else if ((results = /^viewportanchor=(\d{1,2}|100)%,(\d{1,2}|100)%$/
  315.             .exec(word))) {
  316.     region.viewportAnchorX = Number(results[1]);
  317.     region.viewportAnchorY = Number(results[2]);
  318.   } else if ((results = /^scroll=up$/.exec(word))) {
  319.     region.scroll = shaka.text.CueRegion.scrollMode.UP;
  320.   } else {
  321.     return false;
  322.   }
  324.   return true;
  325. };
  328. /**
  329.  * @param {!shaka.text.Cue} cue
  330.  * @param {string} align
  331.  * @private
  332.  */
  333. shaka.text.VttTextParser.setTextAlign_ = function(cue, align) {
  334.   const Cue = shaka.text.Cue;
  335.   if (align == 'middle') {
  336.     cue.textAlign = Cue.textAlign.CENTER;
  337.   } else {
  338.     goog.asserts.assert(align.toUpperCase() in Cue.textAlign,
  339.                         align.toUpperCase() +
  340.                         ' Should be in Cue.textAlign values!');
  342.     cue.textAlign = Cue.textAlign[align.toUpperCase()];
  343.   }
  344. };
  347. /**
  348.  * @param {!shaka.text.Cue} cue
  349.  * @param {string} align
  350.  * @private
  351.  */
  352. shaka.text.VttTextParser.setPositionAlign_ = function(cue, align) {
  353.   const Cue = shaka.text.Cue;
  354.   if (align == 'line-left' || align == 'start') {
  355.     cue.positionAlign = Cue.positionAlign.LEFT;
  356.   } else if (align == 'line-right' || align == 'end') {
  357.     cue.positionAlign = Cue.positionAlign.RIGHT;
  358.   } else {
  359.     cue.positionAlign = Cue.positionAlign.CENTER;
  360.   }
  361. };
  364. /**
  365.  * @param {!shaka.text.Cue} cue
  366.  * @param {string} value
  367.  * @private
  368.  */
  369. shaka.text.VttTextParser.setVerticalWritingDirection_ = function(cue, value) {
  370.   const Cue = shaka.text.Cue;
  371.   if (value == 'lr') {
  372.     cue.writingDirection = Cue.writingDirection.VERTICAL_LEFT_TO_RIGHT;
  373.   } else {
  374.     cue.writingDirection = Cue.writingDirection.VERTICAL_RIGHT_TO_LEFT;
  375.   }
  376. };
  379. /**
  380.  * @param {!shaka.text.Cue} cue
  381.  * @param {string} word
  382.  * @return {boolean}
  383.  * @private
  384.  */
  385. shaka.text.VttTextParser.parsedLineValueAndInterpretation_ =
  386.     function(cue, word) {
  387.   const Cue = shaka.text.Cue;
  388.   let results = null;
  389.   if ((results = /^line:([\d.]+)%(?:,(start|end|center))?$/.exec(word))) {
  390.     cue.lineInterpretation = Cue.lineInterpretation.PERCENTAGE;
  391.     cue.line = Number(results[1]);
  392.     if (results[2]) {
  393.       goog.asserts.assert(results[2].toUpperCase() in Cue.lineAlign,
  394.                           results[2].toUpperCase() +
  395.                           ' Should be in Cue.lineAlign values!');
  396.       cue.lineAlign = Cue.lineAlign[results[2].toUpperCase()];
  397.     }
  398.   } else if ((results = /^line:(-?\d+)(?:,(start|end|center))?$/.exec(word))) {
  399.     cue.lineInterpretation = Cue.lineInterpretation.LINE_NUMBER;
  400.     cue.line = Number(results[1]);
  401.     if (results[2]) {
  402.       goog.asserts.assert(results[2].toUpperCase() in Cue.lineAlign,
  403.                           results[2].toUpperCase() +
  404.                           ' Should be in Cue.lineAlign values!');
  405.       cue.lineAlign = Cue.lineAlign[results[2].toUpperCase()];
  406.     }
  407.   } else {
  408.     return false;
  409.   }
  411.   return true;
  412. };
  415. /**
  416.  * Parses a WebVTT time from the given parser.
  417.  *
  418.  * @param {!shaka.util.TextParser} parser
  419.  * @return {?number}
  420.  * @private
  421.  */
  422. shaka.text.VttTextParser.parseTime_ = function(parser) {
  423.   // 00:00.000 or 00:00:00.000 or 0:00:00.000
  424.   let results = parser.readRegex(/(?:(\d{1,}):)?(\d{2}):(\d{2})\.(\d{3})/g);
  425.   if (results == null) {
  426.     return null;
  427.   }
  428.   // This capture is optional, but will still be in the array as undefined,
  429.   // in which case it is 0.
  430.   let hours = Number(results[1]) || 0;
  431.   let minutes = Number(results[2]);
  432.   let seconds = Number(results[3]);
  433.   let miliseconds = Number(results[4]);
  434.   if (minutes > 59 || seconds > 59) {
  435.     return null;
  436.   }
  438.   return (miliseconds / 1000) + seconds + (minutes * 60) + (hours * 3600);
  439. };
  442. /**
  443.  * @const {number}
  444.  * @private
  445.  */
  446. shaka.text.VttTextParser.MPEG_TIMESCALE_ = 90000;
  448. shaka.text.TextEngine.registerParser(
  449.     'text/vtt',
  450.     shaka.text.VttTextParser);
  452. shaka.text.TextEngine.registerParser(
  453.     'text/vtt; codecs="vtt"',
  454.     shaka.text.VttTextParser);