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.     // Set up the defaults.
  127.     let textColor = shaka.cea.CeaUtils.DEFAULT_TXT_COLOR;
  128.     let italics = false;
  129.     let indent = null;
  131.     // Get PAC index;
  132.     let pacIndex;
  133.     if (b2 > 0x5f) {
  134.       pacIndex = b2 - 0x60;
  135.     } else {
  136.       pacIndex = b2 - 0x40;
  137.     }
  139.     if (pacIndex <= 0xd) {
  140.       const colorIndex = Math.floor(pacIndex / 2);
  141.       textColor = shaka.cea.Cea608DataChannel.TEXT_COLORS[colorIndex];
  142.     } else if (pacIndex <= 0xf) {
  143.       italics = true; // color stays white
  144.     } else {
  145.       indent = Math.floor((pacIndex - 0x10) / 2);
  146.     }
  148.     // PACs toggle underline on the last bit of b2.
  149.     const underline = (b2 & 0x01) === 0x01;
  151.     if (this.type_ === shaka.cea.Cea608DataChannel.CaptionType.TEXT) {
  152.       // Don't execute the PAC if in text mode.
  153.       return;
  154.     }
  156.     // Execute the PAC.
  157.     const buf = this.curBuf_;
  159.     // Move entire scroll window to a new base in rollup mode.
  160.     if (this.type_ === shaka.cea.Cea608DataChannel.CaptionType.ROLLUP &&
  161.         row !== buf.getRow()) {
  162.       const oldTopRow = 1 + buf.getRow() - buf.getScrollSize();
  163.       const newTopRow = 1 + row - buf.getScrollSize();
  165.       // Shift up the scroll window.
  166.       buf.moveRows(newTopRow, oldTopRow, buf.getScrollSize());
  168.       // Clear everything outside of the new scroll window.
  169.       buf.resetRows(0, newTopRow - 1);
  170.       buf.resetRows(row + 1,
  171.           shaka.cea.Cea608Memory.CC_ROWS - row);
  172.     }
  173.     buf.setRow(row);
  175.     buf.setUnderline(underline);
  176.     buf.setItalics(italics);
  177.     buf.setTextColor(textColor);
  178.     buf.setIndent(indent);
  180.     // Clear the background color, since new row (PAC) should reset ALL styles.
  181.     buf.setBackgroundColor(shaka.cea.CeaUtils.DEFAULT_BG_COLOR);
  182.   }
  184.   /**
  185.    * Mid-Row control code handler.
  186.    * @param {number} b2 Byte #2.
  187.    * @private
  188.    */
  189.   controlMidrow_(b2) {
  190.     // Clear all pre-existing midrow style attributes.
  191.     this.curBuf_.setUnderline(false);
  192.     this.curBuf_.setItalics(false);
  193.     this.curBuf_.setTextColor(shaka.cea.CeaUtils.DEFAULT_TXT_COLOR);
  195.     // Mid-row attrs use a space.
  196.     this.curBuf_.addChar(
  197.         shaka.cea.Cea608Memory.CharSet.BASIC_NORTH_AMERICAN, ' '.charCodeAt(0));
  199.     let textColor = shaka.cea.CeaUtils.DEFAULT_TXT_COLOR;
  200.     let italics = false;
  202.     // Midrow codes set underline on last (LSB) bit.
  203.     const underline = (b2 & 0x01) === 0x01;
  205.     // b2 has the form |P|0|1|0|STYLE|U|
  206.     textColor = shaka.cea.Cea608DataChannel.TEXT_COLORS[(b2 & 0xe) >> 1];
  207.     if (textColor === 'white_italics') {
  208.       textColor = 'white';
  209.       italics = true;
  210.     }
  212.     this.curBuf_.setUnderline(underline);
  213.     this.curBuf_.setItalics(italics);
  214.     this.curBuf_.setTextColor(textColor);
  215.   }
  217.   /**
  218.    * Background attribute control code handler.
  219.    * @param {number} b1 Byte #1
  220.    * @param {number} b2 Byte #2.
  221.    * @private
  222.    */
  223.   controlBackgroundAttribute_(b1, b2) {
  224.     let backgroundColor = shaka.cea.CeaUtils.DEFAULT_BG_COLOR;
  225.     if ((b1 & 0x07) === 0x0) {
  226.       // If background provided, last 3 bits of b1 are |0|0|0|. Color is in b2.
  227.       backgroundColor = shaka.cea.Cea608DataChannel.BG_COLORS[(b2 & 0xe) >> 1];
  228.     }
  229.     this.curBuf_.setBackgroundColor(backgroundColor);
  230.   }
  232.   /**
  233.    * The Cea608DataChannel control methods implement all CC control operations.
  234.    * @param {!shaka.cea.Cea608DataChannel.Cea608Packet} ccPacket
  235.    * @return {?shaka.extern.ICaptionDecoder.ClosedCaption}
  236.    * @private
  237.    */
  238.   controlMiscellaneous_(ccPacket) {
  239.     const MiscCmd = shaka.cea.Cea608DataChannel.MiscCmd_;
  240.     const b2 = ccPacket.ccData2;
  241.     const pts = ccPacket.pts;
  242.     let parsedClosedCaption = null;
  244.     switch (b2) {
  245.       case MiscCmd.RCL:
  246.         this.controlRcl_();
  247.         break;
  248.       case MiscCmd.BS:
  249.         this.controlBs_();
  250.         break;
  251.         // unused (alarm off and alarm on)
  252.       case MiscCmd.AOD:
  253.       case MiscCmd.AON:
  254.         break;
  255.       case MiscCmd.DER:
  256.         // Delete to End of Row. Not implemented since position not supported.
  257.         break;
  258.       case MiscCmd.RU2:
  259.         parsedClosedCaption = this.controlRu_(2, pts);
  260.         break;
  261.       case MiscCmd.RU3:
  262.         parsedClosedCaption = this.controlRu_(3, pts);
  263.         break;
  264.       case MiscCmd.RU4:
  265.         parsedClosedCaption = this.controlRu_(4, pts);
  266.         break;
  267.       case MiscCmd.FON:
  268.         this.controlFon_();
  269.         break;
  270.       case MiscCmd.RDC:
  271.         this.controlRdc_(pts);
  272.         break;
  273.       case MiscCmd.TR:
  274.         this.controlTr_();
  275.         break;
  276.       case MiscCmd.RTD:
  277.         this.controlRtd_();
  278.         break;
  279.       case MiscCmd.EDM:
  280.         parsedClosedCaption = this.controlEdm_(pts);
  281.         break;
  282.       case MiscCmd.CR:
  283.         parsedClosedCaption = this.controlCr_(pts);
  284.         break;
  285.       case MiscCmd.ENM:
  286.         this.controlEnm_();
  287.         break;
  288.       case MiscCmd.EOC:
  289.         parsedClosedCaption = this.controlEoc_(pts);
  290.         break;
  291.     }
  292.     return parsedClosedCaption;
  293.   }
  295.   /**
  296.    * Handles CR - Carriage Return (Start new row).
  297.    * CR only affects scroll windows (Rollup and Text modes).
  298.    * Any currently buffered line needs to be emitted, along
  299.    * with a window scroll action.
  300.    * @param {number} pts in seconds.
  301.    * @return {?shaka.extern.ICaptionDecoder.ClosedCaption}
  302.    * @private
  303.    */
  304.   controlCr_(pts) {
  305.     const buf = this.curBuf_;
  306.     // Only rollup and text mode is affected, but we don't emit text mode.
  307.     if (this.type_ !== shaka.cea.Cea608DataChannel.CaptionType.ROLLUP) {
  308.       return null;
  309.     }
  310.     // Force out the scroll window since the top row will cleared.
  311.     const parsedClosedCaption = buf.forceEmit(this.prevEndTime_, pts);
  313.     // Calculate the top of the scroll window.
  314.     const topRow = (buf.getRow() - buf.getScrollSize()) + 1;
  316.     // Shift up the window one row higher.
  317.     buf.moveRows(topRow - 1, topRow, buf.getScrollSize());
  319.     // Clear out anything that's outside of our current scroll window.
  320.     buf.resetRows(0, topRow - 1);
  321.     buf.resetRows(buf.getRow(), shaka.cea.Cea608Memory.CC_ROWS - buf.getRow());
  323.     // Update the end time so the next caption emits starting at this time.
  324.     this.prevEndTime_ = pts;
  325.     return parsedClosedCaption;
  326.   }
  328.   /**
  329.    * Handles RU2, RU3, RU4 - Roll-Up, N rows.
  330.    * If in TEXT, POPON or PAINTON, any displayed captions are erased.
  331.    *    This means must force emit entire display buffer.
  332.    * @param {number} scrollSize New scroll window size.
  333.    * @param {number} pts
  334.    * @return {?shaka.extern.ICaptionDecoder.ClosedCaption}
  335.    * @private
  336.    */
  337.   controlRu_(scrollSize, pts) {
  338.     this.curBuf_ = this.displayedMemory_;  // Point to displayed memory
  339.     const buf = this.curBuf_;
  340.     let parsedClosedCaption = null;
  342.     // For any type except rollup and text mode, it should be emitted,
  343.     // and memories cleared.
  344.     if (this.type_ !== shaka.cea.Cea608DataChannel.CaptionType.ROLLUP &&
  345.         this.type_ !== shaka.cea.Cea608DataChannel.CaptionType.TEXT) {
  346.       parsedClosedCaption = buf.forceEmit(this.prevEndTime_, pts);
  348.       // Clear both memories.
  349.       this.displayedMemory_.eraseBuffer();
  350.       this.nonDisplayedMemory_.eraseBuffer();
  352.       // Rollup base row defaults to the last row (15).
  353.       buf.setRow(shaka.cea.Cea608Memory.CC_ROWS);
  354.     }
  355.     this.type_ = shaka.cea.Cea608DataChannel.CaptionType.ROLLUP;
  357.     // Set the new rollup window size.
  358.     buf.setScrollSize(scrollSize);
  359.     return parsedClosedCaption;
  360.   }
  362.   /**
  363.    * Handles flash on.
  364.    * @private
  365.    */
  366.   controlFon_() {
  367.     this.curBuf_.addChar(
  368.         shaka.cea.Cea608Memory.CharSet.BASIC_NORTH_AMERICAN,
  369.         ' '.charCodeAt(0));
  370.   }
  373.   /**
  374.    * Handles EDM - Erase Displayed Mem
  375.    * Mode check:
  376.    * EDM affects all captioning modes (but not Text mode);
  377.    * @param {number} pts
  378.    * @return {?shaka.extern.ICaptionDecoder.ClosedCaption}
  379.    * @private
  380.    */
  381.   controlEdm_(pts) {
  382.     const buf = this.displayedMemory_;
  383.     let parsedClosedCaption = null;
  384.     if (this.type_ !== shaka.cea.Cea608DataChannel.CaptionType.TEXT) {
  385.       // Clearing displayed memory means we now know how long
  386.       // its contents were displayed, so force it out.
  387.       parsedClosedCaption = buf.forceEmit(this.prevEndTime_, pts);
  388.     }
  389.     buf.resetAllRows();
  390.     return parsedClosedCaption;
  391.   }
  393.   /**
  394.    * Handles RDC - Resume Direct Captions. Initiates Paint-On captioning mode.
  395.    * RDC does not affect current display, so nothing needs to be forced out yet.
  396.    * @param {number} pts in seconds
  397.    * @private
  398.    */
  399.   controlRdc_(pts) {
  400.     this.type_ = shaka.cea.Cea608DataChannel.CaptionType.PAINTON;
  401.     // Point to displayed memory.
  402.     this.curBuf_ = this.displayedMemory_;
  404.     // No scroll window now.
  405.     this.curBuf_.setScrollSize(0);
  407.     // The next paint-on caption needs this time as the start time.
  408.     this.prevEndTime_ = pts;
  409.   }
  412.   /**
  413.    * Handles ENM - Erase Nondisplayed Mem
  414.    * @private
  415.    */
  416.   controlEnm_() {
  417.     this.nonDisplayedMemory_.resetAllRows();
  418.   }
  420.   /**
  421.    * Handles EOC - End Of Caption (flip mem)
  422.    * This forces Pop-On mode, and swaps the displayed and nondisplayed memories.
  423.    * @private
  424.    * @param {number} pts
  425.    * @return {?shaka.extern.ICaptionDecoder.ClosedCaption}
  426.    */
  427.   controlEoc_(pts) {
  428.     let parsedClosedCaption = null;
  429.     if (this.type_ !== shaka.cea.Cea608DataChannel.CaptionType.TEXT) {
  430.       parsedClosedCaption =
  431.         this.displayedMemory_.forceEmit(this.prevEndTime_, pts);
  432.     }
  433.     // Swap memories
  434.     const buf = this.nonDisplayedMemory_;
  435.     this.nonDisplayedMemory_ = this.displayedMemory_;  // Swap buffers
  436.     this.displayedMemory_ = buf;
  438.     // Enter Pop-On mode.
  439.     this.controlRcl_();
  441.     // The caption ended, and so the previous end time should be updated.
  442.     this.prevEndTime_ = pts;
  443.     return parsedClosedCaption;
  444.   }
  446.   /**
  447.    * Handles RCL - Resume Caption Loading
  448.    * Initiates Pop-On style captioning. No need to force anything out upon
  449.    * entering Pop-On mode because it does not affect the current display.
  450.    * @private
  451.    */
  452.   controlRcl_() {
  453.     this.type_ = shaka.cea.Cea608DataChannel.CaptionType.POPON;
  454.     this.curBuf_ = this.nonDisplayedMemory_;
  455.     // No scroll window now
  456.     this.curBuf_.setScrollSize(0);
  457.   }
  460.   /**
  461.    * Handles BS - BackSpace.
  462.    * @private
  463.    */
  464.   controlBs_() {
  465.     this.curBuf_.eraseChar();
  466.   }
  468.   /**
  469.    * Handles TR - Text Restart.
  470.    * Clears text buffer and resumes Text Mode.
  471.    * @private
  472.    */
  473.   controlTr_() {
  474.     this.text_.reset();
  475.     this.controlRtd_();  // Put into text mode.
  476.   }
  478.   /**
  479.    * Handles RTD - Resume Text Display.
  480.    * Resumes text mode. No need to force anything out, because Text Mode doesn't
  481.    * affect current display. Also, this decoder does not emit Text Mode anyway.
  482.    * @private
  483.    */
  484.   controlRtd_() {
  485.     shaka.log.warnOnce('Cea608DataChannel',
  486.         'CEA-608 text mode entered, but is unsupported');
  487.     this.curBuf_ = this.text_;
  488.     this.type_ = shaka.cea.Cea608DataChannel.CaptionType.TEXT;
  489.   }
  491.   /**
  492.    * Handles a Basic North American byte pair.
  493.    * @param {number} b1 Byte 1.
  494.    * @param {number} b2 Byte 2.
  495.    */
  496.   handleBasicNorthAmericanChar(b1, b2) {
  497.     this.curBuf_.addChar(
  498.         shaka.cea.Cea608Memory.CharSet.BASIC_NORTH_AMERICAN, b1);
  499.     this.curBuf_.addChar(
  500.         shaka.cea.Cea608Memory.CharSet.BASIC_NORTH_AMERICAN, b2);
  501.   }
  503.   /**
  504.    * Handles an Extended Western European byte pair.
  505.    * @param {number} b1 Byte 1.
  506.    * @param {number} b2 Byte 2.
  507.    * @private
  508.    */
  509.   handleExtendedWesternEuropeanChar_(b1, b2) {
  510.     // Get the char set from the LSB, which is the char set toggle bit.
  511.     const charSet = b1 & 0x01 ?
  512.           shaka.cea.Cea608Memory.CharSet.PORTUGUESE_GERMAN:
  513.           shaka.cea.Cea608Memory.CharSet.SPANISH_FRENCH;
  515.     this.curBuf_.addChar(charSet, b2);
  516.   }
  518.   /**
  519.    * Handles a tab offset.
  520.    *
  521.    * @param {number} offset
  522.    * @private
  523.    */
  524.   handleOffset_(offset) {
  525.     this.curBuf_.setOffset(offset);
  526.   }
  528.   /**
  529.    * Decodes control code.
  530.    * Three types of control codes:
  531.    * Preamble Address Codes, Mid-Row Codes, and Miscellaneous Control Codes.
  532.    * @param {!shaka.cea.Cea608DataChannel.Cea608Packet} ccPacket
  533.    * @return {?shaka.extern.ICaptionDecoder.ClosedCaption}
  534.    */
  535.   handleControlCode(ccPacket) {
  536.     const b1 = ccPacket.ccData1;
  537.     const b2 = ccPacket.ccData2;
  539.     // FCC wants control codes transmitted twice, and that will often be
  540.     // seen in broadcast captures. If the very next frame has a duplicate
  541.     // control code, that duplicate is ignored. Note that this only applies
  542.     // to the very next frame, and only for one match.
  543.     if (this.lastCp_ === ((b1 << 8) | b2)) {
  544.       this.lastCp_ = null;
  545.       return null;
  546.     }
  548.     // Remember valid control code for checking in next frame!
  549.     this.lastCp_ = (b1 << 8) | b2;
  551.     if (this.isPAC_(b1, b2)) {
  552.       this.controlPac_(b1, b2);
  553.     } else if (this.isMidrowStyleChange_(b1, b2)) {
  554.       this.controlMidrow_(b2);
  555.     } else if (this.isBackgroundAttribute_(b1, b2)) {
  556.       this.controlBackgroundAttribute_(b1, b2);
  557.     } else if (this.isSpecialNorthAmericanChar_(b1, b2)) {
  558.       this.curBuf_.addChar(
  559.           shaka.cea.Cea608Memory.CharSet.SPECIAL_NORTH_AMERICAN, b2);
  560.     } else if (this.isExtendedWesternEuropeanChar_(b1, b2)) {
  561.       this.handleExtendedWesternEuropeanChar_(b1, b2);
  562.     } else if (this.isMiscellaneous_(b1, b2)) {
  563.       return this.controlMiscellaneous_(ccPacket);
  564.     } else if (this.isOffset_(b1, b2)) {
  565.       const offset = b2 - 0x20;
  566.       this.handleOffset_(offset);
  567.     }
  568.     return null;
  569.   }
  571.   /**
  572.    * Checks if this is a Miscellaneous control code.
  573.    * @param {number} b1 Byte 1.
  574.    * @param {number} b2 Byte 2.
  575.    * @return {boolean}
  576.    * @private
  577.    */
  578.   isMiscellaneous_(b1, b2) {
  579.     // For Miscellaneous Control Codes, the bytes take the following form:
  580.     // b1 -> |0|0|0|1|C|1|0|F|
  581.     // b2 -> |0|0|1|0|X|X|X|X|
  582.     return ((b1 & 0xf6) === 0x14) && ((b2 & 0xf0) === 0x20);
  583.   }
  585.   /**
  586.    * Checks if this is a offset control code.
  587.    * @param {number} b1 Byte 1.
  588.    * @param {number} b2 Byte 2.
  589.    * @return {boolean}
  590.    * @private
  591.    */
  592.   isOffset_(b1, b2) {
  593.     return (b1 == 0x17 || b1 == 0x1f) && b2 >= 0x21 && b2 <= 0x23;
  594.   }
  596.   /**
  597.    * Checks if this is a PAC control code.
  598.    * @param {number} b1 Byte 1.
  599.    * @param {number} b2 Byte 2.
  600.    * @return {boolean}
  601.    * @private
  602.    */
  603.   isPAC_(b1, b2) {
  604.     // For Preamble Address Codes, the bytes take the following form:
  605.     // b1 -> |0|0|0|1|X|X|X|X|
  606.     // b2 -> |0|1|X|X|X|X|X|X|
  607.     return ((b1 & 0xf0) === 0x10) && ((b2 & 0xc0) === 0x40);
  608.   }
  610.   /**
  611.    * Checks if this is a Midrow style change control code.
  612.    * @param {number} b1 Byte 1.
  613.    * @param {number} b2 Byte 2.
  614.    * @return {boolean}
  615.    * @private
  616.    */
  617.   isMidrowStyleChange_(b1, b2) {
  618.     // For Midrow Control Codes, the bytes take the following form:
  619.     // b1 -> |0|0|0|1|C|0|0|1|
  620.     // b2 -> |0|0|1|0|X|X|X|X|
  621.     return ((b1 & 0xf7) === 0x11) && ((b2 & 0xf0) === 0x20);
  622.   }
  624.   /**
  625.    * Checks if this is a background attribute control code.
  626.    * @param {number} b1 Byte 1.
  627.    * @param {number} b2 Byte 2.
  628.    * @return {boolean}
  629.    * @private
  630.    */
  631.   isBackgroundAttribute_(b1, b2) {
  632.     // For Background Attribute Codes, the bytes take the following form:
  633.     // Bg provided: b1 -> |0|0|0|1|C|0|0|0| b2 -> |0|0|1|0|COLOR|T|
  634.     // No Bg:       b1 -> |0|0|0|1|C|1|1|1| b2 -> |0|0|1|0|1|1|0|1|
  635.     return (((b1 & 0xf7) === 0x10) && ((b2 & 0xf0) === 0x20)) ||
  636.              (((b1 & 0xf7) === 0x17) && ((b2 & 0xff) === 0x2D));
  637.   }
  639.   /**
  640.    * Checks if the character is in the Special North American char. set.
  641.    * @param {number} b1 Byte 1.
  642.    * @param {number} b2 Byte 2.
  643.    * @return {boolean}
  644.    * @private
  645.    */
  646.   isSpecialNorthAmericanChar_(b1, b2) {
  647.     // The bytes take the following form:
  648.     // b1 -> |0|0|0|1|C|0|0|1|
  649.     // b2 -> |0|0|1|1|  CHAR |
  650.     return ((b1 & 0xf7) === 0x11) && ((b2 & 0xf0) === 0x30);
  651.   }
  653.   /**
  654.    * Checks if the character is in the Extended Western European char. set.
  655.    * @param {number} b1 Byte 1.
  656.    * @param {number} b2 Byte 2.
  657.    * @return {boolean}
  658.    * @private
  659.    */
  660.   isExtendedWesternEuropeanChar_(b1, b2) {
  661.     // The bytes take the following form:
  662.     // b1 -> |0|0|0|1|C|0|1|S|
  663.     // b2 -> |0|0|1|CHARACTER|
  664.     return ((b1 & 0xf6) === 0x12) && ((b2 & 0xe0) === 0x20);
  665.   }
  667.   /**
  668.    * Checks if the data contains a control code.
  669.    * @param {number} b1 Byte 1.
  670.    * @return {boolean}
  671.    */
  672.   static isControlCode(b1) {
  673.     // For control codes, the first byte takes the following form:
  674.     // b1 -> |P|0|0|1|X|X|X|X|
  675.     return (b1 & 0x70) === 0x10;
  676.   }
  678.   /**
  679.    * Checks if the data contains a XDS control code.
  680.    * @param {number} b1 Byte 1.
  681.    * @return {boolean}
  682.    */
  683.   static isXdsControlCode(b1) {
  684.     return b1 >= 0x01 && b1 <= 0x0F;
  685.   }
  686. };
  688. /**
  689.  * Command codes.
  690.  * @enum {number}
  691.  * @private
  692.  */
  693. shaka.cea.Cea608DataChannel.MiscCmd_ = {
  694.   // "RCL - Resume Caption Loading"
  695.   RCL: 0x20,
  697.   // "BS  - BackSpace"
  698.   BS: 0x21,
  700.   // "AOD - Unused (alarm off)"
  701.   AOD: 0x22,
  703.   // "AON - Unused (alarm on)"
  704.   AON: 0x23,
  706.   // "DER - Delete to End of Row"
  707.   DER: 0x24,
  709.   // "RU2 - Roll-Up, 2 rows"
  710.   RU2: 0x25,
  712.   // "RU3 - Roll-Up, 3 rows"
  713.   RU3: 0x26,
  715.   // "RU4 - Roll-Up, 4 rows"
  716.   RU4: 0x27,
  718.   // "FON - Flash On"
  719.   FON: 0x28,
  721.   // "RDC - Resume Direct Captions"
  722.   RDC: 0x29,
  724.   // "TR - Text Restart"
  725.   TR: 0x2a,
  727.   // "RTD - Resume Text Display"
  728.   RTD: 0x2b,
  730.   // "EDM - Erase Displayed Mem"
  731.   EDM: 0x2c,
  733.   // "CR  - Carriage return"
  734.   CR: 0x2d,
  736.   // "ENM - Erase Nondisplayed Mem"
  737.   ENM: 0x2e,
  739.   // "EOC - End Of Caption (flip mem)"
  740.   EOC: 0x2f,
  741. };
  743. /**
  744.  * Caption type.
  745.  * @private @const @enum {number}
  746.  */
  747. shaka.cea.Cea608DataChannel.CaptionType = {
  748.   NONE: 0,
  749.   POPON: 1,
  750.   PAINTON: 2,
  751.   ROLLUP: 3,
  752.   TEXT: 4,
  753. };
  755. /**
  756.  * @const {!Array<string>}
  757.  */
  758. shaka.cea.Cea608DataChannel.BG_COLORS = [
  759.   'black',
  760.   'green',
  761.   'blue',
  762.   'cyan',
  763.   'red',
  764.   'yellow',
  765.   'magenta',
  766.   'black',
  767. ];
  769. /**
  770.  * @const {!Array<string>}
  771.  */
  772. shaka.cea.Cea608DataChannel.TEXT_COLORS = [
  773.   'white',
  774.   'green',
  775.   'blue',
  776.   'cyan',
  777.   'red',
  778.   'yellow',
  779.   'magenta',
  780.   'white_italics',
  781. ];
  783. /**
  784.  * Style associated with a cue.
  785.  * @typedef {{
  786.  *   textColor: ?string,
  787.  *   backgroundColor: ?string,
  788.  *   italics: ?boolean,
  789.  *   underline: ?boolean
  790.  * }}
  791.  */
  792. shaka.cea.Cea608DataChannel.Style;
  794. /**
  795.  * CEA closed captions packet.
  796.  * @typedef {{
  797.  *   pts: number,
  798.  *   type: number,
  799.  *   ccData1: number,
  800.  *   ccData2: number,
  801.  *   order: number
  802.  * }}
  803.  *
  804.  * @property {number} pts
  805.  *   Presentation timestamp (in second) at which this packet was received.
  806.  * @property {number} type
  807.  *   Type of the packet. Either 0 or 1, representing the CEA-608 field.
  808.  * @property {number} ccData1 CEA-608 byte 1.
  809.  * @property {number} ccData2 CEA-608 byte 2.
  810.  * @property {number} order
  811.  *   A number indicating the order this packet was received in a sequence
  812.  *   of packets. Used to break ties in a stable sorting algorithm
  813.  */
  814. shaka.cea.Cea608DataChannel.Cea608Packet;