subtitle 0.2.6 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 99d9960e9d5fb5daa7ddc87e76db91c654ce68453a13fd9124611e7589cc7fe5
-  data.tar.gz: '090e594747871afd7e3e423dab00154313d5b77423664a300f499df07dd895c0'
+  metadata.gz: 49e45fb2713aedd5d6d7d6d290fe4874a292df3249cfad7259913e90b0cb7fd8
+  data.tar.gz: 7f4535875a19028db4ec08de90903daba7b906b659571c5a921850071bf3154c
 SHA512:
-  metadata.gz: 1545c3120f496fe10228473f45f5bb3a78135fd603d15eed6eee7a2aa85fc281f53f4fc5f612c3ab4d710baa9388abd6528c8f5aff52f3fb3bfe424e61c05e2c
-  data.tar.gz: 38fc75d66ea829a7596d5a7235fd6d7f43d256a3dbb1b8ae136926b92ca83b7cbf041c290cf4e506e032d987e73b9a56761cfb89596d6131aafc5d5f87453732
+  metadata.gz: 0b53144f0a627a545c0a989d664f3611078a7afc11e9f00b479065a0d3a1b2bc9bf68e10706bd89b85c0e73ff53d7c4627a2c5e29d38867ec2882c99ea56eda0
+  data.tar.gz: 6999ae152b2f5904a2061944522b11387280df6e02cbf4d36d7d5ae27ba12eb3b6c36357bba791c5a7b4f06575531ce76df904dcbb76b0e5f79bd62b05988704

data/lib/allfather.rb

@@ -1,3 +1,6 @@
+require 'fileutils'
+require_relative "engines/translator"
+
 # 
 # A Module that kind of acts as an interface where the generic methods
 # that applies to each caption type can be defined
@@ -12,6 +15,15 @@ module AllFather
   #
   VALID_FILES = [".scc", ".srt", ".vtt", ".ttml", ".dfxp"]
 
+  #
+  # Caption type constants
+  #
+  TYPE_SCC  = 1
+  TYPE_SRT  = 2
+  TYPE_VTT  = 3
+  TYPE_TTML = 4
+  TYPE_DFXP = 5
+
   # 
   # Generic exception class that is raised for validation errors
   #
@@ -45,12 +57,23 @@ module AllFather
     raise "Not Implemented. Class #{self.class.name} doesn't implement infer_languages"
   end
 
+
+  # 
+  # Method to set a translation engine
+  #
+  # * +translator+  - Instance of translation engine. Refer to `engines/aws` for example
+  #
+  def set_translator(translator)
+    if translator && !(translator.is_a? Translator)
+      raise "Argument is not an instance of Translator"
+    end
+  end
+
   #
   # Method to translate the caption from one language to another
   #
   # :args: src_lang, target_lang, output_file
   #
-  # * +input_caption+   - A Valid input caption file. Refer to #is_valid?
   # * +src_lang+        - can be inferred using #infer_language method
   # * +target_lang+     - Target 2 letter ISO language code to which the source needs to be translated in to.
   # * +output_file+     - Output file. Can be a fully qualified path or just file name
@@ -80,4 +103,55 @@ module AllFather
     # Further checks can be done only in caption specific implementations
     # or translation engine specific implementation
   end
+
+  #
+  # Method to convert from one caption type to other types. If the src_lang is not provided
+  # then all source languages will be converted to target types. For example, if a ttml file
+  # has "en" and "es" and target_type is vtt and no src_lang is provided 2 vtt files would be
+  # created one per language in the source. if a target_lang is provided then one of the lang
+  # from source would be picked for creating the output file with target_lang
+  #
+  # If no target_lang is provided, no translations are applied. output_file is created using
+  # without any need for any language translation services. Hence doesn't incur any cost !!
+  #
+  # * +types+           - An array of Valid input caption type(s). Refer to `#CaptionType`
+  # * +src_lang+        - can be inferred using #infer_language method
+  # * +target_lang+     - Target 2 letter ISO language code to which the source needs to be translated in to.
+  # * +output_dir+      - Output Directory. Generated files would be dumped here
+  #
+  # ==== Raises
+  # 
+  # InvalidInputException shall be raised if
+  # 1. The input file doesn't exist or is unreadable or is invalid caption
+  # 2. The output dir doesn't exist 
+  # 3. Invalid lang codes for a given caption type
+  # 4. Unsupported type to which conversion is requested for
+  #
+  def transform_to(types, src_lang, target_lang, output_dir)
+    if (types - supported_transformations).size != 0
+      raise InvalidInputException.new("Unknown types provided for conversion in input #{types}")
+    end
+    unless File.directory?(output_dir)
+      FileUtils.mkdir_p(output_dir)
+    end
+    # Basic validations
+    if types.include?(TYPE_SCC)
+      if target_lang && !target_lang.eql?("en")
+        raise InvalidInputException.new("SCC can be generated only in en. #{target_lang} is unsupported")
+      end
+    end
+    if target_lang && !target_lang.empty?
+      raise InvalidInputException.new("Translation to other language as part of transform is yet to be implemented")
+    end
+  end
+
+  # 
+  # Method to report on the supported transformations. Each implementor is free to return
+  # the types to which it can convert itself to
+  #
+  # Returns an array of one or more types defined as +TYPE_+ constants here 
+  #
+  def supported_transformations
+    raise "Not Implemented. Class #{self.class.name} doesn't implement supported_transformations"
+  end
 end

