subtitle-library 0.0.1

data/bin/subtitle-library

@@ -0,0 +1,113 @@
+#!/usr/bin/env ruby
+
+require 'subtitle-library'
+
+HELP_MENU = <<-eos
+-f   : The local file, to do an operation on.
+-op  : The operation to be performed.
+        'recognise' - recognise the subtitle format
+        'verify'    - verify subtitle syntax
+        'carriage'  - set the max line length
+        'shift'     - shift the subtitles by seconds/frames
+        'stretch'   - stretch the subtitles
+        'save'      - save the subtitles in new file (perhaps with a new format)
+-cr  : The max line length to be used
+-ss  : The amount of seconds to be used when shifting/stretching
+-fs  : The amount of frames to be used when shifting/stretching
+-fps : Frames per second (will be used when saving/changing subtitles)
+-nf  : The path to the new file to be saved
+-t   : The type of the new file
+        'sr'        - SubRip subtitle type
+        'md'        - MicroDVD type
+        'sv'        - SubViewer type
+eos
+
+index = 0
+fps = -1
+while index < ARGV.length
+  case ARGV[index]
+    when '-f'
+      index += 1
+      subs_path = ARGV[index]
+    when '-op'
+      index += 1
+      operation = ARGV[index]
+    when '-cr'
+      index += 1
+      carriage = ARGV[index].to_i
+    when '-ss'
+      index += 1
+      seconds = ARGV[index].to_f
+    when '-fs'
+      index += 1
+      frames = ARGV[index].to_f
+    when '-fps'
+      index += 1
+      fps = ARGV[index].to_f
+    when '-nf'
+      index += 1
+      new_path = ARGV[index]
+    when '-t'
+      index += 1
+      type = ARGV[index]
+  end
+  index += 1
+end
+
+if operation and subs_path
+  reader = SubsReader.new subs_path
+  if reader.type == 'uk'
+    puts 'Unknown file format.'
+  else
+    case operation
+      when 'recognise'
+        case reader.type
+          when 'sr'
+            puts 'SubRip format.'
+          when 'md'
+            puts 'MicroDVD format.'
+          when 'sv'
+            puts 'SubViewer format.'
+        end
+      when 'verify'
+        puts reader.check_syntax
+      when 'carriage'
+        if not carriage or carriage <= 0
+          puts "Select a positive number for a max line length (-cr option).\n" + HELP_MENU
+        else
+          SubsChanger.new(subs_path).set_max_line carriage
+        end
+      when 'shift'
+        if not seconds and not frames
+          puts "Select an amount of seconds (-ss) or frames (-fs) to shift by.\n" + HELP_MENU
+        elsif seconds
+          SubsChanger.new(subs_path).shift 'ss', seconds, fps
+        else
+          SubsChanger.new(subs_path).shift 'fs', frames, fps
+        end
+      when 'stretch'
+        if not seconds and not frames
+          puts "Select an amount of seconds (-ss) or frames (-fs) to stretch by.\n" + HELP_MENU
+        elsif seconds
+          SubsChanger.new(subs_path).stretch 'ss', seconds, fps
+        else
+          SubsChanger.new(subs_path).stretch 'fs', frames, fps
+        end
+      when 'save'
+        if not new_path or not type
+          puts "Select the new name of the file (-nf) and the type it should be (-t).\n" + HELP_MENU
+        elsif not ['sr', 'md', 'sv'].member? type
+          puts "Select the type of the new file (-t option) from one of the listed below.\n" + HELP_MENU
+        else
+          reader.load_cues
+          SubsWriter.new(reader).save_as new_path, type, fps
+        end
+      else
+        puts "Select one of the operations listed below.\n" + HELP_MENU
+    end
+  end
+elsif not operation
+  puts "Select an operation to be performed (-op option).\n" + HELP_MENU
+else
+  puts "Select a local subtitle file (-f option).\n" + HELP_MENU
+end

