titlekit 1.0.0

data/lib/titlekit/parsers/srt.rb

@@ -0,0 +1,139 @@
+require 'treetop'
+
+module Titlekit
+  module SRT
+
+    class Subtitles < Treetop::Runtime::SyntaxNode
+      def build
+        elements.map { |subtitle| subtitle.build }
+      end
+    end
+
+    class Subtitle < Treetop::Runtime::SyntaxNode
+      def build
+        {
+          id: id.text_value.to_i,
+          start: from.build,
+          end: to.build,
+          lines: lines.text_value.rstrip
+        }
+      end
+    end
+
+    class Timecode < Treetop::Runtime::SyntaxNode
+      def build
+        value = 0
+        value += hours.text_value.to_i * 3600
+        value += minutes.text_value.to_i * 60
+        value += seconds.text_value.to_i
+        value += "0.#{fractions.text_value}".to_f
+        value
+      end
+    end
+
+    # Parses the supplied string and returns the results.
+    #
+    #
+    def self.import(string)
+      Treetop.load(File.join(__dir__, 'srt'))
+      parser = SRTParser.new
+      syntax_tree = parser.parse(string)
+
+      if syntax_tree
+        return syntax_tree.build
+      else
+        failure = "failure_index #{parser.failure_index}\n"
+        failure += "failure_line #{parser.failure_line}\n"
+        failure += "failure_column #{parser.failure_column}\n"
+        failure += "failure_reason #{parser.failure_reason}\n"
+
+        raise failure
+      end 
+    end
+
+    # Master the subtitles for best possible usage of the format's features.
+    #
+    # @param subtitles [Array<Hash>] the subtitles to master
+    def self.master(subtitles)
+      tracks = subtitles.map { |subtitle| subtitle[:track] }.uniq
+
+      if tracks.length == 1
+  
+        # maybe styling? aside that: nada más!
+
+      elsif tracks.length >= 2
+
+        mastered_subtitles = []
+
+        # Determine timeframes with a discrete state
+        cuts = subtitles.map { |s| [s[:start], s[:end]] }.flatten.uniq.sort
+        frames = []
+        cuts.each_cons(2) do |pair|
+          frames << { start: pair[0], end: pair[1] }
+        end
+
+        frames.each do |frame|
+          intersecting = subtitles.select do |subtitle|
+            (subtitle[:end] == frame[:end] || subtitle[:start] == frame[:start] ||
+            (subtitle[:start] < frame[:start] && subtitle[:end] > frame[:end]))
+          end
+
+          if intersecting.any?
+            intersecting.sort_by! { |subtitle| tracks.index(subtitle[:track]) }
+
+            subtitle = {}
+            subtitle[:id] = mastered_subtitles.length+1
+            subtitle[:start] = frame[:start]
+            subtitle[:end] = frame[:end]
+
+            # Combine two or more than three simultaneous tracks by
+            # stacking them directly, with different colors.
+
+            colored_lines = intersecting.map do |subtitle|
+              color = DEFAULT_PALETTE[tracks.index(subtitle[:track]) % DEFAULT_PALETTE.length]
+              "<font color=\"##{color}\">#{subtitle[:lines]}</font>"
+            end
+
+            subtitle[:lines] = colored_lines.join("\n")
+
+            mastered_subtitles << subtitle
+          end
+        end
+
+        subtitles.replace(mastered_subtitles)
+      end
+    end
+
+    def self.export(subtitles)
+      result = ''
+
+      subtitles.each_with_index do |subtitle, index|
+        result << (index+1).to_s
+        result << "\n"
+        result << SRT.build_timecode(subtitle[:start])
+        result << ' --> '
+        result << SRT.build_timecode(subtitle[:end])
+        result << "\n"
+        result << subtitle[:lines]
+        result << "\n\n"
+      end
+
+      return result
+    end
+
+    protected
+
+    def self.build_timecode(seconds)
+      sprintf("%02d:%02d:%02d,%s",
+              seconds / 3600,
+              (seconds%3600) / 60,
+              seconds % 60,
+              sprintf("%.3f", seconds)[-3, 3])
+    end
+
+    def self.parse_timecode(timecode)
+      mres = timecode.match(/(?<h>\d+):(?<m>\d+):(?<s>\d+),(?<ms>\d+)/)
+      "#{mres["h"].to_i * 3600 + mres["m"].to_i * 60 + mres["s"].to_i}.#{mres["ms"]}".to_f
+    end
+  end
+end