data/lib/dfxp.rb

@@ -10,10 +10,10 @@ require_relative "ttml"
 #
 class DFXP < TTML
 
-	def initialize(cc_file, translator, opts={})
+	def initialize(cc_file)
     @cc_file = cc_file
-    @translator = translator
-    @force_detect = opts[:force_detect] || false
+    #@translator = translator
+    #@force_detect = opts[:force_detect] || false
     raise "Invalid TTML file provided" unless is_valid?
   end
 

data/lib/engines/aws.rb

@@ -10,10 +10,9 @@ require_relative 'translator'
 # == Credential Referencing Order
 #
 # * [Arguments]             - Pass the credentials access_key_id and secret_access_key as arguments
-# * [Environment route]     - AWS_ACCESS_KEY_ID & AWS_SECRET_ACCESS_KEY can be exposed as 
-# environment variables
+# * [Environment route]     - AWS_ACCESS_KEY_ID & AWS_SECRET_ACCESS_KEY can be exposed as environment variables
 # * [Profile Name]          - The application uses the credentials of the system and picks the
-# credentials referred to by the profile
+#  credentials referred to by the profile
 #
 class AwsEngine
   include Translator
@@ -71,9 +70,6 @@ class AwsEngine
   # Invokes the language detection API of AWS and returns only the language
   # of the highest score and returns the ISO 639-1 code
   #
-  # :args: text
-  # 
-  # ===== Arguments 
   # * +text+ - The text for which the language is to be inferred
   # 
   def infer_language(text)
@@ -83,12 +79,10 @@ class AwsEngine
 
   # 
   # Invokes the translation API of AWS and returns the translated text
-  # as per the arguments provided
+  # as per the arguments provided.
   # Will Raise exception if a translation cannot be made between the source
   # and target language codes or if the lang code is invalid
   #
-  # :args: input_text, src_lang, target_lang
-  #
   # * +input_text+      - The text that needs to be translated
   # * +src_lang+        - The source language of the text
   # * +target_lang+     - The target language to which the input_text needs to be translated to

data/lib/scc.rb

@@ -1,4 +1,6 @@
 require_relative "engines/translator"
+require_relative "utils/common_utils"
+require_relative "utils/cue_info"
 require_relative "allfather"
 
 #
@@ -10,10 +12,12 @@ require_relative "allfather"
 class SCC
 
   include AllFather
+  include CommonUtils
 
-  def initialize(cc_file, translator)
+  SUPPORTED_TRANSFORMATIONS = [TYPE_SRT, TYPE_VTT, TYPE_TTML, TYPE_DFXP]
+
+  def initialize(cc_file)
     @cc_file = cc_file
-    @translator = translator
     raise "Invalid SCC file provided" unless is_valid?
   end
 
@@ -25,6 +29,11 @@ class SCC
     return false
   end
 
+  def set_translator(translator)
+    super(translator)
+    @translator = translator
+  end
+
   def infer_languages
     lang = nil
     begin
@@ -40,6 +49,71 @@ class SCC
     raise "Not Implemented. Class #{self.class.name} doesn't implement translate yet !!"
   end
 
