subconv 0.1.0

data/lib/subconv/scc/transformer.rb

@@ -0,0 +1,259 @@
+require 'subconv/utility'
+require 'subconv/caption'
+
+module Subconv
+  module Scc
+    # Transform an array of caption grids parsed from SCC into an array of captions
+    # with the caption content converted to a tree of text and style nodes
+    class Transformer
+      # Perform the transformation
+      # Continuous text blocks are collected in each caption grid and merged
+      # Empty grids will end the previously displayed caption
+      def transform(captions)
+        transformed_captions = []
+        return [] if captions.empty?
+
+        # Use fps from Scc
+        fps = captions.first.timecode.fps
+        last_time = Timecode.new(0, fps)
+
+        captions_open = []
+        captions.each do |caption|
+          if caption.grid.nil? || !captions_open.empty?
+            # Close any captions that might be displayed
+            captions_open.each do |caption_to_close|
+              caption_to_close.timespan = Utility::Timespan.new(last_time.dup, caption.timecode.dup)
+            end
+            transformed_captions.concat captions_open
+            # All captions are closed now
+            captions_open = []
+          end
+
+          unless caption.grid.nil?
+            # Collect text chunks in each row and create captions out of them
+            caption.grid.each_with_index do |row, row_number|
+              chunks = collect_chunks(row)
+              chunks.each_pair do |start_column, chunk|
+                content = transform_chunk(chunk)
+                position = position_from_grid(row_number, start_column)
+                captions_open.push(Subconv::Caption.new(
+                                     align:    :start,
+                                     position: position,
+                                     content:  content
+                ))
+              end
+            end
+
+            # Merge continuous rows?
+            # captions_open.each do |caption_open|
+            #
+            # end
+          end
+
+          last_time = caption.timecode
+        end
+
+        unless captions_open.empty?
+          # Close any captions that are still open at the end
+          captions_open.each do |caption_to_close|
+            caption_to_close.timespan = Utility::Timespan.new(last_time.dup, last_time + Timecode.from_seconds(5, fps))
+          end
+          transformed_captions.concat captions_open
+        end
+
+        transformed_captions
+      end
+
+      private
+
+      # Properties in order of priority (first element has the highest priority)
+      # The priority indicates in what order new style nodes should be created when their order
+      # would be indeterminate otherwise. This is required for getting deterministic output.
+      PROPERTIES = %i(color underline italics flash).freeze
+
+      # Get the relative priority of a property
+      def property_priority(property)
+        # First property has the highest priority
+        highest_property_priority - PROPERTIES.find_index(property)
+      end
+
+      # Get the highest possible property priority
+      def highest_property_priority
+        PROPERTIES.length - 1
+      end
+
+      # Map of properties to the corresponding Ruby class
+      PROPERTY_CLASS_MAP = {
+        color:     ColorNode,
+        italics:   ItalicsNode,
+        underline: UnderlineNode,
+        flash:     FlashNode
+      }.freeze
+
+      # Collect all continuous character groups in a row
+      # Input: Grid row as array of Scc::Character instances
+      # Output: Hash with the starting column index as key and Scc::Character array as value
+      def collect_chunks(row)
+        chunks = {}
+
+        collecting = false
+        start_column = 0
+        current_chunk = []
+        row.each_with_index do |column, index|
+          if collecting
+            if column.nil?
+              # Stop collecting, write out chunk
+              collecting = false
+              chunks[start_column] = current_chunk
+              current_chunk = []
+            else
+              # Stay collecting
+              current_chunk.push(column)
+            end
+          else
+            unless column.nil?
+              # Start collecting
+              collecting = true
+              current_chunk.push(column)
+              # Remember first column
+              start_column = index
+            end
+          end
+        end
+
+        # Write out last chunk if still open
+        chunks[start_column] = current_chunk if collecting
+
+        chunks
+      end
+
+      # Convert a grid coordinate to a relative screen position inside the video
+      def position_from_grid(row, column)
+        # TODO: Handle different aspect ratios
+        # The following is only (presumably) true for 16:9 video
+        Position.new(((column.to_f / Scc::GRID_COLUMNS) * 0.8 + 0.1) * 0.75 + 0.125, (row.to_f / Scc::GRID_ROWS) * 0.8 + 0.1)
+      end
+
+      # Transform one chunk of Scc::Character instances into text and style nodes
+      # The parser goes through each character sequentially, opening and closing style nodes as necessary on the way
+      def transform_chunk(chunk)
+        default_style = CharacterStyle.default
+        # Start out with the default style
+        current_style = CharacterStyle.default
+        current_text  = ''
+        # Start with a stack of just the root node
+        parent_node_stack = [RootNode.new]
+
+        chunk.each_with_index do |column, column_index|
+          # Gather the style properties that are different
+          differences = style_differences(current_style, column.style)
+
+          # Adjust the style by opening/closing nodes if there are any differences
+          unless differences.empty?
+            # Finalize currently open text node
+            unless current_text.empty?
+              # Insert text node into the children of the node on top of the stack
+              parent_node_stack.last.children.push(TextNode.new(current_text))
+              current_text = ''
+            end
+
+            # First close any nodes whose old value was different from the default value and has now changed
+            differences_to_close = differences & style_differences(current_style, default_style)
+
+            unless differences_to_close.empty?
+              # Find topmost node that corresponds to any of the differences to close
+              first_matching_node_index = parent_node_stack.find_index { |node|
+                differences_to_close.any? { |difference| node.instance_of?(node_class_for_property(difference)) }
+              }
+
+              fail 'No node for property to close found in stack' if first_matching_node_index.nil?
+
+              # Collect styles below it that should _not_ be closed for possible re-opening because they would otherwise get lost
+              reopen = parent_node_stack[first_matching_node_index..-1].select { |node|
+                !differences_to_close.any? { |difference| node.instance_of?(node_class_for_property(difference)) }
+              }.map { |node| property_for_node_class(node.class) }
+
+              # Add them to the differences (since the current style changed from what was assumed above)
+              differences += reopen
+
+              # Delete the matched node and all following nodes from the stack
+              parent_node_stack.pop(parent_node_stack.length - first_matching_node_index)
+            end
+
+            # Values that are different from both the former style and the default style must result in a new node
+            differences_to_open = differences & style_differences(column.style, default_style)
+
+            # Calculate how long each style persists
+            continuous_lengths = Hash[differences_to_open.map { |property|
+                                        length = 1
+                                        value_now = column.style.send(property)
+                                        (column_index + 1...chunk.length).each do |check_column_index|
+                                          break if chunk[check_column_index].style.send(property) != value_now
+                                          length += 1
+                                        end
+                                        # Sort first by length, then by property priority
+                                        [property, length * (highest_property_priority + 1) + property_priority(property)]
+                                      }]
+            # Sort new nodes by the length this style persists
+            differences_to_open.sort_by! do |property| continuous_lengths[property] end
+            differences_to_open.reverse!
+
+            # Open new nodes
+            differences_to_open.each do |property|
+              value = column.style.send(property)
+              new_node = node_from_property(property, value)
+              # Insert into currently active parent node
+              parent_node_stack.last.children.push(new_node)
+              # Push onto stack
+              parent_node_stack.push(new_node)
+            end
+
+            current_style = column.style
+          end
+
+          # Always add the character to the current text after adjusting the style if necessary
+          current_text << column.character
+        end
+
+        # Add any leftover text
+        unless current_text.empty?
+          parent_node_stack.last.children.push(TextNode.new(current_text))
+        end
+        # Return the root node
+        parent_node_stack.first
+      end
+
+      # Get the Ruby class for a given property (symbol)
+      def node_class_for_property(property)
+        PROPERTY_CLASS_MAP.fetch(property)
+      end
+
+      # Get the property (symbol) for a given Ruby class
+      def property_for_node_class(node_class)
+        PROPERTY_CLASS_MAP.invert.fetch(node_class)
+      end
+
+      # Create a Ruby node instance from a given property (symbol) and the property value
+      def node_from_property(property, value)
+        property_class = node_class_for_property(property)
+        if property_class == ColorNode
+          ColorNode.new(value.to_symbol)
+        else
+          fail 'Cannot create boolean property node for property off' unless value
+          property_class.new
+        end
+      end
+
+      # Determine all properties (as array of symbols) that are different between the
+      # Scc::CharacterStyle instances a and b
+      def style_differences(a, b)
+        PROPERTIES.select { |property|
+          value_a = a.send(property)
+          value_b = b.send(property)
+
+          value_a != value_b
+        }
+      end
+    end
+  end
+end

