amagi-captions 1.3.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6e6e70d742c9b9f90fb4f494641353e883d9f854a15e50d20e8cc1a0e85295dd
+  data.tar.gz: 6fde8355de7aa80ffc716923fac935ae8338a66beb42df0a76b5a4c09f6afbe6
+SHA512:
+  metadata.gz: 9a6c0bfc0c3466f0ae922cc46144018e552a7cbd2fddc6c35de807368951eef6fc8a3bb3f2166852dcb8fa26063bc56bf29f87629f28423e4bc1404d2fca7789
+  data.tar.gz: 3001b3ce3620f766a2b7698b403747d290c604323119daeb32086eef80453b4104db59ab9ae56fd793f4ad95850f5f41c83652709837910985a3774200dec2b9

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,14 @@
+language: ruby
+cache: bundler
+
+rvm:
+  - ruby-2.3.8
+
+script: 'bundle exec rspec'
+
+notifications:
+  email:
+    recipients:
+      - navinre93@gmail.com
+    on_failure: change
+    on_success: never

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in captions.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 navin
+
+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,145 @@
+# Captions - Subtitle Editor and Converter
+
+[![Build Status](https://travis-ci.org/navinre/captions.svg?branch=master)](https://travis-ci.org/navinre/captions)
+
+Captions can read subtitles of various formats, modify them and convert the subtitle to other formats. Currently captions supports `SRT`, `WebVTT` files.
+
+## Supported Features
+- Read subtitles
+- Move subtitles
+- Increase duration
+- Filter subtitles
+- Change frame rate
+- Convert to other format (SRT, WebVTT)
+
+## Features Planned
+- Read subtitle properties (Font Style, Aligment, Position etc.)
+- Delete subtitles
+- Change subtitle fonts
+- Command Line Interface
+- Spell Check
+- And More...
+
+
+## Usage
+
+**Read subtitle file:**
+
+```ruby
+s = Captions::SRT.new('test.srt')
+s.parse
+
+s = Captions::VTT.new('test.vtt')
+s.parse
+```
+
+**Filter subtitles:**
+
+Once the subtitle file has been parsed. Every subtitle will get **start_time, end_time, duration and text**. All the values are stored in milliseconds. `Captions::InvalidSubtitle` error will be thown if start-time or end-time cannot be found for a subtitle.
+
+View all subtitle text:
+```ruby
+s.cues.map { |c| c.text }
+```
+
+Filter subtitles based on condition:
+```ruby
+s.cues { |c| c.start_time > 1000 }
+s.cues { |c| c.end_time > 1000 }
+s.cues { |c| c.duration > 1000 }
+```
+
+To get all subtitles:
+```ruby
+s.cues.each { |c| puts c }
+```
+
+**Move Subtitle:**
+
+```ruby
+s.move_by(1000)
+s.move_by(1000) { |c| c.start_time > 3000 }
+```
+
+Former command moves all subtitles by 1 second. Later moves the subtitles which are starting after 3 seconds by 1 second.
+
+**Increase Duration:**
+
+```ruby
+s.increase_duration_by(1000)
+s.increase_duration_by(1000) { |c| c.start_time > 3000 }
+```
+
+Former command increases duration of all subtitles by 1 second. Later increases the duration of subtitles which are starting after 3 seconds by 1 second.
+
+**Change Frame Rate:**
+
+All subtitles are parsed based on **25 frames/second** by default. This can be changed by passing frame rate at the time of reading the subtitle file.
+
+```ruby
+s = Captions::SRT.new('test.srt', 29.97)
+s.parse
+```
+
+Frame rate can also be changed after parsing. This command changes all the subtitles which are parsed in different frame-rate to new frame-rate.
+
+```ruby
+s.set_frame_rate(29.97)
+```
+
+**Convert to Other Format:**
+
+Subtitles parsed in one format can be converted to other format. Currently export is supported for **SRT** and **WebVTT**. Other formats will be added soon.
+
+```ruby
+s = Captions::SRT.new('test.srt')
+s.parse
+s.export_to_vtt('test.vtt')
+```
+
+Subtitles can also be filtered and those filtered subtitles can be written to a file.
+
+```ruby
+s = Captions::SRT.new('test.srt')
+s.parse
+new_cues = s.cues { |c| c.start_time > 2000 }
+s.export_to_vtt('test.vtt', new_cues)
+```
+
+**Filter subtiltes and Export:**
+
+Subtitles can be filtered with filter option. This returns a new `Captions` object. Once filters new object is created and cues for that becomes the result  of the filter. This can be exported to other formats easily.
+
+```ruby
+new_obj = s.filter { |c| c.start_time > 2000 }
+new_obj.export_to_vtt('test.vtt')
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'captions'
+```
+
+Or install it yourself as:
+
+    $ gem install captions
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/navinre/captions.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/amagi-captions.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'captions/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "amagi-captions"
+  spec.version       = Captions::VERSION
+  spec.authors       = ["navin"]
+  spec.email         = ["cloudport.team@amagi.com"]
+
+  spec.summary       = %q{Subtitle Editor and Converter written in Ruby}
+  spec.description   = %q{Subtitle Editor and Converter written in Ruby. Captions can read/modify/export subtitles from one format to another }
+  spec.homepage      = "https://github.com/amagimedia/captions"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "captions"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/captions/base.rb

@@ -0,0 +1,179 @@
+module Captions
+  class Base
+
+    # Adding Util methods so that it can be used by
+    # any subtitle parser
+    include Util
+
+    # Creates new instance of parser
+    # Usage:
+    #     p = Captions::Base.new(nil, 25)
+    #
+    # This creates new cue-list with no file object
+    # associated with it. `parse` method cannot be
+    # called if no file path is specified.
+    #
+    #    p = Captions::Base.new('file_path', 25)
+    #
+    # This parses the file specified in the file path
+    # `parse` method will be defined in any one of the
+    # classes which extends this base class. This parses
+    # the file in the fps specified. If a subtitle file
+    # has to be parsed in different fps, it can be passed
+    # as a parameter. FPS parameter plays an important
+    # role if the start-time or end-time of a subtitle is
+    # mentioned in frames (i.e) HH:MM:SS:FF (frames)
+    def initialize(file=nil, fps=25)
+      @cue_list = CueList.new(fps)
+      @file = File.new(file, 'r:bom|utf-8') if file
+    end
+
+    # This overrides the existing cuelist which has been
+    # populated with a new cuelist. This is mainly used in
+    # export of one format to another.
+    def cues=(cue_list)
+      @cue_list = CueList.new(@cue_list.fps, cue_list)
+    end
+
+    ############## BEGINNING OF OPERATIONS #################
+    ## Following Operations can performed on subtitles
+
+    # A subtitle is parsed with 25 fps by default. This default
+    # value can be changed when creating a new parser class.
+    # When the subtitle is being parsed, it takes the value
+    # mentioned when the class is created. Even after the
+    # subtitle is parsed, frame rate (fps) can be changed using
+    # this method.
+    # Usage:
+    #     p = Captions::Base.new('file_path', 25)
+    #     p.parse
+    #     p.set_frame_rate(29.97)
+    #
+    # This method changes all the subtitle which are parsed to
+    # the new frame rate.
+    def set_frame_rate(rate)
+      @cue_list.frame_rate = rate
+    end
+
+    # This returns the subtitle which are parsed. A block
+    # can also be passed to filter the cues based on following
+    # parameters.
+    # Usage:
+    #     p.cues
+    #     p.cues { |c| c.start_time > 1000 }
+    #     p.cues { |c| c.end_time > 1000 }
+    #     p.cues { |c| c.duration > 1000 }
+    #
+    # Filters based on the condition and returns new set of cues
+    def cues(&block)
+      if block_given?
+        base = self.class.new()
+        base.cues = fetch_result(&block)
+        return base.cues
+      else
+        @cue_list
+      end
+    end
+
+    # This filters the subtitle based on the condition and returns
+    # a new object. A condition is mandatory to filter subtitles
+    # Usage:
+    #     p.filter
+    #     p.filter { |c| c.start_time > 1000 }
+    #     p.filter { |c| c.end_time > 1000 }
+    #     p.filter { |c| c.duration > 1000 }
+    #
+    # Filters and returns a Captions class rather than a cue list
+    def filter(&block)
+      if block_given?
+        base = self.class.new()
+        base.cues = fetch_result(&block)
+        return base
+      end
+    end
+
+    # Moves subtitles by `n` milliseconds
+    # Usage:
+    #     p.move_by(1000)
+    #     p.move_by("00:00:02.000")
+    #     p.move_by(1000) { |c| c.start_time > 2000 }
+    #
+    # This changes start-time and end-time of subtiltes by
+    # the time passed.
+    def move_by(diff, &block)
+      msec = sanitize(diff, frame_rate)
+      fetch_result(&block).each do |cue|
+        cue.start_time += msec
+        cue.end_time += msec
+      end
+    end
+
+    # Increases duration of subtitles by `n` milliseconds
+    # Usage:
+    #     p.increase_duration_by(1000)
+    #     p.increase_duration_by("00:00:02.000")
+    #     p.increase_duration_by(1000) { |c| c.start_time > 2000 }
+    #
+    # This increases duration of subtiltes by the time passed.
+    def increase_duration_by(diff, &block)
+      msec = sanitize(diff, frame_rate)
+      fetch_result(&block).each do |cue|
+        cue.duration += msec
+      end
+    end
+
+    ################ END OF OPERATIONS ###################
+
+    private
+
+    # This is the base method through which all subtitle
+    # file parsing should be done. This throws error if
+    # no `@file` is found. This also closes the file once
+    # the file has be parsed. All other logic like when the
+    # subtitle has to be inserted into the list, when to set
+    # the start and end time will be defined inside `parse`
+    # method.
+    def base_parser
+      raise UnknownFile, "No subtitle file specified" if @file.nil?
+      begin
+        yield
+      ensure
+        @file.close
+      end
+      return true
+    end
+
+    # This is the base method through which all subtitle
+    # exports has to be done. When a `file_path` is passed
+    # to this base method, it opens the file. Other logic
+    # about how the file should be written is defined inside
+    # `dump` method in one of the subclass.
+    def base_dump(file)
+      begin
+        File.open(file, 'w') do |file|
+          yield(file)
+        end
+      end
+      return true
+    end
+
+    # This returns the frame-rate which was used for parsing
+    # the subtitles
+    def frame_rate
+      @cue_list.fps
+    end
+
+    # This accepts a block and returns the result based
+    # on the condition passed. This acts on the cuelist
+    # whenever a block is passed it does select with the
+    # condition passed and returns the result. When no
+    # block is passed, it returns the entire cuelist.
+    def fetch_result(&block)
+      if block_given?
+        return @cue_list.select(&block)
+      else
+        return @cue_list
+      end
+    end
+  end
+end

data/lib/captions/cue.rb

@@ -0,0 +1,93 @@
+module Captions
+  class Cue
+    include Util
+
+    # Text Properties supported
+    ALIGNMENT    = "alignment"
+    COLOR        = "color"
+    POSITION     = "position"
+
+    # List of Text Properties
+    TEXT_PROPERTIES = [ALIGNMENT, COLOR, POSITION]
+
+    attr_accessor :number, :start_time, :end_time, :duration, :text, :properties
+
+    # Creates a new Cue class
+    # Each cue denotes a subtitle.
+    def initialize(cue_number = nil)
+      self.text = nil
+      self.start_time = nil
+      self.end_time = nil
+      self.duration = nil
+      self.number = cue_number
+      self.properties = {}
+    end
+
+    # Sets the time for the cue. Both start-time and
+    # end-time can be passed together. This just assigns
+    # the value passed.
+    def set_time(start_time, end_time, duration = nil)
+      self.start_time = start_time
+      self.end_time = end_time
+      self.duration = duration
+    end
+
+    # Getter and Setter methods for Text Properties
+    # These are pre-defined properties. This is just to assign
+    # or access the properties of that text.
+    TEXT_PROPERTIES.each do |setting|
+      define_method :"#{setting}" do
+        if self.properties[setting].present?
+          return self.properties[setting]
+        end
+        return nil
+      end
+
+      define_method :"#{setting}=" do |value|
+        self.properties[setting] = value
+      end
+    end
+
+    # Serializes the values set for the cue.
+    # Converts start-time, end-time and duration to milliseconds
+    # If duration is not found, it will be calculated based on
+    # start-time and end-time.
+    def serialize(fps)
+      raise InvalidSubtitle, "Subtitle should have start time" if self.start_time.nil?
+      raise InvalidSubtitle, "Subtitle shold have end time" if self.end_time.nil?
+
+      begin
+        ms_per_frame = (1000.0 / fps)
+        self.start_time = convert_to_msec(self.start_time, ms_per_frame)
+        self.end_time = convert_to_msec(self.end_time, ms_per_frame)
+        if duration.nil?
+          self.duration = self.end_time - self.start_time
+        else
+          self.duration = convert_to_msec(self.duration, ms_per_frame)
+        end
+      rescue
+        raise InvalidSubtitle, "Cannot calculate start-time or end-time"
+      end
+    end
+
+    # Changes start-time, end-time and duration based on new frame-rate
+    def change_frame_rate(old_rate, new_rate)
+      self.start_time = convert_frame_rate(self.start_time, old_rate, new_rate)
+      self.end_time = convert_frame_rate(self.end_time, old_rate, new_rate)
+      self.duration = convert_frame_rate(self.duration, old_rate, new_rate)
+    end
+
+    # Adds text. If text is already found, new-line is appended.
+    def add_text(text)
+      if self.text.nil?
+        self.text = text
+      else
+        self.text += "\n" + text
+      end
+    end
+
+    def <=>(other_cue)
+      self.start_time <=> other_cue.start_time
+    end
+  end
+end

data/lib/captions/error.rb

@@ -0,0 +1,27 @@
+module Captions
+
+  # Used for all execptions thrown from captions
+  class CaptionsError < StandardError
+  end
+
+  # Subtitle has to be in correct format
+  # when its being serialized
+  class InvalidSubtitle < CaptionsError
+  end
+
+  # Subtitle has to be correct format
+  # when its being parsed
+  class MalformedString < CaptionsError
+  end
+
+  # File has to be specifed for parsing
+  # subtitle
+  class UnknownFile < CaptionsError
+  end
+
+  # Input has to be proper for filtering
+  # subtitles
+  class InvalidInput < CaptionsError
+  end
+
+end

data/lib/captions/export.rb

@@ -0,0 +1,25 @@
+module Captions
+
+  # This module adds support for export of subtitles
+  # from one format to another. Subclasses which
+  # extends Captions::Base needs to `dump` method to
+  # support export to that corresponding format
+  module Export
+    Captions.constants.each do |format|
+      obj = Captions.const_get(format)
+      next unless obj.is_a?(Class) and (obj.superclass == Captions::Base)
+      method_name = "export_to_" + format.to_s.downcase
+      define_method(method_name) do |file, cues=nil|
+        sub_format = obj.new()
+        sub_format.cues = cues || self.cues.dup
+        sub_format.dump(file) if sub_format.respond_to?(:dump)
+      end
+    end
+  end
+
+  # Including this module after all the sub-classes of
+  # Captions::Base has been defined.
+  Captions::Base.send(:include, Export)
+
+end
+

data/lib/captions/formats/srt.rb

@@ -0,0 +1,83 @@
+module Captions
+  class SRT < Base
+
+    def parse
+      base_parser do
+        count = 0
+        state = :new_cue
+        cue = nil
+        loop do
+          count += 1
+          line = @file.gets
+          break if line.nil? ## End of file
+          line.chomp!
+          case state
+          when :new_cue
+            line.strip!
+            next if line.empty?  ## just another blank line, remain in new_cue state
+            begin
+              cue = Cue.new(Integer(line))
+            rescue ArgumentError
+              raise InvalidSubtitle, "Invalid Cue Number at line #{count}"
+            end
+            state = :time
+          when :time
+            line.strip!
+            raise InvalidSubtitle, "Invalid Time Format at line #{count}" unless is_time?(line)
+            start_time, end_time = get_time(line)
+            cue.set_time(start_time, end_time)
+            state = :text
+          when :text
+            if line.empty?
+              ## end of previous cue
+              @cue_list.append(cue) if cue && cue.start_time
+              cue = nil
+              state = :new_cue
+            else
+              line.strip!
+              cue.add_text(line)
+            end
+          end
+        end
+        @cue_list.append(cue) if cue && cue.start_time
+      end
+    end
+
+    def dump(file)
+      base_dump(file) do |file|
+        @cue_list.each do |cue|
+          file.write(cue.number)
+          file.write("\n")
+          file.write(msec_to_timecode(cue.start_time).gsub!('.' , ','))
+          file.write(" --> ")
+          file.write(msec_to_timecode(cue.end_time).gsub!('.' , ','))
+          file.write("\n")
+          file.write(cue.text)
+          file.write("\n\n")
+        end
+      end
+    end
+
+    def get_time(line)
+      data = line.split('-->')
+      return format_time(data[0]), format_time(data[1])
+    end
+
+    def format_time(text)
+      text.strip.gsub(/,/,".")
+    end
+
+    def is_number?(text)
+      !!text.match(/^\d+$/)
+    end
+
+    def is_time?(text)
+      !!text.match(/^\d{2}:\d{2}:\d{2},\d{3}.*\d{2}:\d{2}:\d{2},\d{3}$/)
+    end
+
+    def is_text?(text)
+      !text.empty? and text.is_a?(String)
+    end
+
+  end
+end