+  def supported_transformations
+    return SUPPORTED_TRANSFORMATIONS
+  end
+
+  def transform_to(types, src_lang, target_lang, output_dir)
+    # Let's start off with some validations
+    super(types, src_lang, target_lang, output_dir)
+
+    # Suffix output dir with File seperator
+    output_dir = "#{output_dir}#{File::Separator}" unless output_dir.end_with?(File::Separator)
+    
+    # Prepare the output files for each type
+    file_map = {}
+    types.each do |type|
+      output_file = File.basename(@cc_file, File.extname(@cc_file)) + extension_from_type(type)
+      out_file = "#{output_dir}#{output_file}"
+      if create_file(TYPE_SCC, type, out_file, target_lang)
+        file_map[type] = out_file
+      else
+        raise StandardError.new("Failed to create output file for type #{type}")
+      end
+    end
+
+    # Read the file and prepare the cue model
+    prev_cue_info = cur_cue_info = nil
+    ccfile = File.open(@cc_file, 'r:UTF-8', &:read)
+    cue_index = 1
+    ccfile.each_line do | line |
+      time_point = line.scan(/(^\d\d:\d\d:\d\d:\d\d\s)(.*)/)
+      unless time_point.empty?
+        scc_text_code = time_point[0][1].strip
+        message = decode(scc_text_code)
+        # Replace \u0000 with empty as this causes the ttml / dfxp outputs
+        # to treat them as end and terminates the xml the moment this is encountered
+        # https://github.com/sparklemotion/nokogiri/issues/1535
+        message = message.gsub(/\u0000/, '')
+        if prev_cue_info.nil?
+          prev_cue_info = CueInfo.new(TYPE_SCC)
+          prev_cue_info.index = cue_index
+          prev_cue_info.message = message
+          prev_cue_info.start = time_point[0][0].strip
+        else
+          cur_cue_info = CueInfo.new(TYPE_SCC)
+          cur_cue_info.index = cue_index
+          cur_cue_info.message = message
+          cur_cue_info.start = time_point[0][0].strip
+          # Set the previous cue info's end time to current cue's start time
+          # TODO: Need to see if we need to reduce alteast 1 fps or 1s
+          prev_cue_info.end = cur_cue_info.start
+          prev_cue_info.start_time_units = time_details(prev_cue_info.start, TYPE_SCC)
+          prev_cue_info.end_time_units = time_details(prev_cue_info.end, TYPE_SCC)
+          write_cue(prev_cue_info, file_map)
+          prev_cue_info = cur_cue_info
+        end
+        cue_index += 1
+      end
+    end
+    # we need to set some end time, but don't know the same !!
+    # for now setting the start time itself
+    cur_cue_info.end = cur_cue_info.start 
+    cur_cue_info.start_time_units = time_details(cur_cue_info.start, TYPE_SCC)
+    cur_cue_info.end_time_units = time_details(cur_cue_info.end, TYPE_SCC)
+    write_cue(cur_cue_info, file_map, true)
+  end
+
   private
 
   def get_text(srt_file, num_chars)
@@ -78,20 +152,4 @@ class SCC
     end
     decoded_text
   end
-
-  def encode(free_text)
-    encoded_str = ""
-    count = 0
-    free_text.each_byte do |char|
-      count += 1
-      binval = char.to_s(2).count("1") % 2 == 0 ? (char.to_i | 128 ).to_s(2) : char.to_s(2)
-      encode_char = binval.to_i(2).to_s(16)
-      if ((count > 0) && (count % 2 == 0))
-        encoded_str << encode_char << " "
-      else
-        encoded_str << encode_char
-      end
-    end
-    encoded_str
-  end
 end

data/lib/srt.rb

@@ -1,4 +1,6 @@
 require_relative "engines/translator"
+require_relative "utils/common_utils"
+require_relative "utils/cue_info"
 require_relative "allfather"
 
 #
@@ -10,10 +12,12 @@ require_relative "allfather"
 class SRT
 
   include AllFather
+  include CommonUtils
 
-  def initialize(cc_file, translator)
+  SUPPORTED_TRANSFORMATIONS = [TYPE_SCC, TYPE_VTT, TYPE_TTML, TYPE_DFXP]
+
+  def initialize(cc_file)
     @cc_file = cc_file
-    @translator = translator
     raise "Invalid SRT file provided" unless is_valid?
   end
 
@@ -25,6 +29,11 @@ class SRT
     return false
   end
 
+  def set_translator(translator)
+    super(translator)
+    @translator = translator
+  end
+
   def translate(src_lang, dest_lang, out_file)
     super(src_lang, dest_lang, out_file)
     begin
@@ -60,7 +69,6 @@ class SRT
         outfile.puts
       end
     ensure
-      ccfile.close rescue nil
       outfile.close
     end
   end
@@ -76,6 +84,66 @@ class SRT
     [lang]
   end
 
+  def supported_transformations
+    return SUPPORTED_TRANSFORMATIONS
+  end
+
+  def transform_to(types, src_lang, target_lang, output_dir)
+    # Let's start off with some validations
+    super(types, src_lang, target_lang, output_dir)
+
+    # Suffix output dir with File seperator
+    output_dir = "#{output_dir}#{File::Separator}" unless output_dir.end_with?(File::Separator)
+    
+    # Prepare the output files for each type
+    file_map = {}
+    types.each do |type|
+      output_file = File.basename(@cc_file, File.extname(@cc_file)) + extension_from_type(type)
+      out_file = "#{output_dir}#{output_file}"
+      if create_file(TYPE_SRT, type, out_file, target_lang)
+        file_map[type] = out_file
+      else
+        raise StandardError.new("Failed to create output file for type #{type}")
+      end
+    end
+
+    # Read the file and prepare the cue model
+    cue_info = nil
+    ccfile = File.open(@cc_file, 'r:UTF-8', &:read)
+    message = ""
+    ccfile.each_line do | line |
+      # p line
+      next if line.strip.empty?
+      time_points = line.scan(/^((\d\d:)\d\d:\d\d[,.]\d\d\d.*)-->.*((\d\d:)\d\d:\d\d[,.]\d\d\d)/)
+      if time_points.empty?
+        # This is not a time point
+        seq = line.strip
+        if seq.to_i > 0
+          cue_info.message = message unless message.empty?
+          write_cue(cue_info, file_map) if cue_info
+          cue_info = CueInfo.new(TYPE_SRT)
+          cue_info.sequence = seq
+          # Reset the message
+          message = ""
+        else
+          # This is not a sequence number nor it's timepoints
+          # Grab the details until we find next cue point
+          message << line
+        end
+      else
+        # This is a cue point. Fetch timestamps
+        cue_info.start = time_points[0][0]
+        cue_info.end = time_points[0][2]
+        start_units = time_details(cue_info.start, TYPE_SRT)
+        end_units = time_details(cue_info.end, TYPE_SRT)
+        cue_info.start_time_units = start_units
+        cue_info.end_time_units = end_units
+      end
+    end
+    cue_info.message = message unless message.empty?
+    write_cue(cue_info, file_map, true)
+  end
+
   private 
 
   # 