data/lib/titlekit/parsers/srt.treetop

@@ -0,0 +1,73 @@
+grammar SRT
+  rule subtitles
+    subtitle* <Titlekit::SRT::Subtitles>
+  end
+
+  rule subtitle
+    id eol from ' --> ' to coordinates? eol lines eos <Titlekit::SRT::Subtitle>
+  end
+ 
+  rule id
+    number
+  end
+
+  rule from
+    timecode
+  end
+
+  rule to
+    timecode
+  end
+
+  rule timecode
+    hours ':' minutes ':' seconds (',' / '.') fractions <Titlekit::SRT::Timecode>
+  end
+
+  rule hours
+    number
+  end
+
+  rule minutes
+    number
+  end
+
+  rule seconds
+    number
+  end
+
+  rule fractions
+    number
+  end
+
+  rule coordinates
+    ' X1:' number ' X2:' number ' Y1:' number ' Y2:' number
+  end
+
+  rule lines
+    line+
+  end
+
+  rule line
+    string (eol / eof)
+  end
+
+  rule eos
+    eol+ / eof
+  end
+  
+  rule eol
+    "\r\n" / "\n" / "\r"
+  end
+
+  rule eof
+    !.
+  end
+  
+  rule number
+    [0-9]+
+  end
+
+  rule string
+    (!eol .)+
+  end
+end

data/lib/titlekit/parsers/ssa.rb

