subconv 0.1.0 → 1.0.0

data/lib/subconv/scc/transformer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'subconv/utility'
 require 'subconv/caption'
 
@@ -29,25 +31,18 @@ module Subconv
             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
+          # 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
-
-            # Merge continuous rows?
-            # captions_open.each do |caption_open|
-            #
-            # end
           end
 
           last_time = caption.timecode
@@ -64,12 +59,41 @@ module Subconv
         transformed_captions
       end
 
+      # Transform paint-on captions to pop-on captions by combining successive captions that only add text.
+      # As soon as text is removed or text that is already on-screen is changed, a caption is produced.
+      def combine_paint_on_captions(captions)
+        first_paint_on_caption = nil
+        last_paint_on_caption = nil
+        # Insert nil pseudo-element at end for flushing
+        (captions + [nil]).each_with_object([]) do |caption, result_captions|
+          if caption&.paint_on_mode?
+            first_paint_on_caption ||= caption
+            # Detect when characters disappear/change; until then: skip all paint-on captions (that just add text).
+            # At the same time, always produce a cue for empty grids so explicit display clears do not get lost.
+            # Simple character replacement cues that replace standard characters with extended ones should also never trigger a new caption.
+            if !last_paint_on_caption.nil? && !caption.char_replacement? && (!require_grid_object(last_paint_on_caption.grid).without_identical_characters(require_grid_object(caption.grid)).empty? || last_paint_on_caption.grid.nil?)
+              # Take timecode from the first caption of the current batch, but the grid from the current caption
+              result_captions << Scc::Caption.new(timecode: first_paint_on_caption.timecode, grid: last_paint_on_caption.grid, mode: :pop_on)
+              # Caption produced, so this marks a new segment
+              first_paint_on_caption = caption
+            end
+            last_paint_on_caption = caption
+          else
+            # Flush out last paint-on caption if necessary
+            result_captions << Scc::Caption.new(timecode: first_paint_on_caption.timecode, grid: last_paint_on_caption.grid, mode: :pop_on) unless first_paint_on_caption.nil?
+            first_paint_on_caption = nil
+            last_paint_on_caption = nil
+            result_captions << caption unless caption.nil?
+          end
+        end
+      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
+      PROPERTIES = %i[color underline italics flash].freeze
 
       # Get the relative priority of a property
       def property_priority(property)
@@ -140,7 +164,7 @@ module Subconv
         default_style = CharacterStyle.default
         # Start out with the default style
         current_style = CharacterStyle.default
-        current_text  = ''
+        current_text  = +''
         # Start with a stack of just the root node
         parent_node_stack = [RootNode.new]
 
@@ -154,7 +178,7 @@ module Subconv
             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 = ''
+              current_text = +''
             end
 
             # First close any nodes whose old value was different from the default value and has now changed
@@ -169,9 +193,10 @@ module Subconv
               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) }
+              reopen_node_classes = parent_node_stack[first_matching_node_index..-1].reject { |node|
+                differences_to_close.any? { |difference| node.instance_of?(node_class_for_property(difference)) }
+              }
+              reopen = reopen_node_classes.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
@@ -189,6 +214,7 @@ module Subconv
                                         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
@@ -216,9 +242,7 @@ module Subconv
         end
 
         # Add any leftover text
-        unless current_text.empty?
-          parent_node_stack.last.children.push(TextNode.new(current_text))
-        end
+        parent_node_stack.last.children.push(TextNode.new(current_text)) unless current_text.empty?
         # Return the root node
         parent_node_stack.first
       end
@@ -240,20 +264,27 @@ module Subconv
           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)
+      # Scc::CharacterStyle instances style_a and style_b
+      def style_differences(style_a, style_b)
+        PROPERTIES.reject { |property|
+          value_a = style_a.send(property)
+          value_b = style_b.send(property)
 
-          value_a != value_b
+          value_a == value_b
         }
       end
+
+      # Shorthand for creating an empty grid if it is nil (in case the grid object is required).
+      # Grids can be nil on Scc::Caption instances when the grid would be empty
+      def require_grid_object(grid)
+        grid || Scc::Grid.new
+      end
     end
   end
 end

data/lib/subconv/utility.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Subconv
   module Utility
     class InvalidTimespanError < RuntimeError; end