@@ -103,4 +171,4 @@ class SRT
     end
     return text_sample[0, num_chars]
   end
-end
+end

data/lib/subtitle.rb

@@ -7,21 +7,29 @@ require_relative "allfather"
 require_relative "engines/translator"
 require_relative "engines/aws"
 
-
+#
+# Facade that wraps all the complexities surrounding which translation
+# engine to use or which caption instances to be instantiated.
+# 
 class Subtitle
-  def initialize(options={})
+
+  TYPE_MAP = {"scc" => AllFather::TYPE_SCC, "srt" => AllFather::TYPE_SRT, "vtt" => AllFather::TYPE_VTT, 
+              "ttml" => AllFather::TYPE_TTML, "dfxp" => AllFather::TYPE_DFXP}
+
+  def initialize(file, options = nil)
     # Infer the caption handler from the extension
-    @cc_file = options[:cc_file]
+    @cc_file = file
     raise "Input caption not provided. Please provide the same in :cc_file option" if @cc_file.nil?
-    translator = get_translator(options)
-    @handler = get_caption_handler(options, translator)
+    initialize_handler(options) unless options.nil?
   end
 
-  def detect_language
+  def detect_language(options = nil)
+    initialize_handler(options) if @handler.nil?
     @handler.infer_languages
   end
 
-  def translate(dest_lang, src_lang = nil, outfile = nil)
+  def translate(dest_lang, src_lang = nil, outfile = nil, options = nil)
+    initialize_handler(options) if @handler.nil?
     if outfile.nil?
       outfile = "#{@cc_file}_#{dest_lang}"
     end
@@ -33,13 +41,40 @@ class Subtitle
     outfile
   end
 
+  def transform(types, src_lang = nil, target_lang = nil, options = nil)
+    # A quick validation & translation to expected arguments
+    vals = []
+    invalid_vals = []
+    types.each do |type|
+      type_val = TYPE_MAP[type]
+      if type_val.nil?
+        invalid_vals << type
+        next
+      end
+      vals << type_val
+    end
+    unless invalid_vals.empty?
+      raise "Invalid types #{invalid_vals} provided"
+    end
+    # Translator not required if target_lang is nil
+    if @handler.nil?
+      if target_lang.nil?
+        @handler = get_caption_handler(options, nil) 
+      else
+        initialize_handler(options)
+      end
+    end
+    output_dir = options[:outfile]
+    @handler.transform_to(vals, src_lang, target_lang, output_dir)
+  end
+
   def type
     type = nil
     ccfile = File.open(@cc_file, 'r:UTF-8', &:read)
     ccfile.each_line do | line |
       if line =~ /^(\d\d:)\d\d:\d\d[,]\d\d\d.*-->.*(\d\d:)\d\d:\d\d[,]\d\d\d/
         type = "srt"
-      elsif line =~ /(^(\d\d:)\d\d:\d\d[.]\d\d\d.*-->.*(\d\d:)\d\d:\d\d[.]\d\d\d)|(^WEBVTT$)/
+      elsif line =~ /^((\d\d:)+\d\d[.,]\d\d\d)\s-->\s((\d\d:)+\d\d[.,]\d\d\d)|(^WEBVTT$)/
         type = "vtt"
       elsif line =~ /(^\d\d:\d\d:\d\d:\d\d\t(([0-9a-fA-F]{4})\s)*)+|(^Scenarist_SCC V(\d.\d)$)/
         type = "scc"
@@ -63,6 +98,11 @@ class Subtitle
 
   private
 
+  def initialize_handler(options)
+    translator = get_translator(options)
+    @handler = get_caption_handler(options, translator)
+  end
+
   def get_translator(options)
     translator = nil
     # Try to infer the engine based on the passed options