data/lib/subtitle-library.rb

@@ -0,0 +1,3 @@
+require 'subtitle-library/reader'
+require 'subtitle-library/changer'
+require 'subtitle-library/writer'

data/lib/subtitle-library/changer.rb

@@ -0,0 +1,117 @@
+class SubsChanger
+  require 'subtitle-library/reader'
+  require 'subtitle-library/writer'
+
+  def initialize(subs_path)
+    @subs_path = subs_path
+    @reader = SubsReader.new subs_path
+    @reader.load_cues
+  end
+
+  def shift(disp_type, pos, fps = -1)
+    fps = @reader.fps if fps == -1
+    if @reader.type == 'md'
+      disposition_microdvd pos, fps, false, disp_type == 'ss'
+    else
+      disposition_timing pos, fps, false, disp_type == 'ss'
+    end
+  end
+
+  def stretch(disp_type, pos, fps = -1)
+    fps = @reader.fps if fps == -1
+    if @reader.type == 'md'
+      disposition_microdvd pos, fps, true, disp_type == 'ss'
+    else
+      disposition_timing pos, fps, true, disp_type == 'ss'
+    end
+  end
+
+  def disposition_microdvd(pos, fps, stretch, disp_seconds)
+    bottom_time = Time.mktime 1, 1, 1
+    last_end_time = bottom_time
+    invalid_timing = false
+    if stretch
+      step = disp_seconds ? pos * fps : pos
+      disposition = 0
+    else
+      disposition = disp_seconds ? (pos * fps).ceil : pos.ceil
+    end
+    @reader.cues.each do |cue|
+      cue.start += disposition
+      cue.ending += disposition
+      new_start = bottom_time + cue.start / fps
+      new_end = bottom_time + cue.ending / fps
+      if new_start.year + new_start.month + new_start.day +
+        new_end.year + new_end.month + new_end.day != 6 or
+          new_start < bottom_time or new_end < bottom_time or
+            new_start < last_end_time
+              invalid_timing = true
+              puts 'Invalid timing'
+              break
+      end
+      last_end_time = new_end
+      disposition = (disposition + step).ceil if stretch
+    end
+    SubsWriter.new(@reader).save_as(@subs_path, @reader.type) unless invalid_timing
+  end
+
+  def disposition_timing(pos, fps, stretch, disp_seconds)
+    bottom_time = Time.mktime 1, 1, 1
+    last_end_time = bottom_time
+    invalid_timing = false
+    if stretch
+      step = disp_seconds ? pos : pos / fps
+      disposition = 0
+    else
+      disposition = disp_seconds ? pos : pos / fps
+    end
+    @reader.cues.each do |cue|
+      cue.start += disposition
+      cue.ending += disposition
+      if cue.start.year + cue.start.month + cue.start.day +
+        cue.ending.year + cue.ending.month + cue.ending.day != 6 or
+          cue.start < bottom_time or cue.ending < bottom_time or
+            cue.start < last_end_time
+              invalid_timing = true
+              puts 'Invalid timing'
+              break
+      end
+      last_end_time = cue.ending
+      disposition += step if stretch
+    end
+    SubsWriter.new(@reader).save_as(@subs_path, @reader.type) unless invalid_timing
+  end
+
+  def set_max_line(max_line)
+    line_break = @reader.type == 'sr' ? "\n" : (@reader.type == 'md' ? '|' : '[br]')
+    @reader.cues.each do |cue|
+      text = cue.text
+      lines = text.split /\n+/
+      carriage_needed = false
+      lines.each do |line|
+        if line.length > max_line
+          carriage_needed = true
+          break
+        end
+      end
+      if carriage_needed
+        new_text = ''
+        words = lines.collect { |line| line.split /\s+/ }.flatten
+        current_line = ''
+        for i in (0 .. words.length - 1)
+          current_line += (current_line == '' ? '' : ' ') + words[i]
+          if i == words.length - 1
+            new_text += current_line
+            break
+          end
+          if current_line.length > max_line
+            new_text += current_line + line_break
+            current_line = ''
+          end
+        end
+        cue.text = new_text
+      end
+    end
+    SubsWriter.new(@reader).save_as @subs_path, @reader.type
+  end
+end