data/lib/subconv/utility.rb

@@ -0,0 +1,42 @@
+module Subconv
+  module Utility
+    class InvalidTimespanError < RuntimeError; end
+
+    class Timespan
+      def initialize(start_time, end_time)
+        @start_time = start_time
+        @end_time = end_time
+        fail InvalidTimespanError, 'Timespan end time is before start time' if @end_time < @start_time
+        fail InvalidTimespanError, 'Timespan is empty' if @start_time == @end_time
+      end
+
+      def ==(other)
+        self.class == other.class && @start_time == other.start_time && @end_time == other.end_time
+      end
+
+      attr_reader :start_time, :end_time
+    end
+
+    def self.clamp(value, min, max)
+      return min if value < min
+      return max if value > max
+      value
+    end
+
+    def self.node_to_tree_string(node, level = 0)
+      node_text = node.class.to_s
+      if node.is_a?(TextNode)
+        node_text << " \"#{node.text}\""
+      elsif node.is_a?(ColorNode)
+        node_text << " #{node.color}"
+      end
+      result = "\t" * level + node_text + "\n"
+      if node.is_a?(ContainerNode)
+        node.children.each { |child|
+          result << node_to_tree_string(child, level + 1)
+        }
+      end
+      result
+    end
+  end
+end

data/lib/subconv/version.rb