@@ -93,24 +133,26 @@ class Subtitle
   def get_caption_handler(options, translator)
     caption_file = options[:cc_file]
     extension = File.extname(caption_file)
+    extension = ".#{type}" if extension.nil?
     unless AllFather::VALID_FILES.include?(extension)
       raise "Caption support for #{caption_file} of type #{extension} is not supported yet" 
     end
     handler = nil
     case extension.downcase
     when ".scc"
-      handler = SCC.new(caption_file, translator)
+      handler = SCC.new(caption_file)
     when ".srt"
-      handler = SRT.new(caption_file, translator)
+      handler = SRT.new(caption_file)
     when ".vtt"
-      handler = VTT.new(caption_file, translator)
+      handler = VTT.new(caption_file)
     when ".ttml"
-      handler = TTML.new(caption_file, translator, {:force_detect => options[:force_detect]})
+      handler = TTML.new(caption_file)
     when ".dfxp"
-      handler = DFXP.new(caption_file, translator, {:force_detect => options[:force_detect]})
+      handler = DFXP.new(caption_file)
     else
       raise "Cannot handle file type .#{extension}"
     end
+    handler.set_translator(translator)
     handler
   end
 end

data/lib/ttml.rb

@@ -13,10 +13,8 @@ class TTML
 
   include AllFather
 
-  def initialize(cc_file, translator, opts={})
+  def initialize(cc_file)
     @cc_file = cc_file
-    @translator = translator
-    @force_detect = opts[:force_detect] || false
     raise "Invalid TTML file provided" unless is_valid?
   end
 
@@ -30,7 +28,12 @@ class TTML
     return false
   end
 
+  def set_translator(translator)
+    @translator = translator
+  end
+
   def infer_languages
+    force_detect =  false
     lang = []
     begin
       xml_file = File.open(@cc_file)
@@ -43,9 +46,9 @@ class TTML
         if inferred_lang.nil?
           # If lang is not provided in the caption, then override
           # force detect for inferrence
-          @force_detect = true
+          force_detect = true
         end
-        if @force_detect
+        if force_detect
           sample_text = get_text(div, 100)
           inferred_lang = @translator.infer_language(sample_text) rescue nil
           if inferred_lang.nil?

data/lib/utils/common_utils.rb

