Source: lib/text/vtt_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.text.VttTextParser');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.log');
  11. goog.require('shaka.media.ManifestParser');
  12. goog.require('shaka.text.Cue');
  13. goog.require('shaka.text.CueRegion');
  14. goog.require('shaka.text.TextEngine');
  15. goog.require('shaka.util.Error');
  16. goog.require('shaka.util.StringUtils');
  17. goog.require('shaka.util.TextParser');
  18. goog.require('shaka.util.TXml');
  21. /**
  22.  * @implements {shaka.extern.TextParser}
  23.  * @export
  24.  */
  25. shaka.text.VttTextParser = class {
  26.   /** Constructs a VTT parser. */
  27.   constructor() {
  28.     /** @private {boolean} */
  29.     this.sequenceMode_ = false;
  31.     /** @private {string} */
  32.     this.manifestType_ = shaka.media.ManifestParser.UNKNOWN;
  33.   }
  35.   /**
  36.    * @override
  37.    * @export
  38.    */
  39.   parseInit(data) {
  40.     goog.asserts.assert(false, 'VTT does not have init segments');
  41.   }
  43.   /**
  44.    * @override
  45.    * @export
  46.    */
  47.   setSequenceMode(sequenceMode) {
  48.     this.sequenceMode_ = sequenceMode;
  49.   }
  51.   /**
  52.    * @override
  53.    * @export
  54.    */
  55.   setManifestType(manifestType) {
  56.     this.manifestType_ = manifestType;
  57.   }
  59.   /**
  60.    * @override
  61.    * @export
  62.    */
  63.   parseMedia(data, time) {
  64.     const VttTextParser = shaka.text.VttTextParser;
  65.     // Get the input as a string.  Normalize newlines to \n.
  66.     let str = shaka.util.StringUtils.fromUTF8(data);
  67.     str = str.replace(/\r\n|\r(?=[^\n]|$)/gm, '\n');
  68.     const blocks = str.split(/\n{2,}/m);
  70.     if (!/^WEBVTT($|[ \t\n])/m.test(blocks[0])) {
  71.       throw new shaka.util.Error(
  72.           shaka.util.Error.Severity.CRITICAL,
  73.           shaka.util.Error.Category.TEXT,
  74.           shaka.util.Error.Code.INVALID_TEXT_HEADER);
  75.     }
  77.     // Depending on "segmentRelativeVttTiming" configuration,
  78.     // "vttOffset" will correspond to either "periodStart" (default)
  79.     // or "segmentStart", for segmented VTT where timings are relative
  80.     // to the beginning of each segment.
  81.     // NOTE: "periodStart" is the timestamp offset applied via TextEngine.
  82.     // It is no longer closely tied to periods, but the name stuck around.
  83.     // NOTE: This offset and the flag choosing its meaning have no effect on
  84.     // HLS content, which should use X-TIMESTAMP-MAP and periodStart instead.
  85.     let offset = time.vttOffset;
  87.     // Only use 'X-TIMESTAMP-MAP' with HLS.  This overrides offset above.
  88.     if (blocks[0].includes('X-TIMESTAMP-MAP') &&
  89.         this.manifestType_ == shaka.media.ManifestParser.HLS) {
  90.       if (this.sequenceMode_) {
  91.         // Compute a different, rollover-based offset for sequence mode.
  92.         offset = this.computeHlsSequenceModeOffset_(blocks[0], time);
  93.       } else {
  94.         // Calculate the offset from the segment startTime.
  95.         offset = time.segmentStart;
  96.       }
  97.     }
  99.     // Parse VTT regions.
  100.     /* !Array.<!shaka.text.CueRegion> */
  101.     const regions = [];
  102.     for (const line of blocks[0].split('\n')) {
  103.       if (/^Region:/.test(line)) {
  104.         const region = VttTextParser.parseRegion_(line);
  105.         regions.push(region);
  106.       }
  107.     }
  109.     /** @type {!Map.<string, shaka.text.Cue>} */
  110.     const styles = new Map();
  111.     VttTextParser.addDefaultTextColor_(styles);
  113.     // Parse cues.
  114.     const ret = [];
  115.     for (const block of blocks.slice(1)) {
  116.       const lines = block.split('\n');
  117.       VttTextParser.parseStyle_(lines, styles);
  118.       const cue = VttTextParser.parseCue_(lines, offset, regions, styles);
  119.       if (cue) {
  120.         ret.push(cue);
  121.       }
  122.     }
  124.     return ret;
  125.   }
  127.   /**
  128.    * @param {string} headerBlock Contains X-TIMESTAMP-MAP.
  129.    * @param {shaka.extern.TextParser.TimeContext} time
  130.    * @return {number}
  131.    * @private
  132.    */
  133.   computeHlsSequenceModeOffset_(headerBlock, time) {
  134.     // https://bit.ly/2K92l7y
  135.     // The 'X-TIMESTAMP-MAP' header is used in HLS to align text with
  136.     // the rest of the media.
  137.     // The header format is 'X-TIMESTAMP-MAP=MPEGTS:n,LOCAL:m'
  138.     // (the attributes can go in any order)
  139.     // where n is MPEG-2 time and m is cue time it maps to.
  140.     // For example 'X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000'
  141.     // means an offset of 10 seconds
  142.     // 900000/MPEG_TIMESCALE - cue time.
  143.     const cueTimeMatch = headerBlock.match(
  144.         /LOCAL:((?:(\d{1,}):)?(\d{2}):(\d{2})\.(\d{3}))/m);
  145.     const mpegTimeMatch = headerBlock.match(/MPEGTS:(\d+)/m);
  147.     if (!cueTimeMatch || !mpegTimeMatch) {
  148.       throw new shaka.util.Error(
  149.           shaka.util.Error.Severity.CRITICAL,
  150.           shaka.util.Error.Category.TEXT,
  151.           shaka.util.Error.Code.INVALID_TEXT_HEADER);
  152.     }
  154.     const parser = new shaka.util.TextParser(cueTimeMatch[1]);
  155.     const cueTime = shaka.text.VttTextParser.parseTime_(parser);
  156.     if (cueTime == null) {
  157.       throw new shaka.util.Error(
  158.           shaka.util.Error.Severity.CRITICAL,
  159.           shaka.util.Error.Category.TEXT,
  160.           shaka.util.Error.Code.INVALID_TEXT_HEADER);
  161.     }
  163.     let mpegTime = Number(mpegTimeMatch[1]);
  164.     const mpegTimescale = shaka.text.VttTextParser.MPEG_TIMESCALE_;
  166.     const rolloverSeconds =
  167.         shaka.text.VttTextParser.TS_ROLLOVER_ / mpegTimescale;
  168.     let segmentStart = time.segmentStart - time.periodStart;
  169.     while (segmentStart >= rolloverSeconds) {
  170.       segmentStart -= rolloverSeconds;
  171.       mpegTime += shaka.text.VttTextParser.TS_ROLLOVER_;
  172.     }
  174.     return time.periodStart + mpegTime / mpegTimescale - cueTime;
  175.   }
  177.   /**
  178.    * Add default color
  179.    *
  180.    * @param {!Map.<string, shaka.text.Cue>} styles
  181.    * @private
  182.    */
  183.   static addDefaultTextColor_(styles) {
  184.     const textColor = shaka.text.Cue.defaultTextColor;
  185.     for (const [key, value] of Object.entries(textColor)) {
  186.       const cue = new shaka.text.Cue(0, 0, '');
  187.       cue.color = value;
  188.       styles.set('.' + key, cue);
  189.     }
  191.     const bgColor = shaka.text.Cue.defaultTextBackgroundColor;
  192.     for (const [key, value] of Object.entries(bgColor)) {
  193.       const cue = new shaka.text.Cue(0, 0, '');
  194.       cue.backgroundColor = value;
  195.       styles.set('.' + key, cue);
  196.     }
  197.   }
  199.   /**
  200.    * Parses a string into a Region object.
  201.    *
  202.    * @param {string} text
  203.    * @return {!shaka.text.CueRegion}
  204.    * @private
  205.    */
  206.   static parseRegion_(text) {
  207.     const VttTextParser = shaka.text.VttTextParser;
  208.     const parser = new shaka.util.TextParser(text);
  209.     // The region string looks like this:
  210.     // Region: id=fred width=50% lines=3 regionanchor=0%,100%
  211.     //         viewportanchor=10%,90% scroll=up
  212.     const region = new shaka.text.CueRegion();
  214.     // Skip 'Region:'
  215.     parser.readWord();
  216.     parser.skipWhitespace();
  218.     let word = parser.readWord();
  219.     while (word) {
  220.       if (!VttTextParser.parseRegionSetting_(region, word)) {
  221.         shaka.log.warning(
  222.             'VTT parser encountered an invalid VTTRegion setting: ', word,
  223.             ' The setting will be ignored.');
  224.       }
  225.       parser.skipWhitespace();
  226.       word = parser.readWord();
  227.     }
  229.     return region;
  230.   }
  232.   /**
  233.    * Parses a style block into a Cue object.
  234.    *
  235.    * @param {!Array.<string>} text
  236.    * @param {!Map.<string, shaka.text.Cue>} styles
  237.    * @private
  238.    */
  239.   static parseStyle_(text, styles) {
  240.     // Skip empty blocks.
  241.     if (text.length == 1 && !text[0]) {
  242.       return;
  243.     }
  245.     // Skip comment blocks.
  246.     if (/^NOTE($|[ \t])/.test(text[0])) {
  247.       return;
  248.     }
  250.     // Only style block are allowed.
  251.     if (text[0] != 'STYLE') {
  252.       return;
  253.     }
  255.     /** @type {!Array.<!Array.<string>>} */
  256.     const styleBlocks = [];
  257.     let lastBlockIndex = -1;
  258.     for (let i = 1; i < text.length; i++) {
  259.       if (text[i].includes('::cue')) {
  260.         styleBlocks.push([]);
  261.         lastBlockIndex = styleBlocks.length - 1;
  262.       }
  263.       if (lastBlockIndex == -1) {
  264.         continue;
  265.       }
  266.       styleBlocks[lastBlockIndex].push(text[i]);
  267.       if (text[i].includes('}')) {
  268.         lastBlockIndex = -1;
  269.       }
  270.     }
  272.     for (const styleBlock of styleBlocks) {
  273.       let styleSelector = 'global';
  274.       // Look for what is within parentheses. For example:
  275.       // <code>:: cue (b) {</code>, what we are looking for is <code>b</code>
  276.       const selector = styleBlock[0].match(/\((.*)\)/);
  277.       if (selector) {
  278.         styleSelector = selector.pop();
  279.       }
  281.       // We start at 1 to avoid '::cue' and end earlier to avoid '}'
  282.       let propertyLines = styleBlock.slice(1, -1);
  283.       if (styleBlock[0].includes('}')) {
  284.         const payload = /\{(.*?)\}/.exec(styleBlock[0]);
  285.         if (payload) {
  286.           propertyLines = payload[1].split(';');
  287.         }
  288.       }
  290.       // Continue styles over multiple selectors if necessary.
  291.       // For example,
  292.       //   ::cue(b) { background: white; } ::cue(b) { color: blue; }
  293.       // should set both the background and foreground of bold tags.
  294.       let cue = styles.get(styleSelector);
  295.       if (!cue) {
  296.         cue = new shaka.text.Cue(0, 0, '');
  297.       }
  299.       let validStyle = false;
  300.       for (let i = 0; i < propertyLines.length; i++) {
  301.         // We look for CSS properties. As a general rule they are separated by
  302.         // <code>:</code>. Eg: <code>color: red;</code>
  303.         const lineParts = /^\s*([^:]+):\s*(.*)/.exec(propertyLines[i]);
  304.         if (lineParts) {
  305.           const name = lineParts[1].trim();
  306.           const value = lineParts[2].trim().replace(';', '');
  307.           switch (name) {
  308.             case 'background-color':
  309.             case 'background':
  310.               validStyle = true;
  311.               cue.backgroundColor = value;
  312.               break;
  313.             case 'color':
  314.               validStyle = true;
  315.               cue.color = value;
  316.               break;
  317.             case 'font-family':
  318.               validStyle = true;
  319.               cue.fontFamily = value;
  320.               break;
  321.             case 'font-size':
  322.               validStyle = true;
  323.               cue.fontSize = value;
  324.               break;
  325.             case 'font-weight':
  326.               if (parseInt(value, 10) >= 700 || value == 'bold') {
  327.                 validStyle = true;
  328.                 cue.fontWeight = shaka.text.Cue.fontWeight.BOLD;
  329.               }
  330.               break;
  331.             case 'font-style':
  332.               switch (value) {
  333.                 case 'normal':
  334.                   validStyle = true;
  335.                   cue.fontStyle = shaka.text.Cue.fontStyle.NORMAL;
  336.                   break;
  337.                 case 'italic':
  338.                   validStyle = true;
  339.                   cue.fontStyle = shaka.text.Cue.fontStyle.ITALIC;
  340.                   break;
  341.                 case 'oblique':
  342.                   validStyle = true;
  343.                   cue.fontStyle = shaka.text.Cue.fontStyle.OBLIQUE;
  344.                   break;
  345.               }
  346.               break;
  347.             case 'opacity':
  348.               validStyle = true;
  349.               cue.opacity = parseFloat(value);
  350.               break;
  351.             case 'text-combine-upright':
  352.               validStyle = true;
  353.               cue.textCombineUpright = value;
  354.               break;
  355.             case 'text-shadow':
  356.               validStyle = true;
  357.               cue.textShadow = value;
  358.               break;
  359.             case 'white-space':
  360.               validStyle = true;
  361.               cue.wrapLine = value != 'noWrap';
  362.               break;
  363.             default:
  364.               shaka.log.warning('VTT parser encountered an unsupported style: ',
  365.                   lineParts);
  366.               break;
  367.           }
  368.         }
  369.       }
  371.       if (validStyle) {
  372.         styles.set(styleSelector, cue);
  373.       }
  374.     }
  375.   }
  377.   /**
  378.    * Parses a text block into a Cue object.
  379.    *
  380.    * @param {!Array.<string>} text
  381.    * @param {number} timeOffset
  382.    * @param {!Array.<!shaka.text.CueRegion>} regions
  383.    * @param {!Map.<string, shaka.text.Cue>} styles
  384.    * @return {shaka.text.Cue}
  385.    * @private
  386.    */
  387.   static parseCue_(text, timeOffset, regions, styles) {
  388.     const VttTextParser = shaka.text.VttTextParser;
  390.     // Skip empty blocks.
  391.     if (text.length == 1 && !text[0]) {
  392.       return null;
  393.     }
  395.     // Skip comment blocks.
  396.     if (/^NOTE($|[ \t])/.test(text[0])) {
  397.       return null;
  398.     }
  400.     // Skip style and region blocks.
  401.     if (text[0] == 'STYLE' || text[0] == 'REGION') {
  402.       return null;
  403.     }
  405.     let id = null;
  406.     if (!text[0].includes('-->')) {
  407.       id = text[0];
  408.       text.splice(0, 1);
  409.     }
  411.     // Parse the times.
  412.     const parser = new shaka.util.TextParser(text[0]);
  413.     let start = VttTextParser.parseTime_(parser);
  414.     const expect = parser.readRegex(/[ \t]+-->[ \t]+/g);
  415.     let end = VttTextParser.parseTime_(parser);
  417.     if (start == null || expect == null || end == null) {
  418.       shaka.log.alwaysWarn(
  419.           'Failed to parse VTT time code. Cue skipped:', id, text);
  420.       return null;
  421.     }
  423.     start += timeOffset;
  424.     end += timeOffset;
  426.     // Get the payload.
  427.     const payload = text.slice(1).join('\n').trim();
  429.     let cue = null;
  430.     if (styles.has('global')) {
  431.       cue = styles.get('global').clone();
  432.       cue.startTime = start;
  433.       cue.endTime = end;
  434.       cue.payload = '';
  435.     } else {
  436.       cue = new shaka.text.Cue(start, end, '');
  437.     }
  439.     // Parse optional settings.
  440.     parser.skipWhitespace();
  441.     let word = parser.readWord();
  442.     while (word) {
  443.       if (!VttTextParser.parseCueSetting(cue, word, regions)) {
  444.         shaka.log.warning('VTT parser encountered an invalid VTT setting: ',
  445.             word,
  446.             ' The setting will be ignored.');
  447.       }
  448.       parser.skipWhitespace();
  449.       word = parser.readWord();
  450.     }
  452.     VttTextParser.parseCueStyles(payload, cue, styles);
  454.     if (id != null) {
  455.       cue.id = id;
  456.     }
  457.     return cue;
  458.   }
  460.   /**
  461.    * Parses a WebVTT styles from the given payload.
  462.    *
  463.    * @param {string} payload
  464.    * @param {!shaka.text.Cue} rootCue
  465.    * @param {!Map.<string, shaka.text.Cue>} styles
  466.    */
  467.   static parseCueStyles(payload, rootCue, styles) {
  468.     const VttTextParser = shaka.text.VttTextParser;
  469.     const StringUtils = shaka.util.StringUtils;
  470.     const TXml = shaka.util.TXml;
  471.     // Optimization for unstyled payloads.
  472.     if (!payload.includes('<')) {
  473.       rootCue.payload = StringUtils.htmlUnescape(payload);
  474.       return;
  475.     }
  476.     if (styles.size === 0) {
  477.       VttTextParser.addDefaultTextColor_(styles);
  478.     }
  480.     payload = VttTextParser.replaceKaraokeStylePayload_(payload);
  481.     payload = VttTextParser.replaceVoiceStylePayload_(payload);
  482.     payload = VttTextParser.escapeInvalidChevrons_(payload);
  483.     const xmlPayload = '<span>' + payload + '</span>';
  484.     let element;
  485.     try {
  486.       element = TXml.parseXmlString(xmlPayload, 'span');
  487.     } catch (e) {
  488.       shaka.log.warning('cue parse fail: ', e);
  489.     }
  491.     if (element) {
  492.       const childNodes = element.children;
  493.       if (childNodes.length == 1) {
  494.         const childNode = childNodes[0];
  495.         if (!TXml.isNode(childNode)) {
  496.           rootCue.payload = StringUtils.htmlUnescape(payload);
  497.           return;
  498.         }
  499.       }
  500.       for (const childNode of childNodes) {
  501.         VttTextParser.generateCueFromElement_(childNode, rootCue, styles);
  502.       }
  503.     } else {
  504.       shaka.log.warning('The cue\'s markup could not be parsed: ', payload);
  505.       rootCue.payload = StringUtils.htmlUnescape(payload);
  506.     }
  507.   }
  509.   /**
  510.    * This method converts invalid > chevrons to HTML entities.
  511.    * It also removes < chevrons as per spec.
  512.    *
  513.    * @param {!string} input
  514.    * @return {string}
  515.    * @private
  516.    */
  517.   static escapeInvalidChevrons_(input) {
  518.     // Used to map HTML entities to characters.
  519.     const htmlEscapes = {
  520.       '< ': '',
  521.       ' >': ' &gt;',
  522.     };
  524.     const reEscapedHtml = /(< +>|<\s|\s>)/g;
  525.     const reHasEscapedHtml = RegExp(reEscapedHtml.source);
  526.     // This check is an optimization, since replace always makes a copy
  527.     if (input && reHasEscapedHtml.test(input)) {
  528.       return input.replace(reEscapedHtml, (entity) => {
  529.         return htmlEscapes[entity] || '';
  530.       });
  531.     }
  532.     return input || '';
  533.   }
  535.   /**
  536.    * Converts voice style tag to be valid for xml parsing
  537.    * For example,
  538.    * input: <v Shaka>Test
  539.    * output: <v.voice-Shaka>Test</v.voice-Shaka>
  540.    *
  541.    * @param {string} payload
  542.    * @return {string} processed payload
  543.    * @private
  544.    */
  545.   static replaceVoiceStylePayload_(payload) {
  546.     const voiceTag = 'v';
  547.     const names = [];
  548.     let nameStart = -1;
  549.     let newPayload = '';
  550.     let hasVoiceEndTag = false;
  551.     for (let i = 0; i < payload.length; i++) {
  552.       // This condition is used to manage tags that have end tags.
  553.       if (payload[i] === '/') {
  554.         const end = payload.indexOf('>', i);
  555.         if (end === -1) {
  556.           return payload;
  557.         }
  558.         const tagEnd = payload.substring(i + 1, end);
  559.         if (!tagEnd || tagEnd != voiceTag) {
  560.           newPayload += payload[i];
  561.           continue;
  562.         }
  563.         hasVoiceEndTag = true;
  564.         let tagStart = null;
  565.         if (names.length) {
  566.           tagStart = names[names.length -1];
  567.         }
  568.         if (!tagStart) {
  569.           newPayload += payload[i];
  570.         } else if (tagStart === tagEnd) {
  571.           newPayload += '/' + tagEnd + '>';
  572.           i += tagEnd.length + 1;
  573.         } else {
  574.           if (!tagStart.startsWith(voiceTag)) {
  575.             newPayload += payload[i];
  576.             continue;
  577.           }
  578.           newPayload += '/' + tagStart + '>';
  579.           i += tagEnd.length + 1;
  580.         }
  581.       } else {
  582.         // Here we only want the tag name, not any other payload.
  583.         if (payload[i] === '<') {
  584.           nameStart = i + 1;
  585.           if (payload[nameStart] != voiceTag) {
  586.             nameStart = -1;
  587.           }
  588.         } else if (payload[i] === '>') {
  589.           if (nameStart > 0) {
  590.             names.push(payload.substr(nameStart, i - nameStart));
  591.             nameStart = -1;
  592.           }
  593.         }
  594.         newPayload += payload[i];
  595.       }
  596.     }
  597.     for (const name of names) {
  598.       const newName = name.replace(' ', '.voice-');
  599.       newPayload = newPayload.replace(`<${name}>`, `<${newName}>`);
  600.       newPayload = newPayload.replace(`</${name}>`, `</${newName}>`);
  601.       if (!hasVoiceEndTag) {
  602.         newPayload += `</${newName}>`;
  603.       }
  604.     }
  605.     return newPayload;
  606.   }
  608.   /**
  609.    * Converts karaoke style tag to be valid for xml parsing
  610.    * For example,
  611.    * input: Text <00:00:00.450> time <00:00:01.450> 1
  612.    * output: Text <div time="00:00:00.450"> time
  613.    *         <div time="00:00:01.450"> 1</div></div>
  614.    *
  615.    * @param {string} payload
  616.    * @return {string} processed payload
  617.    * @private
  618.    */
  619.   static replaceKaraokeStylePayload_(payload) {
  620.     const names = [];
  621.     let nameStart = -1;
  622.     for (let i = 0; i < payload.length; i++) {
  623.       if (payload[i] === '<') {
  624.         nameStart = i + 1;
  625.       } else if (payload[i] === '>') {
  626.         if (nameStart > 0) {
  627.           const name = payload.substr(nameStart, i - nameStart);
  628.           if (name.match(shaka.text.VttTextParser.timeFormat_)) {
  629.             names.push(name);
  630.           }
  631.           nameStart = -1;
  632.         }
  633.       }
  634.     }
  635.     let newPayload = payload;
  636.     for (const name of names) {
  637.       const replaceTag = '<' + name + '>';
  638.       const startTag = '<div time="' + name + '">';
  639.       const endTag = '</div>';
  640.       newPayload = newPayload.replace(replaceTag, startTag);
  641.       newPayload += endTag;
  642.     }
  643.     return newPayload;
  644.   }
  646.   /**
  647.    * @param {string} value
  648.    * @param {string} defaultValue
  649.    * @private
  650.    */
  651.   static getOrDefault_(value, defaultValue) {
  652.     if (value && value.length > 0) {
  653.       return value;
  654.     }
  655.     return defaultValue;
  656.   }
  658.   /**
  659.    * Merges values created in parseStyle_
  660.    * @param {!shaka.text.Cue} cue
  661.    * @param {shaka.text.Cue} refCue
  662.    * @private
  663.    */
  664.   static mergeStyle_(cue, refCue) {
  665.     if (!refCue) {
  666.       return;
  667.     }
  669.     const VttTextParser = shaka.text.VttTextParser;
  670.     // Overwrites if new value string length > 0
  671.     cue.backgroundColor = VttTextParser.getOrDefault_(
  672.         refCue.backgroundColor, cue.backgroundColor);
  673.     cue.color = VttTextParser.getOrDefault_(
  674.         refCue.color, cue.color);
  675.     cue.fontFamily = VttTextParser.getOrDefault_(
  676.         refCue.fontFamily, cue.fontFamily);
  677.     cue.fontSize = VttTextParser.getOrDefault_(
  678.         refCue.fontSize, cue.fontSize);
  679.     cue.textShadow = VttTextParser.getOrDefault_(
  680.         refCue.textShadow, cue.textShadow);
  682.     // Overwrite with new values as unable to determine
  683.     // if new value is set or not
  684.     cue.fontWeight = refCue.fontWeight;
  685.     cue.fontStyle = refCue.fontStyle;
  686.     cue.opacity = refCue.opacity;
  687.     cue.rubyTag = refCue.rubyTag;
  688.     cue.textCombineUpright = refCue.textCombineUpright;
  689.     cue.wrapLine = refCue.wrapLine;
  690.   }
  692.   /**
  693.    * @param {!shaka.extern.xml.Node} element
  694.    * @param {!shaka.text.Cue} rootCue
  695.    * @param {!Map.<string, shaka.text.Cue>} styles
  696.    * @private
  697.    */
  698.   static generateCueFromElement_(element, rootCue, styles) {
  699.     const VttTextParser = shaka.text.VttTextParser;
  700.     const TXml = shaka.util.TXml;
  701.     const nestedCue = rootCue.clone();
  702.     // We don't want propagate some properties.
  703.     nestedCue.nestedCues = [];
  704.     nestedCue.payload = '';
  705.     nestedCue.rubyTag = '';
  706.     // We don't want propagate some position settings
  707.     nestedCue.line = null;
  708.     nestedCue.region = new shaka.text.CueRegion();
  709.     nestedCue.position = null;
  710.     nestedCue.size = 0;
  712.     if (shaka.util.TXml.isNode(element)) {
  713.       const bold = shaka.text.Cue.fontWeight.BOLD;
  714.       const italic = shaka.text.Cue.fontStyle.ITALIC;
  715.       const underline = shaka.text.Cue.textDecoration.UNDERLINE;
  716.       const tags = element.tagName.split(/(?=[ .])+/g);
  717.       for (const tag of tags) {
  718.         let styleTag = tag;
  719.         // White blanks at start indicate that the style is a voice
  720.         if (styleTag.startsWith('.voice-')) {
  721.           const voice = styleTag.split('-').pop();
  722.           styleTag = `v[voice="${voice}"]`;
  723.           // The specification allows to have quotes and not, so we check to
  724.           // see which one is being used.
  725.           if (!styles.has(styleTag)) {
  726.             styleTag = `v[voice=${voice}]`;
  727.           }
  728.         }
  729.         if (styles.has(styleTag)) {
  730.           VttTextParser.mergeStyle_(nestedCue, styles.get(styleTag));
  731.         }
  732.         switch (tag) {
  733.           case 'br': {
  734.             const lineBreakCue = shaka.text.Cue.lineBreak(
  735.                 nestedCue.startTime, nestedCue.endTime);
  736.             rootCue.nestedCues.push(lineBreakCue);
  737.             return;
  738.           }
  739.           case 'b':
  740.             nestedCue.fontWeight = bold;
  741.             break;
  742.           case 'i':
  743.             nestedCue.fontStyle = italic;
  744.             break;
  745.           case 'u':
  746.             nestedCue.textDecoration.push(underline);
  747.             break;
  748.           case 'font': {
  749.             const color = element.attributes['color'];
  750.             if (color) {
  751.               nestedCue.color = color;
  752.             }
  753.             break;
  754.           }
  755.           case 'div': {
  756.             const time = element.attributes['time'];
  757.             if (!time) {
  758.               break;
  759.             }
  760.             const parser = new shaka.util.TextParser(time);
  761.             const cueTime = shaka.text.VttTextParser.parseTime_(parser);
  762.             if (cueTime) {
  763.               nestedCue.startTime = cueTime;
  764.             }
  765.             break;
  766.           }
  767.           case 'ruby':
  768.           case 'rp':
  769.           case 'rt':
  770.             nestedCue.rubyTag = tag;
  771.             break;
  772.           default:
  773.             break;
  774.         }
  775.       }
  776.     }
  778.     const isTextNode = (item) => shaka.util.TXml.isText(item);
  779.     const childNodes = element.children;
  780.     if (isTextNode(element) ||
  781.         (childNodes.length == 1 && isTextNode(childNodes[0]))) {
  782.       // Trailing line breaks may lost when convert cue to HTML tag
  783.       // Need to insert line break cue to preserve line breaks
  784.       const textArr = TXml.getTextContents(element).split('\n');
  785.       let isFirst = true;
  786.       for (const text of textArr) {
  787.         if (!isFirst) {
  788.           const lineBreakCue = shaka.text.Cue.lineBreak(
  789.               nestedCue.startTime, nestedCue.endTime);
  790.           rootCue.nestedCues.push(lineBreakCue);
  791.         }
  792.         if (text.length > 0) {
  793.           const textCue = nestedCue.clone();
  794.           textCue.payload = shaka.util.StringUtils.htmlUnescape(text);
  795.           rootCue.nestedCues.push(textCue);
  796.         }
  797.         isFirst = false;
  798.       }
  799.     } else {
  800.       rootCue.nestedCues.push(nestedCue);
  801.       for (const childNode of childNodes) {
  802.         VttTextParser.generateCueFromElement_(childNode, nestedCue, styles);
  803.       }
  804.     }
  805.   }
  807.   /**
  808.    * Parses a WebVTT setting from the given word.
  809.    *
  810.    * @param {!shaka.text.Cue} cue
  811.    * @param {string} word
  812.    * @param {!Array.<!shaka.text.CueRegion>} regions
  813.    * @return {boolean} True on success.
  814.    */
  815.   static parseCueSetting(cue, word, regions) {
  816.     const VttTextParser = shaka.text.VttTextParser;
  817.     let results = null;
  818.     if ((results = /^align:(start|middle|center|end|left|right)$/.exec(word))) {
  819.       VttTextParser.setTextAlign_(cue, results[1]);
  820.     } else if ((results = /^vertical:(lr|rl)$/.exec(word))) {
  821.       VttTextParser.setVerticalWritingMode_(cue, results[1]);
  822.     } else if ((results = /^size:([\d.]+)%$/.exec(word))) {
  823.       cue.size = Number(results[1]);
  824.     } else if ((results =
  825.         // eslint-disable-next-line max-len
  826.         /^position:([\d.]+)%(?:,(line-left|line-right|middle|center|start|end|auto))?$/
  827.             .exec(word))) {
  828.       cue.position = Number(results[1]);
  829.       if (results[2]) {
  830.         VttTextParser.setPositionAlign_(cue, results[2]);
  831.       }
  832.     } else if ((results = /^region:(.*)$/.exec(word))) {
  833.       const region = VttTextParser.getRegionById_(regions, results[1]);
  834.       if (region) {
  835.         cue.region = region;
  836.       }
  837.     } else {
  838.       return VttTextParser.parsedLineValueAndInterpretation_(cue, word);
  839.     }
  841.     return true;
  842.   }
  844.   /**
  845.    *
  846.    * @param {!Array.<!shaka.text.CueRegion>} regions
  847.    * @param {string} id
  848.    * @return {?shaka.text.CueRegion}
  849.    * @private
  850.    */
  851.   static getRegionById_(regions, id) {
  852.     const regionsWithId = regions.filter((region) => {
  853.       return region.id == id;
  854.     });
  855.     if (!regionsWithId.length) {
  856.       shaka.log.warning('VTT parser could not find a region with id: ',
  857.           id,
  858.           ' The region will be ignored.');
  859.       return null;
  860.     }
  861.     goog.asserts.assert(regionsWithId.length == 1,
  862.         'VTTRegion ids should be unique!');
  864.     return regionsWithId[0];
  865.   }
  867.   /**
  868.    * Parses a WebVTTRegion setting from the given word.
  869.    *
  870.    * @param {!shaka.text.CueRegion} region
  871.    * @param {string} word
  872.    * @return {boolean} True on success.
  873.    * @private
  874.    */
  875.   static parseRegionSetting_(region, word) {
  876.     let results = null;
  877.     if ((results = /^id=(.*)$/.exec(word))) {
  878.       region.id = results[1];
  879.     } else if ((results = /^width=(\d{1,2}|100)%$/.exec(word))) {
  880.       region.width = Number(results[1]);
  881.     } else if ((results = /^lines=(\d+)$/.exec(word))) {
  882.       region.height = Number(results[1]);
  883.       region.heightUnits = shaka.text.CueRegion.units.LINES;
  884.     } else if ((results = /^regionanchor=(\d{1,2}|100)%,(\d{1,2}|100)%$/
  885.         .exec(word))) {
  886.       region.regionAnchorX = Number(results[1]);
  887.       region.regionAnchorY = Number(results[2]);
  888.     } else if ((results = /^viewportanchor=(\d{1,2}|100)%,(\d{1,2}|100)%$/
  889.         .exec(word))) {
  890.       region.viewportAnchorX = Number(results[1]);
  891.       region.viewportAnchorY = Number(results[2]);
  892.     } else if ((results = /^scroll=up$/.exec(word))) {
  893.       region.scroll = shaka.text.CueRegion.scrollMode.UP;
  894.     } else {
  895.       return false;
  896.     }
  898.     return true;
  899.   }
  901.   /**
  902.    * @param {!shaka.text.Cue} cue
  903.    * @param {string} align
  904.    * @private
  905.    */
  906.   static setTextAlign_(cue, align) {
  907.     const Cue = shaka.text.Cue;
  908.     if (align == 'middle') {
  909.       cue.textAlign = Cue.textAlign.CENTER;
  910.     } else {
  911.       goog.asserts.assert(align.toUpperCase() in Cue.textAlign,
  912.           align.toUpperCase() +
  913.                           ' Should be in Cue.textAlign values!');
  915.       cue.textAlign = Cue.textAlign[align.toUpperCase()];
  916.     }
  917.   }
  919.   /**
  920.    * @param {!shaka.text.Cue} cue
  921.    * @param {string} align
  922.    * @private
  923.    */
  924.   static setPositionAlign_(cue, align) {
  925.     const Cue = shaka.text.Cue;
  926.     if (align == 'line-left' || align == 'start') {
  927.       cue.positionAlign = Cue.positionAlign.LEFT;
  928.     } else if (align == 'line-right' || align == 'end') {
  929.       cue.positionAlign = Cue.positionAlign.RIGHT;
  930.     } else if (align == 'center' || align == 'middle') {
  931.       cue.positionAlign = Cue.positionAlign.CENTER;
  932.     } else {
  933.       cue.positionAlign = Cue.positionAlign.AUTO;
  934.     }
  935.   }
  937.   /**
  938.    * @param {!shaka.text.Cue} cue
  939.    * @param {string} value
  940.    * @private
  941.    */
  942.   static setVerticalWritingMode_(cue, value) {
  943.     const Cue = shaka.text.Cue;
  944.     if (value == 'lr') {
  945.       cue.writingMode = Cue.writingMode.VERTICAL_LEFT_TO_RIGHT;
  946.     } else {
  947.       cue.writingMode = Cue.writingMode.VERTICAL_RIGHT_TO_LEFT;
  948.     }
  949.   }
  951.   /**
  952.    * @param {!shaka.text.Cue} cue
  953.    * @param {string} word
  954.    * @return {boolean}
  955.    * @private
  956.    */
  957.   static parsedLineValueAndInterpretation_(cue, word) {
  958.     const Cue = shaka.text.Cue;
  959.     let results = null;
  960.     if ((results = /^line:([\d.]+)%(?:,(start|end|center))?$/.exec(word))) {
  961.       cue.lineInterpretation = Cue.lineInterpretation.PERCENTAGE;
  962.       cue.line = Number(results[1]);
  963.       if (results[2]) {
  964.         goog.asserts.assert(
  965.             results[2].toUpperCase() in Cue.lineAlign,
  966.             results[2].toUpperCase() + ' Should be in Cue.lineAlign values!');
  967.         cue.lineAlign = Cue.lineAlign[results[2].toUpperCase()];
  968.       }
  969.     } else if ((results =
  970.                     /^line:(-?\d+)(?:,(start|end|center))?$/.exec(word))) {
  971.       cue.lineInterpretation = Cue.lineInterpretation.LINE_NUMBER;
  972.       cue.line = Number(results[1]);
  973.       if (results[2]) {
  974.         goog.asserts.assert(
  975.             results[2].toUpperCase() in Cue.lineAlign,
  976.             results[2].toUpperCase() + ' Should be in Cue.lineAlign values!');
  977.         cue.lineAlign = Cue.lineAlign[results[2].toUpperCase()];
  978.       }
  979.     } else {
  980.       return false;
  981.     }
  983.     return true;
  984.   }
  986.   /**
  987.    * Parses a WebVTT time from the given parser.
  988.    *
  989.    * @param {!shaka.util.TextParser} parser
  990.    * @return {?number}
  991.    * @private
  992.    */
  993.   static parseTime_(parser) {
  994.     const results = parser.readRegex(shaka.text.VttTextParser.timeFormat_);
  995.     if (results == null) {
  996.       return null;
  997.     }
  998.     // This capture is optional, but will still be in the array as undefined,
  999.     // in which case it is 0.
  1000.     const hours = Number(results[1]) || 0;
  1001.     const minutes = Number(results[2]);
  1002.     const seconds = Number(results[3]);
  1003.     const milliseconds = Number(results[4]);
  1004.     if (minutes > 59 || seconds > 59) {
  1005.       return null;
  1006.     }
  1008.     return (milliseconds / 1000) + seconds + (minutes * 60) + (hours * 3600);
  1009.   }
  1010. };
  1012. /**
  1013.  * @const {number}
  1014.  * @private
  1015.  */
  1016. shaka.text.VttTextParser.MPEG_TIMESCALE_ = 90000;
  1018. /**
  1019.  * At this value, timestamps roll over in TS content.
  1020.  * @const {number}
  1021.  * @private
  1022.  */
  1023. shaka.text.VttTextParser.TS_ROLLOVER_ = 0x200000000;
  1025. /**
  1026.  * @const
  1027.  * @private {!RegExp}
  1028.  * @example 00:00.000 or 00:00:00.000 or 0:00:00.000 or
  1029.  * 00:00.00 or 00:00:00.00 or 0:00:00.00
  1030.  */
  1031. shaka.text.VttTextParser.timeFormat_ =
  1032.     /(?:(\d{1,}):)?(\d{2}):(\d{2})\.(\d{2,3})/g;
  1034. shaka.text.TextEngine.registerParser(
  1035.     'text/vtt', () => new shaka.text.VttTextParser());
  1037. shaka.text.TextEngine.registerParser(
  1038.     'text/vtt; codecs="vtt"', () => new shaka.text.VttTextParser());
  1040. shaka.text.TextEngine.registerParser(
  1041.     'text/vtt; codecs="wvtt"', () => new shaka.text.VttTextParser());