Source: lib/cea/cea708_service.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.cea.Cea708Service');
  9. goog.require('shaka.cea.Cea708Window');
  10. goog.require('shaka.cea.DtvccPacket');
  13. /**
  14.  * CEA-708 closed captions service as defined by CEA-708-E. A decoder can own up
  15.  * to 63 services. Each service owns eight windows.
  16.  */
  17. shaka.cea.Cea708Service = class {
  18.   /**
  19.    * @param {number} serviceNumber
  20.    */
  21.   constructor(serviceNumber) {
  22.     /**
  23.      * Number for this specific service (1 - 63).
  24.      * @private {number}
  25.      */
  26.     this.serviceNumber_ = serviceNumber;
  28.     /**
  29.      * Eight Cea708 Windows, as defined by the spec.
  30.      * @private {!Array<?shaka.cea.Cea708Window>}
  31.      */
  32.     this.windows_ = [
  33.       null, null, null, null, null, null, null, null,
  34.     ];
  36.     /**
  37.      * The current window for which window command operate on.
  38.      * @private {?shaka.cea.Cea708Window}
  39.      */
  40.     this.currentWindow_ = null;
  41.   }
  43.   /**
  44.    * Processes a CEA-708 control code.
  45.    * @param {!shaka.cea.DtvccPacket} dtvccPacket
  46.    * @return {?shaka.extern.ICaptionDecoder.ClosedCaption}
  47.    * @throws {!shaka.util.Error}
  48.    */
  49.   handleCea708ControlCode(dtvccPacket) {
  50.     const blockData = dtvccPacket.readByte();
  51.     let controlCode = blockData.value;
  52.     const pts = blockData.pts;
  54.     // Read extended control code if needed.
  55.     if (controlCode === shaka.cea.Cea708Service.EXT_CEA708_CTRL_CODE_BYTE1) {
  56.       const extendedControlCodeBlock = dtvccPacket.readByte();
  57.       controlCode = (controlCode << 16) | extendedControlCodeBlock.value;
  58.     }
  60.     // Control codes are in 1 of 4 logical groups:
  61.     // CL (C0, C2), CR (C1, C3), GL (G0, G2), GR (G1, G2).
  62.     if (controlCode >= 0x00 && controlCode <= 0x1f) {
  63.       return this.handleC0_(controlCode, pts);
  64.     } else if (controlCode >= 0x80 && controlCode <= 0x9f) {
  65.       return this.handleC1_(dtvccPacket, controlCode, pts);
  66.     } else if (controlCode >= 0x1000 && controlCode <= 0x101f) {
  67.       this.handleC2_(dtvccPacket, controlCode & 0xff);
  68.     } else if (controlCode >= 0x1080 && controlCode <= 0x109f) {
  69.       this.handleC3_(dtvccPacket, controlCode & 0xff);
  70.     } else if (controlCode >= 0x20 && controlCode <= 0x7f) {
  71.       this.handleG0_(controlCode);
  72.     } else if (controlCode >= 0xa0 && controlCode <= 0xff) {
  73.       this.handleG1_(controlCode);
  74.     } else if (controlCode >= 0x1020 && controlCode <= 0x107f) {
  75.       this.handleG2_(controlCode & 0xff);
  76.     } else if (controlCode >= 0x10a0 && controlCode <= 0x10ff) {
  77.       this.handleG3_(controlCode & 0xff);
  78.     }
  80.     return null;
  81.   }
  83.   /**
  84.    * Handles G0 group data.
  85.    * @param {number} controlCode
  86.    * @private
  87.    */
  88.   handleG0_(controlCode) {
  89.     if (!this.currentWindow_) {
  90.       return;
  91.     }
  92.     // G0 contains ASCII from 0x20 to 0x7f, with the exception that 0x7f
  93.     // is replaced by a musical note.
  94.     if (controlCode === 0x7f) {
  95.       this.currentWindow_.setCharacter('♪');
  96.       return;
  97.     }
  98.     this.currentWindow_.setCharacter(String.fromCharCode(controlCode));
  99.   }
  101.   /**
  102.    * Handles G1 group data.
  103.    * @param {number} controlCode
  104.    * @private
  105.    */
  106.   handleG1_(controlCode) {
  107.     if (!this.currentWindow_) {
  108.       return;
  109.     }
  110.     // G1 is the Latin-1 Character Set from 0xa0 to 0xff.
  111.     this.currentWindow_.setCharacter(String.fromCharCode(controlCode));
  112.   }
  114.   /**
  115.    * Handles G2 group data.
  116.    * @param {number} controlCode
  117.    * @private
  118.    */
  119.   handleG2_(controlCode) {
  120.     if (!this.currentWindow_) {
  121.       return;
  122.     }
  123.     if (!shaka.cea.Cea708Service.G2Charset.has(controlCode)) {
  124.       // If the character is unsupported, the spec says to put an underline.
  125.       this.currentWindow_.setCharacter('_');
  126.       return;
  127.     }
  129.     const char = shaka.cea.Cea708Service.G2Charset.get(controlCode);
  130.     this.currentWindow_.setCharacter(char);
  131.   }
  133.   /**
  134.    * Handles G3 group data.
  135.    * @param {number} controlCode
  136.    * @private
  137.    */
  138.   handleG3_(controlCode) {
  139.     if (!this.currentWindow_) {
  140.       return;
  141.     }
  143.     // As of CEA-708-E, the G3 group only contains 1 character. It's a
  144.     // [CC] character which has no unicode value on 0xa0.
  145.     if (controlCode != 0xa0) {
  146.       // Similar to G2, the spec decrees an underline if char is unsupported.
  147.       this.currentWindow_.setCharacter('_');
  148.       return;
  149.     }
  151.     this.currentWindow_.setCharacter('[CC]');
  152.   }
  154.   /**
  155.    * Handles C0 group data.
  156.    * @param {number} controlCode
  157.    * @param {number} pts
  158.    * @return {?shaka.extern.ICaptionDecoder.ClosedCaption}
  159.    * @private
  160.    */
  161.   handleC0_(controlCode, pts) {
  162.     // All these commands pertain to the current window, so ensure it exists.
  163.     if (!this.currentWindow_) {
  164.       return null;
  165.     }
  167.     const window = this.currentWindow_;
  168.     let parsedClosedCaption = null;
  170.     // Note: This decoder ignores the "ETX" (end of text) control code. Since
  171.     // this is JavaScript, a '\0' is not needed to terminate a string.
  172.     switch (controlCode) {
  173.       case shaka.cea.Cea708Service.ASCII_BACKSPACE:
  174.         window.backspace();
  175.         break;
  176.       case shaka.cea.Cea708Service.ASCII_CARRIAGE_RETURN:
  177.         // Force out the buffer, since the top row could be lost.
  178.         if (window.isVisible()) {
  179.           parsedClosedCaption = window.forceEmit(pts, this.serviceNumber_);
  180.         }
  181.         window.carriageReturn();
  182.         break;
  183.       case shaka.cea.Cea708Service.ASCII_HOR_CARRIAGE_RETURN:
  184.         // Force out the buffer, a row will be erased.
  185.         if (window.isVisible()) {
  186.           parsedClosedCaption = window.forceEmit(pts, this.serviceNumber_);
  187.         }
  188.         window.horizontalCarriageReturn();
  189.         break;
  190.       case shaka.cea.Cea708Service.ASCII_FORM_FEED:
  191.         // Clear window and move pen to (0,0).
  192.         // Force emit if the window is visible.
  193.         if (window.isVisible()) {
  194.           parsedClosedCaption = window.forceEmit(pts, this.serviceNumber_);
  195.         }
  196.         window.resetMemory();
  197.         window.setPenLocation(0, 0);
  198.         break;
  199.     }
  200.     return parsedClosedCaption;
  201.   }
  203.   /**
  204.    * Processes C1 group data.
  205.    * These are caption commands.
  206.    * @param {!shaka.cea.DtvccPacket} dtvccPacket
  207.    * @param {number} captionCommand
  208.    * @param {number} pts in seconds
  209.    * @return {?shaka.extern.ICaptionDecoder.ClosedCaption}
  210.    * @throws {!shaka.util.Error} a possible out-of-range buffer read.
  211.    * @private
  212.    */
  213.   handleC1_(dtvccPacket, captionCommand, pts) {
  214.     // Note: This decoder ignores delay and delayCancel control codes in the C1.
  215.     // group. These control codes delay processing of data for a set amount of
  216.     // time, however this decoder processes that data immediately.
  218.     if (captionCommand >= 0x80 && captionCommand <= 0x87) {
  219.       const windowNum = captionCommand & 0x07;
  220.       this.setCurrentWindow_(windowNum);
  221.     } else if (captionCommand === 0x88) {
  222.       const bitmap = dtvccPacket.readByte().value;
  223.       return this.clearWindows_(bitmap, pts);
  224.     } else if (captionCommand === 0x89) {
  225.       const bitmap = dtvccPacket.readByte().value;
  226.       this.displayWindows_(bitmap, pts);
  227.     } else if (captionCommand === 0x8a) {
  228.       const bitmap = dtvccPacket.readByte().value;
  229.       return this.hideWindows_(bitmap, pts);
  230.     } else if (captionCommand === 0x8b) {
  231.       const bitmap = dtvccPacket.readByte().value;
  232.       return this.toggleWindows_(bitmap, pts);
  233.     } else if (captionCommand === 0x8c) {
  234.       const bitmap = dtvccPacket.readByte().value;
  235.       return this.deleteWindows_(bitmap, pts);
  236.     } else if (captionCommand === 0x8f) {
  237.       return this.reset_(pts);
  238.     } else if (captionCommand === 0x90) {
  239.       this.setPenAttributes_(dtvccPacket);
  240.     } else if (captionCommand === 0x91) {
  241.       this.setPenColor_(dtvccPacket);
  242.     } else if (captionCommand === 0x92) {
  243.       this.setPenLocation_(dtvccPacket);
  244.     } else if (captionCommand === 0x97) {
  245.       this.setWindowAttributes_(dtvccPacket);
  246.     } else if (captionCommand >= 0x98 && captionCommand <= 0x9f) {
  247.       const windowNum = (captionCommand & 0x0f) - 8;
  248.       this.defineWindow_(dtvccPacket, windowNum, pts);
  249.     }
  250.     return null;
  251.   }
  253.   /**
  254.    * Handles C2 group data.
  255.    * @param {!shaka.cea.DtvccPacket} dtvccPacket
  256.    * @param {number} controlCode
  257.    * @private
  258.    */
  259.   handleC2_(dtvccPacket, controlCode) {
  260.     // As of the CEA-708-E spec there are no commands on the C2 table, but if
  261.     // seen, then the appropriate number of bytes must be skipped as per spec.
  262.     if (controlCode >= 0x08 && controlCode <= 0x0f) {
  263.       dtvccPacket.skip(1);
  264.     } else if (controlCode >= 0x10 && controlCode <= 0x17) {
  265.       dtvccPacket.skip(2);
  266.     } else if (controlCode >= 0x18 && controlCode <= 0x1f) {
  267.       dtvccPacket.skip(3);
  268.     }
  269.   }
  271.   /**
  272.    * Handles C3 group data.
  273.    * @param {!shaka.cea.DtvccPacket} dtvccPacket
  274.    * @param {number} controlCode
  275.    * @private
  276.    */
  277.   handleC3_(dtvccPacket, controlCode) {
  278.     // As of the CEA-708-E spec there are no commands on the C3 table, but if
  279.     // seen, then the appropriate number of bytes must be skipped as per spec.
  280.     if (controlCode >= 0x80 && controlCode <= 0x87) {
  281.       dtvccPacket.skip(4);
  282.     } else if (controlCode >= 0x88 && controlCode <= 0x8f) {
  283.       dtvccPacket.skip(5);
  284.     }
  285.   }
  287.   /**
  288.    * @param {number} windowNum
  289.    * @private
  290.    */
  291.   setCurrentWindow_(windowNum) {
  292.     // If the window isn't created, ignore the command.
  293.     if (!this.windows_[windowNum]) {
  294.       return;
  295.     }
  296.     this.currentWindow_ = this.windows_[windowNum];
  297.   }
  299.   /**
  300.    * Yields each non-null window specified in the 8-bit bitmap.
  301.    * @param {number} bitmap 8 bits corresponding to each of the 8 windows.
  302.    * @return {!Array.<number>}
  303.    * @private
  304.    */
  305.   getSpecifiedWindowIds_(bitmap) {
  306.     const ids = [];
  307.     for (let i = 0; i < 8; i++) {
  308.       const windowSpecified = (bitmap & 0x01) === 0x01;
  309.       if (windowSpecified && this.windows_[i]) {
  310.         ids.push(i);
  311.       }
  312.       bitmap >>= 1;
  313.     }
  314.     return ids;
  315.   }
  317.   /**
  318.    * @param {number} windowsBitmap
  319.    * @param {number} pts
  320.    * @return {?shaka.extern.ICaptionDecoder.ClosedCaption}
  321.    * @private
  322.    */
  323.   clearWindows_(windowsBitmap, pts) {
  324.     let parsedClosedCaption = null;
  326.     // Clears windows from the 8 bit bitmap.
  327.     for (const windowId of this.getSpecifiedWindowIds_(windowsBitmap)) {
  328.       // If window visible and being cleared, emit buffer and reset start time!
  329.       const window = this.windows_[windowId];
  330.       if (window.isVisible()) {
  331.         parsedClosedCaption = window.forceEmit(pts, this.serviceNumber_);
  332.       }
  333.       window.resetMemory();
  334.     }
  335.     return parsedClosedCaption;
  336.   }
  338.   /**
  339.    * @param {number} windowsBitmap
  340.    * @param {number} pts
  341.    * @private
  342.    */
  343.   displayWindows_(windowsBitmap, pts) {
  344.     // Displays windows from the 8 bit bitmap.
  345.     for (const windowId of this.getSpecifiedWindowIds_(windowsBitmap)) {
  346.       const window = this.windows_[windowId];
  347.       if (!window.isVisible()) {
  348.         // We are turning on the visibility, set the start time.
  349.         window.setStartTime(pts);
  350.       }
  351.       window.display();
  352.     }
  353.   }
  355.   /**
  356.    * @param {number} windowsBitmap
  357.    * @param {number} pts
  358.    * @return {?shaka.extern.ICaptionDecoder.ClosedCaption}
  359.    * @private
  360.    */
  361.   hideWindows_(windowsBitmap, pts) {
  362.     let parsedClosedCaption = null;
  364.     // Hides windows from the 8 bit bitmap.
  365.     for (const windowId of this.getSpecifiedWindowIds_(windowsBitmap)) {
  366.       const window = this.windows_[windowId];
  367.       if (window.isVisible()) {
  368.         // We are turning off the visibility, emit!
  369.         parsedClosedCaption = window.forceEmit(pts, this.serviceNumber_);
  370.       }
  371.       window.hide();
  372.     }
  373.     return parsedClosedCaption;
  374.   }
  376.   /**
  377.    * @param {number} windowsBitmap
  378.    * @param {number} pts
  379.    * @return {?shaka.extern.ICaptionDecoder.ClosedCaption}
  380.    * @private
  381.    */
  382.   toggleWindows_(windowsBitmap, pts) {
  383.     let parsedClosedCaption = null;
  385.     // Toggles windows from the 8 bit bitmap.
  386.     for (const windowId of this.getSpecifiedWindowIds_(windowsBitmap)) {
  387.       const window = this.windows_[windowId];
  388.       if (window.isVisible()) {
  389.         // We are turning off the visibility, emit!
  390.         parsedClosedCaption = window.forceEmit(pts, this.serviceNumber_);
  391.       } else {
  392.         // We are turning on visibility, set the start time.
  393.         window.setStartTime(pts);
  394.       }
  396.       window.toggle();
  397.     }
  398.     return parsedClosedCaption;
  399.   }
  401.   /**
  402.    * @param {number} windowsBitmap
  403.    * @param {number} pts
  404.    * @return {?shaka.extern.ICaptionDecoder.ClosedCaption}
  405.    * @private
  406.    */
  407.   deleteWindows_(windowsBitmap, pts) {
  408.     let parsedClosedCaption = null;
  409.     // Deletes windows from the 8 bit bitmap.
  410.     for (const windowId of this.getSpecifiedWindowIds_(windowsBitmap)) {
  411.       const window = this.windows_[windowId];
  412.       if (window.isVisible()) {
  413.         // We are turning off the visibility, emit!
  414.         parsedClosedCaption = window.forceEmit(pts, this.serviceNumber_);
  415.       }
  416.       // Delete the window from the list of windows
  417.       this.windows_[windowId] = null;
  418.     }
  419.     return parsedClosedCaption;
  420.   }
  422.   /**
  423.    * Emits anything currently present in any of the windows, and then
  424.    * deletes all windows, cancels all delays, reinitializes the service.
  425.    * @param {number} pts
  426.    * @return {?shaka.extern.ICaptionDecoder.ClosedCaption}
  427.    * @private
  428.    */
  429.   reset_(pts) {
  430.     const allWindowsBitmap = 0xff; // All windows should be deleted.
  431.     const caption = this.deleteWindows_(allWindowsBitmap, pts);
  432.     this.clear();
  433.     return caption;
  434.   }
  436.   /**
  437.    * Clears the state of the service completely.
  438.    */
  439.   clear() {
  440.     this.currentWindow_ = null;
  441.     this.windows_ = [null, null, null, null, null, null, null, null];
  442.   }
  444.   /**
  445.    * @param {!shaka.cea.DtvccPacket} dtvccPacket
  446.    * @throws {!shaka.util.Error}
  447.    * @private
  448.    */
  449.   setPenAttributes_(dtvccPacket) {
  450.     // Two bytes follow. For the purpose of this decoder, we are only concerned
  451.     // with byte 2, which is of the form |I|U|EDTYP|FNTAG|.
  453.     // I (1 bit): Italics toggle.
  454.     // U (1 bit): Underline toggle.
  455.     // EDTYP (3 bits): Edge type (unused in this decoder).
  456.     // FNTAG (3 bits): Font tag (unused in this decoder).
  457.     // More info at https://en.wikipedia.org/wiki/CEA-708#SetPenAttributes_(0x90_+_2_bytes)
  459.     dtvccPacket.skip(1); // Skip first byte
  460.     const attrByte2 = dtvccPacket.readByte().value;
  462.     if (!this.currentWindow_) {
  463.       return;
  464.     }
  466.     const italics = (attrByte2 & 0x80) > 0;
  467.     const underline = (attrByte2 & 0x40) > 0;
  469.     this.currentWindow_.setPenItalics(italics);
  470.     this.currentWindow_.setPenUnderline(underline);
  471.   }
  473.   /**
  474.    * @param {!shaka.cea.DtvccPacket} dtvccPacket
  475.    * @throws {!shaka.util.Error}
  476.    * @private
  477.    */
  478.   setPenColor_(dtvccPacket) {
  479.     // Read foreground and background properties.
  480.     const foregroundByte = dtvccPacket.readByte().value;
  481.     const backgroundByte = dtvccPacket.readByte().value;
  482.     dtvccPacket.skip(1); // Edge color not supported, skip it.
  484.     if (!this.currentWindow_) {
  485.       return;
  486.     }
  488.     // Byte semantics are described at the following link:
  489.     // https://en.wikipedia.org/wiki/CEA-708#SetPenColor_(0x91_+_3_bytes)
  491.     // Foreground color properties: |FOP|F_R|F_G|F_B|.
  492.     const foregroundBlue = foregroundByte & 0x03;
  493.     const foregroundGreen = (foregroundByte & 0x0c) >> 2;
  494.     const foregroundRed = (foregroundByte & 0x30) >> 4;
  496.     // Background color properties: |BOP|B_R|B_G|B_B|.
  497.     const backgroundBlue = backgroundByte & 0x03;
  498.     const backgroundGreen = (backgroundByte & 0x0c) >> 2;
  499.     const backgroundRed = (backgroundByte & 0x30) >> 4;
  501.     const foregroundColor = this.rgbColorToHex_(
  502.         foregroundRed, foregroundGreen, foregroundBlue);
  504.     const backgroundColor = this.rgbColorToHex_(
  505.         backgroundRed, backgroundGreen, backgroundBlue);
  507.     this.currentWindow_.setPenTextColor(foregroundColor);
  508.     this.currentWindow_.setPenBackgroundColor(backgroundColor);
  509.   }
  511.   /**
  512.    * @param {!shaka.cea.DtvccPacket} dtvccPacket
  513.    * @throws {!shaka.util.Error}
  514.    * @private
  515.    */
  516.   setPenLocation_(dtvccPacket) {
  517.     // Following 2 bytes take the following form:
  518.     // b1 = |0|0|0|0|ROW| and b2 = |0|0|COLUMN|
  519.     const locationByte1 = dtvccPacket.readByte().value;
  520.     const locationByte2 = dtvccPacket.readByte().value;
  522.     if (!this.currentWindow_) {
  523.       return;
  524.     }
  526.     const row = locationByte1 & 0x0f;
  527.     const col = locationByte2 & 0x3f;
  528.     this.currentWindow_.setPenLocation(row, col);
  529.   }
  531.   /**
  532.    * @param {!shaka.cea.DtvccPacket} dtvccPacket
  533.    * @throws {!shaka.util.Error}
  534.    * @private
  535.    */
  536.   setWindowAttributes_(dtvccPacket) {
  537.     // 4 bytes follow, with the following form:
  538.     // Byte 1 contains fill-color information. Unused in this decoder.
  539.     // Byte 2 contains border color information. Unused in this decoder.
  540.     // Byte 3 contains justification information. In this decoder, we only use
  541.     // the last 2 bits, which specifies text justification on the screen.
  542.     // Byte 4 is special effects. Unused in this decoder.
  543.     // More info at https://en.wikipedia.org/wiki/CEA-708#SetWindowAttributes_(0x97_+_4_bytes)
  544.     dtvccPacket.skip(1); // Fill color not supported, skip.
  545.     dtvccPacket.skip(1); // Border colors not supported, skip.
  546.     const b3 = dtvccPacket.readByte().value;
  547.     dtvccPacket.skip(1); // Effects not supported, skip.
  549.     if (!this.currentWindow_) {
  550.       return;
  551.     }
  553.     // Word wrap is outdated as of CEA-708-E, so we ignore those bits.
  554.     // Extract the text justification and set it on the window.
  555.     const justification =
  556.       /** @type {!shaka.cea.Cea708Window.TextJustification} */ (b3 & 0x03);
  557.     this.currentWindow_.setJustification(justification);
  558.   }
  560.   /**
  561.    * @param {!shaka.cea.DtvccPacket} dtvccPacket
  562.    * @param {number} windowNum
  563.    * @param {number} pts
  564.    * @throws {!shaka.util.Error}
  565.    * @private
  566.    */
  567.   defineWindow_(dtvccPacket, windowNum, pts) {
  568.     // Create the window if it doesn't exist.
  569.     const windowAlreadyExists = this.windows_[windowNum] !== null;
  570.     if (!windowAlreadyExists) {
  571.       const window = new shaka.cea.Cea708Window(windowNum, this.serviceNumber_);
  572.       window.setStartTime(pts);
  573.       this.windows_[windowNum] = window;
  574.     }
  576.     // 6 Bytes follow, with the following form:
  577.     // b1 = |0|0|V|R|C|PRIOR| , b2 = |P|VERT_ANCHOR| , b3 = |HOR_ANCHOR|
  578.     // b4 = |ANC_ID|ROW_CNT| , b5 = |0|0|COL_COUNT| , b6 = |0|0|WNSTY|PNSTY|
  579.     // Semantics of these bytes at https://en.wikipedia.org/wiki/CEA-708#DefineWindow07_(0x98-0x9F,_+_6_bytes)
  580.     const b1 = dtvccPacket.readByte().value;
  581.     const b2 = dtvccPacket.readByte().value;
  582.     const b3 = dtvccPacket.readByte().value;
  583.     const b4 = dtvccPacket.readByte().value;
  584.     const b5 = dtvccPacket.readByte().value;
  585.     const b6 = dtvccPacket.readByte().value;
  587.     // As per 8.4.7 of CEA-708-E, row locks and column locks are to be ignored.
  588.     // So this decoder will ignore these values.
  590.     const visible = (b1 & 0x20) > 0;
  591.     const verticalAnchor = b2 & 0x7f;
  592.     const relativeToggle = (b2 & 0x80) > 0;
  593.     const horAnchor = b3;
  594.     const rowCount = (b4 & 0x0f) + 1; // Spec says to add 1.
  595.     const anchorId = (b4 & 0xf0) >> 4;
  596.     const colCount = (b5 & 0x3f) + 1; // Spec says to add 1.
  598.     // If pen style = 0 AND window previously existed, keep its pen style.
  599.     // Otherwise, change the pen style (For now, just reset to the default pen).
  600.     // TODO add support for predefined pen styles and fonts.
  601.     const penStyle = b6 & 0x07;
  602.     if (!windowAlreadyExists || penStyle !== 0) {
  603.       this.windows_[windowNum].resetPen();
  604.     }
  606.     this.windows_[windowNum].defineWindow(visible, verticalAnchor,
  607.         horAnchor, anchorId, relativeToggle, rowCount, colCount);
  609.     // Set the current window to the newly defined window.
  610.     this.currentWindow_ = this.windows_[windowNum];
  611.   }
  613.   /**
  614.    * Maps 64 possible CEA-708 colors to 8 CSS colors.
  615.    * @param {number} red value from 0-3
  616.    * @param {number} green value from 0-3
  617.    * @param {number} blue value from 0-3
  618.    * @return {string}
  619.    * @private
  620.    */
  621.   rgbColorToHex_(red, green, blue) {
  622.     // Rather than supporting 64 colors, this decoder supports 8 colors and
  623.     // gets the closest color, as per 9.19 of CEA-708-E. This is because some
  624.     // colors on television such as white, are often sent with lower intensity
  625.     // and often appear dull/greyish on the browser, making them hard to read.
  627.     // As per CEA-708-E 9.19, these mappings will map 64 colors to 8 colors.
  628.     const colorMapping = {0: 0, 1: 0, 2: 1, 3: 1};
  629.     red = colorMapping[red];
  630.     green = colorMapping[green];
  631.     blue = colorMapping[blue];
  633.     const colorCode = (red << 2) | (green << 1) | blue;
  634.     return shaka.cea.Cea708Service.Colors[colorCode];
  635.   }
  636. };
  638. /**
  639.  * @private @const {number}
  640.  */
  641. shaka.cea.Cea708Service.ASCII_BACKSPACE = 0x08;
  643. /**
  644.  * @private @const {number}
  645.  */
  646. shaka.cea.Cea708Service.ASCII_FORM_FEED = 0x0c;
  648. /**
  649.  * @private @const {number}
  650.  */
  651. shaka.cea.Cea708Service.ASCII_CARRIAGE_RETURN = 0x0d;
  653. /**
  654.  * @private @const {number}
  655.  */
  656. shaka.cea.Cea708Service.ASCII_HOR_CARRIAGE_RETURN = 0x0e;
  658. /**
  659.  * For extended control codes in block_data on CEA-708, byte 1 is 0x10.
  660.  * @private @const {number}
  661.  */
  662. shaka.cea.Cea708Service.EXT_CEA708_CTRL_CODE_BYTE1 = 0x10;
  664. /**
  665.  * Holds characters mapping for bytes that are G2 control codes.
  666.  * @private @const {!Map<number, string>}
  667.  */
  668. shaka.cea.Cea708Service.G2Charset = new Map([
  669.   [0x20, ' '], [0x21, '\xa0'], [0x25, '…'], [0x2a, 'Š'], [0x2c, 'Œ'],
  670.   [0x30, '█'], [0x31, '‘'], [0x32, '’'], [0x33, '“'], [0x34, '”'],
  671.   [0x35, '•'], [0x39, '™'], [0x3a, 'š'], [0x3c, 'œ'], [0x3d, '℠'],
  672.   [0x3f, 'Ÿ'], [0x76, '⅛'], [0x77, '⅜'], [0x78, '⅝'], [0x79, '⅞'],
  673.   [0x7a, '│'], [0x7b, '┐'], [0x7c, '└'], [0x7d, '─'], [0x7e, '┘'], [0x7f, '┌'],
  674. ]);
  676. /**
  677.  * An array of 8 colors that 64 colors can be quantized to. Order here matters.
  678.  * @private @const {!Array<string>}
  679.  */
  680. shaka.cea.Cea708Service.Colors = [
  681.   'black', 'blue', 'green', 'cyan',
  682.   'red', 'magenta', 'yellow', 'white',
  683. ];
  685. /**
  686.  * CEA-708 closed captions byte.
  687.  * @typedef {{
  688.  *   pts: number,
  689.  *   type: number,
  690.  *   value: number,
  691.  *   order: number
  692.  * }}
  693.  *
  694.  * @property {number} pts
  695.  *   Presentation timestamp (in second) at which this packet was received.
  696.  * @property {number} type
  697.  *   Type of the byte. Either 2 or 3, DTVCC Packet Data or a DTVCC Packet Start.
  698.  * @property {number} value The byte containing data relevant to the packet.
  699.  * @property {number} order
  700.  *   A number indicating the order this packet was received in a sequence
  701.  *   of packets. Used to break ties in a stable sorting algorithm
  702.  */
  703. shaka.cea.Cea708Service.Cea708Byte;