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.TextEngine');
  24. goog.require('shaka.util.Error');
  25. goog.require('shaka.util.StringUtils');
  26. goog.require('shaka.util.TextParser');
  30. /**
  31.  * @constructor
  32.  * @implements {shakaExtern.TextParser}
  33.  */
  34. shaka.text.VttTextParser = function() { };
  37. /** @override */
  38. shaka.text.VttTextParser.prototype.parseInit = function(data) {
  39.   goog.asserts.assert(false, 'VTT does not have init segments');
  40. };
  43. /**
  44.  * @override
  45.  * @throws {shaka.util.Error}
  46.  */
  47. shaka.text.VttTextParser.prototype.parseMedia = function(data, time) {
  48.   var VttTextParser = shaka.text.VttTextParser;
  49.   // Get the input as a string.  Normalize newlines to \n.
  50.   var str = shaka.util.StringUtils.fromUTF8(data);
  51.   str = str.replace(/\r\n|\r(?=[^\n]|$)/gm, '\n');
  52.   var blocks = str.split(/\n{2,}/m);
  54.   if (!/^WEBVTT($|[ \t\n])/m.test(blocks[0])) {
  55.     throw new shaka.util.Error(
  56.         shaka.util.Error.Severity.CRITICAL,
  57.         shaka.util.Error.Category.TEXT,
  58.         shaka.util.Error.Code.INVALID_TEXT_HEADER);
  59.   }
  61.   var offset = time.segmentStart;
  62.   // Parse X-TIMESTAMP-MAP metadata header if it's present to get
  63.   // time offset information.
  64.   // https://tools.ietf.org/html/draft-pantos-http-live-streaming-20#section-3.5
  65.   if (blocks[0].indexOf('X-TIMESTAMP-MAP') >= 0) {
  66.     // 'X-TIMESTAMP-MAP' header is used in HLS to align text with
  67.     // the rest of the media.
  68.     // The header format is 'X-TIMESTAMP-MAP=MPEGTS:n,LOCAL:m'
  69.     // (the attributes can go in any order)
  70.     // where n is MPEG-2 time and m is cue time it maps to.
  71.     // For example 'X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000'
  72.     // means an offset of 10 seconds
  73.     // 900000/MPEG_TIMESCALE - cue time.
  74.     var cueTimeMatch =
  75.         blocks[0].match(/LOCAL:((?:(\d{1,}):)?(\d{2}):(\d{2})\.(\d{3}))/m);
  77.     var mpegTimeMatch = blocks[0].match(/MPEGTS:(\d+)/m);
  78.     if (cueTimeMatch && mpegTimeMatch) {
  79.       var parser = new shaka.util.TextParser(cueTimeMatch[1]);
  80.       var cueTime = shaka.text.VttTextParser.parseTime_(parser);
  81.       var mpegTime = Number(mpegTimeMatch[1]);
  82.       var mpegTimescale = shaka.text.VttTextParser.MPEG_TIMESCALE_;
  83.       // Apple-encoded HLS content uses absolute timestamps, so assume
  84.       // the presence of the map tag means the content uses absolute
  85.       // timestamps.
  86.       offset = time.periodStart + (mpegTime / mpegTimescale - cueTime);
  87.     }
  88.   }
  90.   var ret = [];
  91.   for (var i = 1; i < blocks.length; i++) {
  92.     var lines = blocks[i].split('\n');
  93.     var cue = VttTextParser.parseCue_(lines, offset);
  94.     if (cue)
  95.       ret.push(cue);
  96.   }
  98.   return ret;
  99. };
  102. /**
  103.  * Parses a text block into a Cue object.
  104.  *
  105.  * @param {!Array.<string>} text
  106.  * @param {number} timeOffset
  107.  * @return {shaka.text.Cue}
  108.  * @private
  109.  */
  110. shaka.text.VttTextParser.parseCue_ = function(text, timeOffset) {
  111.   // Skip empty blocks.
  112.   if (text.length == 1 && !text[0])
  113.     return null;
  115.   // Skip comment blocks.
  116.   if (/^NOTE($|[ \t])/.test(text[0]))
  117.     return null;
  119.   var id = null;
  120.   var index = text[0].indexOf('-->');
  121.   if (index < 0) {
  122.     id = text[0];
  123.     text.splice(0, 1);
  124.   }
  126.   // Parse the times.
  127.   var parser = new shaka.util.TextParser(text[0]);
  128.   var start = shaka.text.VttTextParser.parseTime_(parser);
  129.   var expect = parser.readRegex(/[ \t]+-->[ \t]+/g);
  130.   var end = shaka.text.VttTextParser.parseTime_(parser);
  132.   if (start == null || expect == null || end == null) {
  133.     throw new shaka.util.Error(
  134.         shaka.util.Error.Severity.CRITICAL,
  135.         shaka.util.Error.Category.TEXT,
  136.         shaka.util.Error.Code.INVALID_TEXT_CUE);
  137.   }
  139.   start += timeOffset;
  140.   end += timeOffset;
  142.   // Get the payload.
  143.   var payload = text.slice(1).join('\n').trim();
  145.   var cue = new shaka.text.Cue(start, end, payload);
  147.   // Parse optional settings.
  148.   parser.skipWhitespace();
  149.   var word = parser.readWord();
  150.   while (word) {
  151.     if (!shaka.text.VttTextParser.parseSetting(cue, word)) {
  152.       shaka.log.warning('VTT parser encountered an invalid VTT setting: ',
  153.                         word,
  154.                         ' The setting will be ignored.');
  155.     }
  156.     parser.skipWhitespace();
  157.     word = parser.readWord();
  158.   }
  160.   if (id != null)
  161.     cue.id = id;
  162.   return cue;
  163. };
  166. /**
  167.  * Parses a WebVTT setting from the given word.
  168.  *
  169.  * @param {!shaka.text.Cue} cue
  170.  * @param {string} word
  171.  * @return {boolean} True on success.
  172.  */
  173. shaka.text.VttTextParser.parseSetting = function(cue, word) {
  174.   var VttTextParser = shaka.text.VttTextParser;
  175.   var results = null;
  176.   if ((results = /^align:(start|middle|center|end|left|right)$/.exec(word))) {
  177.     VttTextParser.setTextAlign_(cue, results[1]);
  178.   } else if ((results = /^vertical:(lr|rl)$/.exec(word))) {
  179.     VttTextParser.setVerticalWritingDirection_(cue, results[1]);
  180.   } else if ((results = /^size:([\d\.]+)%$/.exec(word))) {
  181.     cue.size = Number(results[1]);
  182.   } else if ((results =
  183.       /^position:([\d\.]+)%(?:,(line-left|line-right|center|start|end))?$/
  184.       .exec(word))) {
  185.     cue.position = Number(results[1]);
  186.     if (results[2]) {
  187.       VttTextParser.setPositionAlign_(cue, results[2]);
  188.     }
  189.   } else {
  190.     return VttTextParser.parsedLineValueAndInterpretation_(cue, word);
  191.   }
  193.   return true;
  194. };
  197. /**
  198.  * @param {!shaka.text.Cue} cue
  199.  * @param {!string} align
  200.  * @private
  201.  */
  202. shaka.text.VttTextParser.setTextAlign_ = function(cue, align) {
  203.   var Cue = shaka.text.Cue;
  204.   if (align == 'middle') {
  205.     cue.textAlign = Cue.textAlign.CENTER;
  206.   } else {
  207.     goog.asserts.assert(align.toUpperCase() in Cue.textAlign,
  208.                         align.toUpperCase() +
  209.                         ' Should be in Cue.textAlign values!');
  211.     cue.textAlign = Cue.textAlign[align.toUpperCase()];
  212.   }
  213. };
  216. /**
  217.  * @param {!shaka.text.Cue} cue
  218.  * @param {!string} align
  219.  * @private
  220.  */
  221. shaka.text.VttTextParser.setPositionAlign_ = function(cue, align) {
  222.   var Cue = shaka.text.Cue;
  223.   if (align == 'line-left' || align == 'start')
  224.     cue.positionAlign = Cue.positionAlign.LEFT;
  225.   else if (align == 'line-right' || align == 'end')
  226.     cue.positionAlign = Cue.positionAlign.RIGHT;
  227.   else
  228.     cue.positionAlign = Cue.positionAlign.CENTER;
  229. };
  232. /**
  233.  * @param {!shaka.text.Cue} cue
  234.  * @param {!string} value
  235.  * @private
  236.  */
  237. shaka.text.VttTextParser.setVerticalWritingDirection_ = function(cue, value) {
  238.   var Cue = shaka.text.Cue;
  239.   if (value == 'lr')
  240.     cue.writingDirection = Cue.writingDirection.VERTICAL_LEFT_TO_RIGHT;
  241.   else
  242.     cue.writingDirection = Cue.writingDirection.VERTICAL_RIGHT_TO_LEFT;
  243. };
  246. /**
  247.  * @param {!shaka.text.Cue} cue
  248.  * @param {!string} word
  249.  * @return {boolean}
  250.  * @private
  251.  */
  252. shaka.text.VttTextParser.parsedLineValueAndInterpretation_ =
  253.     function(cue, word) {
  254.   var Cue = shaka.text.Cue;
  255.   var results = null;
  256.   if ((results = /^line:([\d\.]+)%(?:,(start|end|center))?$/.exec(word))) {
  257.     cue.lineInterpretation = Cue.lineInterpretation.PERCENTAGE;
  258.     cue.line = Number(results[1]);
  259.     if (results[2]) {
  260.       goog.asserts.assert(results[2].toUpperCase() in Cue.lineAlign,
  261.                           results[2].toUpperCase() +
  262.                           ' Should be in Cue.lineAlign values!');
  263.       cue.lineAlign = Cue.lineAlign[results[2].toUpperCase()];
  264.     }
  265.   } else if ((results = /^line:(-?\d+)(?:,(start|end|center))?$/.exec(word))) {
  266.     cue.lineInterpretation = Cue.lineInterpretation.LINE_NUMBER;
  267.     cue.line = Number(results[1]);
  268.     if (results[2]) {
  269.       goog.asserts.assert(results[2].toUpperCase() in Cue.lineAlign,
  270.                           results[2].toUpperCase() +
  271.                           ' Should be in Cue.lineAlign values!');
  272.       cue.lineAlign = Cue.lineAlign[results[2].toUpperCase()];
  273.     }
  274.   } else {
  275.     return false;
  276.   }
  278.   return true;
  279. };
  282. /**
  283.  * Parses a WebVTT time from the given parser.
  284.  *
  285.  * @param {!shaka.util.TextParser} parser
  286.  * @return {?number}
  287.  * @private
  288.  */
  289. shaka.text.VttTextParser.parseTime_ = function(parser) {
  290.   // 00:00.000 or 00:00:00.000 or 0:00:00.000
  291.   var results = parser.readRegex(/(?:(\d{1,}):)?(\d{2}):(\d{2})\.(\d{3})/g);
  292.   if (results == null)
  293.     return null;
  294.   // This capture is optional, but will still be in the array as undefined,
  295.   // default to 0.
  296.   var hours = Number(results[1]) || 0;
  297.   var minutes = Number(results[2]);
  298.   var seconds = Number(results[3]);
  299.   var miliseconds = Number(results[4]);
  300.   if (minutes > 59 || seconds > 59)
  301.     return null;
  303.   return (miliseconds / 1000) + seconds + (minutes * 60) + (hours * 3600);
  304. };
  307. /**
  308.  * @const {number}
  309.  * @private
  310.  */
  311. shaka.text.VttTextParser.MPEG_TIMESCALE_ = 90000;
  313. shaka.text.TextEngine.registerParser(
  314.     'text/vtt',
  315.     shaka.text.VttTextParser);
  317. shaka.text.TextEngine.registerParser(
  318.     'text/vtt; codecs="vtt"',
  319.     shaka.text.VttTextParser);