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.     // The explicit type here is to work around an apparent compiler bug where
  45.     // the compiler seems to get confused about the type.  Since we are
  46.     // overriding the interface type, it shouldn't be necessary to do this.
  47.     // Compiler version 20200517.
  48.     /**
  49.      * @override
  50.      * @exportInterface
  51.      * @type {string}
  52.      */
  53.     this.payload = payload;
  55.     /**
  56.      * @override
  57.      * @exportInterface
  58.      */
  59.     this.region = new shaka.text.CueRegion();
  61.     /**
  62.      * @override
  63.      * @exportInterface
  64.      */
  65.     this.position = null;
  67.     /**
  68.      * @override
  69.      * @exportInterface
  70.      */
  71.     this.positionAlign = Cue.positionAlign.AUTO;
  73.     /**
  74.      * @override
  75.      * @exportInterface
  76.      */
  77.     this.size = 0;
  79.     /**
  80.      * @override
  81.      * @exportInterface
  82.      */
  83.     this.textAlign = Cue.textAlign.CENTER;
  85.     /**
  86.      * @override
  87.      * @exportInterface
  88.      */
  89.     this.writingMode = Cue.writingMode.HORIZONTAL_TOP_TO_BOTTOM;
  91.     /**
  92.      * @override
  93.      * @exportInterface
  94.      */
  95.     this.lineInterpretation = Cue.lineInterpretation.LINE_NUMBER;
  97.     /**
  98.      * @override
  99.      * @exportInterface
  100.      */
  101.     this.line = null;
  103.     /**
  104.      * @override
  105.      * @exportInterface
  106.      */
  107.     this.lineHeight = '';
  109.     /**
  110.      * Line Alignment is set to start by default.
  111.      * @override
  112.      * @exportInterface
  113.      */
  114.     this.lineAlign = Cue.lineAlign.START;
  116.     /**
  117.      * Set the captions at the bottom of the text container by default.
  118.      * @override
  119.      * @exportInterface
  120.      */
  121.     this.displayAlign = Cue.displayAlign.AFTER;
  123.     /**
  124.      * @override
  125.      * @exportInterface
  126.      */
  127.     this.color = '';
  129.     /**
  130.      * @override
  131.      * @exportInterface
  132.      */
  133.     this.backgroundColor = '';
  135.     /**
  136.      * @override
  137.      * @exportInterface
  138.      */
  139.     this.backgroundImage = '';
  141.     /**
  142.      * @override
  143.      * @exportInterface
  144.      */
  145.     this.border = '';
  147.     /**
  148.      * @override
  149.      * @exportInterface
  150.      */
  151.     this.fontSize = '';
  153.     /**
  154.      * @override
  155.      * @exportInterface
  156.      */
  157.     this.fontWeight = Cue.fontWeight.NORMAL;
  159.     /**
  160.      * @override
  161.      * @exportInterface
  162.      */
  163.     this.fontStyle = Cue.fontStyle.NORMAL;
  165.     /**
  166.      * @override
  167.      * @exportInterface
  168.      */
  169.     this.fontFamily = '';
  171.     /**
  172.      * @override
  173.      * @exportInterface
  174.      */
  175.     this.letterSpacing = '';
  177.     /**
  178.      * @override
  179.      * @exportInterface
  180.      */
  181.     this.linePadding = '';
  183.     /**
  184.      * @override
  185.      * @exportInterface
  186.      */
  187.     this.opacity = 1;
  189.     /**
  190.      * @override
  191.      * @exportInterface
  192.      */
  193.     this.textDecoration = [];
  195.     /**
  196.      * @override
  197.      * @exportInterface
  198.      */
  199.     this.wrapLine = true;
  201.     /**
  202.      * @override
  203.      * @exportInterface
  204.      */
  205.     this.id = '';
  207.     /**
  208.      * @override
  209.      * @exportInterface
  210.      */
  211.     this.nestedCues = [];
  213.     /**
  214.      * @override
  215.      * @exportInterface
  216.      */
  217.     this.lineBreak = false;
  219.     /**
  220.      * @override
  221.      * @exportInterface
  222.      */
  223.     this.spacer = false;
  225.     /**
  226.      * @override
  227.      * @exportInterface
  228.      */
  229.     this.cellResolution = {
  230.       columns: 32,
  231.       rows: 15,
  232.     };
  233.   }
  235.   /**
  236.    * @param {number} start
  237.    * @param {number} end
  238.    * @return {!shaka.text.Cue}
  239.    */
  240.   static lineBreak(start, end) {
  241.     const cue = new shaka.text.Cue(start, end, '');
  242.     cue.lineBreak = true;
  243.     return cue;
  244.   }
  246.   /**
  247.    * Create a copy of the cue with the same properties.
  248.    * @return {!shaka.text.Cue}
  249.    * @suppress {checkTypes} since we must use [] and "in" with a struct type.
  250.    */
  251.   clone() {
  252.     const clone = new shaka.text.Cue(0, 0, '');
  254.     for (const k in this) {
  255.       clone[k] = this[k];
  257.       // Make copies of array fields, but only one level deep.  That way, if we
  258.       // change, for instance, textDecoration on the clone, we don't affect the
  259.       // original.
  260.       if (clone[k] && clone[k].constructor == Array) {
  261.         clone[k] = /** @type {!Array} */(clone[k]).slice();
  262.       }
  263.     }
  265.     return clone;
  266.   }
  268.   /**
  269.    * Check if two Cues have all the same values in all properties.
  270.    * @param {!shaka.text.Cue} cue1
  271.    * @param {!shaka.text.Cue} cue2
  272.    * @return {boolean}
  273.    * @suppress {checkTypes} since we must use [] and "in" with a struct type.
  274.    */
  275.   static equal(cue1, cue2) {
  276.     // Compare the start time, end time and payload of the cues first for
  277.     // performance optimization.  We can avoid the more expensive recursive
  278.     // checks if the top-level properties don't match.
  279.     // See: https://github.com/google/shaka-player/issues/3018
  280.     if (cue1.startTime != cue2.startTime || cue1.endTime != cue2.endTime ||
  281.       cue1.payload != cue2.payload) {
  282.       return false;
  283.     }
  284.     for (const k in cue1) {
  285.       if (k == 'startTime' || k == 'endTime' || k == 'payload') {
  286.         // Already compared.
  287.       } else if (k == 'nestedCues') {
  288.         // This uses shaka.text.Cue.equal rather than just this.equal, since
  289.         // otherwise recursing here will unbox the method and cause "this" to be
  290.         // undefined in deeper recursion.
  291.         if (!shaka.util.ArrayUtils.equal(
  292.             cue1.nestedCues, cue2.nestedCues, shaka.text.Cue.equal)) {
  293.           return false;
  294.         }
  295.       } else if (k == 'region' || k == 'cellResolution') {
  296.         for (const k2 in cue1[k]) {
  297.           if (cue1[k][k2] != cue2[k][k2]) {
  298.             return false;
  299.           }
  300.         }
  301.       } else if (Array.isArray(cue1[k])) {
  302.         if (!shaka.util.ArrayUtils.equal(cue1[k], cue2[k])) {
  303.           return false;
  304.         }
  305.       } else {
  306.         if (cue1[k] != cue2[k]) {
  307.           return false;
  308.         }
  309.       }
  310.     }
  312.     return true;
  313.   }
  314. };
  317. /**
  318.  * @enum {string}
  319.  * @export
  320.  */
  321. shaka.text.Cue.positionAlign = {
  322.   'LEFT': 'line-left',
  323.   'RIGHT': 'line-right',
  324.   'CENTER': 'center',
  325.   'AUTO': 'auto',
  326. };
  329. /**
  330.  * @enum {string}
  331.  * @export
  332.  */
  333. shaka.text.Cue.textAlign = {
  334.   'LEFT': 'left',
  335.   'RIGHT': 'right',
  336.   'CENTER': 'center',
  337.   'START': 'start',
  338.   'END': 'end',
  339. };
  342. /**
  343.  * Vertical alignments of the cues within their extents.
  344.  * 'BEFORE' means displaying at the top of the captions container box, 'CENTER'
  345.  *  means in the middle, 'AFTER' means at the bottom.
  346.  * @enum {string}
  347.  * @export
  348.  */
  349. shaka.text.Cue.displayAlign = {
  350.   'BEFORE': 'before',
  351.   'CENTER': 'center',
  352.   'AFTER': 'after',
  353. };
  356. /**
  357.  * @enum {string}
  358.  * @export
  359.  */
  360. shaka.text.Cue.direction = {
  361.   'HORIZONTAL_LEFT_TO_RIGHT': 'ltr',
  362.   'HORIZONTAL_RIGHT_TO_LEFT': 'rtl',
  363. };
  366. /**
  367.  * @enum {string}
  368.  * @export
  369.  */
  370. shaka.text.Cue.writingMode = {
  371.   'HORIZONTAL_TOP_TO_BOTTOM': 'horizontal-tb',
  372.   'VERTICAL_LEFT_TO_RIGHT': 'vertical-lr',
  373.   'VERTICAL_RIGHT_TO_LEFT': 'vertical-rl',
  374. };
  377. /**
  378.  * @enum {number}
  379.  * @export
  380.  */
  381. shaka.text.Cue.lineInterpretation = {
  382.   'LINE_NUMBER': 0,
  383.   'PERCENTAGE': 1,
  384. };
  387. /**
  388.  * @enum {string}
  389.  * @export
  390.  */
  391. shaka.text.Cue.lineAlign = {
  392.   'CENTER': 'center',
  393.   'START': 'start',
  394.   'END': 'end',
  395. };
  398. /**
  399.  * Default text color according to
  400.  * https://w3c.github.io/webvtt/#default-text-color
  401.  * @enum {string}
  402.  * @export
  403.  */
  404. shaka.text.Cue.defaultTextColor = {
  405.   'white': '#FFF',
  406.   'lime': '#0F0',
  407.   'cyan': '#0FF',
  408.   'red': '#F00',
  409.   'yellow': '#FF0',
  410.   'magenta': '#F0F',
  411.   'blue': '#00F',
  412.   'black': '#000',
  413. };
  416. /**
  417.  * Default text background color according to
  418.  * https://w3c.github.io/webvtt/#default-text-background
  419.  * @enum {string}
  420.  * @export
  421.  */
  422. shaka.text.Cue.defaultTextBackgroundColor = {
  423.   'bg_white': '#FFF',
  424.   'bg_lime': '#0F0',
  425.   'bg_cyan': '#0FF',
  426.   'bg_red': '#F00',
  427.   'bg_yellow': '#FF0',
  428.   'bg_magenta': '#F0F',
  429.   'bg_blue': '#00F',
  430.   'bg_black': '#000',
  431. };
  434. /**
  435.  * In CSS font weight can be a number, where 400 is normal and 700 is bold.
  436.  * Use these values for the enum for consistency.
  437.  * @enum {number}
  438.  * @export
  439.  */
  440. shaka.text.Cue.fontWeight = {
  441.   'NORMAL': 400,
  442.   'BOLD': 700,
  443. };
  446. /**
  447.  * @enum {string}
  448.  * @export
  449.  */
  450. shaka.text.Cue.fontStyle = {
  451.   'NORMAL': 'normal',
  452.   'ITALIC': 'italic',
  453.   'OBLIQUE': 'oblique',
  454. };
  457. /**
  458.  * @enum {string}
  459.  * @export
  460.  */
  461. shaka.text.Cue.textDecoration = {
  462.   'UNDERLINE': 'underline',
  463.   'LINE_THROUGH': 'lineThrough',
  464.   'OVERLINE': 'overline',
  465. };
  468. /**
  469.  * @implements {shaka.extern.CueRegion}
  470.  * @struct
  471.  * @export
  472.  */
  473. shaka.text.CueRegion = class {
  474.   /** */
  475.   constructor() {
  476.     const CueRegion = shaka.text.CueRegion;
  478.     /**
  479.      * @override
  480.      * @exportInterface
  481.      */
  482.     this.id = '';
  484.     /**
  485.      * @override
  486.      * @exportInterface
  487.      */
  488.     this.viewportAnchorX = 0;
  490.     /**
  491.      * @override
  492.      * @exportInterface
  493.      */
  494.     this.viewportAnchorY = 0;
  496.     /**
  497.      * @override
  498.      * @exportInterface
  499.      */
  500.     this.regionAnchorX = 0;
  502.     /**
  503.      * @override
  504.      * @exportInterface
  505.      */
  506.     this.regionAnchorY = 0;
  508.     /**
  509.      * @override
  510.      * @exportInterface
  511.      */
  512.     this.width = 100;
  514.     /**
  515.      * @override
  516.      * @exportInterface
  517.      */
  518.     this.height = 100;
  520.     /**
  521.      * @override
  522.      * @exportInterface
  523.      */
  524.     this.heightUnits = CueRegion.units.PERCENTAGE;
  526.     /**
  527.      * @override
  528.      * @exportInterface
  529.      */
  530.     this.widthUnits = CueRegion.units.PERCENTAGE;
  532.     /**
  533.      * @override
  534.      * @exportInterface
  535.      */
  536.     this.viewportAnchorUnits = CueRegion.units.PERCENTAGE;
  538.     /**
  539.      * @override
  540.      * @exportInterface
  541.      */
  542.     this.scroll = CueRegion.scrollMode.NONE;
  543.   }
  544. };
  547. /**
  548.  * @enum {number}
  549.  * @export
  550.  */
  551. shaka.text.CueRegion.units = {
  552.   'PX': 0,
  553.   'PERCENTAGE': 1,
  554.   'LINES': 2,
  555. };
  558. /**
  559.  * @enum {string}
  560.  * @export
  561.  */
  562. shaka.text.CueRegion.scrollMode = {
  563.   'NONE': '',
  564.   'UP': 'up',
  565. };