srt 0.0.5 → 0.1.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 28e7323497b349d7a2089aa395ad2c1ba1c3985729111dc56706c3280521bb5f
+  data.tar.gz: 82fe89057aee1e6a6aea48a16d33740686a18d0444f5559820603ff1b9a2a062
+SHA512:
+  metadata.gz: 699aaea2dda022acb10cb2e5d1db24d36ad8adec53528b1e186c6b75a549a049cbfd33f806d2cd4e276ae7ecabde412c9e9181c50335dc2f613ac79cefda5f31
+  data.tar.gz: c8abffc1bf997c624ee0cb0e06b0a49b9dd88b584a6fdb3c9edbd3170acb3a5e8a449b4d35eb3edfd2bc825c79389170da2d44589be602b02dced7a39223e4ef

data/.gitignore

@@ -2,6 +2,8 @@
 *.rbc
 .bundle
 .config
+.ruby-gemset
+.ruby-version
 .rvmrc
 .yardoc
 Gemfile.lock

data/.travis.yml

@@ -1,2 +1,8 @@
+language: ruby
+cache: bundler
+rvm:
+  - 2.0.0
+  - 2.1.0
+  - 2.3.0
 script:
-  - bundle exec rake spec
+  - bundle exec rake spec

data/README.md

@@ -1,6 +1,10 @@
-# SRT [![Build Status](https://travis-ci.org/cpetersen/srt.png?branch=master)](https://travis-ci.org/cpetersen/srt)
+# SRT 
+[![Build Status](https://travis-ci.org/cpetersen/srt.png?branch=master)](https://travis-ci.org/cpetersen/srt)
+[![Code Climate](https://codeclimate.com/github/cpetersen/srt.png)](https://codeclimate.com/github/cpetersen/srt)
+[![Coverage Status](https://coveralls.io/repos/cpetersen/srt/badge.png?branch=master)](https://coveralls.io/r/cpetersen/srt?branch=master)
+[![Gem Version](https://badge.fury.io/rb/srt.png)](http://badge.fury.io/rb/srt)
 
-SRT stands for SubRip text file format, which is a file for storing subtitles; This is a Ruby library for manipulating SRT files.  
+SRT stands for SubRip text file format, which is a file for storing subtitles; This is a Ruby library for manipulating SRT files.
 Current functionality includes **parsing**, **appending**, **splitting** and **timeshifting** (constant, progressive and framerate-based).
 
 ## Installation
@@ -12,7 +16,7 @@ Add this line to your application's Gemfile:
 And then execute:
 
     $ bundle
-    
+
 Or install it yourself as:
 
     $ gem install srt
@@ -31,7 +35,7 @@ You can parse an SRT file with the following code:
 Each line exposes the following methods/members:
 * `sequence` The incrementing subtitle ID (starts at 1)
 * `text` An **Array** holding one or multiple lines of text.
-* `start_time` The subtitle start timecode in seconds as a float 
+* `start_time` The subtitle start timecode in seconds as a float
 * `end_time` The subtitle end timecode in seconds as a float
 * `time_str` Returns a timecode string of the form `"00:53:35,558 --> 00:53:36,556"`
 * `display_coordinates` Optional display coordinates of the form `"X1:100 X2:600 Y1:100 Y2:400"`
@@ -60,37 +64,56 @@ The method `split` splits your subtitles at one (or more) points and returns an
 By default, the timecodes of the split parts are relatively shifted towards their beginnings (to line up with correspondingly split multi-part video);
 By additionally passing `:timeshift => false` you can prevent that behaviour and retain the original timecodes for each split part.
 
+Pass  the option `:renumber => false` to prevent the line sequence number from being reset for a segment.
+
+```ruby
+  parts = file.split( :at => "01:09:24,000", :renumber => false ) # Split the file in two at 01:09:24 but do not reset the sequence number on the second part
+```
+
 Example options for a multi-split: `{ :at => ["00:19:24,500", "01:32:09,120", ...] }`
 
+
+Optionally, for multi-splitting, you can pass a ":every" option to split the subtitles at a fixed interval.
+
+```ruby
+  parts = file.split( :every => "00:01:00,000" ) # Split the file every 1 minute
+```
+Note that the options :at and :every are mutually exclusive, and :at takes precedence.
+
 #### Timeshifting
 
 The method `timeshift` takes a hash and supports three different modes of timecode processing:
 
-**Constant timeshift** 
+**Constant timeshift**
 
 ```ruby
-  file.timeshift( :all => "-2.5s" ) # Shift all subtitles so they show up 2.5 seconds earlier    
+  file.timeshift( :all => "-2.5s" ) # Shift all subtitles so they show up 2.5 seconds earlier
 ```
 
-Simply pass a hash of the form `:all => "[+|-][amount][h|m|s|mil]"`  
-Other example options, e.g.: `:all => "+700mil"`, `:all => "1.34m"`, `:all => "0.15h"`
+Simply pass a hash of the form `:all => "[+|-][amount][h|m|s|ms]"`
+Other example options, e.g.: `:all => "+1.34m"`, `:all => "0.15h"`, `:all => "90ms"`
 
  **Progressive timeshift**
 
 ```ruby
-  file.timeshift({ 1 => "00:02:12,000", 843 => "01:38:06,000" }) # Correct drifting-out-of-sync
+  file.timeshift({ "#1" => "00:02:12,000", "#843" => "01:38:06,000" }) # Correct drifting-out-of-sync
 ```
 
 This example call would shift the **first subtitle** to `00:02:12`, the **last subtitle** (assuming here that `#843` is the last one in your file) to `01:38:06`, and all the ones before, after, and in between those two reference points seamlessly to their own resulting earlier or later begin times.
 
-To make this work pass two `original timecode/id => target timecode` pairs where each takes any of these 4 forms: 
+To make this work pass two `origin timecode => target timecode` pairs, where the *origin timecodes* can be supplied as:
 
-* `[id] => "[hh]:[mm]:[ss],[mil]"`
-* `[id] => "[+/-][amount][h|m|s|mil]"`
-* `"[hh]:[mm]:[ss],[mil]" => "[hh]:[mm]:[ss],[mil]"`
-* `"[hh]:[mm]:[ss],[mil]" => "[+/-][amount][h|m|s|mil]"`
+* `float` providing the raw timecode in *seconds*, e.g.:  `195.65`
+* `"[hh]:[mm]:[ss],[ms]"` string, which is a timecode in SRT notation, e.g.: `"00:02:12,000"`
+* `"#[id]"` string, which references the timecode of the subtitle with the supplied id, e.g.:  `"#317"`
 
-Another full example: `{ "00:00:51,400" => "+13s", "01:12:44,320" => "+2.436m" }`
+... and the *target timecodes* can be supplied as:
+
+* `float` providing the raw timecode in *seconds*, e.g.:  `3211.3`
+* `"[hh]:[mm]:[ss],[ms]"` string, which is a timecode in SRT notation, e.g.: `"01:01:03,300"`
+* `"[+/-][amount][h|m|s|ms]"` string, describing the amount by which to shift the origin timecode, e.g.: `"+1.5s"`
+
+So for example: `{ "00:00:51,400" => "+13s", "01:12:44,320" => "+2.436m" }`
 
 This method can be used to fix subtitles that are *at different times differently out of sync*,
 and comes in handy especially if you have no idea what framerate your video or the video for which your subtitles
@@ -113,3 +136,4 @@ This is usually only useful if you have some background information about the de
 3. Commit your changes (`git commit -am 'Added some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
+

data/lib/srt/file.rb

@@ -1,6 +1,7 @@
 module SRT
   class File
-    def self.parse(input)
+    def self.parse(input, options = {})
+      @debug = options.fetch(:debug, false)
       if input.is_a?(String)
         parse_string(input)
       elsif input.is_a?(::File)
@@ -15,58 +16,58 @@ module SRT
     end
 
     def self.parse_string(srt_data)
-      result = SRT::File.new
-      line = SRT::Line.new
-      
+      result = new
+      line = Line.new
+
       split_srt_data(srt_data).each_with_index do |str, index|
         begin
           if str.strip.empty?
             result.lines << line unless line.empty?
-            line = SRT::Line.new
+            line = Line.new
           elsif !line.error
             if line.sequence.nil?
               line.sequence = str.to_i
             elsif line.start_time.nil?
               if mres = str.match(/(?<start_timecode>[^[[:space:]]]+) -+> (?<end_timecode>[^[[:space:]]]+) ?(?<display_coordinates>X1:\d+ X2:\d+ Y1:\d+ Y2:\d+)?/)
 
-                if (line.start_time = SRT::File.parse_timecode(mres["start_timecode"])) == nil
-                  line.error = "#{line}, Invalid formatting of start timecode, [#{mres["start_timecode"]}]"
-                  puts line.error
+                if (line.start_time = Parser.timecode(mres["start_timecode"])) == nil
+                  line.error = "#{index}, Invalid formatting of start timecode, [#{mres["start_timecode"]}]"
+                  $stderr.puts line.error if @debug
                 end
 
-                if (line.end_time = SRT::File.parse_timecode(mres["end_timecode"])) == nil
-                  line.error = "#{line}, Invalid formatting of end timecode, [#{mres["end_timecode"]}]"
-                  puts line.error
+                if (line.end_time = Parser.timecode(mres["end_timecode"])) == nil
+                  line.error = "#{index}, Invalid formatting of end timecode, [#{mres["end_timecode"]}]"
+                  $stderr.puts line.error if @debug
                 end
 
                 if mres["display_coordinates"]
                   line.display_coordinates = mres["display_coordinates"]
                 end
               else
-                line.error = "#{line}, Invalid Time Line formatting, [#{str}]"
-                puts line.error
+                line.error = "#{index}, Invalid Time Line formatting, [#{str}]"
+                $stderr.puts line.error if @debug
               end
             else
               line.text << str.strip
             end
-
           end
         rescue
           line.error = "#{index}, General Error, [#{str}]"
-          puts line.error
+          $stderr.puts line.error if @debug
         end
       end
       result
     end
 
-    # Ruby often gets the wrong encoding for a file and will throw 
-    # errors on `split` for invalid byte sequences. This chain of 
+    # Ruby often gets the wrong encoding for a file and will throw
+    # errors on `split` for invalid byte sequences. This chain of
     # fallback encodings lets us get something that works.
     def self.split_srt_data(srt_data)
       begin
         srt_data.split(/\n/) + ["\n"]
       rescue
         begin
+          srt_data = srt_data.unpack("C*").pack("U*")
           srt_data.force_encoding('utf-8').split(/\n/) + ["\n"]
         rescue
           srt_data.force_encoding('iso-8859-1').split(/\n/) + ["\n"]
@@ -75,8 +76,8 @@ module SRT
     end
 
     def append(options)
-      if options.length == 1 && options.values[0].class == SRT::File
-        reshift = SRT::File.parse_timecode(options.keys[0]) || (lines.last.end_time + SRT::File.parse_timespan(options.keys[0]))
+      if options.length == 1 && options.values[0].class == self.class
+        reshift = Parser.timecode(options.keys[0]) || (lines.last.end_time + Parser.timespan(options.keys[0]))
         renumber = lines.last.sequence
 
         options.values[0].lines.each do |line|
@@ -91,10 +92,20 @@ module SRT
     end
 
     def split(options)
-      options = { :timeshift => true }.merge(options)
-      if options[:at]
-        split_points = [options[:at]].flatten.map{ |timecode| SRT::File.parse_timecode(timecode) }.sort
-        split_offsprings = [SRT::File.new]
+      options = { :timeshift => true, :renumber => true }.merge(options)
+
+      split_points = []
+
+      if (options[:at])
+        split_points = [options[:at]].flatten.map{ |timecode| Parser.timecode(timecode) }.sort
+      elsif (options[:every])
+        interval = Parser.timecode(options[:every])
+        max = lines.last.end_time
+        (interval..max).step(interval){ |t| split_points << t }
+      end
+
+      if (split_points.count > 0)
+        split_offsprings = [File.new]
 
         reshift = 0
         renumber = 0
@@ -102,7 +113,7 @@ module SRT
         lines.each do |line|
           if split_points.empty? || line.end_time <= split_points.first
             cloned_line = line.clone
-            cloned_line.sequence -= renumber
+            cloned_line.sequence -= renumber if options[:renumber]
             if options[:timeshift]
               cloned_line.start_time -= reshift
               cloned_line.end_time -= reshift
@@ -110,7 +121,7 @@ module SRT
             split_offsprings.last.lines << cloned_line
           elsif line.start_time < split_points.first
             cloned_line = line.clone
-            cloned_line.sequence -= renumber
+            cloned_line.sequence -= renumber if options[:renumber]
             if options[:timeshift]
               cloned_line.start_time -= reshift
               cloned_line.end_time = split_points.first - reshift
@@ -121,9 +132,9 @@ module SRT
             reshift = split_points.first
             split_points.delete_at(0)
 
-            split_offsprings << SRT::File.new
+            split_offsprings << File.new
             cloned_line = line.clone
-            cloned_line.sequence -= renumber
+            cloned_line.sequence -= renumber if options[:renumber]
             if options[:timeshift]
               cloned_line.start_time = 0
               cloned_line.end_time -= reshift
@@ -134,9 +145,9 @@ module SRT
             reshift = split_points.first
             split_points.delete_at(0)
 
-            split_offsprings << SRT::File.new
+            split_offsprings << File.new
             cloned_line = line.clone
-            cloned_line.sequence -= renumber
+            cloned_line.sequence -= renumber if options[:renumber]
             if options[:timeshift]
               cloned_line.start_time -= reshift
               cloned_line.end_time -= reshift
@@ -151,26 +162,37 @@ module SRT
 
     def timeshift(options)
       if options.length == 1
-        if options[:all] && (seconds = SRT::File.parse_timespan(options[:all]))
+        if options[:all] && (seconds = Parser.timespan(options[:all]))
           lines.each do |line|
             line.start_time += seconds
             line.end_time += seconds
           end
-        elsif (original_framerate = SRT::File.parse_framerate(options.keys[0])) && (target_framerate = SRT::File.parse_framerate(options.values[0]))
-          ratio = target_framerate / original_framerate
+        elsif (original_framerate = Parser.framerate(options.keys[0])) && (target_framerate = Parser.framerate(options.values[0]))
+          time_ratio = original_framerate / target_framerate
           lines.each do |line|
-            line.start_time *= ratio
-            line.end_time *= ratio
+            line.start_time *= time_ratio
+            line.end_time *= time_ratio
           end
         end
       elsif options.length == 2
-        original_timecode_a = (options.keys[0].is_a?(String) ? SRT::File.parse_timecode(options.keys[0]) : lines[options.keys[0] - 1].start_time)
-        original_timecode_b = (options.keys[1].is_a?(String) ? SRT::File.parse_timecode(options.keys[1]) : lines[options.keys[1] - 1].start_time)
-        target_timecode_a = SRT::File.parse_timecode(options.values[0]) || (original_timecode_a + SRT::File.parse_timespan(options.values[0]))
-        target_timecode_b = SRT::File.parse_timecode(options.values[1]) || (original_timecode_b + SRT::File.parse_timespan(options.values[1]))
+        origins, targets = options.keys, options.values
+
+        [0,1].each do |i|
+          if origins[i].is_a?(String) && Parser.id(origins[i])
+            origins[i] = lines[Parser.id(origins[i]) - 1].start_time
+          elsif origins[i].is_a?(String) && Parser.timecode(origins[i])
+            origins[i] = Parser.timecode(origins[i])
+          end
+
+          if targets[i].is_a?(String) && Parser.timecode(targets[i])
+            targets[i] = Parser.timecode(targets[i])
+          elsif targets[i].is_a?(String) && Parser.timespan(targets[i])
+            targets[i] = origins[i] + Parser.timespan(targets[i])
+          end
+        end
 
-        time_rescale_factor = (target_timecode_b - target_timecode_a) / (original_timecode_b - original_timecode_a)
-        time_rebase_shift = target_timecode_a - original_timecode_a * time_rescale_factor
+        time_rescale_factor = (targets[1] - targets[0]) / (origins[1] - origins[0])
+        time_rebase_shift = targets[0] - origins[0] * time_rescale_factor
 
         lines.each do |line|
           line.start_time = line.start_time * time_rescale_factor + time_rebase_shift
@@ -187,8 +209,17 @@ module SRT
       end
     end
 
-    def to_s
-      lines.map { |l| [l.sequence, (l.display_coordinates ? l.time_str + l.display_coordinates : l.time_str), l.text, ""] }.flatten.join("\n")
+    def to_s(time_str_function=:time_str)
+      lines.map { |l| l.to_s(time_str_function) }.join("\n")
+    end
+
+    def to_webvtt
+      header = <<eos
+WEBVTT
+X-TIMESTAMP-MAP=MPEGTS:900000,LOCAL:00:00:00.000
+
+eos
+      header + to_s(:webvtt_time_str)
     end
 
     attr_writer :lines
@@ -200,29 +231,5 @@ module SRT
     def errors
       lines.collect { |l| l.error if l.error }.compact
     end
-
-    protected
-
-    def self.parse_framerate(framerate_string)
-      mres = framerate_string.match(/(?<fps>\d+((\.)?\d+))(fps)/)
-      mres ? mres["fps"].to_f : nil
-    end
-
-    def self.parse_timecode(timecode_string)
-      mres = timecode_string.match(/(?<h>\d+):(?<m>\d+):(?<s>\d+),(?<mil>\d+)/)
-      mres ? "#{mres["h"].to_i * 3600 + mres["m"].to_i * 60 + mres["s"].to_i}.#{mres["mil"]}".to_f : nil
-    end
-
-    def self.parse_timespan(timespan_string)
-      factors = { 
-        "mil" => 0.001,
-        "s" => 1,
-        "m" => 60,
-        "h" => 3600 
-      }
-
-      mres = timespan_string.match(/(?<amount>(\+|-)?\d+((\.)?\d+))(?<unit>mil|s|m|h)/)
-      mres ? mres["amount"].to_f * factors[mres["unit"]] : nil
-    end
   end
 end

data/lib/srt/line.rb

@@ -32,8 +32,18 @@ module SRT
       sequence.nil? && start_time.nil? && end_time.nil? && text.empty?
     end
 
-    def time_str
-      [@start_time, @end_time].map { |t| sprintf("%02d:%02d:%02d,%s", t / 3600, (t % 3600) / 60, t % 60, sprintf("%.3f", t)[-3, 3]) }.join(" --> ")
+    def time_str(subframe_separator=",")
+      [@start_time, @end_time].map { |t|  f=sprintf("%.3f", t); ip=f[0,f.size-4].to_i;fp=f[-3,3]; "%02d:%02d:%02d#{subframe_separator}%s" % [ip / 3600, (ip % 3600) / 60, ip % 60,fp] }.join(" --> ")
+    end
+
+    def webvtt_time_str
+      time_str(".")
+    end
+
+    def to_s(time_str_function=:time_str)
+      content = text.empty? ? [''] : text
+      coordinates = display_coordinates ? display_coordinates : ""
+      [sequence, send(time_str_function) + coordinates, content, ""].flatten.join("\n")
     end
   end
 end

data/lib/srt/parser.rb

@@ -0,0 +1,31 @@
+module SRT
+  class Parser
+    class << self
+      def framerate(framerate_string)
+        mres = framerate_string.match(/(?<fps>\d+((\.)?\d+))(fps)/)
+        mres ? mres["fps"].to_f : nil
+      end
+
+      def id(id_string)
+        mres = id_string.match(/#(?<id>\d+)/)
+          mres ? mres["id"].to_i : nil
+      end
+
+      def timecode(timecode_string)
+        mres = timecode_string.match(/(?<h>\d+):(?<m>\d+):(?<s>\d+)[,.]?(?<ms>\d+)?/)
+        mres ? "#{mres["h"].to_i * 3600 + mres["m"].to_i * 60 + mres["s"].to_i}.#{mres["ms"]}".to_f : nil
+      end
+
+      def timespan(timespan_string)
+        factors = {
+          "ms" => 0.001,
+          "s" => 1,
+          "m" => 60,
+          "h" => 3600
+        }
+        mres = timespan_string.match(/(?<amount>(\+|-)?\d+((\.)?\d+)?)(?<unit>ms|s|m|h)/)
+        mres ? mres["amount"].to_f * factors[mres["unit"]] : nil
+      end
+    end
+  end
+end

data/lib/srt/version.rb

@@ -1,3 +1,3 @@
 module SRT
-  VERSION = "0.0.5"
+  VERSION = "0.1.5"
 end

data/lib/srt.rb

@@ -1,3 +1,4 @@
 require "srt/file"
 require "srt/line"
-require "srt/version"
+require "srt/parser"
+require "srt/version"