Source: lib/cea/cea608_data_channel.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.cea.Cea608DataChannel');
  9. goog.require('shaka.cea.Cea608Memory');
  10. goog.require('shaka.cea.CeaUtils');
  11. goog.require('shaka.log');
  14. /**
  15.  * 608 closed captions channel.
  16.  */
  17. shaka.cea.Cea608DataChannel = class {
  18.   /**
  19.    * @param {number} fieldNum Field number.
  20.    * @param {number} channelNum Channel number.
  21.    */
  22.   constructor(fieldNum, channelNum) {
  23.     /**
  24.      * Current Caption Type.
  25.      * @public {!shaka.cea.Cea608DataChannel.CaptionType}
  26.      */
  27.     this.type_ = shaka.cea.Cea608DataChannel.CaptionType.NONE;
  29.     /**
  30.      * Text buffer for CEA-608 "text mode". Although, we don't emit text mode.
  31.      * So, this buffer serves as a no-op placeholder, just in case we receive
  32.      * captions that toggle text mode.
  33.      * @private @const {!shaka.cea.Cea608Memory}
  34.      */
  35.     this.text_ =
  36.         new shaka.cea.Cea608Memory(fieldNum, channelNum);
  38.     /**
  39.      * Displayed memory.
  40.      * @private {!shaka.cea.Cea608Memory}
  41.      */
  42.     this.displayedMemory_ =
  43.         new shaka.cea.Cea608Memory(fieldNum, channelNum);
  45.     /**
  46.      * Non-displayed memory.
  47.      * @private {!shaka.cea.Cea608Memory}
  48.      */
  49.     this.nonDisplayedMemory_ =
  50.         new shaka.cea.Cea608Memory(fieldNum, channelNum);
  52.     /**
  53.      * Points to current buffer.
  54.      * @private {!shaka.cea.Cea608Memory}
  55.      */
  56.     this.curbuf_ = this.nonDisplayedMemory_;
  58.     /**
  59.      * End time of the previous caption, serves as start time of next caption.
  60.      * @private {number}
  61.      */
  62.     this.prevEndTime_ = 0;
  64.     /**
  65.      * Last control pair, 16 bits representing byte 1 and byte 2
  66.      * @private {?number}
  67.      */
  68.     this.lastcp_ = null;
  69.   }
  71.   /**
  72.    * Resets channel state.
  73.    */
  74.   reset() {
  75.     this.type_ = shaka.cea.Cea608DataChannel.CaptionType.NONE;
  76.     this.curbuf_ = this.nonDisplayedMemory_;
  77.     this.lastcp_ = null;
  78.     this.displayedMemory_.reset();
  79.     this.nonDisplayedMemory_.reset();
  80.     this.text_.reset();
  81.   }
  83.   /**
  84.    * Set the initial PTS, which may not be 0 if we start decoding at a later
  85.    * point in the stream.  Without this, the first cue's startTime can be way
  86.    * off.
  87.    *
  88.    * @param {number} pts
  89.    */
  90.   firstPts(pts) {
  91.     this.prevEndTime_ = pts;
  92.   }
  94.   /**
  95.    * Gets the row index from a Preamble Address Code byte pair.
  96.    * @param {number} b1 Byte 1.
  97.    * @param {number} b2 Byte 2.
  98.    * @return {number} Row index.
  99.    * @private
  100.    */
  101.   pacToRow_(b1, b2) {
  102.     const ccrowtab = [
  103.       11, 11,  // 0x00 or 0x01
  104.       1, 2,    // 0x02 -> 0x03
  105.       3, 4,    // 0x04 -> 0x05
  106.       12, 13,  // 0x06 -> 0x07
  107.       14, 15,  // 0x08 -> 0x09
  108.       5, 6,    // 0x0A -> 0x0B
  109.       7, 8,    // 0x0C -> 0x0D
  110.       9, 10,   // 0x0E -> 0x0F
  111.     ];
  112.     return ccrowtab[((b1 & 0x07) << 1) | ((b2 >> 5) & 0x01)];
  113.   }
  115.   /**
  116.    * PAC - Preamble Address Code.
  117.    * b1 is of the form |P|0|0|1|C|0|ROW|
  118.    * b2 is of the form |P|1|N|ATTRIBUTE|U|
  119.    * @param {number} b1 Byte 1.
  120.    * @param {number} b2 Byte 2.
  121.    * @private
  122.    */
  123.   controlPac_(b1, b2) {
  124.     const row = this.pacToRow_(b1, b2);
  126.     // Get attribute bits (4 bits)
  127.     const attr = (b2 & 0x1E) >> 1;
  129.     // Set up the defaults.
  130.     let textColor = shaka.cea.CeaUtils.DEFAULT_TXT_COLOR;
  131.     let italics = false;
  134.     // Attributes < 7 are colors, = 7 is white w/ italics, and >7 are indents
  135.     if (attr < 7) {
  136.       textColor = shaka.cea.Cea608DataChannel.TEXT_COLORS[attr];
  137.     } else if (attr === 7) {
  138.       italics = true; // color stays white
  139.     }
  141.     // PACs toggle underline on the last bit of b2.
  142.     const underline = (b2 & 0x01) === 0x01;
  144.     if (this.type_ === shaka.cea.Cea608DataChannel.CaptionType.TEXT) {
  145.       // Don't execute the PAC if in text mode.
  146.       return;
  147.     }
  149.     // Execute the PAC.
  150.     const buf = this.curbuf_;
  152.     // Move entire scroll window to a new base in rollup mode.
  153.     if (this.type_ === shaka.cea.Cea608DataChannel.CaptionType.ROLLUP &&
  154.         row !== buf.getRow()) {
  155.       const oldTopRow = 1 + buf.getRow() - buf.getScrollSize();
  156.       const newTopRow = 1 + row - buf.getScrollSize();
  158.       // Shift up the scroll window.
  159.       buf.moveRows(newTopRow, oldTopRow, buf.getScrollSize());
  161.       // Clear everything outside of the new scroll window.
  162.       buf.resetRows(0, newTopRow - 1);
  163.       buf.resetRows(row + 1,
  164.           shaka.cea.Cea608Memory.CC_ROWS - row);
  165.     }
  166.     buf.setRow(row);
  168.     buf.setUnderline(underline);
  169.     buf.setItalics(italics);
  170.     buf.setTextColor(textColor);
  172.     // Clear the background color, since new row (PAC) should reset ALL styles.
  173.     buf.setBackgroundColor(shaka.cea.CeaUtils.DEFAULT_BG_COLOR);
  174.   }
  176.   /**
  177.    * Mid-Row control code handler.
  178.    * @param {number} b2 Byte #2.
  179.    * @private
  180.    */
  181.   controlMidrow_(b2) {
  182.     // Clear all pre-existing midrow style attributes.
  183.     this.curbuf_.setUnderline(false);
  184.     this.curbuf_.setItalics(false);
  185.     this.curbuf_.setTextColor(shaka.cea.CeaUtils.DEFAULT_TXT_COLOR);
  187.     // Mid-row attrs use a space.
  188.     this.curbuf_.addChar(
  189.         shaka.cea.Cea608Memory.CharSet.BASIC_NORTH_AMERICAN, ' '.charCodeAt(0));
  191.     let textColor = shaka.cea.CeaUtils.DEFAULT_TXT_COLOR;
  192.     let italics = false;
  194.     // Midrow codes set underline on last (LSB) bit.
  195.     const underline = (b2 & 0x01) === 0x01;
  197.     // b2 has the form |P|0|1|0|STYLE|U|
  198.     textColor = shaka.cea.Cea608DataChannel.TEXT_COLORS[(b2 & 0xe) >> 1];
  199.     if (textColor === 'white_italics') {
  200.       textColor = 'white';
  201.       italics = true;
  202.     }
  204.     this.curbuf_.setUnderline(underline);
  205.     this.curbuf_.setItalics(italics);
  206.     this.curbuf_.setTextColor(textColor);
  207.   }
  209.   /**
  210.    * Background attribute control code handler.
  211.    * @param {number} b1 Byte #1
  212.    * @param {number} b2 Byte #2.
  213.    * @private
  214.    */
  215.   controlBackgroundAttribute_(b1, b2) {
  216.     let backgroundColor = shaka.cea.CeaUtils.DEFAULT_BG_COLOR;
  217.     if ((b1 & 0x07) === 0x0) {
  218.       // If background provided, last 3 bits of b1 are |0|0|0|. Color is in b2.
  219.       backgroundColor = shaka.cea.Cea608DataChannel.BG_COLORS[(b2 & 0xe) >> 1];
  220.     }
  221.     this.curbuf_.setBackgroundColor(backgroundColor);
  222.   }
  224.   /**
  225.    * The Cea608DataChannel control methods implement all CC control operations.
  226.    * @param {!shaka.cea.Cea608DataChannel.Cea608Packet} ccPacket
  227.    * @return {?shaka.extern.ICaptionDecoder.ClosedCaption}
  228.    * @private
  229.    */
  230.   controlMiscellaneous_(ccPacket) {
  231.     const MiscCmd = shaka.cea.Cea608DataChannel.MiscCmd_;
  232.     const b2 = ccPacket.ccData2;
  233.     const pts = ccPacket.pts;
  234.     let parsedClosedCaption = null;
  236.     switch (b2) {
  237.       case MiscCmd.RCL:
  238.         this.controlRcl_();
  239.         break;
  240.       case MiscCmd.BS:
  241.         this.controlBs_();
  242.         break;
  243.         // unused (alarm off and alarm on)
  244.       case MiscCmd.AOD:
  245.       case MiscCmd.AON:
  246.         break;
  247.       case MiscCmd.DER:
  248.         // Delete to End of Row. Not implemented since position not supported.
  249.         break;
  250.       case MiscCmd.RU2:
  251.         parsedClosedCaption = this.controlRu_(2, pts);
  252.         break;
  253.       case MiscCmd.RU3:
  254.         parsedClosedCaption = this.controlRu_(3, pts);
  255.         break;
  256.       case MiscCmd.RU4:
  257.         parsedClosedCaption = this.controlRu_(4, pts);
  258.         break;
  259.       case MiscCmd.FON:
  260.         this.controlFon_();
  261.         break;
  262.       case MiscCmd.RDC:
  263.         this.controlRdc_(pts);
  264.         break;
  265.       case MiscCmd.TR:
  266.         this.controlTr_();
  267.         break;
  268.       case MiscCmd.RTD:
  269.         this.controlRtd_();
  270.         break;
  271.       case MiscCmd.EDM:
  272.         parsedClosedCaption = this.controlEdm_(pts);
  273.         break;
  274.       case MiscCmd.CR:
  275.         parsedClosedCaption = this.controlCr_(pts);
  276.         break;
  277.       case MiscCmd.ENM:
  278.         this.controlEnm_();
  279.         break;
  280.       case MiscCmd.EOC:
  281.         parsedClosedCaption = this.controlEoc_(pts);
  282.         break;
  283.     }
  284.     return parsedClosedCaption;
  285.   }
  287.   /**
  288.    * Handles CR - Carriage Return (Start new row).
  289.    * CR only affects scroll windows (Rollup and Text modes).
  290.    * Any currently buffered line needs to be emitted, along
  291.    * with a window scroll action.
  292.    * @param {number} pts in seconds.
  293.    * @return {?shaka.extern.ICaptionDecoder.ClosedCaption}
  294.    * @private
  295.    */
  296.   controlCr_(pts) {
  297.     const buf = this.curbuf_;
  298.     // Only rollup and text mode is affected, but we don't emit text mode.
  299.     if (this.type_ !== shaka.cea.Cea608DataChannel.CaptionType.ROLLUP) {
  300.       return null;
  301.     }
  302.     // Force out the scroll window since the top row will cleared.
  303.     const parsedClosedCaption = buf.forceEmit(this.prevEndTime_, pts);
  305.     // Calculate the top of the scroll window.
  306.     const toprow = (buf.getRow() - buf.getScrollSize()) + 1;
  308.     // Shift up the window one row higher.
  309.     buf.moveRows(toprow - 1, toprow, buf.getScrollSize());
  311.     // Clear out anything that's outside of our current scroll window.
  312.     buf.resetRows(0, toprow - 1);
  313.     buf.resetRows(buf.getRow(), shaka.cea.Cea608Memory.CC_ROWS - buf.getRow());
  315.     // Update the end time so the next caption emits starting at this time.
  316.     this.prevEndTime_ = pts;
  317.     return parsedClosedCaption;
  318.   }
  320.   /**
  321.    * Handles RU2, RU3, RU4 - Roll-Up, N rows.
  322.    * If in TEXT, POPON or PAINTON, any displayed captions are erased.
  323.    *    This means must force emit entire display buffer.
  324.    * @param {number} scrollSize New scroll window size.
  325.    * @param {number} pts
  326.    * @return {?shaka.extern.ICaptionDecoder.ClosedCaption}
  327.    * @private
  328.    */
  329.   controlRu_(scrollSize, pts) {
  330.     this.curbuf_ = this.displayedMemory_;  // Point to displayed memory
  331.     const buf = this.curbuf_;
  332.     let parsedClosedCaption = null;
  334.     // For any type except rollup and text mode, it should be emitted,
  335.     // and memories cleared.
  336.     if (this.type_ !== shaka.cea.Cea608DataChannel.CaptionType.ROLLUP &&
  337.         this.type_ !== shaka.cea.Cea608DataChannel.CaptionType.TEXT) {
  338.       parsedClosedCaption = buf.forceEmit(this.prevEndTime_, pts);
  340.       // Clear both memories.
  341.       this.displayedMemory_.eraseBuffer();
  342.       this.nonDisplayedMemory_.eraseBuffer();
  344.       // Rollup base row defaults to the last row (15).
  345.       buf.setRow(shaka.cea.Cea608Memory.CC_ROWS);
  346.     }
  347.     this.type_ = shaka.cea.Cea608DataChannel.CaptionType.ROLLUP;
  349.     // Set the new rollup window size.
  350.     buf.setScrollSize(scrollSize);
  351.     return parsedClosedCaption;
  352.   }
  354.   /**
  355.    * Handles flash on.
  356.    * @private
  357.    */
  358.   controlFon_() {
  359.     this.curbuf_.addChar(
  360.         shaka.cea.Cea608Memory.CharSet.BASIC_NORTH_AMERICAN,
  361.         ' '.charCodeAt(0));
  362.   }
  365.   /**
  366.    * Handles EDM - Erase Displayed Mem
  367.    * Mode check:
  368.    * EDM affects all captioning modes (but not Text mode);
  369.    * @param {number} pts
  370.    * @return {?shaka.extern.ICaptionDecoder.ClosedCaption}
  371.    * @private
  372.    */
  373.   controlEdm_(pts) {
  374.     const buf = this.displayedMemory_;
  375.     let parsedClosedCaption = null;
  376.     if (this.type_ !== shaka.cea.Cea608DataChannel.CaptionType.TEXT) {
  377.       // Clearing displayed memory means we now know how long
  378.       // its contents were displayed, so force it out.
  379.       parsedClosedCaption = buf.forceEmit(this.prevEndTime_, pts);
  380.     }
  381.     buf.resetAllRows();
  382.     return parsedClosedCaption;
  383.   }
  385.   /**
  386.    * Handles RDC - Resume Direct Captions. Initiates Paint-On captioning mode.
  387.    * RDC does not affect current display, so nothing needs to be forced out yet.
  388.    * @param {number} pts in seconds
  389.    * @private
  390.    */
  391.   controlRdc_(pts) {
  392.     this.type_ = shaka.cea.Cea608DataChannel.CaptionType.PAINTON;
  393.     // Point to displayed memory.
  394.     this.curbuf_ = this.displayedMemory_;
  396.     // No scroll window now.
  397.     this.curbuf_.setScrollSize(0);
  399.     // The next paint-on caption needs this time as the start time.
  400.     this.prevEndTime_ = pts;
  401.   }
  404.   /**
  405.    * Handles ENM - Erase Nondisplayed Mem
  406.    * @private
  407.    */
  408.   controlEnm_() {
  409.     this.nonDisplayedMemory_.resetAllRows();
  410.   }
  412.   /**
  413.    * Handles EOC - End Of Caption (flip mem)
  414.    * This forces Pop-On mode, and swaps the displayed and nondisplayed memories.
  415.    * @private
  416.    * @param {number} pts
  417.    * @return {?shaka.extern.ICaptionDecoder.ClosedCaption}
  418.    */
  419.   controlEoc_(pts) {
  420.     let parsedClosedCaption = null;
  421.     if (this.type_ !== shaka.cea.Cea608DataChannel.CaptionType.TEXT) {
  422.       parsedClosedCaption =
  423.         this.displayedMemory_.forceEmit(this.prevEndTime_, pts);
  424.     }
  425.     // Swap memories
  426.     const buf = this.nonDisplayedMemory_;
  427.     this.nonDisplayedMemory_ = this.displayedMemory_;  // Swap buffers
  428.     this.displayedMemory_ = buf;
  430.     // Enter Pop-On mode.
  431.     this.controlRcl_();
  433.     // The caption ended, and so the previous end time should be updated.
  434.     this.prevEndTime_ = pts;
  435.     return parsedClosedCaption;
  436.   }
  438.   /**
  439.    * Handles RCL - Resume Caption Loading
  440.    * Initiates Pop-On style captioning. No need to force anything out upon
  441.    * entering Pop-On mode because it does not affect the current display.
  442.    * @private
  443.    */
  444.   controlRcl_() {
  445.     this.type_ = shaka.cea.Cea608DataChannel.CaptionType.POPON;
  446.     this.curbuf_ = this.nonDisplayedMemory_;
  447.     // No scroll window now
  448.     this.curbuf_.setScrollSize(0);
  449.   }
  452.   /**
  453.    * Handles BS - BackSpace.
  454.    * @private
  455.    */
  456.   controlBs_() {
  457.     this.curbuf_.eraseChar();
  458.   }
  460.   /**
  461.    * Handles TR - Text Restart.
  462.    * Clears text buffer and resumes Text Mode.
  463.    * @private
  464.    */
  465.   controlTr_() {
  466.     this.text_.reset();
  467.     this.controlRtd_();  // Put into text mode.
  468.   }
  470.   /**
  471.    * Handles RTD - Resume Text Display.
  472.    * Resumes text mode. No need to force anything out, because Text Mode doesn't
  473.    * affect current display. Also, this decoder does not emit Text Mode anyway.
  474.    * @private
  475.    */
  476.   controlRtd_() {
  477.     shaka.log.warnOnce('Cea608DataChannel',
  478.         'CEA-608 text mode entered, but is unsupported');
  479.     this.curbuf_ = this.text_;
  480.     this.type_ = shaka.cea.Cea608DataChannel.CaptionType.TEXT;
  481.   }
  483.   /**
  484.    * Handles a Basic North American byte pair.
  485.    * @param {number} b1 Byte 1.
  486.    * @param {number} b2 Byte 2.
  487.    */
  488.   handleBasicNorthAmericanChar(b1, b2) {
  489.     this.curbuf_.addChar(
  490.         shaka.cea.Cea608Memory.CharSet.BASIC_NORTH_AMERICAN, b1);
  491.     this.curbuf_.addChar(
  492.         shaka.cea.Cea608Memory.CharSet.BASIC_NORTH_AMERICAN, b2);
  493.   }
  495.   /**
  496.    * Handles an Extended Western European byte pair.
  497.    * @param {number} b1 Byte 1.
  498.    * @param {number} b2 Byte 2.
  499.    * @private
  500.    */
  501.   handleExtendedWesternEuropeanChar_(b1, b2) {
  502.     // Get the char set from the LSB, which is the char set toggle bit.
  503.     const charSet = b1 & 0x01 ?
  504.           shaka.cea.Cea608Memory.CharSet.PORTUGUESE_GERMAN:
  505.           shaka.cea.Cea608Memory.CharSet.SPANISH_FRENCH;
  507.     this.curbuf_.addChar(charSet, b2);
  508.   }
  510.   /**
  511.    * Decodes control code.
  512.    * Three types of control codes:
  513.    * Preamble Address Codes, Mid-Row Codes, and Miscellaneous Control Codes.
  514.    * @param {!shaka.cea.Cea608DataChannel.Cea608Packet} ccPacket
  515.    * @return {?shaka.extern.ICaptionDecoder.ClosedCaption}
  516.    */
  517.   handleControlCode(ccPacket) {
  518.     const b1 = ccPacket.ccData1;
  519.     const b2 = ccPacket.ccData2;
  521.     // FCC wants control codes transmitted twice, and that will often be
  522.     // seen in broadcast captures. If the very next frame has a duplicate
  523.     // control code, that duplicate is ignored. Note that this only applies
  524.     // to the very next frame, and only for one match.
  525.     if (this.lastcp_ === ((b1 << 8) | b2)) {
  526.       this.lastcp_ = null;
  527.       return null;
  528.     }
  530.     // Remember valid control code for checking in next frame!
  531.     this.lastcp_ = (b1 << 8) | b2;
  533.     if (this.isPAC_(b1, b2)) {
  534.       this.controlPac_(b1, b2);
  535.     } else if (this.isMidrowStyleChange_(b1, b2)) {
  536.       this.controlMidrow_(b2);
  537.     } else if (this.isBackgroundAttribute_(b1, b2)) {
  538.       this.controlBackgroundAttribute_(b1, b2);
  539.     } else if (this.isSpecialNorthAmericanChar_(b1, b2)) {
  540.       this.curbuf_.addChar(
  541.           shaka.cea.Cea608Memory.CharSet.SPECIAL_NORTH_AMERICAN, b2);
  542.     } else if (this.isExtendedWesternEuropeanChar_(b1, b2)) {
  543.       this.handleExtendedWesternEuropeanChar_(b1, b2);
  544.     } else if (this.isMiscellaneous_(b1, b2)) {
  545.       return this.controlMiscellaneous_(ccPacket);
  546.     }
  547.     return null;
  548.   }
  550.   /**
  551.    * Checks if this is a Miscellaneous control code.
  552.    * @param {number} b1 Byte 1.
  553.    * @param {number} b2 Byte 2.
  554.    * @return {boolean}
  555.    * @private
  556.    */
  557.   isMiscellaneous_(b1, b2) {
  558.     // For Miscellaneous Control Codes, the bytes take the following form:
  559.     // b1 -> |0|0|0|1|C|1|0|F|
  560.     // b2 -> |0|0|1|0|X|X|X|X|
  561.     return ((b1 & 0xf6) === 0x14) && ((b2 & 0xf0) === 0x20);
  562.   }
  564.   /**
  565.    * Checks if this is a PAC control code.
  566.    * @param {number} b1 Byte 1.
  567.    * @param {number} b2 Byte 2.
  568.    * @return {boolean}
  569.    * @private
  570.    */
  571.   isPAC_(b1, b2) {
  572.     // For Preamble Address Codes, the bytes take the following form:
  573.     // b1 -> |0|0|0|1|X|X|X|X|
  574.     // b2 -> |0|1|X|X|X|X|X|X|
  575.     return ((b1 & 0xf0) === 0x10) && ((b2 & 0xc0) === 0x40);
  576.   }
  578.   /**
  579.    * Checks if this is a Midrow style change control code.
  580.    * @param {number} b1 Byte 1.
  581.    * @param {number} b2 Byte 2.
  582.    * @return {boolean}
  583.    * @private
  584.    */
  585.   isMidrowStyleChange_(b1, b2) {
  586.     // For Midrow Control Codes, the bytes take the following form:
  587.     // b1 -> |0|0|0|1|C|0|0|1|
  588.     // b2 -> |0|0|1|0|X|X|X|X|
  589.     return ((b1 & 0xf7) === 0x11) && ((b2 & 0xf0) === 0x20);
  590.   }
  592.   /**
  593.    * Checks if this is a background attribute control code.
  594.    * @param {number} b1 Byte 1.
  595.    * @param {number} b2 Byte 2.
  596.    * @return {boolean}
  597.    * @private
  598.    */
  599.   isBackgroundAttribute_(b1, b2) {
  600.     // For Background Attribute Codes, the bytes take the following form:
  601.     // Bg provided: b1 -> |0|0|0|1|C|0|0|0| b2 -> |0|0|1|0|COLOR|T|
  602.     // No Bg:       b1 -> |0|0|0|1|C|1|1|1| b2 -> |0|0|1|0|1|1|0|1|
  603.     return (((b1 & 0xf7) === 0x10) && ((b2 & 0xf0) === 0x20)) ||
  604.              (((b1 & 0xf7) === 0x17) && ((b2 & 0xff) === 0x2D));
  605.   }
  607.   /**
  608.    * Checks if the character is in the Special North American char. set.
  609.    * @param {number} b1 Byte 1.
  610.    * @param {number} b2 Byte 2.
  611.    * @return {boolean}
  612.    * @private
  613.    */
  614.   isSpecialNorthAmericanChar_(b1, b2) {
  615.     // The bytes take the following form:
  616.     // b1 -> |0|0|0|1|C|0|0|1|
  617.     // b2 -> |0|0|1|1|  CHAR |
  618.     return ((b1 & 0xf7) === 0x11) && ((b2 & 0xf0) === 0x30);
  619.   }
  621.   /**
  622.    * Checks if the character is in the Extended Western European char. set.
  623.    * @param {number} b1 Byte 1.
  624.    * @param {number} b2 Byte 2.
  625.    * @return {boolean}
  626.    * @private
  627.    */
  628.   isExtendedWesternEuropeanChar_(b1, b2) {
  629.     // The bytes take the following form:
  630.     // b1 -> |0|0|0|1|C|0|1|S|
  631.     // b2 -> |0|0|1|CHARACTER|
  632.     return ((b1 & 0xf6) === 0x12) && ((b2 & 0xe0) === 0x20);
  633.   }
  635.   /**
  636.    * Checks if the data contains a control code.
  637.    * @param {number} b1 Byte 1.
  638.    * @return {boolean}
  639.    */
  640.   static isControlCode(b1) {
  641.     // For control codes, the first byte takes the following form:
  642.     // b1 -> |P|0|0|1|X|X|X|X|
  643.     return (b1 & 0x70) === 0x10;
  644.   }
  646.   /**
  647.    * Checks if the data contains a XDS control code.
  648.    * @param {number} b1 Byte 1.
  649.    * @return {boolean}
  650.    */
  651.   static isXdsControlCode(b1) {
  652.     return b1 >= 0x01 && b1 <= 0x0F;
  653.   }
  654. };
  656. /**
  657.  * Command codes.
  658.  * @enum {number}
  659.  * @private
  660.  */
  661. shaka.cea.Cea608DataChannel.MiscCmd_ = {
  662.   // "RCL - Resume Caption Loading"
  663.   RCL: 0x20,
  665.   // "BS  - BackSpace"
  666.   BS: 0x21,
  668.   // "AOD - Unused (alarm off)"
  669.   AOD: 0x22,
  671.   // "AON - Unused (alarm on)"
  672.   AON: 0x23,
  674.   // "DER - Delete to End of Row"
  675.   DER: 0x24,
  677.   // "RU2 - Roll-Up, 2 rows"
  678.   RU2: 0x25,
  680.   // "RU3 - Roll-Up, 3 rows"
  681.   RU3: 0x26,
  683.   // "RU4 - Roll-Up, 4 rows"
  684.   RU4: 0x27,
  686.   // "FON - Flash On"
  687.   FON: 0x28,
  689.   // "RDC - Resume Direct Captions"
  690.   RDC: 0x29,
  692.   // "TR - Text Restart"
  693.   TR: 0x2a,
  695.   // "RTD - Resume Text Display"
  696.   RTD: 0x2b,
  698.   // "EDM - Erase Displayed Mem"
  699.   EDM: 0x2c,
  701.   // "CR  - Carriage return"
  702.   CR: 0x2d,
  704.   // "ENM - Erase Nondisplayed Mem"
  705.   ENM: 0x2e,
  707.   // "EOC - End Of Caption (flip mem)"
  708.   EOC: 0x2f,
  709. };
  711. /**
  712.  * Caption type.
  713.  * @private @const @enum {number}
  714.  */
  715. shaka.cea.Cea608DataChannel.CaptionType = {
  716.   NONE: 0,
  717.   POPON: 1,
  718.   PAINTON: 2,
  719.   ROLLUP: 3,
  720.   TEXT: 4,
  721. };
  723. /**
  724.  * @const {!Array<string>}
  725.  */
  726. shaka.cea.Cea608DataChannel.BG_COLORS = [
  727.   'black',
  728.   'green',
  729.   'blue',
  730.   'cyan',
  731.   'red',
  732.   'yellow',
  733.   'magenta',
  734.   'black',
  735. ];
  737. /**
  738.  * @const {!Array<string>}
  739.  */
  740. shaka.cea.Cea608DataChannel.TEXT_COLORS = [
  741.   'white',
  742.   'green',
  743.   'blue',
  744.   'cyan',
  745.   'red',
  746.   'yellow',
  747.   'magenta',
  748.   'white_italics',
  749. ];
  751. /**
  752.  * Style associated with a cue.
  753.  * @typedef {{
  754.  *   textColor: ?string,
  755.  *   backgroundColor: ?string,
  756.  *   italics: ?boolean,
  757.  *   underline: ?boolean
  758.  * }}
  759.  */
  760. shaka.cea.Cea608DataChannel.Style;
  762. /**
  763.  * CEA closed captions packet.
  764.  * @typedef {{
  765.   *   pts: number,
  766.   *   type: number,
  767.   *   ccData1: number,
  768.   *   ccData2: number,
  769.   *   order: number
  770.   * }}
  771.   *
  772.   * @property {number} pts
  773.   *   Presentation timestamp (in second) at which this packet was received.
  774.   * @property {number} type
  775.   *   Type of the packet. Either 0 or 1, representing the CEA-608 field.
  776.   * @property {number} ccData1 CEA-608 byte 1.
  777.   * @property {number} ccData2 CEA-608 byte 2.
  778.   * @property {number} order
  779.   *   A number indicating the order this packet was received in a sequence
  780.   *   of packets. Used to break ties in a stable sorting algorithm
  781.   */
  782. shaka.cea.Cea608DataChannel.Cea608Packet;