Source: lib/text/cue.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.text.Cue');
  8. goog.provide('shaka.text.CueRegion');
  10. goog.require('shaka.util.ArrayUtils');
  13. /**
  14.  * @implements {shaka.extern.Cue}
  15.  * @export
  16.  */
  17. shaka.text.Cue = class {
  18.   /**
  19.    * @param {number} startTime
  20.    * @param {number} endTime
  21.    * @param {string} payload
  22.    */
  23.   constructor(startTime, endTime, payload) {
  24.     const Cue = shaka.text.Cue;
  26.     /**
  27.      * @override
  28.      * @exportInterface
  29.      */
  30.     this.startTime = startTime;
  32.     /**
  33.      * @override
  34.      * @exportInterface
  35.      */
  36.     this.direction = Cue.direction.HORIZONTAL_LEFT_TO_RIGHT;
  38.     /**
  39.      * @override
  40.      * @exportInterface
  41.      */
  42.     this.endTime = endTime;
  44.     /**
  45.      * @override
  46.      * @exportInterface
  47.      */
  48.     this.payload = payload;
  50.     /**
  51.      * @override
  52.      * @exportInterface
  53.      */
  54.     this.region = new shaka.text.CueRegion();
  56.     /**
  57.      * @override
  58.      * @exportInterface
  59.      */
  60.     this.position = null;
  62.     /**
  63.      * @override
  64.      * @exportInterface
  65.      */
  66.     this.positionAlign = Cue.positionAlign.AUTO;
  68.     /**
  69.      * @override
  70.      * @exportInterface
  71.      */
  72.     this.size = 0;
  74.     /**
  75.      * @override
  76.      * @exportInterface
  77.      */
  78.     this.textAlign = Cue.textAlign.CENTER;
  80.     /**
  81.      * @override
  82.      * @exportInterface
  83.      */
  84.     this.writingMode = Cue.writingMode.HORIZONTAL_TOP_TO_BOTTOM;
  86.     /**
  87.      * @override
  88.      * @exportInterface
  89.      */
  90.     this.lineInterpretation = Cue.lineInterpretation.LINE_NUMBER;
  92.     /**
  93.      * @override
  94.      * @exportInterface
  95.      */
  96.     this.line = null;
  98.     /**
  99.      * @override
  100.      * @exportInterface
  101.      */
  102.     this.lineHeight = '';
  104.     /**
  105.      * Line Alignment is set to start by default.
  106.      * @override
  107.      * @exportInterface
  108.      */
  109.     this.lineAlign = Cue.lineAlign.START;
  111.     /**
  112.      * Set the captions at the bottom of the text container by default.
  113.      * @override
  114.      * @exportInterface
  115.      */
  116.     this.displayAlign = Cue.displayAlign.AFTER;
  118.     /**
  119.      * @override
  120.      * @exportInterface
  121.      */
  122.     this.color = '';
  124.     /**
  125.      * @override
  126.      * @exportInterface
  127.      */
  128.     this.backgroundColor = '';
  130.     /**
  131.      * @override
  132.      * @exportInterface
  133.      */
  134.     this.backgroundImage = '';
  136.     /**
  137.      * @override
  138.      * @exportInterface
  139.      */
  140.     this.border = '';
  142.     /**
  143.      * @override
  144.      * @exportInterface
  145.      */
  146.     this.textShadow = '';
  148.     /**
  149.      * @override
  150.      * @exportInterface
  151.      */
  152.     this.textStrokeColor = '';
  154.     /**
  155.      * @override
  156.      * @exportInterface
  157.      */
  158.     this.textStrokeWidth = '';
  160.     /**
  161.      * @override
  162.      * @exportInterface
  163.      */
  164.     this.fontSize = '';
  166.     /**
  167.      * @override
  168.      * @exportInterface
  169.      */
  170.     this.fontWeight = Cue.fontWeight.NORMAL;
  172.     /**
  173.      * @override
  174.      * @exportInterface
  175.      */
  176.     this.fontStyle = Cue.fontStyle.NORMAL;
  178.     /**
  179.      * @override
  180.      * @exportInterface
  181.      */
  182.     this.fontFamily = '';
  184.     /**
  185.      * @override
  186.      * @exportInterface
  187.      */
  188.     this.letterSpacing = '';
  190.     /**
  191.      * @override
  192.      * @exportInterface
  193.      */
  194.     this.linePadding = '';
  196.     /**
  197.      * @override
  198.      * @exportInterface
  199.      */
  200.     this.opacity = 1;
  202.     /**
  203.      * @override
  204.      * @exportInterface
  205.      */
  206.     this.textDecoration = [];
  208.     /**
  209.      * @override
  210.      * @exportInterface
  211.      */
  212.     this.wrapLine = true;
  214.     /**
  215.      * @override
  216.      * @exportInterface
  217.      */
  218.     this.id = '';
  220.     /**
  221.      * @override
  222.      * @exportInterface
  223.      */
  224.     this.nestedCues = [];
  226.     /**
  227.      * @override
  228.      * @exportInterface
  229.      */
  230.     this.isContainer = false;
  232.     /**
  233.      * @override
  234.      * @exportInterface
  235.      */
  236.     this.lineBreak = false;
  238.     /**
  239.      * @override
  240.      * @exportInterface
  241.      */
  242.     this.spacer = false;
  244.     /**
  245.      * @override
  246.      * @exportInterface
  247.      */
  248.     this.cellResolution = {
  249.       columns: 32,
  250.       rows: 15,
  251.     };
  252.   }
  254.   /**
  255.    * @param {number} start
  256.    * @param {number} end
  257.    * @return {!shaka.text.Cue}
  258.    */
  259.   static lineBreak(start, end) {
  260.     const cue = new shaka.text.Cue(start, end, '');
  261.     cue.lineBreak = true;
  262.     return cue;
  263.   }
  265.   /**
  266.    * Create a copy of the cue with the same properties.
  267.    * @return {!shaka.text.Cue}
  268.    * @suppress {checkTypes} since we must use [] and "in" with a struct type.
  269.    */
  270.   clone() {
  271.     const clone = new shaka.text.Cue(0, 0, '');
  273.     for (const k in this) {
  274.       clone[k] = this[k];
  276.       // Make copies of array fields, but only one level deep.  That way, if we
  277.       // change, for instance, textDecoration on the clone, we don't affect the
  278.       // original.
  279.       if (clone[k] && clone[k].constructor == Array) {
  280.         clone[k] = /** @type {!Array} */(clone[k]).slice();
  281.       }
  282.     }
  284.     return clone;
  285.   }
  287.   /**
  288.    * Check if two Cues have all the same values in all properties.
  289.    * @param {!shaka.text.Cue} cue1
  290.    * @param {!shaka.text.Cue} cue2
  291.    * @return {boolean}
  292.    * @suppress {checkTypes} since we must use [] and "in" with a struct type.
  293.    */
  294.   static equal(cue1, cue2) {
  295.     // Compare the start time, end time and payload of the cues first for
  296.     // performance optimization.  We can avoid the more expensive recursive
  297.     // checks if the top-level properties don't match.
  298.     // See: https://github.com/shaka-project/shaka-player/issues/3018
  299.     if (cue1.startTime != cue2.startTime || cue1.endTime != cue2.endTime ||
  300.       cue1.payload != cue2.payload) {
  301.       return false;
  302.     }
  303.     for (const k in cue1) {
  304.       if (k == 'startTime' || k == 'endTime' || k == 'payload') {
  305.         // Already compared.
  306.       } else if (k == 'nestedCues') {
  307.         // This uses shaka.text.Cue.equal rather than just this.equal, since
  308.         // otherwise recursing here will unbox the method and cause "this" to be
  309.         // undefined in deeper recursion.
  310.         if (!shaka.util.ArrayUtils.equal(
  311.             cue1.nestedCues, cue2.nestedCues, shaka.text.Cue.equal)) {
  312.           return false;
  313.         }
  314.       } else if (k == 'region' || k == 'cellResolution') {
  315.         for (const k2 in cue1[k]) {
  316.           if (cue1[k][k2] != cue2[k][k2]) {
  317.             return false;
  318.           }
  319.         }
  320.       } else if (Array.isArray(cue1[k])) {
  321.         if (!shaka.util.ArrayUtils.equal(cue1[k], cue2[k])) {
  322.           return false;
  323.         }
  324.       } else {
  325.         if (cue1[k] != cue2[k]) {
  326.           return false;
  327.         }
  328.       }
  329.     }
  331.     return true;
  332.   }
  333. };
  336. /**
  337.  * @enum {string}
  338.  * @export
  339.  */
  340. shaka.text.Cue.positionAlign = {
  341.   'LEFT': 'line-left',
  342.   'RIGHT': 'line-right',
  343.   'CENTER': 'center',
  344.   'AUTO': 'auto',
  345. };
  348. /**
  349.  * @enum {string}
  350.  * @export
  351.  */
  352. shaka.text.Cue.textAlign = {
  353.   'LEFT': 'left',
  354.   'RIGHT': 'right',
  355.   'CENTER': 'center',
  356.   'START': 'start',
  357.   'END': 'end',
  358. };
  361. /**
  362.  * Vertical alignments of the cues within their extents.
  363.  * 'BEFORE' means displaying at the top of the captions container box, 'CENTER'
  364.  *  means in the middle, 'AFTER' means at the bottom.
  365.  * @enum {string}
  366.  * @export
  367.  */
  368. shaka.text.Cue.displayAlign = {
  369.   'BEFORE': 'before',
  370.   'CENTER': 'center',
  371.   'AFTER': 'after',
  372. };
  375. /**
  376.  * @enum {string}
  377.  * @export
  378.  */
  379. shaka.text.Cue.direction = {
  380.   'HORIZONTAL_LEFT_TO_RIGHT': 'ltr',
  381.   'HORIZONTAL_RIGHT_TO_LEFT': 'rtl',
  382. };
  385. /**
  386.  * @enum {string}
  387.  * @export
  388.  */
  389. shaka.text.Cue.writingMode = {
  390.   'HORIZONTAL_TOP_TO_BOTTOM': 'horizontal-tb',
  391.   'VERTICAL_LEFT_TO_RIGHT': 'vertical-lr',
  392.   'VERTICAL_RIGHT_TO_LEFT': 'vertical-rl',
  393. };
  396. /**
  397.  * @enum {number}
  398.  * @export
  399.  */
  400. shaka.text.Cue.lineInterpretation = {
  401.   'LINE_NUMBER': 0,
  402.   'PERCENTAGE': 1,
  403. };
  406. /**
  407.  * @enum {string}
  408.  * @export
  409.  */
  410. shaka.text.Cue.lineAlign = {
  411.   'CENTER': 'center',
  412.   'START': 'start',
  413.   'END': 'end',
  414. };
  417. /**
  418.  * Default text color according to
  419.  * https://w3c.github.io/webvtt/#default-text-color
  420.  * @enum {string}
  421.  * @export
  422.  */
  423. shaka.text.Cue.defaultTextColor = {
  424.   'white': '#FFF',
  425.   'lime': '#0F0',
  426.   'cyan': '#0FF',
  427.   'red': '#F00',
  428.   'yellow': '#FF0',
  429.   'magenta': '#F0F',
  430.   'blue': '#00F',
  431.   'black': '#000',
  432. };
  435. /**
  436.  * Default text background color according to
  437.  * https://w3c.github.io/webvtt/#default-text-background
  438.  * @enum {string}
  439.  * @export
  440.  */
  441. shaka.text.Cue.defaultTextBackgroundColor = {
  442.   'bg_white': '#FFF',
  443.   'bg_lime': '#0F0',
  444.   'bg_cyan': '#0FF',
  445.   'bg_red': '#F00',
  446.   'bg_yellow': '#FF0',
  447.   'bg_magenta': '#F0F',
  448.   'bg_blue': '#00F',
  449.   'bg_black': '#000',
  450. };
  453. /**
  454.  * In CSS font weight can be a number, where 400 is normal and 700 is bold.
  455.  * Use these values for the enum for consistency.
  456.  * @enum {number}
  457.  * @export
  458.  */
  459. shaka.text.Cue.fontWeight = {
  460.   'NORMAL': 400,
  461.   'BOLD': 700,
  462. };
  465. /**
  466.  * @enum {string}
  467.  * @export
  468.  */
  469. shaka.text.Cue.fontStyle = {
  470.   'NORMAL': 'normal',
  471.   'ITALIC': 'italic',
  472.   'OBLIQUE': 'oblique',
  473. };
  476. /**
  477.  * @enum {string}
  478.  * @export
  479.  */
  480. shaka.text.Cue.textDecoration = {
  481.   'UNDERLINE': 'underline',
  482.   'LINE_THROUGH': 'lineThrough',
  483.   'OVERLINE': 'overline',
  484. };
  487. /**
  488.  * @implements {shaka.extern.CueRegion}
  489.  * @struct
  490.  * @export
  491.  */
  492. shaka.text.CueRegion = class {
  493.   /** */
  494.   constructor() {
  495.     const CueRegion = shaka.text.CueRegion;
  497.     /**
  498.      * @override
  499.      * @exportInterface
  500.      */
  501.     this.id = '';
  503.     /**
  504.      * @override
  505.      * @exportInterface
  506.      */
  507.     this.viewportAnchorX = 0;
  509.     /**
  510.      * @override
  511.      * @exportInterface
  512.      */
  513.     this.viewportAnchorY = 0;
  515.     /**
  516.      * @override
  517.      * @exportInterface
  518.      */
  519.     this.regionAnchorX = 0;
  521.     /**
  522.      * @override
  523.      * @exportInterface
  524.      */
  525.     this.regionAnchorY = 0;
  527.     /**
  528.      * @override
  529.      * @exportInterface
  530.      */
  531.     this.width = 100;
  533.     /**
  534.      * @override
  535.      * @exportInterface
  536.      */
  537.     this.height = 100;
  539.     /**
  540.      * @override
  541.      * @exportInterface
  542.      */
  543.     this.heightUnits = CueRegion.units.PERCENTAGE;
  545.     /**
  546.      * @override
  547.      * @exportInterface
  548.      */
  549.     this.widthUnits = CueRegion.units.PERCENTAGE;
  551.     /**
  552.      * @override
  553.      * @exportInterface
  554.      */
  555.     this.viewportAnchorUnits = CueRegion.units.PERCENTAGE;
  557.     /**
  558.      * @override
  559.      * @exportInterface
  560.      */
  561.     this.scroll = CueRegion.scrollMode.NONE;
  562.   }
  563. };
  566. /**
  567.  * @enum {number}
  568.  * @export
  569.  */
  570. shaka.text.CueRegion.units = {
  571.   'PX': 0,
  572.   'PERCENTAGE': 1,
  573.   'LINES': 2,
  574. };
  577. /**
  578.  * @enum {string}
  579.  * @export
  580.  */
  581. shaka.text.CueRegion.scrollMode = {
  582.   'NONE': '',
  583.   'UP': 'up',
  584. };