@@ -0,0 +1,3 @@
+module Subconv
+  VERSION = '0.1.0'.freeze
+end

data/lib/subconv/webvtt/writer.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+require 'subconv/utility'
+require 'subconv/caption'
+
+module Subconv
+  module WebVtt
+    FILE_MAGIC = 'WEBVTT'.freeze
+
+    TIMECODE_FORMAT = '%02d:%02d:%02d.%03d'.freeze
+    CUE_FORMAT = '%{start_time} --> %{end_time} %{settings}'.freeze
+
+    # WebVTT caption writer
+    class Writer
+      def initialize(options = {})
+        @options = options
+      end
+
+      # Write captions to an IO stream
+      # captions must be an array of Caption instances
+      def write(io, captions)
+        io.write(FILE_MAGIC + "\n\n")
+
+        captions.each do |caption|
+          write_caption(io, caption)
+        end
+      end
+
+      # Write a single Scc::Caption to an IO stream
+      def write_caption(io, caption)
+        settings = {
+          'align' => caption.align.to_s
+        }
+        if caption.position.is_a?(Position)
+          settings['line'] = webvtt_percentage(caption.position.y)
+          settings['position'] = webvtt_percentage(caption.position.x)
+        else
+          settings['line'] = case caption.position
+                             when :top
+                               # '0' would be better here, but Chrome does not support that yet
+                               '5%'
+                             when :bottom
+                               '-1,end'
+                             else
+                               fail "Unknown position #{caption.position}"
+                             end
+        end
+
+        # Remove align if it is the default value anyway
+        settings.delete('align') if settings['align'] == 'middle'
+
+        # Convert settings to string representation
+        settings_string = settings.map { |setting|
+          setting.join(':')
+        }.join(' ')
+
+        io.write(CUE_FORMAT % {
+          start_time: timecode_to_webvtt(caption.timespan.start_time),
+          end_time:   timecode_to_webvtt(caption.timespan.end_time),
+          settings:   settings_string
+        } + "\n")
+        text = node_to_webvtt_markup caption.content
+        if @options[:trim_line_whitespace]
+          # Trim leading and trailing whitespace from each line
+          text = text.split("\n").each(&:strip!).join("\n")
+        end
+        io.write "#{text}\n\n"
+      end
+
+      private
+
+      # Format a value between 0 and 1 as percentage with 3 digits behind the decimal point
+      def webvtt_percentage(value)
+        format('%.3f%%', (value * 100.0))
+      end
+
+      # Convert a timecode to the h/m/s format required by WebVTT
+      def timecode_to_webvtt(time)
+        value = time.to_seconds
+
+        milliseconds = ((value * 1000) % 1000).to_i
+        seconds      =  value.to_i % 60
+        minutes      = (value.to_i / 60) % 60
+        hours        =  value.to_i / 60 / 60
+
+        format(TIMECODE_FORMAT, hours, minutes, seconds, milliseconds)
+      end
+
+      # Replace WebVTT special characters in the text
+      def escape_text(text)
+        text = text.dup
+        text.gsub!('&', '&')
+        text.gsub!('<', '&lt;')
+        text.gsub!('>', '&rt;')
+        text
+      end
+
+      # Convert an array of nodes to their corresponding WebVT markup
+      def nodes_to_webvtt_markup(nodes)
+        nodes.map { |node| node_to_webvtt_markup(node) }.join
+      end
+
+      # Convert one node to its corresponding WebVTT markup
+      # Conversion is very straightforward. Container nodes are converted recursively by calling
+      # nodes_to_webvtt_markup from within this function. Recursion depth should not be a problem
+      # since their are not that many different properties.
+      def node_to_webvtt_markup(node)
+        # Text nodes just need to have their text converted
+        return escape_text(node.text) if node.instance_of?(TextNode)
+
+        # If it is not a text node, it must have children
+        children = nodes_to_webvtt_markup(node.children)
+
+        # Use an array because the === operator of Class does not work as expected (Array === Array is false)
+        case [node.class]
+        when [RootNode]
+          children
+        when [ItalicsNode]
+          '<i>' + children + '</i>'
+        when [UnderlineNode]
+          '<u>' + children + '</u>'
+        when [FlashNode]
+          '<c.blink>' + children + '</c>'
+        when [ColorNode]
+          '<c.' + node.color.to_s + '>' + children + '</c>'
+        else
+          fail "Unknown node class #{node.class}"
+        end
+      end
+    end
+  end
+end