@@ -20,11 +22,12 @@ module Subconv
     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
+      node_text = node.class.to_s.dup
       if node.is_a?(TextNode)
         node_text << " \"#{node.text}\""
       elsif node.is_a?(ColorNode)

data/lib/subconv/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Subconv
-  VERSION = '0.1.0'.freeze
+  VERSION = '1.0.0'
 end

data/lib/subconv/webvtt/writer.rb

@@ -1,13 +1,14 @@
 # frozen_string_literal: true
+
 require 'subconv/utility'
 require 'subconv/caption'
 
 module Subconv
   module WebVtt
-    FILE_MAGIC = 'WEBVTT'.freeze
+    FILE_MAGIC = 'WEBVTT'
 
-    TIMECODE_FORMAT = '%02d:%02d:%02d.%03d'.freeze
-    CUE_FORMAT = '%{start_time} --> %{end_time} %{settings}'.freeze
+    TIMECODE_FORMAT = '%02d:%02d:%02d.%03d'
+    CUE_FORMAT = '%<start_time>s --> %<end_time>s %<settings>s'
 
     # WebVTT caption writer
     class Writer
@@ -27,37 +28,9 @@ module Subconv
 
       # 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
+        settings = settings_to_string(caption_settings(caption))
 
-        # 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")
+        io.write(format(CUE_FORMAT, start_time: timecode_to_webvtt(caption.timespan.start_time), end_time: timecode_to_webvtt(caption.timespan.end_time), settings: settings) + "\n")
         text = node_to_webvtt_markup caption.content
         if @options[:trim_line_whitespace]
           # Trim leading and trailing whitespace from each line
@@ -73,6 +46,44 @@ module Subconv
         format('%.3f%%', (value * 100.0))
       end
 
