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