webvtt-ruby 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c0edb293642afb992e4650a9835de04a619c527b
+  data.tar.gz: 17ac19588e370f2f8035196c4152f930a264ea32
+SHA512:
+  metadata.gz: 5236eb0fed07d03d983864f74a1dc8155a0221c2ce26ecb9ebb49736a8202acc0860f5d0a4f9b83134840c413c462ebc90617beb723afd9e813220c5702063d6
+  data.tar.gz: 0d047592a007a532315cd4131e44d649171662acfd07818863dcc6bf94b548a57eef6a9210104bca732031622ef95b0e4f45fa48b6c6761f5c83a123a3610cec

data/.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+*.m3u8

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Bruno Celeste
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,121 @@
+# WebVTT Ruby parser and segmenter
+
+The [WebVTT format](http://dev.w3.org/html5/webvtt/) is a standard captionning format used for HTML5 videos and HTTP Live Streaming (HLS).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'webvtt-ruby'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install webvtt-ruby
+
+## Usage
+
+To parse a webvtt file:
+
+```ruby
+require "webvtt"
+
+webvtt = WebVTT.read("path/sub.webvtt")
+webvtt.cues.each do |cue|
+  puts "identifier: #{cue.identifier}"
+  puts "Start: #{cue.start}"
+  puts "End: #{cue.end}"
+  puts "Style: #{cue.style.inspect}"
+  puts "Text: #{cue.text}"
+  puts "--"
+end
+```
+
+## Converting from SRT
+
+You can also convert an SRT file to a standard WebVTT file:
+
+```ruby
+webvtt = WebVTT.convert_from_srt("path/sub.srt", "path/sub.webvtt")
+puts webvtt.to_webvtt
+```
+
+## Segmenting for HTTP Live Streaming (HLS)
+
+Segmenting is required to work with HLS videos.
+
+```ruby
+WebVTT.segment("subtitles/en.webvtt", :length => 10, :output => "subtitles/en-%05d.webvtt", :playlist => "subtitles/en.m3u8")
+```
+
+It will also generate the playlist in `m3u8`:
+
+```
+#EXTM3U
+#EXT-X-TARGETDURATION:17
+#EXT-X-VERSION:3
+#EXT-X-MEDIA-SEQUENCE:0
+#EXT-X-PLAYLIST-TYPE:VOD
+#EXTINF:13,
+en-00000.webvtt
+#EXTINF:17,
+en-00001.webvtt
+#EXTINF:12,
+en-00002.webvtt
+#EXT-X-ENDLIST
+```
+
+To use the segmented webvtt files with your HLS playlist:
+
+```
+#EXTM3U
+
+#EXT-X-MEDIA:TYPE=SUBTITLES,GROUP-ID="subs",NAME="English",DEFAULT=NO,AUTOSELECT=YES,FORCED=NO,LANGUAGE="en",URI="subtitles/en.m3u8"
+
+#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=300000,SUBTITLES="subs"
+demo-300000.m3u8
+
+#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=600000,SUBTITLES="subs"
+demo-600000.m3u8
+```
+
+## CLI
+
+You can also segment webvtt files using the command line `webvtt-segmenter`:
+
+```
+$ webvtt-segmenter -i subtitles/en.webvtt -t 10 -m subtitles/en.m3u8 -o "subtitles/en-%05d.webvtt"
+```
+
+```
+$ webvtt-segmenter -h
+Usage: bin/webvtt-segmenter [--arg]
+    -i, --input [PATH]               WebVTT or SRT file
+    -b, --base-url [URL]             Base URL
+    -t, --target-duration [DUR]      Duration of each segments. Default: 10
+    -o, --output [PATH]              Path where WebVTT segments will be saved. Default: fileSequence-%05d.webvtt
+    -m, --playlist [PATH]            Path where the playlist in m3u8 will be saved. Default: prog_index.m3u8
+```
+
+## Note
+
+`webvtt-ruby` was written in a few hours because there was no open source tool to segment webvtt files. It's not perfect at all but it does the job.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+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
+
+## Author
+
+**Bruno Celeste**
+
+* http://www.heywatchencoding.com
+* bruno@heywatch.com
+* [@sadikzzz](http://twitter.com/sadikzzz)

data/bin/webvtt-segmenter

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), "..", "lib")
+require "optparse"
+require "webvtt"
+
+@options = {}
+opts = OptionParser.new do |opts|
+  opts.banner = %(Usage: webvtt-segmenter [--arg])
+
+  opts.on("-i", "--input [PATH]", "WebVTT or SRT file") do |path|
+    @options[:input] = path
+  end
+
+  opts.on("-b", "--base-url [URL]", "Base URL") do |url|
+    @options[:base_url] = url
+  end
+
+  opts.on("-t", "--target-duration [DUR]", "Duration of each segments. Default: 10") do |dur|
+    @options[:length] = dur.to_i
+  end
+
+  opts.on("-o", "--output [PATH]", "Path where WebVTT segments will be saved. Default: fileSequence-%05d.webvtt") do |path|
+    @options[:output] = path
+  end
+
+  opts.on("-m", "--playlist [PATH]", "Path where the playlist in m3u8 will be saved. Default: prog_index.m3u8") do |path|
+    @options[:playlist] = path
+  end
+end
+
+begin
+  opts.parse!
+  raise OptionParser::MissingArgument if @options.empty?
+  if ! @options[:input]
+    raise OptionParser::InvalidOption, "Missing argument --input"
+  end
+rescue OptionParser::InvalidOption, OptionParser::MissingArgument
+  $stderr.puts $!.to_s
+  $stderr.puts opts
+  exit
+end
+
+input = @options.delete(:input)
+
+# convert srt to webvtt first
+if File.extname(input) == ".srt"
+  puts "Converting srt to webvtt format..."
+  input = WebVTT.convert_from_srt(input)
+end
+
+res = WebVTT.segment(input, @options)
+puts "Done"

