Source: lib/text/ssa_text_parser.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. // cspell:ignore AABBGGRR HAABBGGRR
  9. goog.provide('shaka.text.SsaTextParser');
  11. goog.require('goog.asserts');
  12. goog.require('shaka.log');
  13. goog.require('shaka.text.Cue');
  14. goog.require('shaka.text.TextEngine');
  15. goog.require('shaka.util.StringUtils');
  18. /**
  19.  * Documentation: http://moodub.free.fr/video/ass-specs.doc
  20.  * https://en.wikipedia.org/wiki/SubStation_Alpha
  21.  * @implements {shaka.extern.TextParser}
  22.  * @export
  23.  */
  24. shaka.text.SsaTextParser = class {
  25.   /**
  26.    * @override
  27.    * @export
  28.    */
  29.   parseInit(data) {
  30.     goog.asserts.assert(false, 'SSA does not have init segments');
  31.   }
  33.   /**
  34.    * @override
  35.    * @export
  36.    */
  37.   setSequenceMode(sequenceMode) {
  38.     // Unused.
  39.   }
  41.   /**
  42.    * @override
  43.    * @export
  44.    */
  45.   setManifestType(manifestType) {
  46.     // Unused.
  47.   }
  49.   /**
  50.    * @override
  51.    * @export
  52.    */
  53.   parseMedia(data, time) {
  54.     const StringUtils = shaka.util.StringUtils;
  55.     const SsaTextParser = shaka.text.SsaTextParser;
  57.     // Get the input as a string.
  58.     const str = StringUtils.fromUTF8(data);
  60.     const section = {
  61.       styles: '',
  62.       events: '',
  63.     };
  65.     let tag = null;
  66.     let lines = null;
  67.     const parts = str.split(/\r?\n\s*\r?\n/);
  68.     for (const part of parts) {
  69.       lines = part;
  70.       // SSA content
  71.       const match = SsaTextParser.ssaContent_.exec(part);
  72.       if (match) {
  73.         tag = match[1];
  74.         lines = match[2];
  75.       }
  76.       if (tag == 'V4 Styles' || tag == 'V4+ Styles') {
  77.         section.styles = lines;
  78.         if (section.events) {
  79.           section.styles += '\n' + lines;
  80.         } else {
  81.           section.styles = lines;
  82.         }
  83.         continue;
  84.       }
  85.       if (tag == 'Events') {
  86.         if (section.events) {
  87.           section.events += '\n' + lines;
  88.         } else {
  89.           section.events = lines;
  90.         }
  91.         continue;
  92.       }
  93.       if (tag == 'Script Info') {
  94.         continue;
  95.       }
  96.       shaka.log.warning('SsaTextParser parser encountered an unknown part.',
  97.           lines);
  98.     }
  100.     // Process styles
  101.     const styles = [];
  103.     // Used to be able to iterate over the style parameters.
  104.     let styleColumns = null;
  106.     const styleLines = section.styles.split(/\r?\n/);
  107.     for (const line of styleLines) {
  108.       if (/^\s*;/.test(line)) {
  109.         // Skip comment
  110.         continue;
  111.       }
  112.       const lineParts = SsaTextParser.lineParts_.exec(line);
  113.       if (lineParts) {
  114.         const name = lineParts[1].trim();
  115.         const value = lineParts[2].trim();
  116.         if (name == 'Format') {
  117.           styleColumns = value.split(SsaTextParser.valuesFormat_);
  118.           continue;
  119.         }
  120.         if (name == 'Style') {
  121.           const values = value.split(SsaTextParser.valuesFormat_);
  122.           const style = {};
  123.           for (let c = 0; c < styleColumns.length && c < values.length; c++) {
  124.             style[styleColumns[c]] = values[c];
  125.           }
  126.           styles.push(style);
  127.           continue;
  128.         }
  129.       }
  130.     }
  132.     // Process cues
  133.     /** @type {!Array<!shaka.text.Cue>} */
  134.     const cues = [];
  136.     // Used to be able to iterate over the event parameters.
  137.     let eventColumns = null;
  139.     const eventLines = section.events.split(/\r?\n/);
  140.     for (const line of eventLines) {
  141.       if (/^\s*;/.test(line)) {
  142.         // Skip comment
  143.         continue;
  144.       }
  145.       const lineParts = SsaTextParser.lineParts_.exec(line);
  146.       if (lineParts) {
  147.         const name = lineParts[1].trim();
  148.         const value = lineParts[2].trim();
  149.         if (name == 'Format') {
  150.           eventColumns = value.split(SsaTextParser.valuesFormat_);
  151.           continue;
  152.         }
  153.         if (name == 'Dialogue') {
  154.           const values = value.split(SsaTextParser.valuesFormat_);
  155.           const data = {};
  156.           for (let c = 0; c < eventColumns.length && c < values.length; c++) {
  157.             data[eventColumns[c]] = values[c];
  158.           }
  160.           const startTime = SsaTextParser.parseTime_(data['Start']);
  161.           const endTime = SsaTextParser.parseTime_(data['End']);
  163.           // Note: Normally, you should take the "Text" field, but if it
  164.           // has a comma, it fails.
  165.           const payload = values.slice(eventColumns.length - 1).join(',')
  166.               .replace(/\\N/g, '\n') // '\n' for new line
  167.               .replace(/\{[^}]+\}/g, ''); // {\pos(400,570)}
  169.           const cue = new shaka.text.Cue(startTime, endTime, payload);
  171.           const styleName = data['Style'];
  172.           const styleData = styles.find((s) => s['Name'] == styleName);
  173.           if (styleData) {
  174.             SsaTextParser.addStyle_(cue, styleData);
  175.           }
  176.           cues.push(cue);
  177.           continue;
  178.         }
  179.       }
  180.     }
  182.     return cues;
  183.   }
  185.   /**
  186.    * Adds applicable style properties to a cue.
  187.    *
  188.    * @param {shaka.text.Cue} cue
  189.    * @param {Object} style
  190.    * @private
  191.    */
  192.   static addStyle_(cue, style) {
  193.     const Cue = shaka.text.Cue;
  194.     const SsaTextParser = shaka.text.SsaTextParser;
  195.     const fontFamily = style['Fontname'];
  196.     if (fontFamily) {
  197.       cue.fontFamily = fontFamily;
  198.     }
  199.     const fontSize = style['Fontsize'];
  200.     if (fontSize) {
  201.       cue.fontSize = fontSize + 'px';
  202.     }
  203.     const color = style['PrimaryColour'];
  204.     if (color) {
  205.       const ccsColor = SsaTextParser.parseSsaColor_(color);
  206.       if (ccsColor) {
  207.         cue.color = ccsColor;
  208.       }
  209.     }
  210.     const backgroundColor = style['BackColour'];
  211.     if (backgroundColor) {
  212.       const cssBackgroundColor = SsaTextParser.parseSsaColor_(backgroundColor);
  213.       if (cssBackgroundColor) {
  214.         cue.backgroundColor = cssBackgroundColor;
  215.       }
  216.     }
  217.     const bold = style['Bold'];
  218.     if (bold) {
  219.       cue.fontWeight = Cue.fontWeight.BOLD;
  220.     }
  221.     const italic = style['Italic'];
  222.     if (italic) {
  223.       cue.fontStyle = Cue.fontStyle.ITALIC;
  224.     }
  225.     const underline = style['Underline'];
  226.     if (underline) {
  227.       cue.textDecoration.push(Cue.textDecoration.UNDERLINE);
  228.     }
  229.     const letterSpacing = style['Spacing'];
  230.     if (letterSpacing) {
  231.       cue.letterSpacing = letterSpacing + 'px';
  232.     }
  233.     const alignment = style['Alignment'];
  234.     if (alignment) {
  235.       const alignmentInt = parseInt(alignment, 10);
  236.       switch (alignmentInt) {
  237.         case 1:
  238.           cue.displayAlign = Cue.displayAlign.AFTER;
  239.           cue.textAlign = Cue.textAlign.START;
  240.           break;
  241.         case 2:
  242.           cue.displayAlign = Cue.displayAlign.AFTER;
  243.           cue.textAlign = Cue.textAlign.CENTER;
  244.           break;
  245.         case 3:
  246.           cue.displayAlign = Cue.displayAlign.AFTER;
  247.           cue.textAlign = Cue.textAlign.END;
  248.           break;
  249.         case 5:
  250.           cue.displayAlign = Cue.displayAlign.BEFORE;
  251.           cue.textAlign = Cue.textAlign.START;
  252.           break;
  253.         case 6:
  254.           cue.displayAlign = Cue.displayAlign.BEFORE;
  255.           cue.textAlign = Cue.textAlign.CENTER;
  256.           break;
  257.         case 7:
  258.           cue.displayAlign = Cue.displayAlign.BEFORE;
  259.           cue.textAlign = Cue.textAlign.END;
  260.           break;
  261.         case 9:
  262.           cue.displayAlign = Cue.displayAlign.CENTER;
  263.           cue.textAlign = Cue.textAlign.START;
  264.           break;
  265.         case 10:
  266.           cue.displayAlign = Cue.displayAlign.CENTER;
  267.           cue.textAlign = Cue.textAlign.CENTER;
  268.           break;
  269.         case 11:
  270.           cue.displayAlign = Cue.displayAlign.CENTER;
  271.           cue.textAlign = Cue.textAlign.END;
  272.           break;
  273.       }
  274.     }
  275.     const opacity = style['AlphaLevel'];
  276.     if (opacity) {
  277.       cue.opacity = parseFloat(opacity);
  278.     }
  279.   }
  281.   /**
  282.    * Parses a SSA color .
  283.    *
  284.    * @param {string} colorString
  285.    * @return {?string}
  286.    * @private
  287.    */
  288.   static parseSsaColor_(colorString) {
  289.     // The SSA V4+ color can be represented in hex (&HAABBGGRR) or in decimal
  290.     // format (byte order AABBGGRR) and in both cases the alpha channel's
  291.     // value needs to be inverted as in case of SSA the 0xFF alpha value means
  292.     // transparent and 0x00 means opaque
  293.     /** @type {number} */
  294.     const abgr = parseInt(colorString.replace('&H', ''), 16);
  295.     if (abgr >= 0) {
  296.       const a = ((abgr >> 24) & 0xFF) ^ 0xFF; // Flip alpha.
  297.       const alpha = a / 255;
  298.       const b = (abgr >> 16) & 0xFF;
  299.       const g = (abgr >> 8) & 0xFF;
  300.       const r = abgr & 0xff;
  301.       return 'rgba(' + r + ',' + g + ',' + b + ',' + alpha + ')';
  302.     }
  303.     return null;
  304.   }
  306.   /**
  307.    * Parses a SSA time from the given parser.
  308.    *
  309.    * @param {string} string
  310.    * @return {number}
  311.    * @private
  312.    */
  313.   static parseTime_(string) {
  314.     const SsaTextParser = shaka.text.SsaTextParser;
  315.     const match = SsaTextParser.timeFormat_.exec(string);
  316.     const hours = match[1] ? parseInt(match[1].replace(':', ''), 10) : 0;
  317.     const minutes = parseInt(match[2], 10);
  318.     const seconds = parseFloat(match[3]);
  319.     return hours * 3600 + minutes * 60 + seconds;
  320.   }
  321. };
  323. /**
  324.  * @const
  325.  * @private {!RegExp}
  326.  * @example [V4 Styles]\nFormat: Name\nStyle: DefaultVCD
  327.  */
  328. shaka.text.SsaTextParser.ssaContent_ =
  329.     /^\s*\[([^\]]+)\]\r?\n([\s\S]*)/;
  331. /**
  332.  * @const
  333.  * @private {!RegExp}
  334.  * @example Style: DefaultVCD,...
  335.  */
  336. shaka.text.SsaTextParser.lineParts_ =
  337.     /^\s*([^:]+):\s*(.*)/;
  339. /**
  340.  * @const
  341.  * @private {!RegExp}
  342.  * @example Style: DefaultVCD,...
  343.  */
  344. shaka.text.SsaTextParser.valuesFormat_ = /\s*,\s*/;
  346. /**
  347.  * @const
  348.  * @private {!RegExp}
  349.  * @example 0:00:01.1 or 0:00:01.18 or 0:00:01.180
  350.  */
  351. shaka.text.SsaTextParser.timeFormat_ =
  352.     /^(\d+:)?(\d{1,2}):(\d{1,2}(?:[.]\d{1,3})?)?$/;
  354. shaka.text.TextEngine.registerParser(
  355.     'text/x-ssa', () => new shaka.text.SsaTextParser());