@@ -0,0 +1,329 @@
+require_relative "../allfather"
+require "nokogiri"
+
+module CommonUtils
+
+  CREDITS = "Credits: Autogenerated by subtitle Rubygem".freeze
+
+  SCC_DEFAULT_FRAME_RATE = ENV["SCC_DEFAULT_FRAME_RATE"] || 23.976
+
+  # 
+  # Method to create the file with basic header informations which can be 
+  # further updated with the transformed caption details by respective
+  # implementations
+  #
+  # * +src_type+      - Source caption type. Refer to AllFather::TYPE_SCC type constants
+  # * +dest_type+     - Target caption type. Refer to AllFather::TYPE_SCC type constants
+  # * +output_file+   - Creates this output_file to which type specific
+  #  information would be dumped into
+  # * +target_lang+   - Target lang of the output_file
+  #
+  # ==== Returns
+  # true if the file is created with right headers and false otherwise
+  #
+  def create_file(src_type, dest_type, output_file, target_lang)
+    file = nil
+    done = false
+    begin
+      # Create the file in overwrite mode
+      file = File.open(output_file, "w")
+
+      # Dump the initial info into the file to start off with
+      case dest_type
+      when AllFather::TYPE_SCC
+        file.write("Scenarist_SCC V1.0\n\n")
+
+      when AllFather::TYPE_SRT
+        file.write("NOTE #{CREDITS}\n\n")
+
+      when AllFather::TYPE_VTT
+        file.write("WEBVTT\n\n")
+        file.write("NOTE #{CREDITS}\n\n")
+
+      when AllFather::TYPE_TTML
+        target_lang ||= ""
+        # TODO: Move this to a template file and load from there !!
+        data = <<-EOF
+<tt xml:lang="" xmlns="http://www.w3.org/ns/ttml">
+  <head>
+    <metadata xmlns:ttm="http://www.w3.org/ns/ttml#metadata">
+      <ttm:desc>#{CREDITS}</ttm:desc>
+    </metadata>
+  </head>
+  <body>
+    <div xml:lang=\"#{target_lang}\">
+          EOF
+          file.write(data)
+
+      when AllFather::TYPE_DFXP
+        target_lang ||= ""
+        data = <<-EOF
+<tt xml:lang="" xmlns="http://www.w3.org/2004/11/ttaf1">
+  <head>
+    <meta xmlns:ttm="http://www.w3.org/2004/11/ttaf1#metadata">
+      <ttm:desc>#{CREDITS}</ttm:desc>
+    </meta>
+  </head>
+  <body>
+    <div xml:lang=\"#{target_lang}\">
+          EOF
+          file.write(data)
+      else
+        raise AllFather::InvalidInputException.new("Not a valid type; Failed to create output file for type #{type}")
+      end
+      done = true
+    ensure
+      file.close if file rescue nil
+    end
+    done
+  end
+
+  # 
+  # Method to return a valid extension for a given caption type
+  # Refer to `AllFather#VALID_FILES`
+  #
+  # * +type+  - Must be one of the valid type defined in `AllFather`
+  #
+  # ====Raises
+  # InvalidInputException if a valid type is not provided
+  #
+  def extension_from_type(type)
+    case type 
+    when AllFather::TYPE_SCC
+      return AllFather::VALID_FILES[0]
+    when AllFather::TYPE_SRT
+      return AllFather::VALID_FILES[1]
+    when AllFather::TYPE_VTT
+      return AllFather::VALID_FILES[2]
+    when AllFather::TYPE_TTML
+      return AllFather::VALID_FILES[3]
+    when AllFather::TYPE_DFXP
+      return AllFather::VALID_FILES[4]
+    else
+      raise AllFather::InvalidInputException.new("Not a valid type; Failed to create output file for type #{type}")
+    end
+  end
+
+  #
+  # Method to encode a text to SCC format
+  #
+  # * +free_text+ - Text that needs to be encoded
+  #
+  # ===== Returns
+  # The encoded string that can be added to SCC file
+  #
+  def scc_encode(free_text)
+    encoded_str = ""
+    count = 0
+    free_text.each_byte do |char|
+      count += 1
+      binval = char.to_s(2).count("1") % 2 == 0 ? (char.to_i | 128 ).to_s(2) : char.to_s(2)
+      encode_char = binval.to_i(2).to_s(16)
+      if ((count > 0) && (count % 2 == 0))
+        encoded_str << encode_char << " "
+      else
+        encoded_str << encode_char
+      end
+    end
+    encoded_str
+  end
+
+  #
+  # Method to return the cue info of the caption based on the model
+  # and target caption type which can be used by the caller's transformation routine
+  #
+  # * +model+         - `CueInfo` instance which is caption agnostic details of a cue
+  # * +target_type+   - The target type to which the new cue is to be generated 
+  # * +last_cue+      - true for last cue and false otherwise.
+  #
+  def new_cue(model, target_type, last_cue = false)
+    message = nil
+    case target_type
+    when AllFather::TYPE_SCC
+      start_unit = model.start_time_units
+      h = start_unit[0].to_s.rjust(2, "0")
+      m = start_unit[1].to_s.rjust(2, "0")
+      s = start_unit[2].to_s.rjust(2, "0")
+      ms = start_unit[3]
+      # Convert to Frames assuming a framerate of 23.976
+      # Pad 0 if frames is <= 9
+      frames = ((ms.to_f * SCC_DEFAULT_FRAME_RATE) / 1000.0).to_i.to_s.rjust(2, "0").to_i
+      # TODO: Might have to strip off non-english characters here
+      message = "#{h}:#{m}:#{s}:#{frames} " + scc_encode(model.message)
+    when AllFather::TYPE_VTT, AllFather::TYPE_SRT
+      start_unit = model.start_time_units
+      end_unit = model.end_time_units
+      message = ""
+      if model.sequence
+        message = model.sequence + "\n"
+      else
+        message = model.index.to_s + "\n"
+      end
+      delimiter_added = false
+      [start_unit, end_unit].each do |unit|
+        h = unit[0].to_s.rjust(2, "0")
+        m = unit[1].to_s.rjust(2, "0")
+        s = unit[2].to_s.rjust(2, "0")
+        ms = unit[3]
+        if ms < 100
+          ms = ms.to_s.rjust(3, "0")
+        end
+        if target_type == AllFather::TYPE_VTT
+          message << "#{h}:#{m}:#{s}:#{ms}"
+        else
+          message << "#{h}:#{m}:#{s},#{ms}"
+        end
+        unless delimiter_added
+          message << " --> "
+          delimiter_added = true
+        end
+      end
+      message << "\n"
+      message << model.message
+      message << "\n"
+      message << "\n" unless model.message.end_with?("\n")
+    when AllFather::TYPE_TTML, AllFather::TYPE_DFXP
+      start_unit = model.start_time_units
+      end_unit = model.end_time_units
+      h = start_unit[0].to_s.rjust(2, "0")
+      m = start_unit[1].to_s.rjust(2, "0")
+      s = start_unit[2].to_s.rjust(2, "0")
+      ms = start_unit[3]
+      begin_time = "#{h}:#{m}:#{s}"
+      begin_time << ".#{ms.to_s.rjust(3, "0")}" if ms > 0
+      h = end_unit[0].to_s.rjust(2, "0")
+      m = end_unit[1].to_s.rjust(2, "0")
+      s = end_unit[2].to_s.rjust(2, "0")
+      ms = end_unit[3]
+      end_time = "#{h}:#{m}:#{s}"
+      end_time << ".#{ms.to_s.rjust(3, "0")}" if ms > 0
+      message = "<p begin=\"#{begin_time}\" end=\"#{end_time}\">#{model.message.encode(:xml => :text)}</p>"
+      message << "</div>\n</body>\n</tt>" if last_cue
+    end
+    message
+  end
+
+  #
+  # Method that normalizes the timestamps from various different caption formats into 
+  # a caption agnostic format
+  #
+  # * +time_stamp+  - The timestamp parsed from the caption file for a given caption type
+  # * +type+        - A valid caption type. Refer to `AllFather` for valid types
+  #
+  def time_details(time_stamp, type)
+    h = m = s = ms = nil
+    elapsed_seconds = nil
+    case type 
+    when AllFather::TYPE_SCC
+      tokens = time_stamp.split(":")
+      h = tokens[0].to_i
+      m = tokens[1].to_i
+      s = tokens[2].to_i
+      frames = tokens[3].to_i
+      ms = (frames * 1000 / SCC_DEFAULT_FRAME_RATE).round(0).to_s.rjust(3, "0").to_i
+      if ms >= 1000
+        ms = 999
+      end
+    when AllFather::TYPE_SRT
+      tokens = time_stamp.split(",")
+      ms = tokens[1].to_i
+      tokens = tokens[0].split(":")
+      h = tokens[0].to_i
+      m = tokens[1].to_i
+      s = tokens[2].to_i
+    when AllFather::TYPE_VTT
+      tokens = time_stamp.split(".")
+      ms = tokens[1].to_i
+      tokens = tokens[0].split(":")
+      if tokens.size == 2
+        h = 0
+        m = tokens[0].to_i
+        s = tokens[1].to_i
+      else
+        h = tokens[0].to_i
+        m = tokens[1].to_i
+        s = tokens[2].to_i
+      end
+    when AllFather::TYPE_TTML, AllFather::TYPE_DFXP
+      # We support only clock-time without framerate / tickrate and only media timebase
+      # For offset hence we don't support frames / ticks
+      tokens = time_stamp.split(":")
+      if tokens.size > 1
+        if tokens.size > 3
+          # This is specified with frames and/or subframes. Unsupported
+          raise AllFather::InvalidInputException.new("TTML file with clock-time referencing frames / ticks is unsupported")
+        end
+        h = tokens[0].to_i
+        m = tokens[1].to_i
+        ms_tokens = tokens[2].split(".")
+        if ms_tokens.size == 1
+          ms = 0
+        else
+          ms = ms_tokens[1].to_i
+        end
+        s = ms_tokens[0].to_i
+      else
+        # Parsing in offset mode
+        if time_stamp.end_with?("ms")
+          unit = "ms"
+          time_with_no_unit = time_stamp[0, time_stamp.size - 2]
+        else
+          unit = time_stamp[time_stamp.size - 1]
+          time_with_no_unit = time_stamp[0, time_stamp.size - 1]
+        end
+        case unit 
+        when "m"
+          time_with_no_unit = time_with_no_unit.to_f * 60
+        when "h"
+          time_with_no_unit = time_with_no_unit.to_f * (60 * 60)
+        when "s"
+          # do nothing
+        when "ms"
+          time_with_no_unit = time_with_no_unit.to_f / 1000.0
+        else
+          # Fail out f / t
+          raise AllFather::InvalidInputException.new("TTML file with offset-time referencing frames / ticks is unsupported")
+        end
+        tokens = time_with_no_unit.to_s.split(".")
+        h = m = 0
+        if tokens.size == 1
+          s = time_with_no_unit
+          ms = 0
+        else
+          s = tokens[0].to_i
+          ms = tokens[1].to_i
+        end
+        h = s / 3600
+        m = (s / 60) % 60
+        s = s % 60
+      end
+    end
+    elapsed_seconds = (h * 60 * 60) + (m * 60) + s
+    return [h, m, s, ms, elapsed_seconds]
+  end
+
+
+  # 
+  # Method to write the cue details to the output files
+  #
+  # * +model+     - Cue instance
+  # * +file_map+  - Hash of files for each caption type
+  # * +last_cue+  - true for last cue and false otherwise
+  #  
+  def write_cue(model, file_map, last_cue = false)
+    file_map.each do |type, file_path|
+      File.open(file_path, "a") do |f|
+        f.puts new_cue(model, type, last_cue)
+      end
+    end
+    if last_cue
+      # Pretty print the output for ttml & dfxp
+      file_map.each do |type, file_path|
+        next unless [AllFather::TYPE_DFXP, AllFather::TYPE_TTML].include?(type)
+        file = File.open(file_path, "r")
+        xml_doc = Nokogiri::XML(file, &:noblanks)
+        File.write(file_path, xml_doc.to_s)
+      end
+    end
+  end
+end