data/lib/parser.rb

@@ -0,0 +1,143 @@
+module WebVTT
+
+  class MalformedFile < RuntimeError; end
+  class InputError < RuntimeError; end
+
+  def self.read(file)
+    File.new(file)
+  end
+
+  def self.convert_from_srt(srt_file, output=nil)
+    if !::File.exists?(srt_file)
+      raise InputError, "SRT file not found"
+    end
+
+    srt = ::File.read(srt_file)
+    output ||= srt_file.gsub(".srt", ".webvtt")
+
+    # convert timestamps and save the file
+    srt.gsub!(/([0-9]{2}:[0-9]{2}:[0-9]{2})([,])([0-9]{3})/, '\1.\3')
+    # normalize new line character
+    srt.gsub!("\r\n", "\n")
+
+    srt = "WEBVTT\n\n#{srt}"
+    ::File.open(output, "w") {|f| f.write(srt)}
+
+    return File.new(output)
+  end
+
+  class File
+    attr_reader :header, :path, :filename
+    attr_accessor :cues
+
+    def initialize(webvtt_file)
+      if !::File.exists?(webvtt_file)
+        raise InputError, "WebVTT file not found"
+      end
+
+      @path = webvtt_file
+      @filename = ::File.basename(@path)
+      @content = ::File.read(webvtt_file).gsub("\r\n", "\n") # normalizing new line character
+      parse
+    end
+
+    def to_webvtt
+      [@header, @cues.map(&:to_webvtt)].flatten.join("\n\n")
+    end
+
+    def total_length
+      @cues.last.end_in_sec
+    end
+
+    def actual_total_length
+      @cues.last.end_in_sec - @cues.first.start_in_sec
+    end
+
+    def save(output=nil)
+      output ||= @path.gsub(".srt", ".webvtt")
+
+      File.open(output, "w") {|f| f.write(to_webvtt)}
+      return output
+    end
+
+    def parse
+      # remove bom first
+      @content.gsub!("\uFEFF", '')
+
+      cues = @content.split("\n\n")
+      @header = cues.shift
+      header_lines = @header.split("\n").map(&:strip)
+      if (header_lines[0] =~ /^WEBVTT/).nil?
+        raise MalformedFile, "Not a valid WebVTT file"
+      end
+
+      @cues = []
+      cues.each do |cue|
+        cue_parsed = Cue.new(cue)
+        if !cue_parsed.text.nil?
+          @cues << cue_parsed
+        end
+      end
+      @cues
+    end
+  end
+
+  class Cue
+    attr_accessor :identifier, :start, :end, :style, :text
+
+    def initialize(cue)
+      @content = cue
+      parse
+    end
+
+    def to_webvtt
+      res = ""
+      if @identifier
+        res << "#{@identifier}\n"
+      end
+      res << "#{@start} --> #{@end} #{@style.map{|k,v| "#{k}:#{v}"}.join(" ")}".strip + "\n"
+      res << @text
+
+      res
+    end
+
+    def self.timestamp_in_sec(timestamp)
+      mres = timestamp.match(/([0-9]{2}):([0-9]{2}):([0-9]{2}\.[0-9]{3})/)
+      sec = mres[3].to_f # seconds and subseconds
+      sec += mres[2].to_f * 60 # minutes
+      sec += mres[1].to_f * 60 * 60 # hours
+      return sec
+    end
+
+    def start_in_sec
+      Cue.timestamp_in_sec(@start)
+    end
+
+    def end_in_sec
+      Cue.timestamp_in_sec(@end)
+    end
+
+    def length
+      end_in_sec - start_in_sec
+    end
+
+    def parse
+      lines = @content.split("\n").map(&:strip)
+
+      # it's a note, ignore
+      return if lines[0] =~ /NOTE/
+
+      if !lines[0].include?("-->")
+        @identifier = lines[0]
+        lines.shift
+      end
+
+      if lines[0].match(/([0-9]{2}:[0-9]{2}:[0-9]{2}\.[0-9]{3}) -+> ([0-9]{2}:[0-9]{2}:[0-9]{2}\.[0-9]{3})(.*)/)
+        @start = $1
+        @end = $2
+        @style = Hash[$3.strip.split(" ").map{|s| s.split(":").map(&:strip) }]
+      end
+      @text = lines[1..-1].join("\n")
+    end
+  end
+end

