Source: externs/shaka/text.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.  */
  19. /** @externs */
  22. /**
  23.  * @interface
  24.  * @exportDoc
  25.  */
  26. shakaExtern.CueRegion = function() {};
  29. /**
  30.  * Region identifier.
  31.  * @type {string}
  32.  * @exportDoc
  33.  */
  34. shakaExtern.CueRegion.prototype.id;
  37. /**
  38.  * The X offset to start the rendering area in anchorUnits of the video width.
  39.  * @type {number}
  40.  * @exportDoc
  41.  */
  42. shakaExtern.CueRegion.prototype.viewportAnchorX;
  45. /**
  46.  * The X offset to start the rendering area in anchorUnits of the video height.
  47.  * @type {number}
  48.  * @exportDoc
  49.  */
  50. shakaExtern.CueRegion.prototype.viewportAnchorY;
  53. /**
  54.  * The X offset to start the rendering area in percentage (0-100) of
  55.  * the region width.
  56.  * @type {number}
  57.  * @exportDoc
  58.  */
  59. shakaExtern.CueRegion.prototype.regionAnchorX;
  62. /**
  63.  * The Y offset to start the rendering area in percentage (0-100) of
  64.  * the region height.
  65.  * @type {number}
  66.  * @exportDoc
  67.  */
  68. shakaExtern.CueRegion.prototype.regionAnchorY;
  71. /**
  72.  * The width of the rendering area in widthUnits.
  73.  * @type {number}
  74.  * @exportDoc
  75.  */
  76. shakaExtern.CueRegion.prototype.width;
  79. /**
  80.  * The width of the rendering area in heightUnits.
  81.  * @type {number}
  82.  * @exportDoc
  83.  */
  84. shakaExtern.CueRegion.prototype.height;
  87. /**
  88.  * The units (percentage, pixels or lines) the region height is in.
  89.  * @type {shaka.text.CueRegion.units}
  90.  * @exportDoc
  91.  */
  92. shakaExtern.CueRegion.prototype.heightUnits;
  95. /**
  96.  * The units (percentage or pixels) the region width is in.
  97.  * @type {shaka.text.CueRegion.units}
  98.  * @exportDoc
  99.  */
  100. shakaExtern.CueRegion.prototype.widthUnits;
  103. /**
  104.  * The units (percentage or pixels) the region viewportAnchors are in.
  105.  * @type {shaka.text.CueRegion.units}
  106.  * @exportDoc
  107.  */
  108. shakaExtern.CueRegion.prototype.viewportAnchorUnits;
  111. /**
  112.  * If scroll=UP, it means that cues in the region will be added to the bottom of
  113.  * the region and will push any already displayed cues in the region up.
  114.  * Otherwise (scroll=NONE) cues will stay fixed at the location
  115.  * they were first painted in.
  116.  * @type {shaka.text.CueRegion.scrollMode}
  117.  * @exportDoc
  118.  */
  119. shakaExtern.CueRegion.prototype.scroll;
  122. /**
  123.  * @interface
  124.  * @exportDoc
  125.  */
  126. shakaExtern.Cue = function() {};
  129. /**
  130.  * The start time of the cue in seconds, relative to the start of the
  131.  * presentation.
  132.  * @type {number}
  133.  * @exportDoc
  134.  */
  135. shakaExtern.Cue.prototype.startTime;
  138. /**
  139.  * The end time of the cue in seconds, relative to the start of the
  140.  * presentation.
  141.  * @type {number}
  142.  * @exportDoc
  143.  */
  144. shakaExtern.Cue.prototype.endTime;
  147. /**
  148.  * The text payload of the cue.
  149.  * @type {!string}
  150.  * @exportDoc
  151.  */
  152. shakaExtern.Cue.prototype.payload;
  155. /**
  156.  * The region to render the cue into.
  157.  * @type {shakaExtern.CueRegion}
  158.  * @exportDoc
  159.  */
  160. shakaExtern.Cue.prototype.region;
  163. /**
  164.  * The indent (in percent) of the cue box in the direction defined by the
  165.  * writing direction.
  166.  * @type {?number}
  167.  * @exportDoc
  168.  */
  169. shakaExtern.Cue.prototype.position;
  172. /**
  173.  * Position alignment of the cue.
  174.  * @type {shaka.text.Cue.positionAlign}
  175.  * @exportDoc
  176.  */
  177. shakaExtern.Cue.prototype.positionAlign;
  180. /**
  181.  * Size of the cue box (in percents).
  182.  * @type {number}
  183.  * @exportDoc
  184.  */
  185. shakaExtern.Cue.prototype.size;
  188. /**
  189.  * Alignment of the text inside the cue box.
  190.  * @type {shaka.text.Cue.textAlign}
  191.  * @exportDoc
  192.  */
  193. shakaExtern.Cue.prototype.textAlign;
  196. /**
  197.  * Text writing direction of the cue.
  198.  * @type {shaka.text.Cue.writingDirection}
  199.  * @exportDoc
  200.  */
  201. shakaExtern.Cue.prototype.writingDirection;
  204. /**
  205.  * The way to interpret line field. (Either as an integer line number or
  206.  * percentage from the display box).
  207.  * @type {shaka.text.Cue.lineInterpretation}
  208.  * @exportDoc
  209.  */
  210. shakaExtern.Cue.prototype.lineInterpretation;
  213. /**
  214.  * The offset from the display box in either number of lines or
  215.  * percentage depending on the value of lineInterpretation.
  216.  * @type {?number}
  217.  * @exportDoc
  218.  */
  219. shakaExtern.Cue.prototype.line;
  222. /**
  223.  * Separation between line areas inside the cue box in px or em
  224.  * (e.g. '100px'/'100em'). If not specified, this should be no less than
  225.  * the largest font size applied to the text in the cue.
  226.  * @type {string}.
  227.  * @exportDoc
  228.  */
  229. shakaExtern.Cue.prototype.lineHeight;
  232. /**
  233.  * Line alignment of the cue box.
  234.  * @type {shaka.text.Cue.lineAlign}
  235.  * @exportDoc
  236.  */
  237. shakaExtern.Cue.prototype.lineAlign;
  240. /**
  241.  * Vertical alignments of the cues within their extents.
  242.  * @type {shaka.text.Cue.displayAlign}
  243.  * @exportDoc
  244.  */
  245. shakaExtern.Cue.prototype.displayAlign;
  248. /**
  249.  * Text color represented by any string that would be accepted in CSS.
  250.  * E. g. '#FFFFFF' or 'white'.
  251.  * @type {!string}
  252.  * @exportDoc
  253.  */
  254. shakaExtern.Cue.prototype.color;
  257. /**
  258.  * Text background color represented by any string that would be
  259.  * accepted in CSS.
  260.  * E. g. '#FFFFFF' or 'white'.
  261.  * @type {!string}
  262.  * @exportDoc
  263.  */
  264. shakaExtern.Cue.prototype.backgroundColor;
  267. /**
  268.  * Text font size in px or em (e.g. '100px'/'100em').
  269.  * @type {string}
  270.  * @exportDoc
  271.  */
  272. shakaExtern.Cue.prototype.fontSize;
  275. /**
  276.  * Text font weight. Either normal or bold.
  277.  * @type {shaka.text.Cue.fontWeight}
  278.  * @exportDoc
  279.  */
  280. shakaExtern.Cue.prototype.fontWeight;
  283. /**
  284.  * Text font style. Normal, italic or oblique.
  285.  * @type {shaka.text.Cue.fontStyle}
  286.  * @exportDoc
  287.  */
  288. shakaExtern.Cue.prototype.fontStyle;
  291. /**
  292.  * Text font family.
  293.  * @type {!string}
  294.  * @exportDoc
  295.  */
  296. shakaExtern.Cue.prototype.fontFamily;
  299. /**
  300.  * Text decoration. A combination of underline, overline
  301.  * and line through. Empty array means no decoration.
  302.  * @type {!Array.<!shaka.text.Cue.textDecoration>}
  303.  * @exportDoc
  304.  */
  305. shakaExtern.Cue.prototype.textDecoration;
  308. /**
  309.  * Whether or not line wrapping should be applied to the cue.
  310.  * @type {boolean}
  311.  * @exportDoc
  312.  */
  313. shakaExtern.Cue.prototype.wrapLine;
  316. /**
  317.  * Id of the cue.
  318.  * @type {!string}
  319.  * @exportDoc
  320.  */
  321. shakaExtern.Cue.prototype.id;
  325. /**
  326.  * An interface for plugins that parse text tracks.
  327.  *
  328.  * @interface
  329.  * @exportDoc
  330.  */
  331. shakaExtern.TextParser = function() {};
  334. /**
  335.  * A collection of time offsets used to adjust text cue times.
  336.  *
  337.  * @typedef {{
  338.  *   periodStart: number,
  339.  *   segmentStart: ?number,
  340.  *   segmentEnd: number
  341.  * }}
  342.  *
  343.  * @property {number} periodStart
  344.  *     The absolute start time of the period in seconds.
  345.  * @property {?number} segmentStart
  346.  *     The absolute start time of the segment in seconds.
  347.  *     Null if the manifest does not provide this information, such as in HLS.
  348.  * @property {number} segmentEnd
  349.  *     The absolute end time of the segment in seconds.
  350.  *
  351.  * @exportDoc
  352.  */
  353. shakaExtern.TextParser.TimeContext;
  356. /**
  357.  * Parse an initialization segment. Some formats do not have init
  358.  * segments so this won't always be called.
  359.  *
  360.  * @param {!Uint8Array} data
  361.  *    The data that makes up the init segment.
  362.  *
  363.  * @exportDoc
  364.  */
  365. shakaExtern.TextParser.prototype.parseInit = function(data) {};
  368. /**
  369.  * Parse a media segment and return the cues that make up the segment.
  370.  *
  371.  * @param {!Uint8Array} data
  372.  *    The next section of buffer.
  373.  * @param {shakaExtern.TextParser.TimeContext} timeContext
  374.  *    The time information that should be used to adjust the times values
  375.  *    for each cue.
  376.  * @return {!Array.<!shakaExtern.Cue>}
  377.  *
  378.  * @exportDoc
  379.  */
  380. shakaExtern.TextParser.prototype.parseMedia = function(data, timeContext) {};
  383. /**
  384.  * @typedef {function(new:shakaExtern.TextParser)}
  385.  * @exportDoc
  386.  */
  387. shakaExtern.TextParserPlugin;
  391. /**
  392.  * An interface for plugins that display text.
  393.  *
  394.  * @interface
  395.  * @extends {shaka.util.IDestroyable}
  396.  * @exportDoc
  397.  */
  398. shakaExtern.TextDisplayer = function() {};
  401. /**
  402.  * @override
  403.  * @exportDoc
  404.  */
  405. shakaExtern.TextDisplayer.prototype.destroy = function() {};
  408. /**
  409.  * Append given text cues to the list of cues to be displayed.
  410.  *
  411.  * @param {!Array.<!shaka.text.Cue>} cues
  412.  *    Text cues to be appended.
  413.  *
  414.  * @exportDoc
  415.  */
  416. shakaExtern.TextDisplayer.prototype.append = function(cues) {};
  419. /**
  420.  * Remove cues in a given time range.
  421.  *
  422.  * @param {number} startTime relative to the start of the presentation
  423.  * @param {number} endTime relative to the start of the presentation
  424.  * @return {boolean}
  425.  *
  426.  * @exportDoc
  427.  */
  428. shakaExtern.TextDisplayer.prototype.remove = function(startTime, endTime) {};
  431. /**
  432.  * Returns true if text is currently visible.
  433.  *
  434.  * @return {boolean}
  435.  *
  436.  * @exportDoc
  437.  */
  438. shakaExtern.TextDisplayer.prototype.isTextVisible = function() {};
  441. /**
  442.  * Set text visibility.
  443.  *
  444.  * @param {boolean} on
  445.  *
  446.  * @exportDoc
  447.  */
  448. shakaExtern.TextDisplayer.prototype.setTextVisibility = function(on) {};
  451. /**
  452.  * A factory for creating a TextDisplayer.
  453.  *
  454.  * @typedef {function(new:shakaExtern.TextDisplayer)}
  455.  * @exportDoc
  456.  */
  457. shakaExtern.TextDisplayer.Factory;