data/lib/utils/cue_info.rb

@@ -0,0 +1,40 @@
+class CueInfo
+  def initialize(type)
+    @type = type
+    @start = @end = @sequence = nil
+    @message = ""
+    @start_time_units = []
+    @end_time_units = []
+    @index = 1
+  end
+
+  attr_reader :type, :start, :end, :sequence, :message, :start_time_units, :end_time_units, :index
+
+  def start=(start)
+    @start = start 
+  end
+
+  def end=(end_point)
+    @end = end_point
+  end
+
+  def message=(msg)
+    @message = msg 
+  end
+
+  def sequence=(seq)
+    @sequence = seq 
+  end
+
+  def index=(index)
+    @index = index
+  end
+
+  def start_time_units=(units)
+    @start_time_units = units
+  end
+
+  def end_time_units=(units)
+    @end_time_units = units 
+  end
+end

data/lib/vtt.rb

@@ -1,4 +1,6 @@
 require_relative "engines/translator"
+require_relative "utils/common_utils"
+require_relative "utils/cue_info"
 require_relative "allfather"
 
 #
@@ -10,13 +12,20 @@ require_relative "allfather"
 class VTT
 
   include AllFather
+  include CommonUtils
 
-  def initialize(cc_file, translator)
+  SUPPORTED_TRANSFORMATIONS = [TYPE_SCC, TYPE_SRT, TYPE_TTML, TYPE_DFXP]
+
+  def initialize(cc_file)
     @cc_file = cc_file