+      # Convert simple top/bottom positions to their corresponding WebVTT setting
+      def webvtt_simple_position(position)
+        case position
+        when :top
+          # '0' would be better here, but Chrome does not support that yet
+          '5%'
+        when :bottom
+          '-1,end'
+        else
+          fail ArgumentError, "Unknown position #{caption.position}"
+        end
+      end
+
+      # Convert WebVTT cue settings from a caption
+      def caption_settings(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'] = webvtt_simple_position(caption.position)
+        end
+
+        # Remove align if it is the default value anyway
+        settings.delete('align') if settings['align'] == 'middle'
+
+        settings
+      end
+
+      # Convert a setting hash to the WebVTT settings string
+      def settings_to_string(settings)
+        settings.map { |setting|
+          setting.join(':')
+        }.join(' ')
+      end
+
       # Convert a timecode to the h/m/s format required by WebVTT
       def timecode_to_webvtt(time)
         value = time.to_seconds

data/spec/.rubocop.yml

@@ -0,0 +1,8 @@
+inherit_from:
+  - ../.rubocop.yml
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false

data/spec/caption_filter_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Subconv

data/spec/scc/reader_spec.rb

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Subconv
   # Often used codes:
   # 9420: Resume caption loading
+  # 9429: Resume direct captioning
   # 91d0: Preamble address code for row 0 column 0
   # 942f: End of caption
   describe Scc::Reader do
@@ -10,6 +13,7 @@ module Subconv
 
     let(:backspace) { '94a1 94a1' }
     let(:test) { '54e5 73f4' }
+    let(:text) { '54e5 f8f4' }
     let(:a) { 'c180' }
 
     before(:each) do
@@ -42,15 +46,11 @@ module Subconv
     end
 
     it 'should decode simple text' do
-      expected_grid = Scc::Grid.new.insert_text(0, 0, 'Test')
-
-      expect(get_captions(caption_at_zero("9420 91d0 #{test} 942f"))).to eq([Scc::Caption.new(timecode: Timecode.new(4, default_fps), grid: expected_grid)])
+      expect(get_captions(caption_at_zero("9420 91d0 #{test} 942f"))).to eq(grids_to_captions(4 => 'Test'))
     end
 
     it 'should not reject data with wrong parity when checking is not requested' do
-      expected_grid = Scc::Grid.new.insert_text(0, 0, 'Test')
-
-      expect(get_captions(caption_at_zero("9420 11d0 #{test} 942f"), default_fps, false)).to eq([Scc::Caption.new(timecode: Timecode.new(4, default_fps), grid: expected_grid)])
+      expect(get_captions(caption_at_zero("9420 11d0 #{test} 942f"), default_fps, false)).to eq(grids_to_captions(4 => 'Test'))
     end
 
     expected_rows = {
@@ -73,8 +73,7 @@ module Subconv
 
     expected_rows.each_pair do |pac, row|
       it "should decode the preamble address code #{pac} to row #{row}" do
-        expected_grid = Scc::Grid.new.insert_text(row, 0, 'Test')
-        expect(get_captions(caption_at_zero("9420 #{pac} #{test} 942f"))).to eq([Scc::Caption.new(timecode: Timecode.new(4, default_fps), grid: expected_grid)])
+        expect(get_captions(caption_at_zero("9420 #{pac} #{test} 942f"))).to eq(grids_to_captions(4 => Scc::Grid.new.insert_text(row, 0, 'Test')))
       end
     end
 
@@ -91,31 +90,31 @@ module Subconv
 
     expected_column.each_pair do |pac, column|
       it "should decode the preamble address code #{pac} to column #{column}" do
-        expected_grid = Scc::Grid.new.insert_text(0, column, 'Test')
-        expect(get_captions(caption_at_zero("9420 #{pac} #{test} 942f"))).to eq([Scc::Caption.new(timecode: Timecode.new(4, default_fps), grid: expected_grid)])
+        expect(get_captions(caption_at_zero("9420 #{pac} #{test} 942f"))).to eq(grids_to_captions(4 => Scc::Grid.new.insert_text(0, column, 'Test')))
       end
     end
 
+    it 'should reset column on style preamble address code' do
+      expect(get_captions(caption_at_zero("9420 9152 #{text} 9140 #{test} 942f"))).to eq(grids_to_captions(7 => 'TestText'))
+    end
+
     it 'should handle backspace' do
-      expected_grid = Scc::Grid.new.insert_text(1, 0, 'Test')
       # Write AA, then backspace three times, go to next row, write Tesu, backspace one time, then write t
       # -> Should result in the first line being empty and the second line reading "Test"
-      expect(get_captions(caption_at_zero('9420 91d0 c1c1 ' + (backspace + ' ') * 3 + "91e0 54e5 7375 #{backspace} f480 942f"))).to eq([Scc::Caption.new(timecode: Timecode.new(15, default_fps), grid: expected_grid)])
+      expect(get_captions(caption_at_zero('9420 91d0 c1c1 ' + (backspace + ' ') * 3 + "91e0 54e5 7375 #{backspace} f480 942f"))).to eq(grids_to_captions(15 => Scc::Grid.new.insert_text(1, 0, 'Test')))
     end
 
     it 'should handle overflowing lines' do
-      expected_grid = Scc::Grid.new.insert_text(0, 0, 'A' * 31 + 'B')
-      # Write 40 As and then tw Bs
+      # Write 40 As and then two Bs
       # -> Should result in 31 As and one B since after overflow the last column is overwritten the whole time
-      expect(get_captions(caption_at_zero('9420 91d0 ' + ('c1c1 ' * 20) + 'c2c2 942f'))).to eq([Scc::Caption.new(timecode: Timecode.new(23, default_fps), grid: expected_grid)])
+      expect(get_captions(caption_at_zero('9420 91d0 ' + ('c1c1 ' * 20) + 'c2c2 942f'))).to eq(grids_to_captions(23 => 'A' * 31 + 'B'))
     end
 
     it 'should handle italics' do
       style = Scc::CharacterStyle.default
       style.italics = true
       # Italics is a mid-row spacing code, so expect a space before the text
-      expected_grid = Scc::Grid.new.insert_text(0, 0, ' ').insert_text(0, 1, 'Test', style)
-      expect(get_captions(caption_at_zero("9420 91d0 91ae #{test} 942f"))).to eq([Scc::Caption.new(timecode: Timecode.new(5, default_fps), grid: expected_grid)])
+      expect(get_captions(caption_at_zero("9420 91d0 91ae #{test} 942f"))).to eq(grids_to_captions(5 => Scc::Grid.new.insert_text(0, 0, ' ').insert_text(0, 1, 'Test', style)))
     end
 
     it 'should turn off flash on italics mid-row codes' do
@@ -124,32 +123,28 @@ module Subconv
       style.italics = true
       flash_style.flash = true
       # Two spaces before the text
-      expected_grid = Scc::Grid.new.insert_text(0, 0, ' ').insert_text(0, 1, ' ', flash_style).insert_text(0, 2, 'Test', style)
       # "<flash on><italics>Test"
-      expect(get_captions(caption_at_zero("9420 91d0 94a8 91ae #{test} 942f"))).to eq([Scc::Caption.new(timecode: Timecode.new(6, default_fps), grid: expected_grid)])
+      expect(get_captions(caption_at_zero("9420 91d0 94a8 91ae #{test} 942f"))).to eq(grids_to_captions(6 => Scc::Grid.new.insert_text(0, 0, ' ').insert_text(0, 1, ' ', flash_style).insert_text(0, 2, 'Test', style)))
     end
 
     it 'should handle italics preamble address code' do
       style = Scc::CharacterStyle.default
       style.italics = true
-      expected_grid = Scc::Grid.new.insert_text(0, 0, 'Test', style)
-      expect(get_captions(caption_at_zero("9420 91ce #{test} 942f"))).to eq([Scc::Caption.new(timecode: Timecode.new(4, default_fps), grid: expected_grid)])
+      expect(get_captions(caption_at_zero("9420 91ce #{test} 942f"))).to eq(grids_to_captions(4 => Scc::Grid.new.insert_text(0, 0, 'Test', style)))
     end
 
     it 'should handle italics and underline preamble address code' do
       style = Scc::CharacterStyle.default
       style.italics = true
       style.underline = true
-      expected_grid = Scc::Grid.new.insert_text(0, 0, 'Test', style)
-      expect(get_captions(caption_at_zero("9420 914f #{test} 942f"))).to eq([Scc::Caption.new(timecode: Timecode.new(4, default_fps), grid: expected_grid)])
+      expect(get_captions(caption_at_zero("9420 914f #{test} 942f"))).to eq(grids_to_captions(4 => Scc::Grid.new.insert_text(0, 0, 'Test', style)))
     end
 
     it 'should handle underline' do
       style = Scc::CharacterStyle.default
       style.underline = true
       # Underline is a mid-row spacing code, so expect a space before the text
-      expected_grid = Scc::Grid.new.insert_text(0, 0, ' ').insert_text(0, 1, 'Test', style)
-      expect(get_captions(caption_at_zero("9420 91d0 91a1 #{test} 942f"))).to eq([Scc::Caption.new(timecode: Timecode.new(5, default_fps), grid: expected_grid)])
+      expect(get_captions(caption_at_zero("9420 91d0 91a1 #{test} 942f"))).to eq(grids_to_captions(5 => Scc::Grid.new.insert_text(0, 0, ' ').insert_text(0, 1, 'Test', style)))
     end
 
     it 'should handle italics and underline' do
@@ -157,8 +152,7 @@ module Subconv
       style.italics = true
       style.underline = true
       # Italics/underline is a mid-row spacing code, so expect a space before the text
-      expected_grid = Scc::Grid.new.insert_text(0, 0, ' ').insert_text(0, 1, 'Test', style)
-      expect(get_captions(caption_at_zero("9420 91d0 912f #{test} 942f"))).to eq([Scc::Caption.new(timecode: Timecode.new(5, default_fps), grid: expected_grid)])
+      expect(get_captions(caption_at_zero("9420 91d0 912f #{test} 942f"))).to eq(grids_to_captions(5 => Scc::Grid.new.insert_text(0, 0, ' ').insert_text(0, 1, 'Test', style)))
     end
 
     color_code_map = {
@@ -175,8 +169,7 @@ module Subconv
       it "should handle the color #{color}" do
         style = Scc::CharacterStyle.default
         style.color = color
-        expected_grid = Scc::Grid.new.insert_text(0, 0, 'A', style)
-        expect(get_captions(caption_at_zero("9420 91d0 #{color_code} #{backspace} #{a} 942f"))).to eq([Scc::Caption.new(timecode: Timecode.new(6, default_fps), grid: expected_grid)])
+        expect(get_captions(caption_at_zero("9420 91d0 #{color_code} #{backspace} #{a} 942f"))).to eq(grids_to_captions(6 => Scc::Grid.new.insert_text(0, 0, 'A', style)))
       end
     end
 
@@ -186,9 +179,8 @@ module Subconv
       style.color = Scc::Color::RED
       italics_style.italics = true
       # Two spaces before the text
-      expected_grid = Scc::Grid.new.insert_text(0, 0, ' ').insert_text(0, 1, ' ', italics_style).insert_text(0, 2, 'Test', style)
       # "<italics><red>Test"
-      expect(get_captions(caption_at_zero("9420 91d0 91ae 91a8 #{test} 942f"))).to eq([Scc::Caption.new(timecode: Timecode.new(6, default_fps), grid: expected_grid)])
+      expect(get_captions(caption_at_zero("9420 91d0 91ae 91a8 #{test} 942f"))).to eq(grids_to_captions(6 => Scc::Grid.new.insert_text(0, 0, ' ').insert_text(0, 1, ' ', italics_style).insert_text(0, 2, 'Test', style)))
     end
 
     it 'should handle all available attributes combined' do
@@ -203,109 +195,192 @@ module Subconv
       style.flash = true
       expected_grid.insert_text(0, 2, 'Test', style.dup)
       # Set color via preamble address code to test that too, then set italics/underline via mid-row code, then assign flash via "flash on" miscellaneous control code
-      expect(get_captions(caption_at_zero("9420 91c8 912f 94a8 #{test} 942f"))).to eq([Scc::Caption.new(timecode: Timecode.new(6, default_fps), grid: expected_grid)])
+      expect(get_captions(caption_at_zero("9420 91c8 912f 94a8 #{test} 942f"))).to eq(grids_to_captions(6 => expected_grid))
     end
 
     it 'should handle transparent space' do
       # Column 1 should be empty
-      expected_grid = Scc::Grid.new.insert_text(0, 0, 'A').insert_text(0, 2, 'A')
       # "A<transparent space>A"
-      expect(get_captions(caption_at_zero("9420 91d0 #{a} 91b9 #{a} 942f"))).to eq([Scc::Caption.new(timecode: Timecode.new(5, default_fps), grid: expected_grid)])
+      expect(get_captions(caption_at_zero("9420 91d0 #{a} 91b9 #{a} 942f"))).to eq(grids_to_captions(5 => Scc::Grid.new.insert_text(0, 0, 'A').insert_text(0, 2, 'A')))
     end
 
     it 'should delete characters behind transparent space' do
       # Column 1 should be empty
-      expected_grid = Scc::Grid.new.insert_text(0, 1, 'est')
       # "Test<PAC><transparent space>"
-      expect(get_captions(caption_at_zero("9420 91d0 #{test} 91d0 91b9 942f"))).to eq([Scc::Caption.new(timecode: Timecode.new(6, default_fps), grid: expected_grid)])
+      expect(get_captions(caption_at_zero("9420 91d0 #{test} 91d0 91b9 942f"))).to eq(grids_to_captions(6 => Scc::Grid.new.insert_text(0, 1, 'est')))
     end
 
     it 'should handle standard space' do
-      expected_grid = Scc::Grid.new.insert_text(0, 0, 'A A')
       # "A A"
-      expect(get_captions(caption_at_zero('9420 91d0 c120 c180 942f'))).to eq([Scc::Caption.new(timecode: Timecode.new(4, default_fps), grid: expected_grid)])
+      expect(get_captions(caption_at_zero('9420 91d0 c120 c180 942f'))).to eq(grids_to_captions(4 => 'A A'))
     end
 
     it 'should handle tab offset' do
       # Space between the As should be empty
       expected_grid = Scc::Grid.new.insert_text(0, 0, 'A').insert_text(0, 2, 'A').insert_text(0, 5, 'A').insert_text(0, 9, 'A')
       # "A<tab offset 1>A<tab offset 2>A<tab offset 3>A"
-      expect(get_captions(caption_at_zero("9420 91d0 #{a} 97a1 #{a} 97a2 #{a} 9723 #{a} 942f"))).to eq([Scc::Caption.new(timecode: Timecode.new(9, default_fps), grid: expected_grid)])
+      expect(get_captions(caption_at_zero("9420 91d0 #{a} 97a1 #{a} 97a2 #{a} 9723 #{a} 942f"))).to eq(grids_to_captions(9 => expected_grid))
     end
 
     it 'should not delete characters on tab offset' do
       # Space between the As should be empty
-      expected_grid = Scc::Grid.new.insert_text(0, 0, 'TAst')
       # "Test<PAC><tab offset 1>A"
-      expect(get_captions(caption_at_zero("9420 91d0 #{test} 91d0 97a1 #{a} 942f"))).to eq([Scc::Caption.new(timecode: Timecode.new(7, default_fps), grid: expected_grid)])
+      expect(get_captions(caption_at_zero("9420 91d0 #{test} 91d0 97a1 #{a} 942f"))).to eq(grids_to_captions(7 => 'TAst'))
     end
 
     it 'should ignore repeated commands' do
       # There should be only one, not two spaces between the As
-      expected_grid = Scc::Grid.new.insert_text(0, 0, 'A').insert_text(0, 2, 'A')
       # "A<transparent space><transparent space>A"
-      expect(get_captions(caption_at_zero("9420 91d0 #{a} 91b9 91b9 #{a} 942f"))).to eq([Scc::Caption.new(timecode: Timecode.new(6, default_fps), grid: expected_grid)])
+      expect(get_captions(caption_at_zero("9420 91d0 #{a} 91b9 91b9 #{a} 942f"))).to eq(grids_to_captions(6 => Scc::Grid.new.insert_text(0, 0, 'A').insert_text(0, 2, 'A')))
     end
 
     it 'should not ignore multiply repeated commands' do
       # Now there should be not, not four or one, spaces between the As
-      expected_grid = Scc::Grid.new.insert_text(0, 0, 'A').insert_text(0, 3, 'A')
       # "A<transparent space><transparent space<transparent space><transparent space>>A"
-      expect(get_captions(caption_at_zero("9420 91d0 #{a} 91b9 91b9 91b9 91b9 #{a} 942f"))).to eq([Scc::Caption.new(timecode: Timecode.new(8, default_fps), grid: expected_grid)])
+      expect(get_captions(caption_at_zero("9420 91d0 #{a} 91b9 91b9 91b9 91b9 #{a} 942f"))).to eq(grids_to_captions(8 => Scc::Grid.new.insert_text(0, 0, 'A').insert_text(0, 3, 'A')))
     end
 
     it 'should handle delete to end of row' do
-      expected_grid = Scc::Grid.new.insert_text(0, 0, 'AAAA')
       # "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA<PAC indent 4><delete to end of row>"
-      expect(get_captions(caption_at_zero('9420 91d0 ' + (a + ' ') * 32 + '9152 94a4 942f'))).to eq([Scc::Caption.new(timecode: Timecode.new(36, default_fps), grid: expected_grid)])
+      expect(get_captions(caption_at_zero('9420 91d0 ' + (a + ' ') * 32 + '9152 94a4 942f'))).to eq(grids_to_captions(36 => 'AAAA'))
     end
 
     it 'should handle erase displayed memory' do
-      expected_grid = Scc::Grid.new.insert_text(0, 0, 'Test')
       # Display "Test", wait 2 frames, erase displayed memory
       # -> should result in an empty caption 3 frames later
-      expect(get_captions(caption_at_zero("9420 91d0 #{test} 942f 8080 8080 942c"))).to eq([Scc::Caption.new(timecode: Timecode.new(4, default_fps), grid: expected_grid), Scc::Caption.new(timecode: Timecode.new(7, default_fps))])
+      expect(get_captions(caption_at_zero("9420 91d0 #{test} 942f 8080 8080 942c"))).to eq(grids_to_captions(4 => 'Test', 7 => nil))
     end
 
     it 'should handle erase non-displayed memory' do
-      expected_grid = Scc::Grid.new.insert_text(0, 0, 'A')
       # Insert "Test", delete the non-displayed memory, insert "A" and then flip captions
-      expect(get_captions(caption_at_zero("9420 91d0 #{test} 94ae 91d0 #{a} 942f"))).to eq([Scc::Caption.new(timecode: Timecode.new(7, default_fps), grid: expected_grid)])
+      expect(get_captions(caption_at_zero("9420 91d0 #{test} 94ae 91d0 #{a} 942f"))).to eq(grids_to_captions(7 => 'A'))
     end
 
     it 'should handle special characters' do
-      expected_grid = Scc::Grid.new.insert_text(0, 0, '♪')
-      expect(get_captions(caption_at_zero('9420 91d0 9137 942f'))).to eq([Scc::Caption.new(timecode: Timecode.new(3, default_fps), grid: expected_grid)])
+      expect(get_captions(caption_at_zero('9420 91d0 9137 942f'))).to eq(grids_to_captions(3 => '♪'))
+    end
+
+    it 'should handle extended characters' do
+      expect(get_captions(caption_at_zero("9420 91d0 #{a} 92a4 #{a} 133b 942f"))).to eq(grids_to_captions(6 => 'Üø'))
     end
 
     it 'should handle multiple timecodes and captions' do
       expected_grid_test = Scc::Grid.new.insert_text(0, 0, 'Test')
       expected_grid_a = Scc::Grid.new.insert_text(0, 0, 'A')
       expected_grid_b = Scc::Grid.new.insert_text(0, 0, 'B')
-      caption_text = <<"END"
-Scenarist_SCC V1.0
+      caption_text = <<~"SCC"
+        Scenarist_SCC V1.0
 
-00:00:01:00\t9420 91d0 #{test} 942f 94ae
+        00:00:01:00\t9420 91d0 #{test} 942f 94ae
 
-00:00:02:00\t9420 91d0 #{test} 942f 94ae
+        00:00:02:00\t9420 91d0 #{test} 942f 94ae
 
-00:00:03:00\t942c
+        00:00:03:00\t942c
 
-00:00:04:00\t9420 91d0 c180 942f
+        00:00:04:00\t9420 91d0 c180 942f
 
-00:00:05:00\t9420 91d0 c280 942f
-END
+        00:00:05:00\t9420 91d0 c280 942f
+      SCC
       expect(get_captions(caption_text)).to eq([
         # First caption: Test
-        Scc::Caption.new(timecode: Timecode.parse('00:00:01:04', default_fps), grid: expected_grid_test),
+        Scc::Caption.new(timecode: Timecode.parse('00:00:01:04', default_fps), grid: expected_grid_test, mode: :pop_on),
         # Caption at 00:00:02:00 should be identical to the first one and thus not get put out
         # At 00:00:03:00: erase displayed caption
-        Scc::Caption.new(timecode: Timecode.parse('00:00:03:00', default_fps)),
+        Scc::Caption.new(timecode: Timecode.parse('00:00:03:00', default_fps), mode: :pop_on),
         # At 00:00:04:00: Display "A"
-        Scc::Caption.new(timecode: Timecode.parse('00:00:04:03', default_fps), grid: expected_grid_a),
+        Scc::Caption.new(timecode: Timecode.parse('00:00:04:03', default_fps), grid: expected_grid_a, mode: :pop_on),
         # At 00:00:05:00: Display "B" without erasing A beforehand
-        Scc::Caption.new(timecode: Timecode.parse('00:00:05:03', default_fps), grid: expected_grid_b)
+        Scc::Caption.new(timecode: Timecode.parse('00:00:05:03', default_fps), grid: expected_grid_b, mode: :pop_on)
       ])
     end
+
+    context 'in paint-on mode' do
+      it 'should produce one caption for every change' do
+        expected_grids = %w[Te Test TestTe TestText TestTex].map { |text| Scc::Grid.new.insert_text(0, 0, text) }
+        expect(get_captions(caption_at_zero("9429 91d0 #{test} #{text} #{backspace}"))).to eq(
+          expected_grids.each_with_index.map { |grid, i|
+            Scc::Caption.new(timecode: Timecode.new(i + 2, default_fps), grid: grid, mode: :paint_on)
+          }
+        )
+      end
+
+      it 'should handle special characters' do
+        expect(get_captions(caption_at_zero('9429 91d0 9137'))).to eq(grids_to_captions(:paint_on, 2 => '♪'))
+      end
+
+      it 'should handle style attributes' do
+        style = Scc::CharacterStyle.default
+        style.italics = true
+        # Italics is a mid-row spacing code, so expect a space before the text
+        expected_grids = {
+          2 => Scc::Grid.new.insert_text(0, 0, ' '),
+          3 => Scc::Grid.new.insert_text(0, 0, ' ').insert_text(0, 1, 'Te', style),
+          4 => Scc::Grid.new.insert_text(0, 0, ' ').insert_text(0, 1, 'Test', style)
+        }
+        expect(get_captions(caption_at_zero("9429 91d0 91ae #{test}"))).to eq(grids_to_captions(:paint_on, expected_grids))
+      end
+
+      it 'should handle backspace' do
+        expected_grids = {
+          2  => 'Te',
+          3  => 'Test',
+          4  => 'Tes',
+          6  => 'TesTe',
+          7  => 'TesText',
+          8  => 'TesTex',
+          10 => 'TesTe'
+        }
+        expect(get_captions(caption_at_zero("9429 91d0 #{test} #{backspace} #{text} #{backspace} #{backspace}"))).to eq(grids_to_captions(:paint_on, expected_grids))
+      end
+
+      it 'should handle erase displayed memory' do
+        expect(get_captions(caption_at_zero("9429 91d0 #{test} 8080 942c"))).to eq(grids_to_captions(:paint_on, 2 => 'Te', 3 => 'Test', 5 => nil))
+      end
+
+      it 'should not change captions on erase non-displayed memory' do
+        expect(get_captions(caption_at_zero("9429 91d0 #{test} 94ae"))).to eq(grids_to_captions(:paint_on, 2 => 'Te', 3 => 'Test'))
+      end
+
+      it 'should handle delete to end of row' do
+        expected_grids = {
+          2 => 'A',
+          3 => 'AA',
+          4 => 'AAA',
+          5 => 'AAAA',
+          6 => 'AAAATe',
+          7 => 'AAAATest',
+          9 => 'AAAA'
+        }
+        # "AAAATest<PAC indent 4><delete to end of row>"
+        expect(get_captions(caption_at_zero('9429 91d0 ' + (a + ' ') * 4 + "#{test} 9152 94a4"))).to eq(grids_to_captions(:paint_on, expected_grids))
+      end
+    end
+
+    it 'should keep paint-on captions active when switching to pop-on mode' do
+      expected_captions = [
+        Scc::Caption.new(timecode: Timecode.new(2, default_fps), grid: Scc::Grid.new.insert_text(0, 0, 'A'), mode: :paint_on),
+        Scc::Caption.new(timecode: Timecode.new(6, default_fps), grid: Scc::Grid.new.insert_text(0, 1, 'Test'), mode: :pop_on)
+      ]
+      expect(get_captions(caption_at_zero("9429 91d0 #{a} 9420 #{test} 942f"))).to eq(expected_captions)
+    end
+
+    it 'should keep paint-on captions in non-displayed memory when ending paint-on mode via end of caption' do
+      expected_captions = [
+        Scc::Caption.new(timecode: Timecode.new(2, default_fps), grid: Scc::Grid.new.insert_text(0, 0, 'Te'), mode: :paint_on),
+        Scc::Caption.new(timecode: Timecode.new(3, default_fps), grid: Scc::Grid.new.insert_text(0, 0, 'Test'), mode: :paint_on),
+        Scc::Caption.new(timecode: Timecode.new(4, default_fps), mode: :pop_on),
+        Scc::Caption.new(timecode: Timecode.new(7, default_fps), grid: Scc::Grid.new.insert_text(0, 0, 'TestText'), mode: :pop_on)
+      ]
+      expect(get_captions(caption_at_zero("9429 91d0 #{test} 942f #{text} 942f"))).to eq(expected_captions)
+    end
+
+    it 'should keep displayed pop-on captions active when switching to paint-on mode' do
+      expected_captions = [
+        Scc::Caption.new(timecode: Timecode.new(3, default_fps), grid: Scc::Grid.new.insert_text(0, 0, 'Test'), mode: :pop_on),
+        Scc::Caption.new(timecode: Timecode.new(5, default_fps), grid: Scc::Grid.new.insert_text(0, 0, 'TestTe'), mode: :paint_on),
+        Scc::Caption.new(timecode: Timecode.new(6, default_fps), grid: Scc::Grid.new.insert_text(0, 0, 'TestText'), mode: :paint_on)
+      ]
+      expect(get_captions(caption_at_zero("9420 #{test} 942f 9429 #{text}"))).to eq(expected_captions)
+    end
   end
 end