data/lib/subtitle-library/cue.rb

@@ -0,0 +1,16 @@
+class Cue
+  attr_accessor :start, :ending, :text
+
+  def initialize(start, ending, text)
+    @start = start
+    @ending = ending
+    @text = text
+  end
+
+  def ==(other_cue)
+    @start == other_cue.start and
+      @ending == other_cue.ending and
+        @text == other_cue.text
+  end
+end
+

data/lib/subtitle-library/reader.rb

@@ -0,0 +1,357 @@
+class SubsReader
+  require 'subtitle-library/regex-patterns'
+  require 'subtitle-library/cue'
+  include Patterns
+
+  attr_reader :type, :fps
+  attr_accessor :cues
+
+  def initialize(subs_path)
+    @subs_path = subs_path
+    @type = recognize
+    case @type
+      when 'sr'
+        @inner_reader = SubRipReader.new subs_path
+      when 'md'
+        @inner_reader = MicroDVDReader.new subs_path
+      when 'sv'
+        @inner_reader = SubviewerReader.new subs_path
+    end
+    @fps = 23.976
+  end
+
+  def recognize
+    File.open(@subs_path, 'r') do |subs|
+      while line = subs.gets
+        return 'sr' if SUB_RIP_LINE =~ line
+        return 'md' if MICRO_DVD_LINE =~ line
+        return 'sv' if SUBVIEWER_LINE =~ line
+      end
+    end
+    'uk'
+  end
+
+  def load_cues
+    if @inner_reader
+      @cues, @fps = @inner_reader.read_subs false
+    else
+      'Unknown file format'
+    end
+  end
+
+  def check_syntax
+    if @inner_reader
+      @inner_reader.read_subs true
+    else
+      'Unknown file format'
+    end
+  end
+
+end
+
+class SubRipReader
+  include Patterns
+
+  def initialize(subs_path)
+    @subs_path = subs_path
+    @fps = 23.976
+  end
+
+  def read_subs(check_syntax)
+    cues = []
+    actual_lines = 0
+    error_log = ""
+    is_eof = false
+    last_end_time = Time.new 1, 1, 1
+    File.open(@subs_path, 'r') do |subs|
+      while true
+        is_eof, actual_lines, strip_line = read_until_timing(subs, actual_lines)
+        break if is_eof
+        if SUB_RIP_LINE =~ strip_line
+          start_time, end_time = parse_timing strip_line
+          valid_timing, error_log = check_timing start_time, end_time, last_end_time, error_log, check_syntax, actual_lines
+          unless valid_timing
+            is_eof, actual_lines, strip_line = read_until_index subs, actual_lines, strip_line, false
+            break if is_eof
+            next
+          end
+          last_end_time = end_time
+          line = subs.gets
+          break unless line
+          actual_lines += 1
+          text = line.strip
+          strip_line = line.strip
+          while strip_line != ''
+            line = subs.gets
+            unless line
+              is_eof = true
+              break
+            end
+            actual_lines += 1
+            strip_line = line.strip
+            text += "\n" + strip_line
+          end
+          if is_eof
+            cues << Cue.new(start_time, end_time, text.rstrip) unless check_syntax
+            break
+          end
+          line = subs.gets
+          unless line
+            cues << Cue.new(start_time, end_time, text.rstrip) unless check_syntax
+            break
+          end
+          actual_lines += 1
+          is_eof, actual_lines, strip_line, text = read_until_index subs, actual_lines, line, true, text
+          cues << Cue.new(start_time, end_time, text.strip) unless check_syntax
+          break if is_eof
+        elsif check_syntax
+          error_log += "Syntax error at line #{actual_lines}.\n"
+          line = subs.gets
+          break unless line
+          actual_lines += 1
+          is_eof, actual_lines, strip_line = read_until_index subs, actual_lines, line, false
+          break if is_eof
+        else
+          line = subs.gets
+          break unless line
+          actual_lines += 1
+          is_eof, actual_lines, strip_line = read_until_index subs, actual_lines, line, false
+          break if is_eof
+        end
+      end
+    end
+    if check_syntax
+      error_log == '' ? 'No errors were found.' : error_log.rstrip
+    else
+      [cues, @fps]
+    end
+  end
+
+  def check_timing(start_time, end_time, last_end_time, error_log, check_syntax, actual_lines)
+    if start_time.year + start_time.month + start_time.day +
+      end_time.year + end_time.month + end_time.day != 6 or
+        start_time >= end_time or start_time < last_end_time
+          if check_syntax
+            error_log += "Invalid timing at line #{actual_lines}.\n"
+          else
+            puts "Invalid timing at line #{actual_lines}.\n"
+          end
+          return [false, error_log]
+    end
+    [true, error_log]
+  end
+
+  def read_until_timing(subs, actual_lines)
+    line = subs.gets
+    return true unless line
+    actual_lines += 1
+    strip_line = line.strip
+    while strip_line == '' or /\A\d+$/ =~ strip_line
+      line = subs.gets
+      unless line
+        is_eof = true
+        break
+      end
+      actual_lines += 1
+      strip_line = line.strip
+    end
+    [is_eof, actual_lines, strip_line]
+  end
+
+  def parse_timing(line)
+    match = SUB_RIP_TIMING.match line
+    time_args = [1, 1, 1] + match.to_s.split(/,|:/).collect(&:to_i)
+    time_args[6] *= 1000
+    start_time = Time.mktime *time_args
+    match = SUB_RIP_TIMING.match match.post_match
+    time_args = [1, 1, 1] + match.to_s.split(/,|:/).collect(&:to_i)
+    time_args[6] *= 1000
+    [start_time, Time.mktime(*time_args)]
+  end
+
+  def read_until_index(subs, actual_lines, line, append, text = nil)
+    strip_line = line.strip
+    while not /\A\d+$/ =~ strip_line
+      text += "\n" + strip_line if append
+      line = subs.gets
+      unless line
+        is_eof = true
+        break
+      end
+      actual_lines += 1
+      strip_line = line.strip
+    end
+    [is_eof, actual_lines, strip_line] + (append ? [text] : [])
+  end
+
+end
+
+class MicroDVDReader
+  include Patterns
+
+  def initialize(subs_path)
+    @subs_path = subs_path
+    @fps = 23.976
+  end
+
+  def read_subs(check_syntax)
+    cues = []
+    error_log = ''
+    last_end_frame = 0
+    File.open(@subs_path, 'r') do |subs|
+      line, actual_lines = find_out_fps subs
+      while line
+        strip_line = line.strip
+        if strip_line != ''
+          if MICRO_DVD_LINE =~ strip_line
+            last_end_frame, error_log = add_new_line strip_line, cues, last_end_frame, error_log, check_syntax, actual_lines
+          elsif check_syntax
+            error_log += "Syntax error at line #{actual_lines}.\n"
+          end
+        end
+        line = subs.gets
+        actual_lines += 1
+      end
+    end
+    if check_syntax
+      error_log == '' ? 'No errors were found.' : error_log.rstrip
+    else
+      [cues, @fps]
+    end
+  end
+
+  def find_out_fps(subs)
+    line = subs.gets
+    actual_lines = 1
+    while line
+      strip_line = line.strip
+      if strip_line != ''
+        if MICRO_DVD_LINE =~ strip_line
+          first_line = MICRO_DVD_LINE.match(strip_line).post_match.strip
+          if /\A\d*\.?\d*$/ =~ first_line
+            @fps = first_line.to_f
+            line = subs.gets
+            actual_lines += 1
+          end
+        end
+        break
+      end
+      line = subs.gets
+      actual_lines += 1
+    end
+    [line, actual_lines]
+  end
+
+  def add_new_line(line, cues, last_end_frame, error_log, check_syntax, actual_lines)
+    match = /\d+/.match line
+    start_frame = match.to_s.to_i
+    match = /\d+/.match match.post_match
+    end_frame = match.to_s.to_i
+    if start_frame <= end_frame and start_frame >= last_end_frame
+      unless check_syntax
+        text = MICRO_DVD_LINE.match(line).post_match
+        cues << Cue.new(start_frame, end_frame, text.gsub('|', "\n"))
+      end
+      last_end_frame = end_frame
+    elsif check_syntax
+      error_log += "Syntax error at line #{actual_lines}.\n"
+    end
+    [last_end_frame, error_log]
+  end
+
+end
+
+class SubviewerReader
+  include Patterns
+
+  def initialize(subs_path)
+    @subs_path = subs_path
+    @fps = 23.976
+  end
+
+  def read_subs(check_syntax)
+    cues = []
+    error_log = ''
+    last_end_time = Time.mktime 1, 1, 1
+    File.open(@subs_path, 'r') do |subs|
+      actual_lines, error_log, line = read_metadata subs, check_syntax 
+      while line
+        strip_line = line.strip
+        if strip_line != ''
+          if SUBVIEWER_LINE =~ strip_line
+            start_time, end_time = parse_timing strip_line
+            valid_timing, error_log = check_timing start_time, end_time, last_end_time, error_log, check_syntax, actual_lines
+            unless valid_timing
+              break unless subs.gets
+              line = subs.gets
+              actual_lines += 2
+              next
+            end
+            line = subs.gets
+            break unless line
+            actual_lines += 1
+            cues << Cue.new(start_time, end_time, line.strip.gsub('[br]', "\n")) unless check_syntax
+            last_end_time = end_time
+          else
+            error_log += "Syntax error at line #{actual_lines}.\n" if check_syntax
+            break unless subs.gets
+            line = subs.gets
+            actual_lines += 2
+            next
+          end
+        end
+        line = subs.gets
+        actual_lines += 1
+      end
+    end
+    if check_syntax
+      error_log == '' ? 'No errors were found.' : error_log.rstrip
+    else
+      [cues, @fps]
+    end
+  end
+
+  def read_metadata(subs, check_syntax)
+    actual_lines = 0
+    error_log = ''
+    metadata = ''
+    while line = subs.gets
+      actual_lines += 1
+      strip_line = line.strip
+      if strip_line != ''
+        if /\A\d/ =~ strip_line
+          error_log += "Syntax error in metadata.\n" if check_syntax and not SUBVIEWER_METADATA =~ metadata
+          break
+        end
+        metadata += strip_line
+      end
+    end
+    [actual_lines, error_log, line]
+  end
+
+  def parse_timing(line)
+    start_end = line.split ','
+    time_args = [1,1,1] + start_end[0].split(/\.|:/).collect(&:to_i)
+    time_args[6] *= 1000
+    start_time = Time.mktime *time_args
+    time_args = [1,1,1] + start_end[1].split(/\.|:/).collect(&:to_i)
+    time_args[6] *= 1000
+    [start_time, Time.mktime(*time_args)]
+  end
+
+  def check_timing(start_time, end_time, last_end_time, error_log, check_syntax, actual_lines)
+    if start_time.year + start_time.month + start_time.day +
+      end_time.year + end_time.month + end_time.day != 6 or
+        start_time >= end_time or start_time < last_end_time
+          if check_syntax
+            error_log += "Invalid timing at line #{actual_lines}.\n"
+          else
+            puts "Invalid timing at line #{actual_lines}.\n"
+          end
+          return [false, error_log]
+    end
+    [true, error_log]
+  end
+
+end
+