@@ -0,0 +1,201 @@
+require 'treetop'
+
+module Titlekit
+  module SSA
+
+    class Subtitles < Treetop::Runtime::SyntaxNode
+      def build
+        event_section.events.build
+      end
+    end
+
+    class ScriptInfo < Treetop::Runtime::SyntaxNode
+      def build
+        # elements.map { |subtitle| subtitle.build }
+      end
+    end
+
+    class V4PStyles < Treetop::Runtime::SyntaxNode
+      def build
+        # elements.map { |subtitle| subtitle.build }
+      end
+    end
+
+    class Events < Treetop::Runtime::SyntaxNode
+      def build
+        elements.map do |line|
+          subtitle = {}
+
+          fields = line.text_value.split(',')
+          
+          subtitle[:id] = elements.index(line) + 1
+          subtitle[:start] = SSA.parse_timecode(fields[1])
+          subtitle[:end] = SSA.parse_timecode(fields[2])
+          subtitle[:lines] = fields[9..-1].join.gsub('\N', "\n")
+
+          subtitle
+        end
+      end
+    end    
+
+    # class Subtitle < Treetop::Runtime::SyntaxNode
+    #   def build
+    #     {
+    #       id: id.text_value.to_i,
+    #       start: from.build,
+    #       end: to.build,
+    #       lines: lines.text_value.rstrip
+    #     }
+    #   end
+    # end
+
+    # class Timecode < Treetop::Runtime::SyntaxNode
+    #   def build
+    #     value = 0
+    #     value += hours.text_value.to_i * 3600
+    #     value += minutes.text_value.to_i * 60
+    #     value += seconds.text_value.to_i
+    #     value += "0.#{fractions.text_value}".to_f
+    #     value
+    #   end
+    # end
+
+    # Parses the supplied string and returns the results.
+    #
+    #
+    def self.import(string)
+      Treetop.load(File.join(__dir__, 'ssa'))
+      parser = SSAParser.new
+      syntax_tree = parser.parse(string)
+
+      if syntax_tree
+        return syntax_tree.build
+      else
+        failure = "failure_index #{parser.failure_index}\n"
+        failure += "failure_line #{parser.failure_line}\n"
+        failure += "failure_column #{parser.failure_column}\n"
+        failure += "failure_reason #{parser.failure_reason}\n"
+
+        raise failure
+      end 
+    end
+
+    # Master the subtitles for best possible usage of the format's features.
+    #
+    # @param subtitles [Array<Hash>] the subtitles to master
+    def self.master(subtitles)
+      tracks = subtitles.map { |subtitle| subtitle[:track] }.uniq
+
+      if tracks.length == 1
+  
+        # maybe styling? aside that: nada más!
+
+      elsif (2..3).include?(tracks.length)
+
+        subtitles.each do |subtitle|
+          case tracks.index(subtitle[:track])
+          when 0
+            subtitle[:style] = 'Default'
+          when 1
+            subtitle[:style] = 'Top'
+          when 2
+            subtitle[:style] = 'Middle'
+          end
+        end
+
+      elsif tracks.length >= 4
+
+        mastered_subtitles = []
+
+        # Determine timeframes with a discrete state
+        cuts = subtitles.map { |s| [s[:start], s[:end]] }.flatten.uniq.sort
+        frames = []
+        cuts.each_cons(2) do |pair|
+          frames << { start: pair[0], end: pair[1] }
+        end
+
+        frames.each do |frame|
+          intersecting = subtitles.select do |subtitle|
+            (subtitle[:end] == frame[:end] || subtitle[:start] == frame[:start] ||
+            (subtitle[:start] < frame[:start] && subtitle[:end] > frame[:end]))
+          end
+
+          if intersecting.any?
+            intersecting.sort_by! { |subtitle| tracks.index(subtitle[:track]) }
+            intersecting.each do |subtitle|
+              new_subtitle = {}
+              new_subtitle[:id] = mastered_subtitles.length+1
+              new_subtitle[:start] = frame[:start]
+              new_subtitle[:end] = frame[:end]
+
+              color = DEFAULT_PALETTE[tracks.index(subtitle[:track]) % DEFAULT_PALETTE.length]
+              new_subtitle[:style] = color
+              new_subtitle[:lines]  = subtitle[:lines]
+
+              mastered_subtitles << new_subtitle
+            end
+          end
+        end
+
+        subtitles.replace(mastered_subtitles)
+      end
+    end
+
+    def self.export(subtitles)
+      result = ''
+
+      result << "[Script Info]\nScriptType: v4.00\n\n"
+
+      result << "[V4 Styles]\nFormat: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, TertiaryColour, BackColour, Bold, Italic, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, AlphaLevel, Encoding\n"
+      result << "Style: Default,Arial,16,16777215,16777215,16777215,-2147483640,0,0,1,3,0,2,70,70,40,0,0\n"
+      result << "Style: Middle,Arial,16,16777215,16777215,16777215,-2147483640,0,0,1,3,0,10,70,70,40,0,0\n"
+      result << "Style: Top,Arial,16,16777215,16777215,16777215,-2147483640,0,0,1,3,0,6,70,70,40,0,0\n"
+      
+      DEFAULT_PALETTE.each do |color|
+        # reordered_color = ""
+        # reordered_color << color[4..5]
+        # reordered_color << color[2..3]
+        # reordered_color << color[0..1]\
+        processed_color = (color[4..5]+color[2..3]+color[0..1]).to_i(16)
+        result << "Style: #{color},Arial,16,#{processed_color},#{processed_color},#{processed_color},-2147483640,0,0,1,3,0,2,70,70,40,0,0\n"
+      end
+
+      result << "\n" # Close styles section
+
+      result << "[Events]\nFormat: Marked, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\n"
+      subtitles.each do |subtitle|
+        fields = [
+          'Dialogue: 0',  # Format: Marked
+          SSA.build_timecode(subtitle[:start]),  # Start
+          SSA.build_timecode(subtitle[:end]),  # End
+          subtitle[:style] || 'Default',  # Style
+          '',  # Name
+          '0000',  # MarginL
+          '0000',  # MarginR
+          '0000',  # MarginV
+          '',# Effect
+          subtitle[:lines].gsub("\n", '\N')  # Text
+        ]
+
+        result << (fields.join(',') + "\n")
+      end
+
+      return result
+    end
+
+    protected
+
+    def self.build_timecode(seconds)
+      sprintf("%01d:%02d:%02d.%s",
+              seconds / 3600,
+              (seconds%3600) / 60,
+              seconds % 60,
+              sprintf("%.2f", seconds)[-2, 3])
+    end 
+
+    def self.parse_timecode(timecode)
+      mres = timecode.match(/(?<h>\d):(?<m>\d{2}):(?<s>\d{2})[:|\.](?<ms>\d+)/)
+      return "#{mres["h"].to_i * 3600 + mres["m"].to_i * 60 + mres["s"].to_i}.#{mres["ms"]}".to_f
+    end 
+  end
+end