-    @translator = translator
     raise "Invalid VTT file provided" unless is_valid?
   end
 
+  def set_translator(translator)
+    super(translator)
+    @translator = translator
+  end
+
   def translate(src_lang, dest_lang, out_file)
     super(src_lang, dest_lang, out_file)
     begin
@@ -53,7 +62,6 @@ class VTT
         outfile.puts
       end
     ensure
-      ccfile.close rescue nil
       outfile.close
     end
   end
@@ -85,6 +93,69 @@ class VTT
     return false
   end
 
+  def supported_transformations
+    return SUPPORTED_TRANSFORMATIONS
+  end
+
+  def transform_to(types, src_lang, target_lang, output_dir)
+    # Let's start off with some validations
+    super(types, src_lang, target_lang, output_dir)
+
+    # Suffix output dir with File seperator
+    output_dir = "#{output_dir}#{File::Separator}" unless output_dir.end_with?(File::Separator)
+    
+    # Prepare the output files for each type
+    file_map = {}
+    types.each do |type|
+      output_file = File.basename(@cc_file, File.extname(@cc_file)) + extension_from_type(type)
+      out_file = "#{output_dir}#{output_file}"
+      if create_file(TYPE_VTT, type, out_file, target_lang)
+        file_map[type] = out_file
+      else
+        raise StandardError.new("Failed to create output file for type #{type}")
+      end
+    end
+
+    # Read the file and prepare the cue model
+    cue_info = nil
+    ccfile = File.open(@cc_file, 'r:UTF-8', &:read)
+    message = ""
+    collect_msg = false
+    cue_index = 1
+    ccfile.each_line do | line |
+      if line.strip.empty?
+        collect_msg = false
+        next 
+      end
+      time_points = line.scan(/^((\d\d:)+\d\d[.,]\d\d\d)\s-->\s((\d\d:)+\d\d[.,]\d\d\d)/)
+      if time_points.empty?
+        if collect_msg
+          message << line
+        end
+      else
+        collect_msg = false
+        unless message.empty?
+          cue_info.message = message 
+          write_cue(cue_info, file_map)
+          message = ""
+          cue_index += 1
+        end
+        # This is a cue point. Fetch timestamps
+        cue_info = CueInfo.new(AllFather::TYPE_VTT)
+        cue_info.index = cue_index
+        cue_info.start = time_points[0][0]
+        cue_info.end = time_points[0][2]
+        start_units = time_details(cue_info.start, TYPE_VTT)
+        end_units = time_details(cue_info.end, TYPE_VTT)
+        cue_info.start_time_units = start_units
+        cue_info.end_time_units = end_units
+        collect_msg = true
+      end
+    end
+    cue_info.message = message unless message.empty?
+    write_cue(cue_info, file_map, true)
+  end
+
   private 
 
   # 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: subtitle
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.3.0
 platform: ruby
 authors:
 - Maheshwaran G
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-11 00:00:00.000000000 Z
+date: 2019-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -67,6 +67,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: optimist
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Subtitle gem helps you to detect language and translate closed caption
   to required language.
 email:
@@ -85,6 +113,8 @@ files:
 - lib/srt.rb
 - lib/subtitle.rb
 - lib/ttml.rb
+- lib/utils/common_utils.rb
+- lib/utils/cue_info.rb
 - lib/vtt.rb
 homepage: https://github.com/cloudaffair/subtitle
 licenses: