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