data/lib/titlekit/parsers/ssa.treetop

@@ -0,0 +1,72 @@
+grammar SSA
+  rule subtitles
+    info?
+    styles?
+    event_section
+    fonts?
+    graphics?
+    end_of_data
+
+    <Titlekit::SSA::Subtitles>
+  end
+
+  rule info
+    '[Script Info]' end_of_line lines* end_of_section <Titlekit::SSA::ScriptInfo>
+  end
+
+  rule styles
+    '[V4 Styles]' end_of_line lines* end_of_section <Titlekit::SSA::V4PStyles>
+  end
+
+  rule event_section
+    '[Events]' end_of_line line events end_of_section
+  end
+
+  rule events
+    line* <Titlekit::SSA::Events>
+  end
+
+  rule event
+    'Dialogue'
+  end
+
+  rule fonts
+    '[Fonts]' end_of_line lines* end_of_section
+  end
+
+  rule graphics
+    '[Graphics]' end_of_line lines* end_of_section
+  end
+
+  rule lines
+    line+
+  end
+
+  rule line
+    string (end_of_line / end_of_file)
+  end
+
+  rule end_of_section
+    end_of_line+ / end_of_file
+  end
+  
+  rule end_of_line
+    "\r\n" / "\n" / "\r"
+  end
+
+  rule end_of_data
+    end_of_line+ / end_of_file
+  end
+
+  rule end_of_file
+    !.
+  end
+  
+  rule number
+    [0-9]+
+  end
+
+  rule string
+    (!end_of_line .)+
+  end
+end

data/lib/titlekit/specification.rb

