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. /**
  20.  * @externs
  21.  */
  24. /**
  25.  * @interface
  26.  * @exportDoc
  27.  */
  28. shaka.extern.CueRegion = function() {};
  31. /**
  32.  * Region identifier.
  33.  * @type {string}
  34.  * @exportDoc
  35.  */
  36. shaka.extern.CueRegion.prototype.id;
  39. /**
  40.  * The X offset to start the rendering area in viewportAnchorUnits of the video
  41.  * width.
  42.  * @type {number}
  43.  * @exportDoc
  44.  */
  45. shaka.extern.CueRegion.prototype.viewportAnchorX;
  48. /**
  49.  * The X offset to start the rendering area in viewportAnchorUnits of the video
  50.  * height.
  51.  * @type {number}
  52.  * @exportDoc
  53.  */
  54. shaka.extern.CueRegion.prototype.viewportAnchorY;
  57. /**
  58.  * The X offset to start the rendering area in percentage (0-100) of
  59.  * the region width.
  60.  * @type {number}
  61.  * @exportDoc
  62.  */
  63. shaka.extern.CueRegion.prototype.regionAnchorX;
  66. /**
  67.  * The Y offset to start the rendering area in percentage (0-100) of
  68.  * the region height.
  69.  * @type {number}
  70.  * @exportDoc
  71.  */
  72. shaka.extern.CueRegion.prototype.regionAnchorY;
  75. /**
  76.  * The width of the rendering area in widthUnits.
  77.  * @type {number}
  78.  * @exportDoc
  79.  */
  80. shaka.extern.CueRegion.prototype.width;
  83. /**
  84.  * The width of the rendering area in heightUnits.
  85.  * @type {number}
  86.  * @exportDoc
  87.  */
  88. shaka.extern.CueRegion.prototype.height;
  91. /**
  92.  * The units (percentage, pixels or lines) the region height is in.
  93.  * @type {shaka.text.CueRegion.units}
  94.  * @exportDoc
  95.  */
  96. shaka.extern.CueRegion.prototype.heightUnits;
  99. /**
  100.  * The units (percentage or pixels) the region width is in.
  101.  * @type {shaka.text.CueRegion.units}
  102.  * @exportDoc
  103.  */
  104. shaka.extern.CueRegion.prototype.widthUnits;
  107. /**
  108.  * The units (percentage or pixels) the region viewportAnchors are in.
  109.  * @type {shaka.text.CueRegion.units}
  110.  * @exportDoc
  111.  */
  112. shaka.extern.CueRegion.prototype.viewportAnchorUnits;
  115. /**
  116.  * If scroll=UP, it means that cues in the region will be added to the bottom of
  117.  * the region and will push any already displayed cues in the region up.
  118.  * Otherwise (scroll=NONE) cues will stay fixed at the location
  119.  * they were first painted in.
  120.  * @type {shaka.text.CueRegion.scrollMode}
  121.  * @exportDoc
  122.  */
  123. shaka.extern.CueRegion.prototype.scroll;
  126. /**
  127.  * @interface
  128.  * @exportDoc
  129.  */
  130. shaka.extern.Cue = function() {};
  133. /**
  134.  * The start time of the cue in seconds, relative to the start of the
  135.  * presentation.
  136.  * @type {number}
  137.  * @exportDoc
  138.  */
  139. shaka.extern.Cue.prototype.startTime;
  142. /**
  143.  * The end time of the cue in seconds, relative to the start of the
  144.  * presentation.
  145.  * @type {number}
  146.  * @exportDoc
  147.  */
  148. shaka.extern.Cue.prototype.endTime;
  151. /**
  152.  * The text payload of the cue.  If nestedCues is non-empty, this should be
  153.  * empty.  Top-level block containers should have no payload of their own.
  154.  * @type {!string}
  155.  * @exportDoc
  156.  */
  157. shaka.extern.Cue.prototype.payload;
  160. /**
  161.  * The region to render the cue into.
  162.  * @type {shaka.extern.CueRegion}
  163.  * @exportDoc
  164.  */
  165. shaka.extern.Cue.prototype.region;
  168. /**
  169.  * The indent (in percent) of the cue box in the direction defined by the
  170.  * writing direction.
  171.  * @type {?number}
  172.  * @exportDoc
  173.  */
  174. shaka.extern.Cue.prototype.position;
  177. /**
  178.  * Position alignment of the cue.
  179.  * @type {shaka.text.Cue.positionAlign}
  180.  * @exportDoc
  181.  */
  182. shaka.extern.Cue.prototype.positionAlign;
  185. /**
  186.  * Size of the cue box (in percents), where 0 means "auto".
  187.  * @type {number}
  188.  * @exportDoc
  189.  */
  190. shaka.extern.Cue.prototype.size;
  193. /**
  194.  * Alignment of the text inside the cue box.
  195.  * @type {shaka.text.Cue.textAlign}
  196.  * @exportDoc
  197.  */
  198. shaka.extern.Cue.prototype.textAlign;
  201. /**
  202.  * Text direction of the cue.
  203.  * @type {shaka.text.Cue.direction}
  204.  * @exportDoc
  205.  */
  206. shaka.extern.Cue.prototype.direction;
  209. /**
  210.  * Text writing mode of the cue.
  211.  * @type {shaka.text.Cue.writingMode}
  212.  * @exportDoc
  213.  */
  214. shaka.extern.Cue.prototype.writingMode;
  217. /**
  218.  * The way to interpret line field. (Either as an integer line number or
  219.  * percentage from the display box).
  220.  * @type {shaka.text.Cue.lineInterpretation}
  221.  * @exportDoc
  222.  */
  223. shaka.extern.Cue.prototype.lineInterpretation;
  226. /**
  227.  * The offset from the display box in either number of lines or
  228.  * percentage depending on the value of lineInterpretation.
  229.  * @type {?number}
  230.  * @exportDoc
  231.  */
  232. shaka.extern.Cue.prototype.line;
  235. /**
  236.  * Separation between line areas inside the cue box in px or em
  237.  * (e.g. '100px'/'100em'). If not specified, this should be no less than
  238.  * the largest font size applied to the text in the cue.
  239.  * @type {string}.
  240.  * @exportDoc
  241.  */
  242. shaka.extern.Cue.prototype.lineHeight;
  245. /**
  246.  * Line alignment of the cue box.
  247.  * Start alignment means the cue box’s top side (for horizontal cues), left side
  248.  * (for vertical growing right), or right side (for vertical growing left) is
  249.  * aligned at the line.
  250.  * Center alignment means the cue box is centered at the line.
  251.  * End alignment The cue box’s bottom side (for horizontal cues), right side
  252.  * (for vertical growing right), or left side (for vertical growing left) is
  253.  * aligned at the line.
  254.  * @type {shaka.text.Cue.lineAlign}
  255.  * @exportDoc
  256.  */
  257. shaka.extern.Cue.prototype.lineAlign;
  260. /**
  261.  * Vertical alignments of the cues within their extents.
  262.  * 'BEFORE' means displaying the captions at the top of the text display
  263.  * container box, 'CENTER' means in the middle, 'AFTER' means at the bottom.
  264.  * @type {shaka.text.Cue.displayAlign}
  265.  * @exportDoc
  266.  */
  267. shaka.extern.Cue.prototype.displayAlign;
  270. /**
  271.  * Text color represented by any string that would be accepted in CSS.
  272.  * E. g. '#FFFFFF' or 'white'.
  273.  * @type {!string}
  274.  * @exportDoc
  275.  */
  276. shaka.extern.Cue.prototype.color;
  279. /**
  280.  * Text background color represented by any string that would be
  281.  * accepted in CSS.
  282.  * E. g. '#FFFFFF' or 'white'.
  283.  * @type {!string}
  284.  * @exportDoc
  285.  */
  286. shaka.extern.Cue.prototype.backgroundColor;
  289. /**
  290.  * Image background represented by any string that would be
  291.  * accepted in image HTML element.
  292.  * E. g. 'data:[mime type];base64,[data]'.
  293.  * @type {!string}
  294.  * @exportDoc
  295.  */
  296. shaka.extern.Cue.prototype.backgroundImage;
  299. /**
  300.  * Text font size in px or em (e.g. '100px'/'100em').
  301.  * @type {string}
  302.  * @exportDoc
  303.  */
  304. shaka.extern.Cue.prototype.fontSize;
  307. /**
  308.  * Text font weight. Either normal or bold.
  309.  * @type {shaka.text.Cue.fontWeight}
  310.  * @exportDoc
  311.  */
  312. shaka.extern.Cue.prototype.fontWeight;
  315. /**
  316.  * Text font style. Normal, italic or oblique.
  317.  * @type {shaka.text.Cue.fontStyle}
  318.  * @exportDoc
  319.  */
  320. shaka.extern.Cue.prototype.fontStyle;
  323. /**
  324.  * Text font family.
  325.  * @type {!string}
  326.  * @exportDoc
  327.  */
  328. shaka.extern.Cue.prototype.fontFamily;
  331. /**
  332.  * Text decoration. A combination of underline, overline
  333.  * and line through. Empty array means no decoration.
  334.  * @type {!Array.<!shaka.text.Cue.textDecoration>}
  335.  * @exportDoc
  336.  */
  337. shaka.extern.Cue.prototype.textDecoration;
  340. /**
  341.  * Whether or not line wrapping should be applied to the cue.
  342.  * @type {boolean}
  343.  * @exportDoc
  344.  */
  345. shaka.extern.Cue.prototype.wrapLine;
  348. /**
  349.  * Id of the cue.
  350.  * @type {!string}
  351.  * @exportDoc
  352.  */
  353. shaka.extern.Cue.prototype.id;
  355. /**
  356.  * Nested cues, which should be laid out horizontally in one block.
  357.  * @type {Array.<!shaka.extern.Cue>}
  358.  * @exportDoc
  359.  */
  360. shaka.extern.Cue.prototype.nestedCues;
  362. /**
  363.  * Whether or not the cue only acts as a line break between two nested cues.
  364.  * Should only appear in nested cues.
  365.  * @type {boolean}
  366.  * @exportDoc
  367.  */
  368. shaka.extern.Cue.prototype.spacer;
  371. /**
  372.  * An interface for plugins that parse text tracks.
  373.  *
  374.  * @interface
  375.  * @exportDoc
  376.  */
  377. shaka.extern.TextParser = function() {};
  380. /**
  381.  * A collection of time offsets used to adjust text cue times.
  382.  *
  383.  * @typedef {{
  384.  *   periodStart: number,
  385.  *   segmentStart: ?number,
  386.  *   segmentEnd: number
  387.  * }}
  388.  *
  389.  * @property {number} periodStart
  390.  *     The absolute start time of the period in seconds.
  391.  * @property {?number} segmentStart
  392.  *     The absolute start time of the segment in seconds.
  393.  *     Null if the manifest does not provide this information, such as in HLS.
  394.  * @property {number} segmentEnd
  395.  *     The absolute end time of the segment in seconds.
  396.  *
  397.  * @exportDoc
  398.  */
  399. shaka.extern.TextParser.TimeContext;
  402. /**
  403.  * Parse an initialization segment. Some formats do not have init
  404.  * segments so this won't always be called.
  405.  *
  406.  * @param {!Uint8Array} data
  407.  *    The data that makes up the init segment.
  408.  *
  409.  * @exportDoc
  410.  */
  411. shaka.extern.TextParser.prototype.parseInit = function(data) {};
  414. /**
  415.  * Parse a media segment and return the cues that make up the segment.
  416.  *
  417.  * @param {!Uint8Array} data
  418.  *    The next section of buffer.
  419.  * @param {shaka.extern.TextParser.TimeContext} timeContext
  420.  *    The time information that should be used to adjust the times values
  421.  *    for each cue.
  422.  * @return {!Array.<!shaka.extern.Cue>}
  423.  *
  424.  * @exportDoc
  425.  */
  426. shaka.extern.TextParser.prototype.parseMedia = function(data, timeContext) {};
  429. /**
  430.  * @typedef {function(new:shaka.extern.TextParser)}
  431.  * @exportDoc
  432.  */
  433. shaka.extern.TextParserPlugin;
  436. /**
  437.  * An interface for plugins that display text.
  438.  *
  439.  * @interface
  440.  * @extends {shaka.util.IDestroyable}
  441.  * @exportDoc
  442.  */
  443. shaka.extern.TextDisplayer = function() {};
  446. /**
  447.  * @override
  448.  * @exportDoc
  449.  */
  450. shaka.extern.TextDisplayer.prototype.destroy = function() {};
  453. /**
  454.  * Append given text cues to the list of cues to be displayed.
  455.  *
  456.  * @param {!Array.<!shaka.text.Cue>} cues
  457.  *    Text cues to be appended.
  458.  *
  459.  * @exportDoc
  460.  */
  461. shaka.extern.TextDisplayer.prototype.append = function(cues) {};
  464. /**
  465.  * Remove all cues that are fully contained by the given time range (relative
  466.  * to the presentation). |endTime| will be greater to equal to |startTime|.
  467.  * |remove| should only return |false| if the displayer has been destroyed. If
  468.  * the displayer has not been destroyed |remove| should return |true|.
  469.  *
  470.  * @param {number} startTime
  471.  * @param {number} endTime
  472.  *
  473.  * @return {boolean}
  474.  *
  475.  * @exportDoc
  476.  */
  477. shaka.extern.TextDisplayer.prototype.remove = function(startTime, endTime) {};
  480. /**
  481.  * Returns true if text is currently visible.
  482.  *
  483.  * @return {boolean}
  484.  *
  485.  * @exportDoc
  486.  */
  487. shaka.extern.TextDisplayer.prototype.isTextVisible = function() {};
  490. /**
  491.  * Set text visibility.
  492.  *
  493.  * @param {boolean} on
  494.  *
  495.  * @exportDoc
  496.  */
  497. shaka.extern.TextDisplayer.prototype.setTextVisibility = function(on) {};
  500. /**
  501.  * A factory for creating a TextDisplayer.
  502.  *
  503.  * @typedef {function(new:shaka.extern.TextDisplayer)}
  504.  * @exportDoc
  505.  */
  506. shaka.extern.TextDisplayer.Factory;