vtt2ass 0.3.2 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5e94988be1922e26d861f105404e3eff863a2df470aa3aa7fc5f35cdf26c3c71
-  data.tar.gz: 055641cfd88eef119e3c623adbae16b9eb70a7091c26b13410d8b94c2c8e55ec
+  metadata.gz: 3047227acbd6bf731e5dc95113a7d70081bed94392e3b00078b760ebbc4440a4
+  data.tar.gz: e9bc514e5b41028d872d9e983cc4dbd4442fc648ab1065e2c3e5a2aca3c9b8fd
 SHA512:
-  metadata.gz: 785df255fc71e0479a8b124222e25033e2aca337765cdd17bf46c6ef0e11adae7fb854b01fa23959946f8d9ebd8bbfefcaf6cafc10b9a7089a52b11806f5e82a
-  data.tar.gz: 9cd4940b1d5667136aa51d9bff670a2d98e4a966ee898110230c15d710c87898aaf596afd6a6c7173f0ef06cf26eb57e7f2b3acd1c670f95209d97be9c5d5480
+  metadata.gz: 388af342ebe22e69e52e92e4dadf5a04ea48cb6e491398e864ed1e9d5ae3a602601cddc070ae20f7e8edef0b652a87aa3e8a66f8b8128626315dbac0dd421873
+  data.tar.gz: fa2f3b0fa33c3ee1ade343b14837e8f09d2b5145f41e60f68e1cc7236e17e23c67cb7a811f5abf145df7e7121fd651364870073b6ff74679f6c9ddfe375a2ddc

data/.rubocop.yml

@@ -0,0 +1,19 @@
+---
+AllCops:
+  TargetRubyVersion: 2.7.2
+  NewCops: enable
+# Set method line number to 25
+Metrics/MethodLength:
+  Max: 25
+# Set parameter number to 10
+Metrics/ParameterLists:
+  Max: 10
+# Disable checking of ABC metrics (assignment, branch, condition)
+Metrics/AbcSize:
+  Enabled: false
+# Disable method perceived complexity (how it is hard to read a method)
+Metrics/PerceivedComplexity:
+  Enabled: false
+# Disable cyclomatic complexity which is a number of paths through a method
+Metrics/CyclomaticComplexity:
+  Enabled: false

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in vtt2ass.gemspec

data/README.md