@@ -0,0 +1,131 @@
+module Titlekit
+  class Specification
+
+    # Only for internal usage by the job control center
+    attr_accessor :subtitles
+
+    def initialize
+      @encoding = nil
+      @file = nil
+      @fps = nil
+      @references = {}
+      @subtitles = []
+      @track = nil
+
+      return self
+    end
+
+    # @param [String] A string specifying the encoding, e.g. 'utf-8' or 'ISO-8859-1'
+    # @return If you omit the argument, it returns the already specified encoding
+    def encoding(*args)
+      if args.empty?
+        return @encoding
+      else
+        @encoding = args[0]
+        return self
+      end
+    end
+
+    # @param [String] A string specifying the path to the file
+    # @return If you omit the argument, it returns the already specified path 
+    def file(*args)
+      if args.empty?
+        return @file
+      else
+        @file = args[0]
+        return self
+      end
+    end
+
+    # @param [String] A string specifying the track identifier
+    # @return If you omit the argument, it returns the already specified track 
+    def track(*args)
+      if args.empty?
+        return @track
+      else
+        @track = args[0]
+        return self
+      end
+    end      
+
+    # @param [Float] A float specifying the frames per second, e.g. 23.976
+    # @return If you omit the argument, it returns the already specified fps
+    def fps(*args)
+      if args.empty?
+        return @fps
+      else
+        @fps = args[0]
+        return self
+      end
+    end
+
+    # Returns all named references you have specified
+    def references
+      return @references
+    end
+
+    # Places a named reference (in the form of a string or a symbol)
+    # on a timecode specified by either +hours+, +minutes+, +seconds+
+    # or +milliseconds+.
+    #
+    # Its typical use-case is to reference a specific subtitle you can
+    # recognize in both the movie and your subtitle file, where usually
+    # for the subtitle file (represented by {Have}) you will reference
+    # the subtitle index and for the movie (represented by {Want}) you
+    # will reference the timecode that is displayed when the line occurs
+    # in the movie.
+    #
+    # @example Referencing a timecode by hours
+    #   have.reference('Earl grey, hot', hours: 0.963)
+    #  
+    # @example Referencing a timecode by seconds
+    #   have.reference('In a galaxy ...', seconds: 14.2)
+    #
+    # @example Referencing a timecode by an SRT-style timecode
+    #   have.reference('In a galaxy ...', srt_timecode: '00:00:14,200')
+    #
+    # @example Referencing a timecode by an ASS-style timecode
+    #   have.reference('In a galaxy ...', ass_timecode: '0:00:14,20')
+    #
+    # @example Referencing a timecode by an SSA-style timecode
+    #   have.reference('In a galaxy ...', ssa_timecode: '0:00:14,20')
+    #    
+    # @example Symbols can be used as references as well!
+    #   have.reference(:narrator_begins, minutes: 9.6)
+    #
+    # @param name [String, Symbol] The name of the reference
+    # @param hours [Float]
+    # @param minutes [Float]
+    # @param seconds [Float]
+    # @param milliseconds [Float]
+    def reference(name,
+                  *args,
+                  hours: nil,
+                  minutes: nil,
+                  seconds: nil,
+                  milliseconds: nil,
+                  srt_timecode: nil,
+                  ssa_timecode: nil,
+                  ass_timecode: nil)
+
+      @references[name] = case
+      when hours
+        { timecode: hours * 3600 }
+      when minutes
+        { timecode: minutes * 60 }
+      when seconds
+        { timecode: seconds }
+      when milliseconds
+        { timecode: milliseconds / 1000 }
+      when srt_timecode
+        { timecode: Titlekit::SRT.parse_timecode(srt_timecode) }
+      when ssa_timecode
+        { timecode: Titlekit::SSA.parse_timecode(ssa_timecode) }
+      when ass_timecode
+        { timecode: Titlekit::ASS.parse_timecode(ass_timecode) }
+      end
+
+      return self
+    end   
+  end
+end

data/lib/titlekit/utilities.rb

@@ -0,0 +1,3 @@
+module Titlekit
+  DEFAULT_PALETTE = %w{EDF393 F5E665 FFC472 FFA891 89BABE}
+end

data/lib/titlekit/version.rb

@@ -0,0 +1,3 @@
+module Titlekit
+  VERSION = '1.0.0'
+end

data/lib/titlekit/want.rb

@@ -0,0 +1,24 @@
+module Titlekit
+  class Want < Specification
+
+    def initialize
+      super
+      @glue_treshold = 0.08
+    end
+
+    # For dual subtitles the starts and ends of simultaneously occuring
+    # subtitles can be micro-adjusted together if their distance is smaller
+    # than the glue_treshold. Normally defaults to 0.08 (super-conservative).
+    #
+    # @param [Float] Specifies the new glue_treshold
+    # @return If you omit the argument, it returns the set glue_treshold
+    def glue_treshold(*args)
+      if args.empty?
+        return @glue_treshold
+      else
+        @glue_treshold = args[0]
+        return self
+      end
+    end
+  end
+end

data/lib/titlekit.rb

@@ -0,0 +1,9 @@
+require 'titlekit/utilities'
+require 'titlekit/parsers/ass'
+require 'titlekit/parsers/ssa'
+require 'titlekit/parsers/srt'
+require 'titlekit/specification'
+require 'titlekit/have'
+require 'titlekit/want'
+require 'titlekit/job'
+require 'titlekit/version'