Source: lib/text/ttml_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.TtmlTextParser');
  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.ArrayUtils');
  26. goog.require('shaka.util.Error');
  27. goog.require('shaka.util.StringUtils');
  28. goog.require('shaka.util.XmlUtils');
  32. /**
  33.  * @constructor
  34.  * @implements {shakaExtern.TextParser}
  35.  */
  36. shaka.text.TtmlTextParser = function() {};
  39. /**
  40.  * @const {string}
  41.  * @private
  42.  */
  43. shaka.text.TtmlTextParser.parameterNs_ = 'http://www.w3.org/ns/ttml#parameter';
  46. /**
  47.  * @const {string}
  48.  * @private
  49.  */
  50. shaka.text.TtmlTextParser.styleNs_ = 'http://www.w3.org/ns/ttml#styling';
  53. /** @override */
  54. shaka.text.TtmlTextParser.prototype.parseInit = function(data) {
  55.   goog.asserts.assert(false, 'TTML does not have init segments');
  56. };
  59. /** @override */
  60. shaka.text.TtmlTextParser.prototype.parseMedia = function(data, time) {
  61.   const TtmlTextParser = shaka.text.TtmlTextParser;
  62.   const XmlUtils = shaka.util.XmlUtils;
  63.   const ttpNs = TtmlTextParser.parameterNs_;
  64.   let str = shaka.util.StringUtils.fromUTF8(data);
  65.   let ret = [];
  66.   let parser = new DOMParser();
  67.   let xml = null;
  69.   try {
  70.     xml = parser.parseFromString(str, 'text/xml');
  71.   } catch (exception) {
  72.     throw new shaka.util.Error(
  73.         shaka.util.Error.Severity.CRITICAL,
  74.         shaka.util.Error.Category.TEXT,
  75.         shaka.util.Error.Code.INVALID_XML);
  76.   }
  78.   if (xml) {
  79.     // Try to get the framerate, subFrameRate and frameRateMultiplier
  80.     // if applicable
  81.     let frameRate = null;
  82.     let subFrameRate = null;
  83.     let frameRateMultiplier = null;
  84.     let tickRate = null;
  85.     let spaceStyle = null;
  86.     let tts = xml.getElementsByTagName('tt');
  87.     let tt = tts[0];
  88.     // TTML should always have tt element.
  89.     if (!tt) {
  90.       throw new shaka.util.Error(
  91.           shaka.util.Error.Severity.CRITICAL,
  92.           shaka.util.Error.Category.TEXT,
  93.           shaka.util.Error.Code.INVALID_XML);
  94.     } else {
  95.       frameRate = XmlUtils.getAttributeNS(tt, ttpNs, 'frameRate');
  96.       subFrameRate = XmlUtils.getAttributeNS(tt, ttpNs, 'subFrameRate');
  97.       frameRateMultiplier =
  98.           XmlUtils.getAttributeNS(tt, ttpNs, 'frameRateMultiplier');
  99.       tickRate = XmlUtils.getAttributeNS(tt, ttpNs, 'tickRate');
  100.       spaceStyle = tt.getAttribute('xml:space') || 'default';
  101.     }
  103.     if (spaceStyle != 'default' && spaceStyle != 'preserve') {
  104.       throw new shaka.util.Error(
  105.           shaka.util.Error.Severity.CRITICAL,
  106.           shaka.util.Error.Category.TEXT,
  107.           shaka.util.Error.Code.INVALID_XML);
  108.     }
  109.     let whitespaceTrim = spaceStyle == 'default';
  111.     let rateInfo = new TtmlTextParser.RateInfo_(
  112.         frameRate, subFrameRate, frameRateMultiplier, tickRate);
  114.     let styles = TtmlTextParser.getLeafNodes_(
  115.         tt.getElementsByTagName('styling')[0]);
  116.     let regionElements = TtmlTextParser.getLeafNodes_(
  117.         tt.getElementsByTagName('layout')[0]);
  118.     let cueRegions = [];
  119.     for (let i = 0; i < regionElements.length; i++) {
  120.       let cueRegion = TtmlTextParser.parseCueRegion_(
  121.           regionElements[i], styles);
  122.       if (cueRegion) {
  123.         cueRegions.push(cueRegion);
  124.       }
  125.     }
  127.     let textNodes = TtmlTextParser.getLeafNodes_(
  128.         tt.getElementsByTagName('body')[0]);
  130.     for (let i = 0; i < textNodes.length; i++) {
  131.       let cue = TtmlTextParser.parseCue_(textNodes[i],
  132.                                          time.periodStart,
  133.                                          rateInfo,
  134.                                          styles,
  135.                                          regionElements,
  136.                                          cueRegions,
  137.                                          whitespaceTrim);
  138.       if (cue) {
  139.         ret.push(cue);
  140.       }
  141.     }
  142.   }
  144.   return ret;
  145. };
  148. /**
  149.  * @const
  150.  * @private {!RegExp}
  151.  * @example 50% 10%
  152.  */
  153. shaka.text.TtmlTextParser.percentValues_ = /^(\d{1,2}|100)% (\d{1,2}|100)%$/;
  156. /**
  157.  * @const
  158.  * @private {!RegExp}
  159.  * @example 100px
  160.  */
  161. shaka.text.TtmlTextParser.unitValues_ = /^(\d+px|\d+em)$/;
  164. /**
  165.  * @const
  166.  * @private {!RegExp}
  167.  * @example 100px
  168.  */
  169. shaka.text.TtmlTextParser.pixelValues_ = /^(\d+)px (\d+)px$/;
  171. /**
  172.  * @const
  173.  * @private {!RegExp}
  174.  * @example 00:00:40:07 (7 frames) or 00:00:40:07.1 (7 frames, 1 subframe)
  175.  */
  176. shaka.text.TtmlTextParser.timeColonFormatFrames_ =
  177.     /^(\d{2,}):(\d{2}):(\d{2}):(\d{2})\.?(\d+)?$/;
  180. /**
  181.  * @const
  182.  * @private {!RegExp}
  183.  * @example 00:00:40 or 00:40
  184.  */
  185. shaka.text.TtmlTextParser.timeColonFormat_ = /^(?:(\d{2,}):)?(\d{2}):(\d{2})$/;
  188. /**
  189.  * @const
  190.  * @private {!RegExp}
  191.  * @example 01:02:43.0345555 or 02:43.03
  192.  */
  193. shaka.text.TtmlTextParser.timeColonFormatMilliseconds_ =
  194.     /^(?:(\d{2,}):)?(\d{2}):(\d{2}\.\d{2,})$/;
  197. /**
  198.  * @const
  199.  * @private {!RegExp}
  200.  * @example 75f or 75.5f
  201.  */
  202. shaka.text.TtmlTextParser.timeFramesFormat_ = /^(\d*(?:\.\d*)?)f$/;
  205. /**
  206.  * @const
  207.  * @private {!RegExp}
  208.  * @example 50t or 50.5t
  209.  */
  210. shaka.text.TtmlTextParser.timeTickFormat_ = /^(\d*(?:\.\d*)?)t$/;
  213. /**
  214.  * @const
  215.  * @private {!RegExp}
  216.  * @example 3.45h, 3m or 4.20s
  217.  */
  218. shaka.text.TtmlTextParser.timeHMSFormat_ =
  219.     new RegExp(['^(?:(\\d*(?:\\.\\d*)?)h)?',
  220.                 '(?:(\\d*(?:\\.\\d*)?)m)?',
  221.                 '(?:(\\d*(?:\\.\\d*)?)s)?',
  222.                 '(?:(\\d*(?:\\.\\d*)?)ms)?$'].join(''));
  226. /**
  227.  * @const
  228.  * @private {!Object.<string, shaka.text.Cue.lineAlign>}
  229.  */
  230. shaka.text.TtmlTextParser.textAlignToLineAlign_ = {
  231.   'left': shaka.text.Cue.lineAlign.START,
  232.   'center': shaka.text.Cue.lineAlign.CENTER,
  233.   'right': shaka.text.Cue.lineAlign.END,
  234.   'start': shaka.text.Cue.lineAlign.START,
  235.   'end': shaka.text.Cue.lineAlign.END,
  236. };
  239. /**
  240.  * @const
  241.  * @private {!Object.<string, shaka.text.Cue.positionAlign>}
  242.  */
  243. shaka.text.TtmlTextParser.textAlignToPositionAlign_ = {
  244.   'left': shaka.text.Cue.positionAlign.LEFT,
  245.   'center': shaka.text.Cue.positionAlign.CENTER,
  246.   'right': shaka.text.Cue.positionAlign.RIGHT,
  247. };
  250. /**
  251.  * Gets the leaf nodes of the xml node tree. Ignores the text, br elements
  252.  * and the spans positioned inside paragraphs
  253.  *
  254.  * @param {Element} element
  255.  * @return {!Array.<!Element>}
  256.  * @private
  257.  */
  258. shaka.text.TtmlTextParser.getLeafNodes_ = function(element) {
  259.   let result = [];
  260.   if (!element) {
  261.     return result;
  262.   }
  264.   let childNodes = element.childNodes;
  265.   for (let i = 0; i < childNodes.length; i++) {
  266.     // Currently we don't support styles applicable to span
  267.     // elements, so they are ignored.
  268.     let isSpanChildOfP = childNodes[i].nodeName == 'span' &&
  269.         element.nodeName == 'p';
  270.     if (childNodes[i].nodeType == Node.ELEMENT_NODE &&
  271.         childNodes[i].nodeName != 'br' && !isSpanChildOfP) {
  272.       // Get the leaves the child might contain.
  273.       goog.asserts.assert(childNodes[i] instanceof Element,
  274.                           'Node should be Element!');
  275.       let leafChildren = shaka.text.TtmlTextParser.getLeafNodes_(
  276.           /** @type {Element} */(childNodes[i]));
  277.       goog.asserts.assert(leafChildren.length > 0,
  278.                           'Only a null Element should return no leaves!');
  279.       result = result.concat(leafChildren);
  280.     }
  281.   }
  283.   // if no result at this point, the element itself must be a leaf.
  284.   if (!result.length) {
  285.     result.push(element);
  286.   }
  287.   return result;
  288. };
  291. /**
  292.  * Inserts \n where <br> tags are found.
  293.  *
  294.  * @param {!Node} element
  295.  * @param {boolean} whitespaceTrim
  296.  * @private
  297.  */
  298. shaka.text.TtmlTextParser.addNewLines_ = function(element, whitespaceTrim) {
  299.   let childNodes = element.childNodes;
  301.   for (let i = 0; i < childNodes.length; i++) {
  302.     if (childNodes[i].nodeName == 'br' && i > 0) {
  303.       childNodes[i - 1].textContent += '\n';
  304.     } else if (childNodes[i].childNodes.length > 0) {
  305.       shaka.text.TtmlTextParser.addNewLines_(childNodes[i], whitespaceTrim);
  306.     } else if (whitespaceTrim) {
  307.       // Trim leading and trailing whitespace.
  308.       let trimmed = childNodes[i].textContent.trim();
  309.       // Collapse multiple spaces into one.
  310.       trimmed = trimmed.replace(/\s+/g, ' ');
  312.       childNodes[i].textContent = trimmed;
  313.     }
  314.   }
  315. };
  318. /**
  319.  * Parses an Element into a TextTrackCue or VTTCue.
  320.  *
  321.  * @param {!Element} cueElement
  322.  * @param {number} offset
  323.  * @param {!shaka.text.TtmlTextParser.RateInfo_} rateInfo
  324.  * @param {!Array.<!Element>} styles
  325.  * @param {!Array.<!Element>} regionElements
  326.  * @param {!Array.<!shaka.text.CueRegion>} cueRegions
  327.  * @param {boolean} whitespaceTrim
  328.  * @return {shaka.text.Cue}
  329.  * @private
  330.  */
  331. shaka.text.TtmlTextParser.parseCue_ = function(
  332.     cueElement, offset, rateInfo, styles, regionElements,
  333.     cueRegions, whitespaceTrim) {
  335.   // Disregard empty elements:
  336.   // TTML allows for empty elements like <div></div>.
  337.   // If cueElement has neither time attributes, nor
  338.   // non-whitespace text, don't try to make a cue out of it.
  339.   if (!cueElement.hasAttribute('begin') &&
  340.       !cueElement.hasAttribute('end') &&
  341.       /^\s*$/.test(cueElement.textContent)) {
  342.     return null;
  343.   }
  345.   shaka.text.TtmlTextParser.addNewLines_(cueElement, whitespaceTrim);
  347.   // Get time.
  348.   let start = shaka.text.TtmlTextParser.parseTime_(
  349.       cueElement.getAttribute('begin'), rateInfo);
  350.   let end = shaka.text.TtmlTextParser.parseTime_(
  351.       cueElement.getAttribute('end'), rateInfo);
  352.   let duration = shaka.text.TtmlTextParser.parseTime_(
  353.       cueElement.getAttribute('dur'), rateInfo);
  354.   let payload = cueElement.textContent;
  356.   if (end == null && duration != null) {
  357.     end = start + duration;
  358.   }
  360.   if (start == null || end == null) {
  361.     throw new shaka.util.Error(
  362.         shaka.util.Error.Severity.CRITICAL,
  363.         shaka.util.Error.Category.TEXT,
  364.         shaka.util.Error.Code.INVALID_TEXT_CUE);
  365.   }
  367.   start += offset;
  368.   end += offset;
  370.   let cue = new shaka.text.Cue(start, end, payload);
  372.   // Get other properties if available.
  373.   let regionElement = shaka.text.TtmlTextParser.getElementFromCollection_(
  374.       cueElement, 'region', regionElements);
  375.   if (regionElement && regionElement.getAttribute('xml:id')) {
  376.     let regionId = regionElement.getAttribute('xml:id');
  377.     let regionsWithId = cueRegions.filter(function(region) {
  378.       return region.id == regionId;
  379.     });
  380.     cue.region = regionsWithId[0];
  381.   }
  382.   shaka.text.TtmlTextParser.addStyle_(cue, cueElement, regionElement, styles);
  384.   return cue;
  385. };
  388. /**
  389.  * Parses an Element into a TextTrackCue or VTTCue.
  390.  *
  391.  * @param {!Element} regionElement
  392.  * @param {!Array.<!Element>} styles
  393.  * @return {shaka.text.CueRegion}
  394.  * @private
  395.  */
  396. shaka.text.TtmlTextParser.parseCueRegion_ = function(regionElement, styles) {
  397.   const TtmlTextParser = shaka.text.TtmlTextParser;
  398.   let region = new shaka.text.CueRegion();
  399.   let id = regionElement.getAttribute('xml:id');
  400.   if (!id) {
  401.     shaka.log.warning('TtmlTextParser parser encountered a region with ' +
  402.                       'no id. Region will be ignored.');
  403.     return null;
  404.   }
  405.   region.id = id;
  407.   let results = null;
  408.   let percentage = null;
  409.   let extent = TtmlTextParser.getStyleAttributeFromRegion_(
  410.       regionElement, styles, 'extent');
  411.   if (extent) {
  412.     percentage = TtmlTextParser.percentValues_.exec(extent);
  413.     results = percentage || TtmlTextParser.pixelValues_.exec(extent);
  414.     if (results != null) {
  415.       region.width = Number(results[1]);
  416.       region.height = Number(results[2]);
  417.       region.widthUnits = percentage ?
  418.                          shaka.text.CueRegion.units.PERCENTAGE :
  419.                          shaka.text.CueRegion.units.PX;
  421.       region.heightUnits = percentage ?
  422.                          shaka.text.CueRegion.units.PERCENTAGE :
  423.                          shaka.text.CueRegion.units.PX;
  424.     }
  425.   }
  427.   let origin = TtmlTextParser.getStyleAttributeFromRegion_(
  428.       regionElement, styles, 'origin');
  429.   if (origin) {
  430.     percentage = TtmlTextParser.percentValues_.exec(origin);
  431.     results = percentage || TtmlTextParser.pixelValues_.exec(origin);
  432.     if (results != null) {
  433.       region.viewportAnchorX = Number(results[1]);
  434.       region.viewportAnchorY = Number(results[2]);
  435.       region.viewportAnchorUnits = percentage ?
  436.                 shaka.text.CueRegion.units.PERCENTAGE :
  437.                 shaka.text.CueRegion.units.PX;
  438.     }
  439.   }
  441.   return region;
  442. };
  444. /**
  445.  * Adds applicable style properties to a cue.
  446.  *
  447.  * @param {!shaka.text.Cue} cue
  448.  * @param {!Element} cueElement
  449.  * @param {Element} region
  450.  * @param {!Array.<!Element>} styles
  451.  * @private
  452.  */
  453. shaka.text.TtmlTextParser.addStyle_ = function(
  454.     cue, cueElement, region, styles) {
  455.   const TtmlTextParser = shaka.text.TtmlTextParser;
  456.   const Cue = shaka.text.Cue;
  458.   let direction = TtmlTextParser.getStyleAttribute_(
  459.       cueElement, region, styles, 'direction');
  460.   if (direction == 'rtl') {
  461.     cue.writingDirection = Cue.writingDirection.HORIZONTAL_RIGHT_TO_LEFT;
  462.   }
  464.   // Direction attribute specifies one-dimentional writing direction
  465.   // (left to right or right to left). Writing mode specifies that
  466.   // plus whether text is vertical or horizontal.
  467.   // They should not contradict each other. If they do, we give
  468.   // preference to writing mode.
  469.   let writingMode = TtmlTextParser.getStyleAttribute_(
  470.       cueElement, region, styles, 'writingMode');
  471.   if (writingMode == 'tb' || writingMode == 'tblr') {
  472.     cue.writingDirection = Cue.writingDirection.VERTICAL_LEFT_TO_RIGHT;
  473.   } else if (writingMode == 'tbrl') {
  474.     cue.writingDirection = Cue.writingDirection.VERTICAL_RIGHT_TO_LEFT;
  475.   } else if (writingMode == 'rltb' || writingMode == 'rl') {
  476.     cue.writingDirection = Cue.writingDirection.HORIZONTAL_RIGHT_TO_LEFT;
  477.   } else if (writingMode) {
  478.     cue.writingDirection = Cue.writingDirection.HORIZONTAL_LEFT_TO_RIGHT;
  479.   }
  481.   let align = TtmlTextParser.getStyleAttribute_(
  482.       cueElement, region, styles, 'textAlign');
  483.   if (align) {
  484.     cue.positionAlign = TtmlTextParser.textAlignToPositionAlign_[align];
  485.     cue.lineAlign = TtmlTextParser.textAlignToLineAlign_[align];
  487.     goog.asserts.assert(align.toUpperCase() in Cue.textAlign,
  488.                         align.toUpperCase() +
  489.                         ' Should be in Cue.textAlign values!');
  491.     cue.textAlign = Cue.textAlign[align.toUpperCase()];
  492.   }
  494.   let displayAlign = TtmlTextParser.getStyleAttribute_(
  495.       cueElement, region, styles, 'displayAlign');
  496.   if (displayAlign) {
  497.     goog.asserts.assert(displayAlign.toUpperCase() in Cue.displayAlign,
  498.                         displayAlign.toUpperCase() +
  499.                         ' Should be in Cue.displayAlign values!');
  500.     cue.displayAlign = Cue.displayAlign[displayAlign.toUpperCase()];
  501.   }
  503.   let color = TtmlTextParser.getStyleAttribute_(
  504.       cueElement, region, styles, 'color');
  505.   if (color) {
  506.     cue.color = color;
  507.   }
  509.   let backgroundColor = TtmlTextParser.getStyleAttribute_(
  510.       cueElement, region, styles, 'backgroundColor');
  511.   if (backgroundColor) {
  512.     cue.backgroundColor = backgroundColor;
  513.   }
  515.   let fontFamily = TtmlTextParser.getStyleAttribute_(
  516.       cueElement, region, styles, 'fontFamily');
  517.   if (fontFamily) {
  518.     cue.fontFamily = fontFamily;
  519.   }
  521.   let fontWeight = TtmlTextParser.getStyleAttribute_(
  522.       cueElement, region, styles, 'fontWeight');
  523.   if (fontWeight && fontWeight == 'bold') {
  524.     cue.fontWeight = Cue.fontWeight.BOLD;
  525.   }
  527.   let wrapOption = TtmlTextParser.getStyleAttribute_(
  528.       cueElement, region, styles, 'wrapOption');
  529.   if (wrapOption && wrapOption == 'noWrap') {
  530.     cue.wrapLine = false;
  531.   }
  533.   let lineHeight = TtmlTextParser.getStyleAttribute_(
  534.       cueElement, region, styles, 'lineHeight');
  535.   if (lineHeight && lineHeight.match(TtmlTextParser.unitValues_)) {
  536.     cue.lineHeight = lineHeight;
  537.   }
  539.   let fontSize = TtmlTextParser.getStyleAttribute_(
  540.       cueElement, region, styles, 'fontSize');
  541.   if (fontSize && fontSize.match(TtmlTextParser.unitValues_)) {
  542.     cue.fontSize = fontSize;
  543.   }
  545.   let fontStyle = TtmlTextParser.getStyleAttribute_(
  546.       cueElement, region, styles, 'fontStyle');
  547.   if (fontStyle) {
  548.     goog.asserts.assert(fontStyle.toUpperCase() in Cue.fontStyle,
  549.                         fontStyle.toUpperCase() +
  550.                         ' Should be in Cue.fontStyle values!');
  551.     cue.fontStyle = Cue.fontStyle[fontStyle.toUpperCase()];
  552.   }
  554.   // Text decoration is an array of values which can come both from the
  555.   // element's style or be inherited from elements' parent nodes. All of those
  556.   // values should be applied as long as they don't contradict each other. If
  557.   // they do, elements' own style gets preference.
  558.   let textDecorationRegion = TtmlTextParser.getStyleAttributeFromRegion_(
  559.       region, styles, 'textDecoration');
  560.   if (textDecorationRegion) {
  561.     TtmlTextParser.addTextDecoration_(cue, textDecorationRegion);
  562.   }
  564.   let textDecorationElement = TtmlTextParser.getStyleAttributeFromElement_(
  565.       cueElement, styles, 'textDecoration');
  566.   if (textDecorationElement) {
  567.     TtmlTextParser.addTextDecoration_(cue, textDecorationElement);
  568.   }
  569. };
  572. /**
  573.  * Parses text decoration values and adds/removes them to/from the cue.
  574.  *
  575.  * @param {!shaka.text.Cue} cue
  576.  * @param {string} decoration
  577.  * @private
  578.  */
  579. shaka.text.TtmlTextParser.addTextDecoration_ = function(cue, decoration) {
  580.   const Cue = shaka.text.Cue;
  581.   let values = decoration.split(' ');
  582.   for (let i = 0; i < values.length; i++) {
  583.     switch (values[i]) {
  584.       case 'underline':
  585.         if (cue.textDecoration.indexOf(Cue.textDecoration.UNDERLINE) < 0) {
  586.           cue.textDecoration.push(Cue.textDecoration.UNDERLINE);
  587.         }
  588.         break;
  589.       case 'noUnderline':
  590.         if (cue.textDecoration.indexOf(Cue.textDecoration.UNDERLINE) >= 0) {
  591.           shaka.util.ArrayUtils.remove(cue.textDecoration,
  592.                                        Cue.textDecoration.UNDERLINE);
  593.         }
  594.         break;
  595.       case 'lineThrough':
  596.         if (cue.textDecoration.indexOf(Cue.textDecoration.LINE_THROUGH) < 0) {
  597.           cue.textDecoration.push(Cue.textDecoration.LINE_THROUGH);
  598.         }
  599.         break;
  600.       case 'noLineThrough':
  601.         if (cue.textDecoration.indexOf(Cue.textDecoration.LINE_THROUGH) >= 0) {
  602.           shaka.util.ArrayUtils.remove(cue.textDecoration,
  603.                                        Cue.textDecoration.LINE_THROUGH);
  604.         }
  605.         break;
  606.       case 'overline':
  607.         if (cue.textDecoration.indexOf(Cue.textDecoration.OVERLINE) < 0) {
  608.           cue.textDecoration.push(Cue.textDecoration.OVERLINE);
  609.         }
  610.         break;
  611.       case 'noOverline':
  612.         if (cue.textDecoration.indexOf(Cue.textDecoration.OVERLINE) >= 0) {
  613.           shaka.util.ArrayUtils.remove(cue.textDecoration,
  614.                                        Cue.textDecoration.OVERLINE);
  615.         }
  616.         break;
  617.     }
  618.   }
  619. };
  622. /**
  623.  * Finds a specified attribute on either the original cue element or its
  624.  * associated region and returns the value if the attribute was found.
  625.  *
  626.  * @param {!Element} cueElement
  627.  * @param {Element} region
  628.  * @param {!Array.<!Element>} styles
  629.  * @param {string} attribute
  630.  * @return {?string}
  631.  * @private
  632.  */
  633. shaka.text.TtmlTextParser.getStyleAttribute_ = function(
  634.     cueElement, region, styles, attribute) {
  635.   // An attribute can be specified on region level or in a styling block
  636.   // associated with the region or original element.
  637.   const TtmlTextParser = shaka.text.TtmlTextParser;
  638.   let attr = TtmlTextParser.getStyleAttributeFromElement_(
  639.       cueElement, styles, attribute);
  640.   if (attr) {
  641.     return attr;
  642.   }
  644.   return TtmlTextParser.getStyleAttributeFromRegion_(
  645.       region, styles, attribute);
  646. };
  649. /**
  650.  * Finds a specified attribute on the element's associated region
  651.  * and returns the value if the attribute was found.
  652.  *
  653.  * @param {Element} region
  654.  * @param {!Array.<!Element>} styles
  655.  * @param {string} attribute
  656.  * @return {?string}
  657.  * @private
  658.  */
  659. shaka.text.TtmlTextParser.getStyleAttributeFromRegion_ = function(
  660.     region, styles, attribute) {
  661.   const XmlUtils = shaka.util.XmlUtils;
  662.   const ttsNs = shaka.text.TtmlTextParser.styleNs_;
  664.   let regionChildren = shaka.text.TtmlTextParser.getLeafNodes_(region);
  665.   for (let i = 0; i < regionChildren.length; i++) {
  666.     let attr = XmlUtils.getAttributeNS(regionChildren[i], ttsNs, attribute);
  667.     if (attr) {
  668.       return attr;
  669.     }
  670.   }
  672.   let style = shaka.text.TtmlTextParser.getElementFromCollection_(
  673.       region, 'style', styles);
  674.   if (style) {
  675.     return XmlUtils.getAttributeNS(style, ttsNs, attribute);
  676.   }
  677.   return null;
  678. };
  681. /**
  682.  * Finds a specified attribute on the cue element and returns the value
  683.  * if the attribute was found.
  684.  *
  685.  * @param {!Element} cueElement
  686.  * @param {!Array.<!Element>} styles
  687.  * @param {string} attribute
  688.  * @return {?string}
  689.  * @private
  690.  */
  691. shaka.text.TtmlTextParser.getStyleAttributeFromElement_ = function(
  692.     cueElement, styles, attribute) {
  693.   const XmlUtils = shaka.util.XmlUtils;
  694.   const ttsNs = shaka.text.TtmlTextParser.styleNs_;
  696.   let getElementFromCollection_ =
  697.       shaka.text.TtmlTextParser.getElementFromCollection_;
  698.   let style = getElementFromCollection_(cueElement, 'style', styles);
  699.   if (style) {
  700.     return XmlUtils.getAttributeNS(style, ttsNs, attribute);
  701.   }
  702.   return null;
  703. };
  706. /**
  707.  * Selects an item from |collection| whose id matches |attributeName|
  708.  * from |element|.
  709.  *
  710.  * @param {Element} element
  711.  * @param {string} attributeName
  712.  * @param {!Array.<Element>} collection
  713.  * @return {Element}
  714.  * @private
  715.  */
  716. shaka.text.TtmlTextParser.getElementFromCollection_ = function(
  717.     element, attributeName, collection) {
  718.   if (!element || collection.length < 1) {
  719.     return null;
  720.   }
  721.   let item = null;
  722.   let itemName = shaka.text.TtmlTextParser.getInheritedAttribute_(
  723.       element, attributeName);
  724.   if (itemName) {
  725.     for (let i = 0; i < collection.length; i++) {
  726.       if (collection[i].getAttribute('xml:id') == itemName) {
  727.         item = collection[i];
  728.         break;
  729.       }
  730.     }
  731.   }
  733.   return item;
  734. };
  737. /**
  738.  * Traverses upwards from a given node until a given attribute is found.
  739.  *
  740.  * @param {!Element} element
  741.  * @param {string} attributeName
  742.  * @return {?string}
  743.  * @private
  744.  */
  745. shaka.text.TtmlTextParser.getInheritedAttribute_ = function(
  746.     element, attributeName) {
  747.   let ret = null;
  748.   while (element) {
  749.     ret = element.getAttribute(attributeName);
  750.     if (ret) {
  751.       break;
  752.     }
  754.     // Element.parentNode can lead to XMLDocument, which is not an Element and
  755.     // has no getAttribute().
  756.     let parentNode = element.parentNode;
  757.     if (parentNode instanceof Element) {
  758.       element = parentNode;
  759.     } else {
  760.       break;
  761.     }
  762.   }
  763.   return ret;
  764. };
  767. /**
  768.  * Parses a TTML time from the given word.
  769.  *
  770.  * @param {string} text
  771.  * @param {!shaka.text.TtmlTextParser.RateInfo_} rateInfo
  772.  * @return {?number}
  773.  * @private
  774.  */
  775. shaka.text.TtmlTextParser.parseTime_ = function(text, rateInfo) {
  776.   let ret = null;
  777.   const TtmlTextParser = shaka.text.TtmlTextParser;
  779.   if (TtmlTextParser.timeColonFormatFrames_.test(text)) {
  780.     ret = TtmlTextParser.parseColonTimeWithFrames_(rateInfo, text);
  781.   } else if (TtmlTextParser.timeColonFormat_.test(text)) {
  782.     ret = TtmlTextParser.parseTimeFromRegex_(
  783.         TtmlTextParser.timeColonFormat_, text);
  784.   } else if (TtmlTextParser.timeColonFormatMilliseconds_.test(text)) {
  785.     ret = TtmlTextParser.parseTimeFromRegex_(
  786.         TtmlTextParser.timeColonFormatMilliseconds_, text);
  787.   } else if (TtmlTextParser.timeFramesFormat_.test(text)) {
  788.     ret = TtmlTextParser.parseFramesTime_(rateInfo, text);
  789.   } else if (TtmlTextParser.timeTickFormat_.test(text)) {
  790.     ret = TtmlTextParser.parseTickTime_(rateInfo, text);
  791.   } else if (TtmlTextParser.timeHMSFormat_.test(text)) {
  792.     ret = TtmlTextParser.parseTimeFromRegex_(
  793.         TtmlTextParser.timeHMSFormat_, text);
  794.   }
  796.   return ret;
  797. };
  800. /**
  801.  * Parses a TTML time in frame format.
  802.  *
  803.  * @param {!shaka.text.TtmlTextParser.RateInfo_} rateInfo
  804.  * @param {string} text
  805.  * @return {?number}
  806.  * @private
  807.  */
  808. shaka.text.TtmlTextParser.parseFramesTime_ = function(rateInfo, text) {
  810.   // 75f or 75.5f
  811.   let results = shaka.text.TtmlTextParser.timeFramesFormat_.exec(text);
  812.   let frames = Number(results[1]);
  814.   return frames / rateInfo.frameRate;
  815. };
  818. /**
  819.  * Parses a TTML time in tick format.
  820.  *
  821.  * @param {!shaka.text.TtmlTextParser.RateInfo_} rateInfo
  822.  * @param {string} text
  823.  * @return {?number}
  824.  * @private
  825.  */
  826. shaka.text.TtmlTextParser.parseTickTime_ = function(rateInfo, text) {
  828.   // 50t or 50.5t
  829.   let results = shaka.text.TtmlTextParser.timeTickFormat_.exec(text);
  830.   let ticks = Number(results[1]);
  832.   return ticks / rateInfo.tickRate;
  833. };
  836. /**
  837.  * Parses a TTML colon formatted time containing frames.
  838.  *
  839.  * @param {!shaka.text.TtmlTextParser.RateInfo_} rateInfo
  840.  * @param {string} text
  841.  * @return {?number}
  842.  * @private
  843.  */
  844. shaka.text.TtmlTextParser.parseColonTimeWithFrames_ = function(
  845.     rateInfo, text) {
  847.   // 01:02:43:07 ('07' is frames) or 01:02:43:07.1 (subframes)
  848.   let results = shaka.text.TtmlTextParser.timeColonFormatFrames_.exec(text);
  850.   let hours = Number(results[1]);
  851.   let minutes = Number(results[2]);
  852.   let seconds = Number(results[3]);
  853.   let frames = Number(results[4]);
  854.   let subframes = Number(results[5]) || 0;
  856.   frames += subframes / rateInfo.subFrameRate;
  857.   seconds += frames / rateInfo.frameRate;
  859.   return seconds + (minutes * 60) + (hours * 3600);
  860. };
  863. /**
  864.  * Parses a TTML time with a given regex. Expects regex to be some
  865.  * sort of a time-matcher to match hours, minutes, seconds and milliseconds
  866.  *
  867.  * @param {!RegExp} regex
  868.  * @param {string} text
  869.  * @return {?number}
  870.  * @private
  871.  */
  872. shaka.text.TtmlTextParser.parseTimeFromRegex_ = function(regex, text) {
  873.   let results = regex.exec(text);
  874.   if (results == null || results[0] == '') {
  875.     return null;
  876.   }
  877.   // This capture is optional, but will still be in the array as undefined,
  878.   // in which case it is 0.
  879.   let hours = Number(results[1]) || 0;
  880.   let minutes = Number(results[2]) || 0;
  881.   let seconds = Number(results[3]) || 0;
  882.   let miliseconds = Number(results[4]) || 0;
  884.   return (miliseconds / 1000) + seconds + (minutes * 60) + (hours * 3600);
  885. };
  889. /**
  890.  * Contains information about frame/subframe rate
  891.  * and frame rate multiplier for time in frame format.
  892.  *
  893.  * @example 01:02:03:04(4 frames) or 01:02:03:04.1(4 frames, 1 subframe)
  894.  * @param {?string} frameRate
  895.  * @param {?string} subFrameRate
  896.  * @param {?string} frameRateMultiplier
  897.  * @param {?string} tickRate
  898.  * @constructor
  899.  * @struct
  900.  * @private
  901.  */
  902. shaka.text.TtmlTextParser.RateInfo_ = function(
  903.     frameRate, subFrameRate, frameRateMultiplier, tickRate) {
  905.   /**
  906.    * @type {number}
  907.    */
  908.   this.frameRate = Number(frameRate) || 30;
  910.   /**
  911.    * @type {number}
  912.    */
  913.   this.subFrameRate = Number(subFrameRate) || 1;
  915.   /**
  916.    * @type {number}
  917.    */
  918.   this.tickRate = Number(tickRate);
  919.   if (this.tickRate == 0) {
  920.     if (frameRate) {
  921.       this.tickRate = this.frameRate * this.subFrameRate;
  922.     } else {
  923.       this.tickRate = 1;
  924.     }
  925.   }
  927.   if (frameRateMultiplier) {
  928.     let multiplierResults = /^(\d+) (\d+)$/g.exec(frameRateMultiplier);
  929.     if (multiplierResults) {
  930.       let numerator = multiplierResults[1];
  931.       let denominator = multiplierResults[2];
  932.       let multiplierNum = numerator / denominator;
  933.       this.frameRate *= multiplierNum;
  934.     }
  935.   }
  936. };
  939. shaka.text.TextEngine.registerParser(
  940.     'application/ttml+xml',
  941.     shaka.text.TtmlTextParser);