@@ -2,35 +2,54 @@
 
 [![Gem Version](https://badge.fury.io/rb/vtt2ass.svg)](https://badge.fury.io/rb/vtt2ass)
 
-This is a simple application to convert VTT files to ASS subtitles.
+## Description
+
+This is a simple CLI (Command Line Interface) application to convert VTT files to ASS subtitles.
+
+This application is originally based on the `vttconvert` module of [anidl/hidive-downloader-nx](https://github.com/anidl/hidive-downloader-nx) repository. The [maxwbot/maxwhidive](https://github.com/maxwbot/maxwhidive) repository was also used as inspiration for handling the positionning of subs.
+
+Those two tools were missing features and didn't work well on a lot of more complex subtitles files. For that reason, I wrote a new tool that can handle everything.
+
+### Features
+
+- Convert simple VTT files
+- Convert complex VTT files with positioning
+- Convert Hidive VTT files with CSS styling
+- Convert subtitles in batches by specifying the input directory
+- Handles subtitles made for lower resolution video
+- Can add offset to subtitle lines
+- Can output result to the CLI
+- Can output to the specifed directory
+- Can change the base font size
+- Can specify a custom font family for non-styled lines
+- Can add a title to the converted files
 
 ## Requirements
+
 - ruby 2.7.2 or newer
 
-It might work with older versions of ruby, but it hasn't been tested
+Development is currently done on ruby 3.0+, but the Gitlab runner for builds works with ruby version 2.7.2. Older versions of ruby may be compatible, but they won't be tested.
 
 ## Installation
 
 To install:
 ```bash
-gem install vtt2ass
-```
-
-# Build
-
-```bash
-gem build vtt2ass.gemspec
+$ gem install vtt2ass
 ```
 
 ## Usage
 
+- Empty arguments lists the available commands
 ```bash
 $ vtt2ass
 Commands:
   vtt2ass convert INPUT   # Run the VTT to ASS conversion for the specified file(s)
   vtt2ass help [COMMAND]  # Describe available commands or one specific command
   vtt2ass version         # Show version
+```
 
+- Help command shows available options of the specified command
+```bash
 $ vtt2ass help convert
 Usage:
   vtt2ass convert INPUT
@@ -45,12 +64,53 @@ Options:
   -c, [--css=CSS]                  # Specify a CSS file path for Hidive subs
   -l, [--line-offset=N]            # Specify a line offset for the main dialog (e.g. 50 lowers the text line by 50px of the total height)
                                    # Default: 0
+  -w, [--width=N]                  # Specify the video width
+                                   # Default: 1920
+  -h, [--height=N]                 # Specify the video height
+                                   # Default: 1080
   -q, [--quiet], [--no-quiet]      # Don't output to the console
 
 Run the VTT to ASS conversion for the specified file(s)
 ```
 
-# Donate
+- Convert command
+```bash
+$ vtt2ass convert ./path/to/input/ -o ./path/to/output/ -l 50 -q
+```
+
+- Version command shows the application version
+```bash
+$ vtt2ass version
+0.3.3
+```
+
+## Contributing
+
+Contributions are welcome. Create an *Issue* on Gitlab and link it with a *Pull Request* of the changes made. The changes needs to pass the ruby tests.
+
+```
+$ rake test
+```
+
+## Build
+
+To build a gem file for local installation:
+```bash
+$ git clone https://gitlab.com/dkb-weeblets/vtt2ass.git
+$ cd vtt2ass/
+$ gem build vtt2ass.gemspec
+```
+
+To install the gem file:
+```bash
+$ gem install ./vtt2ass-0.3.5.gem
+```
+
+## License
+
+Licensed under the **MIT** Licence. For more information read the `LICENSE.txt` file.
+
+## Donate
 
 If you want to support me, consider buying me a coffee.
 

data/Rakefile

@@ -1,10 +1,12 @@
-require "bundler/gem_tasks"
-require "rake/testtask"
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
 
 Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  t.libs << "lib"
-  t.test_files = FileList["test/**/*_test.rb"]
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
 end
 
-task :default => :test
+task default: :test

data/bin/vtt2ass

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require_relative '../lib/vtt2ass'
-MainCommand.start
+MainCommand.start

data/exe/vtt2ass

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'vtt2ass'
-MainCommand.start
+MainCommand.start

data/lib/vtt2ass/application.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative 'vtt_file'
+require_relative 'ass_file'
+
+##
+# Main application class that manages all the operations.
+class Application
+  ##
+  # Creates a new Application instance.
+  # It receives +options+ that can define the input and output directories.
+  def initialize(input, options)
+    @options = options
+    @input = sanitize_path(input)
+  end
+
+  ##
+  # Replace backslashes from Windows paths to normal slashes.
+  # Deletes the trailing slash if there is one.
+  def sanitize_path(path)
+    path&.gsub('\\', '/')&.delete_suffix('/')
+  end
+
+  ##
+  # This method starts the application process.
+  # It sends the file_paths of VTT files in the input directory to convertFileToASS method
+  # and outputs the resulting ASS format to a new file.
+  def start
+    if File.directory?(@input)
+      Dir["#{@input}/*.vtt"].each do |file_path|
+        convert(file_path)
+      end
+    elsif File.file?(@input)
+      convert(@input)
+    else
+      raise StandardError, 'ERROR: Input file or directory does not exist.'
+    end
+  rescue SystemExit, Interrupt
+    puts 'ERROR: The application stopped unexpectedly. The conversion may not have been completed.'
+  rescue StandardError => e
+    puts e.message
+  end
+
+  ##
+  # This method launches the conversion process on the specified input file.
+  def convert(input_path)
+    output = sanitize_path(@options[:output])
+    raise StandardError, 'ERROR: Output directory does not exist.' unless File.directory?(output)
+
+    ass_file = vtt_to_ass(input_path)
+    ass_file.write_to_file("#{output}/#{File.basename(input_path).gsub('.vtt', '.ass')}") unless output.nil?
+    puts ass_file.to_s unless @options[:quiet]
+  end
+
+  ##
+  # This method creates a new VTTFile object from the file path provided and convert its content
+  # inside a new ASSFile object.
+  def vtt_to_ass(file_path)
+    base_file_name = File.basename(file_path).gsub('.vtt', '')
+    css_file =
+      if !@options[:css].nil? && File.directory?(@options[:css])
+        "#{sanitize_path(@options[:css])}/#{base_file_name}.css"
+      elsif File.file?("#{file_path.gsub('.vtt', '')}.css")
+        "#{file_path.gsub('.vtt', '')}.css"
+      else
+        @options[:css]
+      end
+    vtt_file = VTTFile.new(file_path, @options[:width], @options[:height])
+    ass_file = ASSFile.new(
+      (@options[:title].nil? ? base_file_name : @options[:title]),
+      @options[:width],
+      @options[:height],
+      css_file
+    )
+    ass_file.convert_vtt_to_ass(vtt_file, @options[:font_family], @options[:font_size], @options[:line_offset])
+    ass_file
+  end
+end

data/lib/vtt2ass/ass_file.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require_relative 'ass_line'
+require_relative 'ass_style'
+require_relative 'css_file'
+require_relative 'css_rule'
+
+##
+# This class defines an ASS subtitle file.
+class ASSFile
+  attr_reader :title, :width, :height
+  attr_accessor :ass_styles, :ass_lines
+
+  ##
+  # Creates a new ASSFile instance and assigns the default values of instance variables.
+  def initialize(title, width, height, css_file_path = nil)
+    @width = width
+    @height = height
+    @css_file = CSSFile.new(css_file_path) unless css_file_path.nil?
+    @header = <<~HEADER
+      [Script Info]
+      Title: #{title}
+      ScriptType: v4.00+
+      Collisions: Normal
+      PlayDepth: 0
+      PlayResX: #{@width}
+      PlayResY: #{@height}
+      WrapStyle: 0
+      ScaledBorderAndShadow: yes
+
+      [V4+ Styles]
+      Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
+    HEADER
+    @events = <<~EVENTS
+
+      [Events]
+      Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
+    EVENTS
+    @ass_styles = []
+    @ass_lines = []
+  end
+
+  ##
+  # This method receives a VTTFile object and font arguments creates new ASSLine with the params of
+  # each VTTLine. All those ASSLine are stored in an array. It also creates an array of ASSStyle that
+  # will be used in the ASS style list.
+  def convert_vtt_to_ass(vtt_file, font_family, font_size, line_offset = 0) # rubocop:disable Metrics/MethodLength
+    fs = font_size
+    vtt_file.lines.each do |line| # rubocop:disable Metrics/BlockLength
+      font_color = '&H00FFFFFF'
+      is_italic = false
+      is_bold = false
+      @ass_lines.push(ASSLine.new(line.style, line.time_start, line.time_end, line.text))
+      style_exists = false
+      @ass_styles.each do |style|
+        if style.style_name.eql? line.style
+          style_exists = true
+          break
+        end
+      end
+      next if style_exists
+
+      unless @css_file.nil?
+        css_rule = @css_file.find_rule(line.style)
+        css_rule&.properties&.each do |property|
+          case property[:key]
+          when 'font-family'
+            font_family = property[:value].gsub('"', '').split(' ,').last
+          when 'font-size'
+            em_size = 1
+            em_size = "0#{property[:value]}".gsub('em', '').to_f if property[:value][0].eql? '.'
+            font_size = (fs * em_size).to_i
+          when 'color'
+            font_color = ASSStyle.convert_color(property[:value])
+          when 'font-weight'
+            is_bold = true if property[:value].eql? 'bold'
+          when 'font-style'
+            is_italic = true if property[:value].eql? 'italic'
+          end
+        end
+      end
+      @ass_styles.push(
+        ASSStyle.new(
+          line.style, line.params,
+          font_family, font_size, font_color, is_bold, is_italic,
+          line_offset, @width, @height
+        )
+      )
+    end
+  end
+
+  ##
+  # This method writes the content of the ASSFile object into a file path that is provided.
+  def write_to_file(file_path)
+    File.open(file_path, 'w') do |line|
+      line.print "\ufeff"
+      line.puts to_s
+    end
+  end
+
+  ##
+  # This method concatenates the object data in the right order for a string output.
+  def to_s
+    "#{@header}#{@ass_styles.join("\n")}#{@events}#{@ass_lines.join("\n")}"
+  end
+end

data/lib/vtt2ass/ass_line.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'htmlentities'
+
+##
+# This class defines an ASS subtile line.
+class ASSLine
+  attr_reader :style, :time_start, :time_end, :text
+
+  ##
+  # This method creates an instance of an ASSLine.
+  #
+  # * Requires a +style+ name as input.
+  # * Requires +time_start+, a VTT formatted timestamp as input.
+  # * Requires +time_start+, a VTT formatted timestamp as input.
+  # * Requires +text+, a VTT formatted string as input.
+  def initialize(style, time_start, time_end, text)
+    @style = style
+    @time_start = convert_time(time_start)
+    @time_end = convert_time(time_end)
+    @text = convert_to_ass_text(text)
+  end
+
+  ##
+  # This method assigns the object values and outputs an ASS dialogue line.
+  def to_s
+    "Dialogue: 0,#{@time_start},#{@time_end},#{@style},,0,0,0,,#{@text}"
+  end
+
+  ##
+  # This method replaces characters and tags to ASS compatible characters and tags.
+  #
+  # * Requires +text+, a string of VTT formated text as input.
+  def convert_to_ass_text(text)
+    decoder = HTMLEntities.new
+    text =
+      text
+      .gsub(/\r/, '')
+      .gsub(/\n/, '\\N')
+      .gsub(/\\n/, '\\N')
+      .gsub(/\\N +/, '\\N')
+      .gsub(/ +\\N/, '\\N')
+      .gsub(/(\\N)+/, '\\N')
+      .gsub(%r{<b[^>]*>([^<]*)</b>}) { |_s| "{\\b1}#{Regexp.last_match(1)}{\\b0}" }
+      .gsub(%r{<i[^>]*>([^<]*)</i>}) { |_s| "{\\i1}#{Regexp.last_match(1)}{\\i0}" }
+      .gsub(%r{<u[^>]*>([^<]*)</u>}) { |_s| "{\\u1}#{Regexp.last_match(1)}{\\u0}" }
+      .gsub(%r{<c[^>]*>([^<]*)</c>}) { |_s| Regexp.last_match(1) }
+      .gsub(/<[^>]>/, '')
+      .gsub(/\\N$/, '')
+      .gsub(/ +$/, '')
+    decoder.decode(text)
+  end
+
+  ##
+  # This method validates the time format and sends the matching time to be converted
+  #
+  # * Requires +str+, a VTT formatted time string.
+  def convert_time(time)
+    matched_time = time.match(/([\d:]*)\.?(\d*)/)
+    to_subs_time(matched_time[0])
+  end
+
+  ##
+  # This method converts time from VTT format to the ASS format.
+  #
+  # * Requires +str+, a VTT formatted time string.
+  def to_subs_time(str)
+    n = []
+    x = str.split(/[:.]/).map(&:to_i)
+
+    ms_len = 2
+    h_len = 1
+
+    x[3] = "0.#{x[3].to_s.rjust(3, '0')}"
+    sx = (x[0] * 60 * 60) + (x[1] * 60) + x[2] + x[3].to_f
+    sx = format('%.2f', sx).split('.')
+
+    n.unshift(pad_time_num('.', sx[1], ms_len))
+    sx = sx[0].to_f
+
+    n.unshift(pad_time_num(':', (sx % 60).to_i, 2))
+    n.unshift(pad_time_num(':', (sx / 60).floor % 60, 2))
+    n.unshift(pad_time_num('',  (sx / 3600).floor % 60, h_len))
+
+    n.join
+  end
+
+  ##
+  # This method pads text so that time numbers are a fixed number of digit.
+  #
+  # * Requires +sep+, a string separator.
+  # * Requires +input+, an integer.
+  # * Requires +pad+, an integer for the number of digits to be padded.
+  def pad_time_num(sep, input, pad)
+    sep + input.to_s.rjust(pad, '0')
+  end
+end

data/lib/vtt2ass/ass_style.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative 'ass_style_params'
+require_relative 'validator'
+require 'redgreenblue'
+
+##
+# This class defines an ASS style that can be applied on a subtitle line.
+class ASSStyle
+  attr_reader :style_name
+
+  ##
+  # This method creates and instance of an ASSStyle.
+  #
+  # * Requires +style_name+, a string name for the style as input.
+  # * Requires +params+, a string of VTT styling as input.
+  # * Requires a video +width+ as input.
+  # * Requires a video +height+ as input.
+  def initialize(style_name, params, font_family, font_size, font_color, is_bold, is_italic, line_offset, width, height)
+    @width = width
+    @height = height
+    @font_family = font_family
+    @font_size = font_size
+    @font_color = font_color
+    @style_name = style_name
+    @s_params = ASSStyleParams.new(params, width, height)
+    @s_params.vertical_margin = 50 if style_name.eql? 'MainTop'
+    @s_params.vertical_margin -= line_offset if style_name.include? 'Subtitle'
+    @is_italic = is_italic
+    @is_bold = is_bold
+  end
+
+  ##
+  # This method assigns the object values to an ASS style line and outputs it.
+  def to_s
+    # Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour,
+    # Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment,
+    # MarginL, MarginR, MarginV, Encoding
+    "Style: #{@style_name},#{@font_family},#{@font_size},#{@font_color},&H000000FF,&H00020713,&H00000000,"\
+      "#{@is_bold ? '-1' : '0'},#{@is_italic ? '-1' : '0'},0,0,100,100,0,0,1,2.0,2.0,#{@s_params.alignment},"\
+      "#{@s_params.horizontal_margin},0,#{@s_params.vertical_margin},1"
+  end
+
+  ##
+  # This method returns a ASS formated color value based on hex or color name value
+  def self.convert_color(color_value)
+    color_value.gsub!('#', '')
+    color = Validator.hex?(color_value) ? RGB.hex(color_value) : RGB.css(color_value)
+    format('&H00%<blue>02x%<green>02x%<red>02x', blue: color.b, green: color.g, red: color.r).upcase
+  end
+end

data/lib/vtt2ass/ass_style_params.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+##
+# This class defines the ASS style parameters from VTT cue settings.
+class ASSStyleParams
+  attr_accessor :horizontal_margin, :vertical_margin, :alignment, :align
+
+  ##
+  # Creates an instance of ASSStyleParams
+  # It takes VTT style arguments and assign them to their respectful instance variable.
+  # It calls methods to create ASS values from the VTT cue settings.
+  def initialize(params, width, height)
+    split_params(params)
+    create_alignment
+    create_horizontal_margin(width)
+    create_vertical_margin(height)
+  end
+
+  def split_params(params)
+    (params.split.map { |p| p.split(':') }).each do |p|
+      case p[0]
+      when 'position'
+        @position = p[1].gsub(/%/, '').to_i
+      when 'line'
+        @line = p[1].gsub(/%/, '').to_i
+        @line = @line == -1 ? 100 : @line
+      when 'align'
+        @align = p[1].chomp
+      end
+    end
+  end
+
+  ##
+  # This method decides the alignement value in a 9 position grid based of the
+  # values in cue settings "align" and "line".
+  def create_alignment
+    @alignment =
+      if defined?(@line) && !defined?(@position)
+        find_alignment(@align)
+      elsif defined?(@line) && defined?(@position)
+        1 # bottom left
+      else
+        find_default_alignment(@align)
+      end
+  end
+
+  ##
+  # This method returns alignment when "line" value is specified but not "position"
+  def find_alignment(align)
+    if align.nil?
+      # If position is higher than 50% align to bottom center, else align to top center
+      @line >= 50 ? 2 : 8
+    else
+      case align
+      when 'left', 'start'
+        @line >= 50 ? 1 : 7
+      when 'right', 'end'
+        @line >= 50 ? 3 : 9
+      when 'center', 'middle'
+        @line >= 50 ? 2 : 8
+      end
+    end
+  end
+
+  ##
+  # This method returns alignment when "line" and "position" values are not specified
+  def find_default_alignment(align)
+    case align
+    when 'left', 'start'
+      1
+    when 'right', 'end'
+      3
+    # when 'center', 'middle'
+    else
+      2
+    end
+  end
+
+  ##
+  # This method calculates the horizontal margin in px between the alignement position and
+  # and the content displayed by using the "position" cue setting.
+  def create_horizontal_margin(width)
+    steps = (width / 100).to_i
+    @horizontal_margin =
+      if defined?(@position)
+        @position * steps
+      else
+        0
+      end
+  end
+
+  ##
+  # This method calculates the vertical margin in px between the alignement position and
+  # and the content displayed by using the "line" cue setting.
+  def create_vertical_margin(height)
+    steps = (height / 100).to_i
+    @vertical_margin =
+      if defined?(@line)
+        if @alignment == 1
+          (100 - @line) * steps
+        else
+          @line >= 50 ? (100 - @line) * steps : @line * steps
+        end
+      else
+        50
+      end
+  end
+end

data/lib/vtt2ass/css_file.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'css_parser'
+require_relative 'css_rule'
+
+##
+# This class defines a CSS file for subtitles.
+class CSSFile
+  attr_reader :rules
+
+  include CssParser
+
+  def initialize(file_path)
+    @file_path = file_path
+    parser = CssParser::Parser.new
+    parser.load_file!(file_path)
+    @rules = []
+    parser.each_selector do |selector, declarations, _specificity|
+      css_obj = CSSRule.new(selector, declarations)
+      @rules.push(css_obj) unless css_obj.name.empty?
+    end
+  end
+
+  def find_rule(value)
+    return_rule = nil
+    @rules.each do |rule|
+      if rule.name == value
+        return_rule = rule
+        break
+      end
+    end
+    return_rule
+  end
+
+  def to_s
+    @file_path
+  end
+end