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