Source: lib/cea/cea708_window.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.cea.Cea708Window');
  9. goog.require('shaka.cea.CeaUtils');
  10. goog.require('shaka.cea.CeaUtils.StyledChar');
  11. goog.require('shaka.cea.ICaptionDecoder');
  12. goog.require('shaka.text.Cue');
  13. goog.require('shaka.util.Functional');
  16. /**
  17.  * CEA-708 Window. Each CEA-708 service owns 8 of these.
  18.  */
  19. shaka.cea.Cea708Window = class {
  20.   /**
  21.    * @param {number} windowNum
  22.    */
  23.   constructor(windowNum) {
  24.     /**
  25.      * A number from 0 - 7 indicating the window number in the
  26.      * service that owns this window.
  27.      * @private {number}
  28.      */
  29.     this.windowNum_ = windowNum;
  31.     /**
  32.      * Indicates whether this window is visible.
  33.      * @private {boolean}
  34.      */
  35.     this.visible_ = false;
  37.     /**
  38.      * Indicates whether the horizontal and vertical anchors coordinates specify
  39.      * a percentage of the screen, or physical coordinates on the screen.
  40.      * @private {boolean}
  41.      */
  42.     this.relativeToggle_ = false;
  44.     /**
  45.      * Horizontal anchor. Loosely corresponds to a WebVTT viewport X anchor.
  46.      * @private {number}
  47.      */
  48.     this.horizontalAnchor_ = 0;
  50.     /**
  51.      * Vertical anchor. Loosely corresponds to a WebVTT viewport Y anchor.
  52.      * @private {number}
  53.      */
  54.     this.verticalAnchor_ = 0;
  56.     /**
  57.      * If valid, ranges from 0 to 8, specifying one of 9 locations on window:
  58.      * 0________1________2
  59.      * |        |        |
  60.      * 3________4________5
  61.      * |        |        |
  62.      * 6________7________8
  63.      * Diagram is valid as per CEA-708-E section 8.4.4.
  64.      * Each of these locations corresponds to a WebVTT region's "region anchor".
  65.      * @private {number}
  66.      */
  67.     this.anchorId_ = 0;
  69.     /**
  70.      * Indicates the number of rows in this window's buffer/memory.
  71.      * @private {number}
  72.      */
  73.     this.rowCount_ = 0;
  75.     /**
  76.      * Indicates the number of columns in this window's buffer/memory.
  77.      * @private {number}
  78.      */
  79.     this.colCount_ = 0;
  81.     /**
  82.      * Center by default.
  83.      * @private {!shaka.cea.Cea708Window.TextJustification}
  84.      */
  85.     this.justification_ = shaka.cea.Cea708Window.TextJustification.CENTER;
  87.     /**
  88.      * An array of rows of styled characters, representing the
  89.      * current text and styling of text in this window.
  90.      * @private {!Array<!Array<?shaka.cea.CeaUtils.StyledChar>>}
  91.      */
  92.     this.memory_ = [];
  94.     /**
  95.      * @private {number}
  96.      */
  97.     this.startTime_ = 0;
  99.     /**
  100.      * Row that the current pen is pointing at.
  101.      * @private {number}
  102.      */
  103.     this.row_ = 0;
  105.     /**
  106.      * Column that the current pen is pointing at.
  107.      * @private {number}
  108.      */
  109.     this.col_ = 0;
  111.     /**
  112.      * Indicates whether the current pen position is italicized.
  113.      * @private {boolean}
  114.      */
  115.     this.italics_ = false;
  117.     /**
  118.      * Indicates whether the current pen position is underlined.
  119.      * @private {boolean}
  120.      */
  121.     this.underline_ = false;
  123.     /**
  124.      * Indicates the text color at the current pen position.
  125.      * @private {string}
  126.      */
  127.     this.textColor_ = shaka.cea.CeaUtils.DEFAULT_TXT_COLOR;
  129.     /**
  130.      * Indicates the background color at the current pen position.
  131.      * @private {string}
  132.      */
  133.     this.backgroundColor_ = shaka.cea.CeaUtils.DEFAULT_BG_COLOR;
  135.     this.resetMemory();
  137.     // TODO Support window positioning by mapping them to Regions.
  138.     // https://dvcs.w3.org/hg/text-tracks/raw-file/default/608toVTT/608toVTT.html#positioning-in-cea-708
  139.     shaka.util.Functional.ignored(this.verticalAnchor_, this.relativeToggle_,
  140.         this.horizontalAnchor_, this.anchorId_, this.windowNum_);
  141.   }
  143.   /**
  144.    * @param {boolean} visible
  145.    * @param {number} verticalAnchor
  146.    * @param {number} horizontalAnchor
  147.    * @param {number} anchorId
  148.    * @param {boolean} relativeToggle
  149.    * @param {number} rowCount
  150.    * @param {number} colCount
  151.    */
  152.   defineWindow(visible, verticalAnchor, horizontalAnchor, anchorId,
  153.       relativeToggle, rowCount, colCount) {
  154.     this.visible_ = visible;
  155.     this.verticalAnchor_ = verticalAnchor;
  156.     this.horizontalAnchor_ = horizontalAnchor;
  157.     this.anchorId_ = anchorId;
  158.     this.relativeToggle_ = relativeToggle;
  159.     this.rowCount_ = rowCount;
  160.     this.colCount_ = colCount;
  161.   }
  163.   /**
  164.    * Resets the memory buffer.
  165.    */
  166.   resetMemory() {
  167.     this.memory_ = [];
  168.     for (let i = 0; i < shaka.cea.Cea708Window.MAX_ROWS; i++) {
  169.       this.memory_.push(this.createNewRow_());
  170.     }
  171.   }
  173.   /**
  174.    * Allocates and returns a new row.
  175.    * @return {!Array<?shaka.cea.CeaUtils.StyledChar>}
  176.    * @private
  177.    */
  178.   createNewRow_() {
  179.     const row = [];
  180.     for (let j = 0; j < shaka.cea.Cea708Window.MAX_COLS; j++) {
  181.       row.push(null);
  182.     }
  183.     return row;
  184.   }
  186.   /**
  187.    * Sets the unicode value for a char at the current pen location.
  188.    * @param {string} char
  189.    */
  190.   setCharacter(char) {
  191.     // Check if the pen is out of bounds.
  192.     if (!this.isPenInBounds_()) {
  193.       return;
  194.     }
  196.     const cea708Char = new shaka.cea.CeaUtils.StyledChar(
  197.         char, this.underline_, this.italics_,
  198.         this.backgroundColor_, this.textColor_);
  199.     this.memory_[this.row_][this.col_] = cea708Char;
  201.     // Increment column
  202.     this.col_ ++;
  203.   }
  205.   /**
  206.    * Erases a character from the buffer and moves the pen back.
  207.    */
  208.   backspace() {
  209.     if (!this.isPenInBounds_()) {
  210.       return;
  211.     }
  213.     // Check if a backspace can be done.
  214.     if (this.col_ <= 0 && this.row_ <= 0) {
  215.       return;
  216.     }
  218.     if (this.col_ <= 0) {
  219.       // Move pen back a row.
  220.       this.col_ = this.colCount_ - 1;
  221.       this.row_--;
  222.     } else {
  223.       // Move pen back a column.
  224.       this.col_--;
  225.     }
  227.     // Erase the character occupied at that position.
  228.     this.memory_[this.row_][this.col_] = null;
  229.   }
  231.   /**
  232.    * @private
  233.    */
  234.   isPenInBounds_() {
  235.     const inRowBounds = this.row_ < this.rowCount_ && this.row_ >= 0;
  236.     const inColBounds = this.col_ < this.colCount_ && this.col_ >= 0;
  237.     return inRowBounds && inColBounds;
  238.   }
  240.   /**
  241.    * @return {boolean}
  242.    */
  243.   isVisible() {
  244.     return this.visible_;
  245.   }
  247.   /**
  248.    * Moves up <count> rows in the buffer.
  249.    * @param {number} count
  250.    * @private
  251.    */
  252.   moveUpRows_(count) {
  253.     let dst = 0; // Row each row should be moved to.
  255.     // Move existing rows up by <count>.
  256.     for (let i = count; i < shaka.cea.Cea708Window.MAX_ROWS; i++, dst++) {
  257.       this.memory_[dst] = this.memory_[i];
  258.     }
  260.     // Create <count> new rows at the bottom.
  261.     for (let i = 0; i < count; i++, dst++) {
  262.       this.memory_[dst] = this.createNewRow_();
  263.     }
  264.   }
  266.   /**
  267.    * Handles CR. Increments row - if last row, "roll up" all rows by one.
  268.    */
  269.   carriageReturn() {
  270.     if (this.row_ + 1 >= this.rowCount_) {
  271.       this.moveUpRows_(1);
  272.       this.col_ = 0;
  273.       return;
  274.     }
  276.     this.row_++;
  277.     this.col_ = 0;
  278.   }
  280.   /**
  281.    * Handles HCR. Moves the pen to the beginning of the cur. row and clears it.
  282.    */
  283.   horizontalCarriageReturn() {
  284.     this.memory_[this.row_] = this.createNewRow_();
  285.     this.col_ = 0;
  286.   }
  288.   /**
  289.    * @param {number} endTime
  290.    * @param {number} serviceNumber Number of the service emitting this caption.
  291.    * @return {?shaka.cea.ICaptionDecoder.ClosedCaption}
  292.    */
  293.   forceEmit(endTime, serviceNumber) {
  294.     const stream = `svc${serviceNumber}`;
  295.     const TextJustification = shaka.cea.Cea708Window.TextJustification;
  296.     const topLevelCue = new shaka.text.Cue(
  297.         this.startTime_, endTime, /* payload= */ '');
  299.     if (this.justification_ === TextJustification.LEFT) {
  300.       // LEFT justified.
  301.       topLevelCue.textAlign = shaka.text.Cue.textAlign.LEFT;
  302.     } else if (this.justification_ === TextJustification.RIGHT) {
  303.       // RIGHT justified.
  304.       topLevelCue.textAlign = shaka.text.Cue.textAlign.RIGHT;
  305.     } else {
  306.       // CENTER justified. Both FULL and CENTER are handled as CENTER justified.
  307.       topLevelCue.textAlign = shaka.text.Cue.textAlign.CENTER;
  308.     }
  310.     const caption = shaka.cea.CeaUtils.getParsedCaption(
  311.         topLevelCue, stream, this.memory_, this.startTime_, endTime);
  312.     if (caption) {
  313.       // If a caption is being emitted, then the next caption's start time
  314.       // should be no less than this caption's end time.
  315.       this.setStartTime(endTime);
  316.     }
  317.     return caption;
  318.   }
  320.   /**
  321.    * @param {number} row
  322.    * @param {number} col
  323.    */
  324.   setPenLocation(row, col) {
  325.     this.row_ = row;
  326.     this.col_ = col;
  327.   }
  329.   /**
  330.    * @param {string} backgroundColor
  331.    */
  332.   setPenBackgroundColor(backgroundColor) {
  333.     this.backgroundColor_ = backgroundColor;
  334.   }
  336.   /**
  337.    * @param {string} textColor
  338.    */
  339.   setPenTextColor(textColor) {
  340.     this.textColor_ = textColor;
  341.   }
  343.   /**
  344.    * @param {boolean} underline
  345.    */
  346.   setPenUnderline(underline) {
  347.     this.underline_ = underline;
  348.   }
  350.   /**
  351.    * @param {boolean} italics
  352.    */
  353.   setPenItalics(italics) {
  354.     this.italics_ = italics;
  355.   }
  357.   /** Reset the pen to 0,0 with default styling. */
  358.   resetPen() {
  359.     this.row_ = 0;
  360.     this.col_ = 0;
  361.     this.underline_ = false;
  362.     this.italics_ = false;
  363.     this.textColor_ = shaka.cea.CeaUtils.DEFAULT_TXT_COLOR;
  364.     this.backgroundColor_ = shaka.cea.CeaUtils.DEFAULT_BG_COLOR;
  365.   }
  367.   /**
  368.    * @param {!shaka.cea.Cea708Window.TextJustification} justification
  369.    */
  370.   setJustification(justification) {
  371.     this.justification_ = justification;
  372.   }
  374.   /**
  375.    * Sets the window to visible.
  376.    */
  377.   display() {
  378.     this.visible_ = true;
  379.   }
  381.   /**
  382.    * Sets the window to invisible.
  383.    */
  384.   hide() {
  385.     this.visible_ = false;
  386.   }
  388.   /**
  389.    * Toggles the visibility of the window.
  390.    */
  391.   toggle() {
  392.     this.visible_ = !this.visible_;
  393.   }
  395.   /**
  396.    * Sets the start time for the cue to be emitted.
  397.    * @param {number} pts
  398.    */
  399.   setStartTime(pts) {
  400.     this.startTime_ = pts;
  401.   }
  402. };
  404. /**
  405.  * Caption type.
  406.  * @const @enum {number}
  407.  */
  408. shaka.cea.Cea708Window.TextJustification = {
  409.   LEFT: 0,
  410.   RIGHT: 1,
  411.   CENTER: 2,
  412.   FULL: 3,
  413. };
  415. /**
  416.  * Can be indexed 0-31 for 4:3 format, and 0-41 for 16:9 formats.
  417.  * Thus the absolute maximum is 42 columns for the 16:9 format.
  418.  * @private @const {number}
  419.  */
  420. shaka.cea.Cea708Window.MAX_COLS = 42;
  422. /**
  423.  * Maximum of 15 rows that can be indexed from 0 to 14.
  424.  * @private @const {number}
  425.  */
  426. shaka.cea.Cea708Window.MAX_ROWS = 15;