data/lib/segmenter.rb

@@ -0,0 +1,127 @@
+module WebVTT
+
+  class InputError < RuntimeError; end
+
+  def self.segment(input, options={})
+    if input.is_a?(String)
+      input = File.new(input)
+    end
+
+    if ! input.respond_to?(:to_webvtt)
+      raise InputError, "Input must be a WebVTT instance or a path"
+    end
+
+    segmenter = Segmenter.new(input, options)
+    subs = segmenter.split_to_files
+    playlist = segmenter.generate_playlist(subs)
+
+    return [playlist, subs]
+  end
+
+  class Segmenter
+    attr_reader :webvtt
+
+    def initialize(webvtt, options={})
+      @webvtt = webvtt
+      @options = options
+      @options[:length] ||= 10
+      @options[:output] ||= "fileSequence-%05d.webvtt"
+      @options[:playlist] ||= "prog_index.m3u8"
+    end
+
+    def find_segment_files(cue)
+      seg = find_segments(cue)
+
+      # we need to find out how many segments we
+      # have to remove from our calculation
+      # in the case of first cue not starting at 0
+      start = @webvtt.cues[0].start_in_sec
+      to_remove = (start / @options[:length]).floor
+      return seg.map{|s| s-to_remove}
+    end
+
+    def find_segments(cue)
+      all_cues = @webvtt.cues
+      index_cue = all_cues.index(cue)
+      seg = [(cue.start_in_sec / @options[:length]).floor]
+      start_seg = seg[0] * @options[:length]
+      end_seg = start_seg + @options[:length]
+
+      # if the cue length is > than desired length
+      # or if cue end in sec is > end of the segment in sec
+      # we display it in the next segment as well
+
+      if (cue.length > @options[:length]) ||
+        (cue.end_in_sec > end_seg)
+
+        (cue.length / @options[:length]).ceil.to_i.times.each do |s|
+          seg << seg.last + 1
+        end
+      end
+
+      return seg
+    end
+
+    def generate_playlist(files)
+      lines = []
+      target_duration = 0
+      files.each_with_index do |file,i|
+
+        # if first cue ever we calculate from 0 sec
+        if i == 0
+          total_length = file.total_length
+        else
+          total_length = file.actual_total_length
+        end
+
+        target_duration = total_length if total_length > target_duration
+        if @options[:base_url].nil?
+          url = file.filename
+        else
+          url = ::File.join(@options[:base_url], file.filename)
+        end
+        lines << %(#EXTINF:#{total_length.round},
+#{url})
+      end
+
+      playlist = [%(#EXTM3U
+#EXT-X-TARGETDURATION:#{target_duration.ceil}
+#EXT-X-VERSION:3
+#EXT-X-MEDIA-SEQUENCE:0
+#EXT-X-PLAYLIST-TYPE:VOD)]
+      playlist.concat(lines)
+      playlist << "#EXT-X-ENDLIST"
+
+      ::File.open(@options[:playlist], "w") {|f| f.write(playlist.join("\n")) }
+      return @options[:playlist]
+    end
+
+    def split_to_files
+      filenames = []
+      segment_files = []
+
+      @webvtt.cues.each_with_index do |cue,i|
+        find_segment_files(cue).each do |seg|
+          segment_files[seg] ||= []
+          segment_files[seg] << cue
+        end
+      end
+
+      segment_files.compact.each_with_index do |f,i|
+        filename = sprintf(@options[:output], i)
+        header = @webvtt.header
+
+        if !header.include?("X-TIMESTAMP-MAP=MPEGTS")
+          header << "\nX-TIMESTAMP-MAP=MPEGTS:900000,LOCAL:00:00:00.000"
+        end
+
+        content = [header, f.map{|c| c.to_webvtt }.join("\n\n")].join("\n\n")
+
+        ::File.open(filename, "w") {|f| f.write(content)}
+
+        filenames << filename
+      end
+      return filenames.map{|f| File.new(f) }
+    end
+  end
+end