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