data/spec/caption_filter_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+
+module Subconv
+  describe CaptionFilter do
+    include TestHelpers
+
+    it 'should not do anything by default' do
+      expected, captions = caption_filter_process({}) { caption_all_node_types }
+      expect(captions).to eq(expected)
+    end
+
+    it 'should remove color nodes' do
+      expected, captions = caption_filter_process(remove_color: true) { caption_all_node_types }
+      expected[0].content.children[0] = TextNode.new('1')
+      expect(captions).to eq(expected)
+    end
+
+    it 'should remove flash nodes' do
+      expected, captions = caption_filter_process(remove_flash: true) { caption_all_node_types }
+      expected[0].content.children[1] = TextNode.new('2')
+      expect(captions).to eq(expected)
+    end
+
+    it 'should remove color and flash nodes' do
+      expected, captions = caption_filter_process(remove_color: true, remove_flash: true) { caption_all_node_types }
+      expected[0].content.children[0] = TextNode.new('12')
+      expected[0].content.children.delete_at 1
+      expect(captions).to eq(expected)
+    end
+
+    it 'should remove nodes recursively' do
+      captions = single_caption_with_content([
+        TextNode.new('a'),
+        ItalicsNode.new([
+          ColorNode.new(:blue, [
+            TextNode.new('b'),
+            FlashNode.new([
+              TextNode.new('c'),
+              UnderlineNode.new([
+                TextNode.new('de')
+              ])
+            ])
+          ]),
+          ColorNode.new(:cyan, [
+            UnderlineNode.new([
+              TextNode.new('f')
+            ])
+          ])
+        ])
+      ])
+      CaptionFilter.new(remove_color: true, remove_flash: true).process!(captions)
+      expected = single_caption_with_content([
+        TextNode.new('a'),
+        ItalicsNode.new([
+          TextNode.new('bc'),
+          UnderlineNode.new([
+            TextNode.new('de')
+          ]),
+          UnderlineNode.new([
+            TextNode.new('f')
+          ])
+        ])
+      ])
+      expect(captions).to eq(expected)
+    end
+
+    context 'when converting XY positions to simple top/bottom centered positions' do
+      it 'should remove the X position' do
+        expected, captions = caption_filter_process(xy_position_to_top_or_bottom: true) {
+          [
+            Caption.new(timespan: t1_2, position: Position.new(0.1, 0.1), content: root_with_text('Test 1'), align: :start),
+            Caption.new(timespan: t2_3, position: Position.new(0.1, 0.7), content: root_with_text('Test 2'), align: :start)
+          ]
+        }
+        expected[0].position = :top
+        expected[1].position = :bottom
+        expected[0].align = :middle
+        expected[1].align = :middle
+        expect(captions).to eq(expected)
+      end
+
+      it 'should support simultaneous top and bottom captions' do
+        expected, captions = caption_filter_process(xy_position_to_top_or_bottom: true) {
+          [
+            Caption.new(timespan: t1_2, position: Position.new(0.1, 0.1), content: root_with_text('Test 1'), align: :start),
+            Caption.new(timespan: t1_2, position: Position.new(0.1, 0.7), content: root_with_text('Test 2'), align: :start)
+          ]
+        }
+        expected[0].position = :top
+        expected[1].position = :bottom
+        expected[0].align = :middle
+        expected[1].align = :middle
+        expect(captions).to eq(expected)
+      end
+
+      it 'should not split continuous on-screen lines starting in the top region to top and bottom' do
+        expected, captions = caption_filter_process(xy_position_to_top_or_bottom: true) {
+          [
+            Caption.new(timespan: t1_2, position: Position.new(0.1, 0.49), content: root_with_text('Test 1'), align: :start),
+            Caption.new(timespan: t1_2, position: Position.new(0.1, 0.51), content: root_with_text('Test 2'), align: :start),
+            Caption.new(timespan: t2_3, position: Position.new(0.1, 0.52), content: root_with_text('Test 2'), align: :start)
+          ]
+        }
+        expected[0].position = :top
+        expected[1].position = :top
+        expected[2].position = :bottom
+        expected[0].align = :middle
+        expected[1].align = :middle
+        expected[2].align = :middle
+        expect(captions).to eq(expected)
+      end
+
+      it 'should merge captions in the same region when requested' do
+        expected, captions = caption_filter_process(xy_position_to_top_or_bottom: true, merge_by_position: true) {
+          [
+            Caption.new(timespan: t1_2, position: Position.new(0.1, 0.1), content: root_with_text('Test 1'), align: :start),
+            Caption.new(timespan: t1_2, position: Position.new(0.1, 0.2), content: root_with_text('Test 2'), align: :start),
+            Caption.new(timespan: t1_2, position: Position.new(0.1, 0.7), content: root_with_text('Test 3'), align: :start),
+            Caption.new(timespan: t1_2, position: Position.new(0.1, 0.8), content: root_with_text('Test 4'), align: :start)
+          ]
+        }
+        expected.delete_at 1
+        expected.delete_at 2
+        expected[0].position = :top
+        expected[1].position = :bottom
+        expected[0].content.children[0].text = "Test 1\nTest 2"
+        expected[1].content.children[0].text = "Test 3\nTest 4"
+        expected[0].align = :middle
+        expected[1].align = :middle
+        expect(captions).to eq(expected)
+      end
+
+      it 'should not merge captions with different timecodes' do
+        expected, captions = caption_filter_process(xy_position_to_top_or_bottom: true, merge_by_position: true) {
+          [
+            Caption.new(timespan: t1_2, position: Position.new(0.1, 0.1), content: root_with_text('Test 1'), align: :start),
+            Caption.new(timespan: t1_2, position: Position.new(0.1, 0.6), content: root_with_text('Test 2'), align: :start),
+            Caption.new(timespan: t2_3, position: Position.new(0.1, 0.7), content: root_with_text('Test 3'), align: :start),
+            Caption.new(timespan: t2_3, position: Position.new(0.1, 0.8), content: root_with_text('Test 4'), align: :start)
+          ]
+        }
+        expected.delete_at 3
+        expected[0].position = :top
+        expected[1].position = :bottom
+        expected[2].position = :bottom
+        expected[2].content.children[0].text = "Test 3\nTest 4"
+        expected[0].align = :middle
+        expected[1].align = :middle
+        expected[1].align = :middle
+        expect(captions).to eq(expected)
+      end
+    end
+  end
+end