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.text.Cue');
  13. shaka.cea.CeaUtils = class {
  14.   /**
  15.    * Emits a closed caption based on the state of the buffer.
  16.    * @param {!shaka.text.Cue} topLevelCue
  17.    * @param {string} stream
  18.    * @param {!Array<!Array<?shaka.cea.CeaUtils.StyledChar>>} memory
  19.    * @param {number} startTime Start time of the cue.
  20.    * @param {number} endTime End time of the cue.
  21.    * @return {?shaka.extern.ICaptionDecoder.ClosedCaption}
  22.    */
  23.   static getParsedCaption(topLevelCue, stream, memory, startTime, endTime) {
  24.     if (startTime >= endTime) {
  25.       return null;
  26.     }
  28.     // Find the first and last row that contains characters.
  29.     let firstNonEmptyRow = -1;
  30.     let lastNonEmptyRow = -1;
  32.     for (let i = 0; i < memory.length; i++) {
  33.       if (memory[i].some((e) => e != null && e.getChar().trim() != '')) {
  34.         firstNonEmptyRow = i;
  35.         break;
  36.       }
  37.     }
  39.     for (let i = memory.length - 1; i >= 0; i--) {
  40.       if (memory[i].some((e) => e != null && e.getChar().trim() != '')) {
  41.         lastNonEmptyRow = i;
  42.         break;
  43.       }
  44.     }
  46.     // Exit early if no non-empty row was found.
  47.     if (firstNonEmptyRow === -1 || lastNonEmptyRow === -1) {
  48.       return null;
  49.     }
  51.     // Keeps track of the current styles for a cue being emitted.
  52.     let currentUnderline = false;
  53.     let currentItalics = false;
  54.     let currentTextColor = shaka.cea.CeaUtils.DEFAULT_TXT_COLOR;
  55.     let currentBackgroundColor = shaka.cea.CeaUtils.DEFAULT_BG_COLOR;
  57.     // Create first cue that will be nested in top level cue. Default styles.
  58.     let currentCue = shaka.cea.CeaUtils.createStyledCue(
  59.         startTime, endTime, currentUnderline, currentItalics,
  60.         currentTextColor, currentBackgroundColor);
  62.     // Logic: Reduce rows into a single top level cue containing nested cues.
  63.     // Each nested cue corresponds either a style change or a line break.
  65.     for (let i = firstNonEmptyRow; i <= lastNonEmptyRow; i++) {
  66.       // Find the first and last non-empty characters in this row. We do this so
  67.       // no styles creep in before/after the first and last non-empty chars.
  68.       const row = memory[i];
  69.       let firstNonEmptyCol = -1;
  70.       let lastNonEmptyCol = -1;
  72.       for (let j = 0; j < row.length; j++) {
  73.         if (row[j] != null && row[j].getChar().trim() !== '') {
  74.           firstNonEmptyCol = j;
  75.           break;
  76.         }
  77.       }
  79.       for (let j = row.length - 1; j >= 0; j--) {
  80.         if (row[j] != null && row[j].getChar().trim() !== '') {
  81.           lastNonEmptyCol = j;
  82.           break;
  83.         }
  84.       }
  86.       // If no non-empty char. was found in this row, it must be a linebreak.
  87.       if (firstNonEmptyCol === -1 || lastNonEmptyCol === -1) {
  88.         const linebreakCue = shaka.cea.CeaUtils
  89.             .createLineBreakCue(startTime, endTime);
  90.         topLevelCue.nestedCues.push(linebreakCue);
  91.         continue;
  92.       }
  94.       for (let j = firstNonEmptyCol; j <= lastNonEmptyCol; j++) {
  95.         const styledChar = row[j];
  97.         // A null between non-empty cells in a row is handled as a space.
  98.         if (!styledChar) {
  99.           currentCue.payload += ' ';
  100.           continue;
  101.         }
  102.         const underline = styledChar.isUnderlined();
  103.         const italics = styledChar.isItalicized();
  104.         const textColor = styledChar.getTextColor();
  105.         const backgroundColor = styledChar.getBackgroundColor();
  107.         // If any style properties have changed, we need to open a new cue.
  108.         if (underline != currentUnderline || italics != currentItalics ||
  109.             textColor != currentTextColor ||
  110.             backgroundColor != currentBackgroundColor) {
  111.           // Push the currently built cue and start a new cue, with new styles.
  112.           if (currentCue.payload) {
  113.             topLevelCue.nestedCues.push(currentCue);
  114.           }
  115.           currentCue = shaka.cea.CeaUtils.createStyledCue(
  116.               startTime, endTime, underline,
  117.               italics, textColor, backgroundColor);
  119.           currentUnderline = underline;
  120.           currentItalics = italics;
  121.           currentTextColor = textColor;
  122.           currentBackgroundColor = backgroundColor;
  123.         }
  125.         currentCue.payload += styledChar.getChar();
  126.       }
  127.       if (currentCue.payload) {
  128.         topLevelCue.nestedCues.push(currentCue);
  129.       }
  131.       // Add a linebreak since the row just ended.
  132.       if (i !== lastNonEmptyRow) {
  133.         const linebreakCue = shaka.cea.CeaUtils
  134.             .createLineBreakCue(startTime, endTime);
  135.         topLevelCue.nestedCues.push(linebreakCue);
  136.       }
  138.       // Create a new cue.
  139.       currentCue = shaka.cea.CeaUtils.createStyledCue(
  140.           startTime, endTime, currentUnderline, currentItalics,
  141.           currentTextColor, currentBackgroundColor);
  142.     }
  144.     if (topLevelCue.nestedCues.length) {
  145.       return {
  146.         cue: topLevelCue,
  147.         stream,
  148.       };
  149.     }
  151.     return null;
  152.   }
  154.   /**
  155.    * @param {number} startTime
  156.    * @param {number} endTime
  157.    * @param {boolean} underline
  158.    * @param {boolean} italics
  159.    * @param {string} txtColor
  160.    * @param {string} bgColor
  161.    * @return {!shaka.text.Cue}
  162.    */
  163.   static createStyledCue(startTime, endTime, underline,
  164.       italics, txtColor, bgColor) {
  165.     const cue = new shaka.text.Cue(startTime, endTime, /* payload= */ '');
  166.     if (underline) {
  167.       cue.textDecoration.push(shaka.text.Cue.textDecoration.UNDERLINE);
  168.     }
  169.     if (italics) {
  170.       cue.fontStyle = shaka.text.Cue.fontStyle.ITALIC;
  171.     }
  172.     cue.color = txtColor;
  173.     cue.backgroundColor = bgColor;
  174.     return cue;
  175.   }
  177.   /**
  178.    * @param {number} startTime
  179.    * @param {number} endTime
  180.    * @return {!shaka.text.Cue}
  181.    */
  182.   static createLineBreakCue(startTime, endTime) {
  183.     const linebreakCue = new shaka.text.Cue(
  184.         startTime, endTime, /* payload= */ '');
  185.     linebreakCue.lineBreak = true;
  186.     return linebreakCue;
  187.   }
  188. };
  190. shaka.cea.CeaUtils.StyledChar = class {
  191.   /**
  192.    * @param {string} character
  193.    * @param {boolean} underline
  194.    * @param {boolean} italics
  195.    * @param {string} backgroundColor
  196.    * @param {string} textColor
  197.    */
  198.   constructor(character, underline, italics, backgroundColor, textColor) {
  199.     /**
  200.      * @private {string}
  201.      */
  202.     this.character_ = character;
  204.     /**
  205.      * @private {boolean}
  206.      */
  207.     this.underline_ = underline;
  209.     /**
  210.      * @private {boolean}
  211.      */
  212.     this.italics_ = italics;
  214.     /**
  215.      * @private {string}
  216.      */
  217.     this.backgroundColor_ = backgroundColor;
  219.     /**
  220.      * @private {string}
  221.      */
  222.     this.textColor_ = textColor;
  223.   }
  225.   /**
  226.    * @return {string}
  227.    */
  228.   getChar() {
  229.     return this.character_;
  230.   }
  232.   /**
  233.    * @return {boolean}
  234.    */
  235.   isUnderlined() {
  236.     return this.underline_;
  237.   }
  239.   /**
  240.    * @return {boolean}
  241.    */
  242.   isItalicized() {
  243.     return this.italics_;
  244.   }
  246.   /**
  247.    * @return {string}
  248.    */
  249.   getBackgroundColor() {
  250.     return this.backgroundColor_;
  251.   }
  253.   /**
  254.    * @return {string}
  255.    */
  256.   getTextColor() {
  257.     return this.textColor_;
  258.   }
  259. };
  261. /**
  262.  * Default background color for text.
  263.  * @const {string}
  264.  */
  265. shaka.cea.CeaUtils.DEFAULT_BG_COLOR = 'black';
  267. /**
  268.  * Default text color.
  269.  * @const {string}
  270.  */
  271. shaka.cea.CeaUtils.DEFAULT_TXT_COLOR = 'white';
  273. /**
  274.  * NALU type for Supplemental Enhancement Information (SEI) for H.264.
  275.  * @const {number}
  276.  */
  277. shaka.cea.CeaUtils.H264_NALU_TYPE_SEI = 0x06;
  279. /**
  280.  * NALU type for Supplemental Enhancement Information (SEI) for H.265.
  281.  * @const {number}
  282.  */
  283. shaka.cea.CeaUtils.H265_PREFIX_NALU_TYPE_SEI = 0x27;
  285. /**
  286.  * NALU type for Supplemental Enhancement Information (SEI) for H.265.
  287.  * @const {number}
  288.  */
  289. shaka.cea.CeaUtils.H265_SUFFIX_NALU_TYPE_SEI = 0x28;
  291. /**
  292.  * NALU type for Supplemental Enhancement Information (SEI) for H.266.
  293.  * @const {number}
  294.  */
  295. shaka.cea.CeaUtils.H266_PREFIX_NALU_TYPE_SEI = 0x17;
  297. /**
  298.  * NALU type for Supplemental Enhancement Information (SEI) for H.266.
  299.  * @const {number}
  300.  */
  301. shaka.cea.CeaUtils.H266_SUFFIX_NALU_TYPE_SEI = 0x18;
  303. /**
  304.  * Default timescale value for a track.
  305.  * @const {number}
  306.  */
  307. shaka.cea.CeaUtils.DEFAULT_TIMESCALE_VALUE = 90000;