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.text.Cue');
  22. goog.require('shaka.text.TextEngine');
  23. goog.require('shaka.util.ArrayUtils');
  24. goog.require('shaka.util.Error');
  25. goog.require('shaka.util.StringUtils');
  29. /**
  30.  * @constructor
  31.  * @implements {shakaExtern.TextParser}
  32.  */
  33. shaka.text.TtmlTextParser = function() {};
  36. /** @override */
  37. shaka.text.TtmlTextParser.prototype.parseInit = function(data) {
  38.   goog.asserts.assert(false, 'TTML does not have init segments');
  39. };
  42. /** @override */
  43. shaka.text.TtmlTextParser.prototype.parseMedia = function(data, time) {
  44.   var str = shaka.util.StringUtils.fromUTF8(data);
  45.   var ret = [];
  46.   var parser = new DOMParser();
  47.   var xml = null;
  49.   try {
  50.     xml = parser.parseFromString(str, 'text/xml');
  51.   } catch (exception) {
  52.     throw new shaka.util.Error(
  53.         shaka.util.Error.Severity.CRITICAL,
  54.         shaka.util.Error.Category.TEXT,
  55.         shaka.util.Error.Code.INVALID_XML);
  56.   }
  58.   if (xml) {
  59.     // Try to get the framerate, subFrameRate and frameRateMultiplier
  60.     // if applicable
  61.     var frameRate = null;
  62.     var subFrameRate = null;
  63.     var frameRateMultiplier = null;
  64.     var tickRate = null;
  65.     var spaceStyle = null;
  66.     var tts = xml.getElementsByTagName('tt');
  67.     var tt = tts[0];
  68.     // TTML should always have tt element
  69.     if (!tt) {
  70.       throw new shaka.util.Error(
  71.           shaka.util.Error.Severity.CRITICAL,
  72.           shaka.util.Error.Category.TEXT,
  73.           shaka.util.Error.Code.INVALID_XML);
  74.     } else {
  75.       frameRate = tt.getAttribute('ttp:frameRate');
  76.       subFrameRate = tt.getAttribute('ttp:subFrameRate');
  77.       frameRateMultiplier = tt.getAttribute('ttp:frameRateMultiplier');
  78.       tickRate = tt.getAttribute('ttp:tickRate');
  79.       spaceStyle = tt.getAttribute('xml:space') || 'default';
  80.     }
  82.     if (spaceStyle != 'default' && spaceStyle != 'preserve') {
  83.       throw new shaka.util.Error(
  84.           shaka.util.Error.Severity.CRITICAL,
  85.           shaka.util.Error.Category.TEXT,
  86.           shaka.util.Error.Code.INVALID_XML);
  87.     }
  88.     var whitespaceTrim = spaceStyle == 'default';
  90.     var rateInfo = new shaka.text.TtmlTextParser.RateInfo_(
  91.         frameRate, subFrameRate, frameRateMultiplier, tickRate);
  93.     var styles = shaka.text.TtmlTextParser.getLeafNodes_(
  94.         tt.getElementsByTagName('styling')[0]);
  95.     var regions = shaka.text.TtmlTextParser.getLeafNodes_(
  96.         tt.getElementsByTagName('layout')[0]);
  97.     var textNodes = shaka.text.TtmlTextParser.getLeafNodes_(
  98.         tt.getElementsByTagName('body')[0]);
  100.     for (var i = 0; i < textNodes.length; i++) {
  101.       var cue = shaka.text.TtmlTextParser.parseCue_(textNodes[i],
  102.                                                     time.periodStart,
  103.                                                     rateInfo,
  104.                                                     styles,
  105.                                                     regions,
  106.                                                     whitespaceTrim);
  107.       if (cue)
  108.         ret.push(cue);
  109.     }
  110.   }
  112.   return ret;
  113. };
  116. /**
  117.  * @const
  118.  * @private {!RegExp}
  119.  * @example 00:00:40:07 (7 frames) or 00:00:40:07.1 (7 frames, 1 subframe)
  120.  */
  121. shaka.text.TtmlTextParser.timeColonFormatFrames_ =
  122.     /^(\d{2,}):(\d{2}):(\d{2}):(\d{2})\.?(\d+)?$/;
  125. /**
  126.  * @const
  127.  * @private {!RegExp}
  128.  * @example 00:00:40 or 00:40
  129.  */
  130. shaka.text.TtmlTextParser.timeColonFormat_ =
  131.     /^(?:(\d{2,}):)?(\d{2}):(\d{2})$/;
  134. /**
  135.  * @const
  136.  * @private {!RegExp}
  137.  * example 01:02:43.0345555 or 02:43.03
  138.  */
  139. shaka.text.TtmlTextParser.timeColonFormatMilliseconds_ =
  140.     /^(?:(\d{2,}):)?(\d{2}):(\d{2}\.\d{2,})$/;
  143. /**
  144.  * @const
  145.  * @private {!RegExp}
  146.  * @example 75f or 75.5f
  147.  */
  148. shaka.text.TtmlTextParser.timeFramesFormat_ = /^(\d*\.?\d*)f$/;
  151. /**
  152.  * @const
  153.  * @private {!RegExp}
  154.  * @example 50t or 50.5t
  155.  */
  156. shaka.text.TtmlTextParser.timeTickFormat_ = /^(\d*\.?\d*)t$/;
  159. /**
  160.  * @const
  161.  * @private {!RegExp}
  162.  * @example 3.45h, 3m or 4.20s
  163.  */
  164. shaka.text.TtmlTextParser.timeHMSFormat_ =
  165.     /^(?:(\d*\.?\d*)h)?(?:(\d*\.?\d*)m)?(?:(\d*\.?\d*)s)?(?:(\d*\.?\d*)ms)?$/;
  168. /**
  169.  * @const
  170.  * @private {!RegExp}
  171.  * @example 50% 10%
  172.  */
  173. shaka.text.TtmlTextParser.percentValues_ = /^(\d{1,2}|100)% (\d{1,2}|100)%$/;
  176. /**
  177.  * @const
  178.  * @private {!RegExp}
  179.  * @example 100px
  180.  */
  181. shaka.text.TtmlTextParser.unitValues_ = /^(\d+px|\d+em)$/;
  184. /**
  185.  * @const
  186.  * @private {!Object}
  187.  */
  188. shaka.text.TtmlTextParser.textAlignToLineAlign_ = {
  189.   'left': 'start',
  190.   'center': 'center',
  191.   'right': 'end',
  192.   'start': 'start',
  193.   'end': 'end'
  194. };
  197. /**
  198.  * @const
  199.  * @private {!Object}
  200.  */
  201. shaka.text.TtmlTextParser.textAlignToPositionAlign_ = {
  202.   'left': 'line-left',
  203.   'center': 'center',
  204.   'right': 'line-right'
  205. };
  208. /**
  209.  * Gets leaf nodes of the xml node tree. Ignores the text, br elements
  210.  * and the spans positioned inside paragraphs
  211.  *
  212.  * @param {Element} element
  213.  * @return {!Array.<!Element>}
  214.  * @private
  215.  */
  216. shaka.text.TtmlTextParser.getLeafNodes_ = function(element) {
  217.   var result = [];
  218.   if (!element)
  219.     return result;
  221.   var childNodes = element.childNodes;
  222.   for (var i = 0; i < childNodes.length; i++) {
  223.     // Currently we don't support styles applicable to span
  224.     // elements, so they are ignored
  225.     var isSpanChildOfP = childNodes[i].nodeName == 'span' &&
  226.         element.nodeName == 'p';
  227.     if (childNodes[i].nodeType == Node.ELEMENT_NODE &&
  228.         childNodes[i].nodeName != 'br' && !isSpanChildOfP) {
  229.       // Get the leafs the child might contain
  230.       goog.asserts.assert(childNodes[i] instanceof Element,
  231.                           'Node should be Element!');
  232.       var leafChildren = shaka.text.TtmlTextParser.getLeafNodes_(
  233.           /** @type {Element} */(childNodes[i]));
  234.       goog.asserts.assert(leafChildren.length > 0,
  235.                           'Only a null Element should return no leaves!');
  236.       result = result.concat(leafChildren);
  237.     }
  238.   }
  240.   // if no result at this point, the element itself must be a leaf
  241.   if (!result.length) {
  242.     result.push(element);
  243.   }
  244.   return result;
  245. };
  248. /**
  249.  * Insert \n where <br> tags are found
  250.  *
  251.  * @param {!Node} element
  252.  * @param {boolean} whitespaceTrim
  253.  * @private
  254.  */
  255. shaka.text.TtmlTextParser.addNewLines_ = function(element, whitespaceTrim) {
  256.   var childNodes = element.childNodes;
  258.   for (var i = 0; i < childNodes.length; i++) {
  259.     if (childNodes[i].nodeName == 'br' && i > 0) {
  260.       childNodes[i - 1].textContent += '\n';
  261.     } else if (childNodes[i].childNodes.length > 0) {
  262.       shaka.text.TtmlTextParser.addNewLines_(childNodes[i], whitespaceTrim);
  263.     } else if (whitespaceTrim) {
  264.       // Trim leading and trailing whitespace.
  265.       var trimmed = childNodes[i].textContent.trim();
  266.       // Collapse multiple spaces into one.
  267.       trimmed = trimmed.replace(/\s+/g, ' ');
  269.       childNodes[i].textContent = trimmed;
  270.     }
  271.   }
  272. };
  275. /**
  276.  * Parses an Element into a TextTrackCue or VTTCue.
  277.  *
  278.  * @param {!Element} cueElement
  279.  * @param {number} offset
  280.  * @param {!shaka.text.TtmlTextParser.RateInfo_} rateInfo
  281.  * @param {!Array.<!Element>} styles
  282.  * @param {!Array.<!Element>} regions
  283.  * @param {boolean} whitespaceTrim
  284.  * @return {shaka.text.Cue}
  285.  * @private
  286.  */
  287. shaka.text.TtmlTextParser.parseCue_ = function(
  288.     cueElement, offset, rateInfo, styles, regions, whitespaceTrim) {
  290.   // Disregard empty elements:
  291.   // TTML allows for empty elements like <div></div>.
  292.   // If cueElement has neither time attributes, nor
  293.   // non-whitespace text, don't try to make a cue out of it.
  294.   if (!cueElement.hasAttribute('begin') &&
  295.       !cueElement.hasAttribute('end') &&
  296.       /^\s*$/.test(cueElement.textContent))
  297.     return null;
  299.   shaka.text.TtmlTextParser.addNewLines_(cueElement, whitespaceTrim);
  301.   // Get time
  302.   var start = shaka.text.TtmlTextParser.parseTime_(
  303.       cueElement.getAttribute('begin'), rateInfo);
  304.   var end = shaka.text.TtmlTextParser.parseTime_(
  305.       cueElement.getAttribute('end'), rateInfo);
  306.   var duration = shaka.text.TtmlTextParser.parseTime_(
  307.       cueElement.getAttribute('dur'), rateInfo);
  308.   var payload = cueElement.textContent;
  310.   if (end == null && duration != null)
  311.     end = start + duration;
  313.   if (start == null || end == null) {
  314.     throw new shaka.util.Error(
  315.         shaka.util.Error.Severity.CRITICAL,
  316.         shaka.util.Error.Category.TEXT,
  317.         shaka.util.Error.Code.INVALID_TEXT_CUE);
  318.   }
  320.   start += offset;
  321.   end += offset;
  323.   var cue = new shaka.text.Cue(start, end, payload);
  325.   // Get other properties if available
  326.   var region = shaka.text.TtmlTextParser.getElementFromCollection_(
  327.       cueElement, 'region', regions);
  328.   shaka.text.TtmlTextParser.addStyle_(cue, cueElement, region, styles);
  330.   return cue;
  331. };
  334. /**
  335.  * Adds applicable style properties to a cue.
  336.  *
  337.  * @param {!shaka.text.Cue} cue
  338.  * @param {!Element} cueElement
  339.  * @param {Element} region
  340.  * @param {!Array.<!Element>} styles
  341.  * @private
  342.  */
  343. shaka.text.TtmlTextParser.addStyle_ = function(
  344.     cue, cueElement, region, styles) {
  345.   var TtmlTextParser = shaka.text.TtmlTextParser;
  346.   var Cue = shaka.text.Cue;
  348.   var results = null;
  350.   var extent = TtmlTextParser.getStyleAttribute_(
  351.       cueElement, region, styles, 'tts:extent');
  352.   if (extent) {
  353.     results = TtmlTextParser.percentValues_.exec(extent);
  354.     if (results != null) {
  355.       // Use width value of the extent attribute for size.
  356.       // Height value is ignored.
  357.       cue.size = Number(results[1]);
  358.     }
  359.   }
  361.   var direction = TtmlTextParser.getStyleAttribute_(
  362.       cueElement, region, styles, 'tts:direction');
  363.   if (direction == 'rtl')
  364.     cue.writingDirection = Cue.writingDirection.HORIZONTAL_RIGHT_TO_LEFT;
  366.   // Direction attribute specifies one-dimentional writing direction
  367.   // (left to right or right to left). Writing mode specifies that
  368.   // plus whether text is vertical or horizontal.
  369.   // They should not contradict each other. If they do, we give
  370.   // preference to writing mode.
  371.   var writingMode = TtmlTextParser.getStyleAttribute_(
  372.       cueElement, region, styles, 'tts:writingMode');
  373.   if (writingMode == 'tb' || writingMode == 'tblr')
  374.     cue.writingDirection = Cue.writingDirection.VERTICAL_LEFT_TO_RIGHT;
  375.   else if (writingMode == 'tbrl')
  376.     cue.writingDirection = Cue.writingDirection.VERTICAL_RIGHT_TO_LEFT;
  377.   else if (writingMode == 'rltb' || writingMode == 'rl')
  378.     cue.writingDirection = Cue.writingDirection.HORIZONTAL_RIGHT_TO_LEFT;
  379.   else if (writingMode)
  380.     cue.writingDirection = Cue.writingDirection.HORIZONTAL_LEFT_TO_RIGHT;
  382.   var origin = TtmlTextParser.getStyleAttribute_(
  383.       cueElement, region, styles, 'tts:origin');
  384.   if (origin) {
  385.     results = TtmlTextParser.percentValues_.exec(origin);
  386.     if (results != null) {
  387.       // for horizontal text use first coordinate of tts:origin
  388.       // to represent position of the cue and second - for line.
  389.       // Otherwise (vertical), use them the other way around.
  390.       if (cue.writingDirection ==
  391.           Cue.writingDirection.HORIZONTAL_LEFT_TO_RIGHT ||
  392.           cue.writingDirection ==
  393.           Cue.writingDirection.HORIZONTAL_RIGHT_TO_LEFT) {
  394.         cue.position = Number(results[1]);
  395.         cue.line = Number(results[2]);
  396.       } else {
  397.         cue.position = Number(results[2]);
  398.         cue.line = Number(results[1]);
  399.       }
  401.       cue.lineInterpretation = Cue.lineInterpretation.PERCENTAGE;
  402.     }
  403.   }
  405.   var align = TtmlTextParser.getStyleAttribute_(
  406.       cueElement, region, styles, 'tts:textAlign');
  407.   if (align) {
  408.     cue.positionAlign = TtmlTextParser.textAlignToPositionAlign_[align];
  409.     cue.lineAlign = TtmlTextParser.textAlignToLineAlign_[align];
  411.     goog.asserts.assert(align.toUpperCase() in Cue.textAlign,
  412.                         align.toUpperCase() +
  413.                         ' Should be in Cue.textAlign values!');
  415.     cue.textAlign = Cue.textAlign[align.toUpperCase()];
  416.   }
  418.   var displayAlign = TtmlTextParser.getStyleAttribute_(
  419.       cueElement, region, styles, 'tts:displayAlign');
  420.   if (displayAlign) {
  421.     goog.asserts.assert(displayAlign.toUpperCase() in Cue.displayAlign,
  422.                         displayAlign.toUpperCase() +
  423.                         ' Should be in Cue.displayAlign values!');
  424.     cue.displayAlign = Cue.displayAlign[displayAlign.toUpperCase()];
  425.   }
  427.   var color = TtmlTextParser.getStyleAttribute_(
  428.       cueElement, region, styles, 'tts:color');
  429.   if (color)
  430.     cue.color = color;
  432.   var backgroundColor = TtmlTextParser.getStyleAttribute_(
  433.       cueElement, region, styles, 'tts:backgroundColor');
  434.   if (backgroundColor)
  435.     cue.backgroundColor = backgroundColor;
  437.   var fontFamily = TtmlTextParser.getStyleAttribute_(
  438.       cueElement, region, styles, 'tts:fontFamily');
  439.   if (fontFamily)
  440.     cue.fontFamily = fontFamily;
  442.   var fontWeight = TtmlTextParser.getStyleAttribute_(
  443.       cueElement, region, styles, 'tts:fontWeight');
  444.   if (fontWeight && fontWeight == 'bold')
  445.     cue.fontWeight = Cue.fontWeight.BOLD;
  447.   var wrapOption = TtmlTextParser.getStyleAttribute_(
  448.       cueElement, region, styles, 'tts:wrapOption');
  449.   if (wrapOption && wrapOption == 'noWrap')
  450.     cue.wrapLine = false;
  452.   var lineHeight = TtmlTextParser.getStyleAttribute_(
  453.       cueElement, region, styles, 'tts:lineHeight');
  454.   if (lineHeight && lineHeight.match(TtmlTextParser.unitValues_))
  455.     cue.lineHeight = lineHeight;
  457.   var fontSize = TtmlTextParser.getStyleAttribute_(
  458.       cueElement, region, styles, 'tts:fontSize');
  459.   if (fontSize && fontSize.match(TtmlTextParser.unitValues_))
  460.     cue.fontSize = fontSize;
  462.   var fontStyle = TtmlTextParser.getStyleAttribute_(
  463.       cueElement, region, styles, 'tts:fontStyle');
  464.   if (fontStyle) {
  465.     goog.asserts.assert(fontStyle.toUpperCase() in Cue.fontStyle,
  466.                         fontStyle.toUpperCase() +
  467.                         ' Should be in Cue.fontStyle values!');
  468.     cue.fontStyle = Cue.fontStyle[fontStyle.toUpperCase()];
  469.   }
  471.   // Text decoration is an array of values which can come both
  472.   // from the element's style or be inherited from elements'
  473.   // parent nodes. All of those values should be applied as long
  474.   // as they don't contradict each other. If they do, elements'
  475.   // own style gets preference.
  476.   var textDecorationRegion = TtmlTextParser.getStyleAttributeFromRegion_(
  477.       region, styles, 'tts:textDecoration');
  478.   if (textDecorationRegion)
  479.     TtmlTextParser.addTextDecoration_(cue, textDecorationRegion);
  481.   var textDecorationElement = TtmlTextParser.getStyleAttributeFromElement_(
  482.       cueElement, styles, 'tts:textDecoration');
  483.   if (textDecorationElement)
  484.     TtmlTextParser.addTextDecoration_(cue, textDecorationElement);
  485. };
  488. /**
  489.  * Parses text decoration values and adds/removes them to/from the cue.
  490.  *
  491.  * @param {!shaka.text.Cue} cue
  492.  * @param {string} decoration
  493.  * @private
  494.  */
  495. shaka.text.TtmlTextParser.addTextDecoration_ = function(cue, decoration) {
  496.   var Cue = shaka.text.Cue;
  497.   var values = decoration.split(' ');
  498.   for (var i = 0; i < values.length; i++) {
  499.     switch (values[i]) {
  500.       case 'underline':
  501.         if (cue.textDecoration.indexOf(Cue.textDecoration.UNDERLINE) < 0)
  502.           cue.textDecoration.push(Cue.textDecoration.UNDERLINE);
  503.         break;
  504.       case 'noUnderline':
  505.         if (cue.textDecoration.indexOf(Cue.textDecoration.UNDERLINE) >= 0) {
  506.           shaka.util.ArrayUtils.remove(cue.textDecoration,
  507.                                        Cue.textDecoration.UNDERLINE);
  508.         }
  509.         break;
  510.       case 'lineThrough':
  511.         if (cue.textDecoration.indexOf(Cue.textDecoration.LINE_THROUGH) < 0)
  512.           cue.textDecoration.push(Cue.textDecoration.LINE_THROUGH);
  513.         break;
  514.       case 'noLineThrough':
  515.         if (cue.textDecoration.indexOf(Cue.textDecoration.LINE_THROUGH) >= 0) {
  516.           shaka.util.ArrayUtils.remove(cue.textDecoration,
  517.                                        Cue.textDecoration.LINE_THROUGH);
  518.         }
  519.         break;
  520.       case 'overline':
  521.         if (cue.textDecoration.indexOf(Cue.textDecoration.OVERLINE) < 0)
  522.           cue.textDecoration.push(Cue.textDecoration.OVERLINE);
  523.         break;
  524.       case 'noOverline':
  525.         if (cue.textDecoration.indexOf(Cue.textDecoration.OVERLINE) >= 0) {
  526.           shaka.util.ArrayUtils.remove(cue.textDecoration,
  527.                                        Cue.textDecoration.OVERLINE);
  528.         }
  529.         break;
  530.     }
  531.   }
  532. };
  535. /**
  536.  * Finds a specified attribute on either the original cue element or its
  537.  * associated region and returns the value if the attribute was found.
  538.  *
  539.  * @param {!Element} cueElement
  540.  * @param {Element} region
  541.  * @param {!Array.<!Element>} styles
  542.  * @param {string} attribute
  543.  * @return {?string}
  544.  * @private
  545.  */
  546. shaka.text.TtmlTextParser.getStyleAttribute_ = function(
  547.     cueElement, region, styles, attribute) {
  548.   // An attribute can be specified on region level or in a styling block
  549.   // associated with the region or original element.
  550.   var TtmlTextParser = shaka.text.TtmlTextParser;
  551.   var attr = TtmlTextParser.getStyleAttributeFromElement_(
  552.       cueElement, styles, attribute);
  553.   if (attr)
  554.     return attr;
  556.   return TtmlTextParser.getStyleAttributeFromRegion_(
  557.       region, styles, attribute);
  558. };
  561. /**
  562.  * Finds a specified attribute on the element's associated region
  563.  * and returns the value if the attribute was found.
  564.  *
  565.  * @param {Element} region
  566.  * @param {!Array.<!Element>} styles
  567.  * @param {string} attribute
  568.  * @return {?string}
  569.  * @private
  570.  */
  571. shaka.text.TtmlTextParser.getStyleAttributeFromRegion_ = function(
  572.     region, styles, attribute) {
  573.   var regionChildren = shaka.text.TtmlTextParser.getLeafNodes_(region);
  574.   for (var i = 0; i < regionChildren.length; i++) {
  575.     var attr = regionChildren[i].getAttribute(attribute);
  576.     if (attr)
  577.       return attr;
  578.   }
  580.   var style = shaka.text.TtmlTextParser.getElementFromCollection_(
  581.       region, 'style', styles);
  582.   if (style)
  583.     return style.getAttribute(attribute);
  584.   return null;
  585. };
  588. /**
  589.  * Finds a specified attribute on the cue element and returns the value
  590.  * if the attribute was found.
  591.  *
  592.  * @param {!Element} cueElement
  593.  * @param {!Array.<!Element>} styles
  594.  * @param {string} attribute
  595.  * @return {?string}
  596.  * @private
  597.  */
  598. shaka.text.TtmlTextParser.getStyleAttributeFromElement_ = function(
  599.     cueElement, styles, attribute) {
  600.   var getElementFromCollection_ =
  601.       shaka.text.TtmlTextParser.getElementFromCollection_;
  602.   var style = getElementFromCollection_(cueElement, 'style', styles);
  603.   if (style)
  604.     return style.getAttribute(attribute);
  605.   return null;
  606. };
  609. /**
  610.  * Selects an item from |collection| whose id matches |attributeName|
  611.  * from |element|.
  612.  *
  613.  * @param {Element} element
  614.  * @param {string} attributeName
  615.  * @param {!Array.<Element>} collection
  616.  * @return {Element}
  617.  * @private
  618.  */
  619. shaka.text.TtmlTextParser.getElementFromCollection_ = function(
  620.     element, attributeName, collection) {
  621.   if (!element || collection.length < 1) {
  622.     return null;
  623.   }
  624.   var item = null;
  625.   var itemName = shaka.text.TtmlTextParser.getInheritedAttribute_(
  626.       element, attributeName);
  627.   if (itemName) {
  628.     for (var i = 0; i < collection.length; i++) {
  629.       if (collection[i].getAttribute('xml:id') == itemName) {
  630.         item = collection[i];
  631.         break;
  632.       }
  633.     }
  634.   }
  636.   return item;
  637. };
  640. /**
  641.  * Traverses upwards from a given node until a given attribute is found.
  642.  *
  643.  * @param {!Element} element
  644.  * @param {string} attributeName
  645.  * @return {?string}
  646.  * @private
  647.  */
  648. shaka.text.TtmlTextParser.getInheritedAttribute_ = function(
  649.     element, attributeName) {
  650.   var ret = null;
  651.   while (element) {
  652.     ret = element.getAttribute(attributeName);
  653.     if (ret) {
  654.       break;
  655.     }
  657.     // Element.parentNode can lead to XMLDocument, which is not an Element and
  658.     // has no getAttribute().
  659.     var parentNode = element.parentNode;
  660.     if (parentNode instanceof Element) {
  661.       element = parentNode;
  662.     } else {
  663.       break;
  664.     }
  665.   }
  666.   return ret;
  667. };
  670. /**
  671.  * Parses a TTML time from the given word.
  672.  *
  673.  * @param {string} text
  674.  * @param {!shaka.text.TtmlTextParser.RateInfo_} rateInfo
  675.  * @return {?number}
  676.  * @private
  677.  */
  678. shaka.text.TtmlTextParser.parseTime_ = function(text, rateInfo) {
  679.   var ret = null;
  680.   var TtmlTextParser = shaka.text.TtmlTextParser;
  682.   if (TtmlTextParser.timeColonFormatFrames_.test(text)) {
  683.     ret = TtmlTextParser.parseColonTimeWithFrames_(rateInfo, text);
  684.   } else if (TtmlTextParser.timeColonFormat_.test(text)) {
  685.     ret = TtmlTextParser.parseTimeFromRegex_(
  686.         TtmlTextParser.timeColonFormat_, text);
  687.   } else if (TtmlTextParser.timeColonFormatMilliseconds_.test(text)) {
  688.     ret = TtmlTextParser.parseTimeFromRegex_(
  689.         TtmlTextParser.timeColonFormatMilliseconds_, text);
  690.   } else if (TtmlTextParser.timeFramesFormat_.test(text)) {
  691.     ret = TtmlTextParser.parseFramesTime_(rateInfo, text);
  692.   } else if (TtmlTextParser.timeTickFormat_.test(text)) {
  693.     ret = TtmlTextParser.parseTickTime_(rateInfo, text);
  694.   } else if (TtmlTextParser.timeHMSFormat_.test(text)) {
  695.     ret = TtmlTextParser.parseTimeFromRegex_(
  696.         TtmlTextParser.timeHMSFormat_, text);
  697.   }
  699.   return ret;
  700. };
  703. /**
  704.  * Parses a TTML time in frame format
  705.  *
  706.  * @param {!shaka.text.TtmlTextParser.RateInfo_} rateInfo
  707.  * @param {string} text
  708.  * @return {?number}
  709.  * @private
  710.  */
  711. shaka.text.TtmlTextParser.parseFramesTime_ = function(rateInfo, text) {
  713.   // 75f or 75.5f
  714.   var results = shaka.text.TtmlTextParser.timeFramesFormat_.exec(text);
  715.   var frames = Number(results[1]);
  717.   return frames / rateInfo.frameRate;
  718. };
  721. /**
  722.  * Parses a TTML time in tick format
  723.  *
  724.  * @param {!shaka.text.TtmlTextParser.RateInfo_} rateInfo
  725.  * @param {string} text
  726.  * @return {?number}
  727.  * @private
  728.  */
  729. shaka.text.TtmlTextParser.parseTickTime_ = function(rateInfo, text) {
  731.   // 50t or 50.5t
  732.   var results = shaka.text.TtmlTextParser.timeTickFormat_.exec(text);
  733.   var ticks = Number(results[1]);
  735.   return ticks / rateInfo.tickRate;
  736. };
  739. /**
  740.  * Parses a TTML colon formatted time containing frames
  741.  *
  742.  * @param {!shaka.text.TtmlTextParser.RateInfo_} rateInfo
  743.  * @param {string} text
  744.  * @return {?number}
  745.  * @private
  746.  */
  747. shaka.text.TtmlTextParser.parseColonTimeWithFrames_ = function(
  748.     rateInfo, text) {
  750.   // 01:02:43:07 ('07' is frames) or 01:02:43:07.1 (subframes)
  751.   var results = shaka.text.TtmlTextParser.timeColonFormatFrames_.exec(text);
  753.   var hours = Number(results[1]);
  754.   var minutes = Number(results[2]);
  755.   var seconds = Number(results[3]);
  756.   var frames = Number(results[4]);
  757.   var subframes = Number(results[5]) || 0;
  759.   frames += subframes / rateInfo.subFrameRate;
  760.   seconds += frames / rateInfo.frameRate;
  762.   return seconds + (minutes * 60) + (hours * 3600);
  763. };
  766. /**
  767.  * Parses a TTML time with a given regex. Expects regex to be some
  768.  * sort of a time-matcher to match hours, minutes, seconds and milliseconds
  769.  *
  770.  * @param {!RegExp} regex
  771.  * @param {string} text
  772.  * @return {?number}
  773.  * @private
  774.  */
  775. shaka.text.TtmlTextParser.parseTimeFromRegex_ = function(regex, text) {
  776.   var results = regex.exec(text);
  777.   if (results == null || results[0] == '')
  778.     return null;
  779.   // This capture is optional, but will still be in the array as undefined,
  780.   // default to 0.
  781.   var hours = Number(results[1]) || 0;
  782.   var minutes = Number(results[2]) || 0;
  783.   var seconds = Number(results[3]) || 0;
  784.   var miliseconds = Number(results[4]) || 0;
  786.   return (miliseconds / 1000) + seconds + (minutes * 60) + (hours * 3600);
  787. };
  791. /**
  792.  * Contains information about frame/subframe rate
  793.  * and frame rate multiplier for time in frame format.
  794.  * ex. 01:02:03:04(4 frames) or 01:02:03:04.1(4 frames, 1 subframe)
  795.  *
  796.  * @param {?string} frameRate
  797.  * @param {?string} subFrameRate
  798.  * @param {?string} frameRateMultiplier
  799.  * @param {?string} tickRate
  800.  * @constructor
  801.  * @struct
  802.  * @private
  803.  */
  804. shaka.text.TtmlTextParser.RateInfo_ = function(
  805.     frameRate, subFrameRate, frameRateMultiplier, tickRate) {
  807.   /**
  808.    * @type {number}
  809.    */
  810.   this.frameRate = Number(frameRate) || 30;
  812.   /**
  813.    * @type {number}
  814.    */
  815.   this.subFrameRate = Number(subFrameRate) || 1;
  817.   /**
  818.    * @type {number}
  819.    */
  820.   this.tickRate = Number(tickRate);
  821.   if (this.tickRate == 0) {
  822.     if (frameRate)
  823.       this.tickRate = this.frameRate * this.subFrameRate;
  824.     else
  825.       this.tickRate = 1;
  826.   }
  828.   if (frameRateMultiplier) {
  829.     var multiplierResults = /^(\d+) (\d+)$/g.exec(frameRateMultiplier);
  830.     if (multiplierResults) {
  831.       var numerator = multiplierResults[1];
  832.       var denominator = multiplierResults[2];
  833.       var multiplierNum = numerator / denominator;
  834.       this.frameRate *= multiplierNum;
  835.     }
  836.   }
  837. };
  840. shaka.text.TextEngine.registerParser(
  841.     'application/ttml+xml',
  842.     shaka.text.TtmlTextParser);