Source: lib/cea/cea_utils.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.cea.CeaUtils');
  8. goog.provide('shaka.cea.CeaUtils.StyledChar');
  10. goog.require('shaka.cea.ICaptionDecoder');
  11. goog.require('shaka.text.Cue');
  14. shaka.cea.CeaUtils = class {
  15.   /**
  16.    * Emits a closed caption based on the state of the buffer.
  17.    * @param {!shaka.text.Cue} topLevelCue
  18.    * @param {!string} stream
  19.    * @param {!Array<!Array<?shaka.cea.CeaUtils.StyledChar>>} memory
  20.    * @param {!number} startTime Start time of the cue.
  21.    * @param {!number} endTime End time of the cue.
  22.    * @return {?shaka.cea.ICaptionDecoder.ClosedCaption}
  23.    */
  24.   static getParsedCaption(topLevelCue, stream, memory, startTime, endTime) {
  25.     if (startTime >= endTime) {
  26.       return null;
  27.     }
  29.     // Find the first and last row that contains characters.
  30.     let firstNonEmptyRow = -1;
  31.     let lastNonEmptyRow = -1;
  33.     for (let i = 0; i < memory.length; i++) {
  34.       if (memory[i].some((e) => e != null && e.getChar().trim() != '')) {
  35.         firstNonEmptyRow = i;
  36.         break;
  37.       }
  38.     }
  40.     for (let i = memory.length - 1; i >= 0; i--) {
  41.       if (memory[i].some((e) => e != null && e.getChar().trim() != '')) {
  42.         lastNonEmptyRow = i;
  43.         break;
  44.       }
  45.     }
  47.     // Exit early if no non-empty row was found.
  48.     if (firstNonEmptyRow === -1 || lastNonEmptyRow === -1) {
  49.       return null;
  50.     }
  52.     // Keeps track of the current styles for a cue being emitted.
  53.     let currentUnderline = false;
  54.     let currentItalics = false;
  55.     let currentTextColor = shaka.cea.CeaUtils.DEFAULT_TXT_COLOR;
  56.     let currentBackgroundColor = shaka.cea.CeaUtils.DEFAULT_BG_COLOR;
  58.     // Create first cue that will be nested in top level cue. Default styles.
  59.     let currentCue = shaka.cea.CeaUtils.createStyledCue(
  60.         startTime, endTime, currentUnderline, currentItalics,
  61.         currentTextColor, currentBackgroundColor);
  63.     // Logic: Reduce rows into a single top level cue containing nested cues.
  64.     // Each nested cue corresponds either a style change or a line break.
  66.     for (let i = firstNonEmptyRow; i <= lastNonEmptyRow; i++) {
  67.       // Find the first and last non-empty characters in this row. We do this so
  68.       // no styles creep in before/after the first and last non-empty chars.
  69.       const row = memory[i];
  70.       let firstNonEmptyCol = -1;
  71.       let lastNonEmptyCol = -1;
  73.       for (let j = 0; j < row.length; j++) {
  74.         if (row[j] != null && row[j].getChar().trim() !== '') {
  75.           firstNonEmptyCol = j;
  76.           break;
  77.         }
  78.       }
  80.       for (let j = row.length - 1; j >= 0; j--) {
  81.         if (row[j] != null && row[j].getChar().trim() !== '') {
  82.           lastNonEmptyCol = j;
  83.           break;
  84.         }
  85.       }
  87.       // If no non-empty char. was found in this row, it must be a linebreak.
  88.       if (firstNonEmptyCol === -1 || lastNonEmptyCol === -1) {
  89.         const linebreakCue = shaka.cea.CeaUtils
  90.             .createLineBreakCue(startTime, endTime);
  91.         topLevelCue.nestedCues.push(linebreakCue);
  92.         continue;
  93.       }
  95.       for (let j = firstNonEmptyCol; j <= lastNonEmptyCol; j++) {
  96.         const styledChar = row[j];
  98.         // A null between non-empty cells in a row is handled as a space.
  99.         if (!styledChar) {
  100.           currentCue.payload += ' ';
  101.           continue;
  102.         }
  103.         const underline = styledChar.isUnderlined();
  104.         const italics = styledChar.isItalicized();
  105.         const textColor = styledChar.getTextColor();
  106.         const backgroundColor = styledChar.getBackgroundColor();
  108.         // If any style properties have changed, we need to open a new cue.
  109.         if (underline != currentUnderline || italics != currentItalics ||
  110.             textColor != currentTextColor ||
  111.             backgroundColor != currentBackgroundColor) {
  112.           // Push the currently built cue and start a new cue, with new styles.
  113.           if (currentCue.payload) {
  114.             topLevelCue.nestedCues.push(currentCue);
  115.           }
  116.           currentCue = shaka.cea.CeaUtils.createStyledCue(
  117.               startTime, endTime, underline,
  118.               italics, textColor, backgroundColor);
  120.           currentUnderline = underline;
  121.           currentItalics = italics;
  122.           currentTextColor = textColor;
  123.           currentBackgroundColor = backgroundColor;
  124.         }
  126.         currentCue.payload += styledChar.getChar();
  127.       }
  128.       if (currentCue.payload) {
  129.         topLevelCue.nestedCues.push(currentCue);
  130.       }
  132.       // Add a linebreak since the row just ended.
  133.       if (i !== lastNonEmptyRow) {
  134.         const linebreakCue = shaka.cea.CeaUtils
  135.             .createLineBreakCue(startTime, endTime);
  136.         topLevelCue.nestedCues.push(linebreakCue);
  137.       }
  139.       // Create a new cue.
  140.       currentCue = shaka.cea.CeaUtils.createStyledCue(
  141.           startTime, endTime, currentUnderline, currentItalics,
  142.           currentTextColor, currentBackgroundColor);
  143.     }
  145.     if (topLevelCue.nestedCues.length) {
  146.       return {
  147.         cue: topLevelCue,
  148.         stream,
  149.       };
  150.     }
  152.     return null;
  153.   }
  155.   /**
  156.    * @param {!number} startTime
  157.    * @param {!number} endTime
  158.    * @param {!boolean} underline
  159.    * @param {!boolean} italics
  160.    * @param {!string} txtColor
  161.    * @param {!string} bgColor
  162.    * @return {!shaka.text.Cue}
  163.    */
  164.   static createStyledCue(startTime, endTime, underline,
  165.       italics, txtColor, bgColor) {
  166.     const cue = new shaka.text.Cue(startTime, endTime, /* payload= */ '');
  167.     if (underline) {
  168.       cue.textDecoration.push(shaka.text.Cue.textDecoration.UNDERLINE);
  169.     }
  170.     if (italics) {
  171.       cue.fontStyle = shaka.text.Cue.fontStyle.ITALIC;
  172.     }
  173.     cue.color = txtColor;
  174.     cue.backgroundColor = bgColor;
  175.     return cue;
  176.   }
  178.   /**
  179.    * @param {!number} startTime
  180.    * @param {!number} endTime
  181.    * @return {!shaka.text.Cue}
  182.    */
  183.   static createLineBreakCue(startTime, endTime) {
  184.     const linebreakCue = new shaka.text.Cue(
  185.         startTime, endTime, /* payload= */ '');
  186.     linebreakCue.lineBreak = true;
  187.     return linebreakCue;
  188.   }
  189. };
  191. shaka.cea.CeaUtils.StyledChar = class {
  192.   /**
  193.    * @param {string} character
  194.    * @param {boolean} underline
  195.    * @param {boolean} italics
  196.    * @param {string} backgroundColor
  197.    * @param {string} textColor
  198.    */
  199.   constructor(character, underline, italics, backgroundColor, textColor) {
  200.     /**
  201.      * @private {!string}
  202.      */
  203.     this.character_ = character;
  205.     /**
  206.      * @private {!boolean}
  207.      */
  208.     this.underline_ = underline;
  210.     /**
  211.      * @private {!boolean}
  212.      */
  213.     this.italics_ = italics;
  215.     /**
  216.      * @private {!string}
  217.      */
  218.     this.backgroundColor_ = backgroundColor;
  220.     /**
  221.      * @private {!string}
  222.      */
  223.     this.textColor_ = textColor;
  224.   }
  226.   /**
  227.    * @return {!string}
  228.    */
  229.   getChar() {
  230.     return this.character_;
  231.   }
  233.   /**
  234.    * @return {!boolean}
  235.    */
  236.   isUnderlined() {
  237.     return this.underline_;
  238.   }
  240.   /**
  241.    * @return {!boolean}
  242.    */
  243.   isItalicized() {
  244.     return this.italics_;
  245.   }
  247.   /**
  248.    * @return {!string}
  249.    */
  250.   getBackgroundColor() {
  251.     return this.backgroundColor_;
  252.   }
  254.   /**
  255.    * @return {!string}
  256.    */
  257.   getTextColor() {
  258.     return this.textColor_;
  259.   }
  260. };
  262. /**
  263.  * Default background color for text.
  264.  * @const {!string}
  265.  */
  266. shaka.cea.CeaUtils.DEFAULT_BG_COLOR = 'black';
  268. /**
  269.  * Default text color.
  270.  * @const {!string}
  271.  */
  272. shaka.cea.CeaUtils.DEFAULT_TXT_COLOR = 'white';