Version 4.0.18 - blend filter

Author: Doug Anarino

Changelog

@@ -2,6 +2,11 @@
 version <future>:
 - freeze frame
 
+version 4.0.18:
+  - support added for blend filter
+  - stopped using movie filter in favor of indexed video labels
+  - added support for pixel_format output option
+
 version 4.0.17:
 - now using labeled inputs instead of movie filter in filtergraphs
 - fixed issues with image output in ffmpeg 3 (don't include video_rate)

lib/graph.rb

@@ -2,6 +2,17 @@
 module MovieMasher
   # base class for most other graph related classes
   class GraphUtility
+    def __join_commands(cmds)
+      joined_commands = []
+      cmds = cmds.reject(&:empty?)
+      c = cmds.length
+      c.times do |i|
+        cmd = cmds[i]
+        cmd = "#{cmd}," unless (i.zero? && cmd.end_with?(':v]')) || i == c - 1
+        joined_commands << cmd
+      end
+      joined_commands.join
+    end
     def __coerce_if_numeric(value)
       Evaluate.coerce_if_numeric(value)
     end
@@ -49,6 +60,7 @@ def duration
       @render_range.length_seconds
     end
     def graph_command(output)
+      FilterSourceRaw.input_index = 0
       @job_output = output
     end
     def graph_scope
@@ -93,17 +105,13 @@ def initialize(id = nil)
   # base for all filter chains
   class Chain < GraphUtility
     def chain_command(scope)
-      cmds = []
-      @filters.each do |filter|
-        cmd =
-          if filter.is_a?(Filter)
-            filter.filter_command(scope)
-          else
-            filter.chain_command(scope)
-          end
-        cmds << cmd unless cmd.to_s.empty?
+      cmds = @filters.map do |f|
+        f.send(f.is_a?(Filter) ? :filter_command : :chain_command, scope)
       end
-      cmds.join(',')
+      __join_commands(cmds)
+    end
+    def chain_labels(label, i)
+      "[#{label}#{1 == i ? '' : 'ed'}#{i - 1}][#{label}#{i}]"
     end
     def initialize(input = nil, job_input = nil)
       @input = input
@@ -132,7 +140,12 @@ def initialize(input, job_input)
     def initialize_chains
       if @input[:merger]
         @input[:merger][:dimensions] ||= @input[:dimensions]
-        @merger_chain = ChainModule.new(@input[:merger], @job_input, @input)
+        @merger_chain =
+          if 'com.moviemasher.merger.blend' == @input[:merger][:id]
+            ChainBlend.new(@input[:merger], @job_input, @input)
+          else
+            ChainModule.new(@input[:merger], @job_input, @input)
+          end
       else
         @merger_chain = ChainOverlay.new(@job_input)
       end
@@ -151,12 +164,7 @@ def inputs
     end
     def layer_command(scope)
       layer_scope(scope)
-      cmds = []
-      @chains.each do |chain|
-        chain_cmd = chain.chain_command(scope)
-        cmds << chain_cmd unless chain_cmd.to_s.empty?
-      end
-      cmds.join(',')
+      __join_commands(@chains.map { |chain| chain.chain_command(scope) })
     end
     def layer_scope(scope)
       __raise_unless(@input[:length], "no input length #{@input}")
@@ -166,8 +174,10 @@ def layer_scope(scope)
         scope[:overlay_w], scope[:overlay_h] = @input[:dimensions].split('x')
       end
     end
-    def merger_command(scope)
-      @merger_chain.chain_command(scope)
+    def merger_command(scope, label, i)
+      merge_cmd = @merger_chain.chain_command(scope)
+      __raise_if_empty(merge_cmd, "merger produced nothing #{self}")
+      "#{@merger_chain.chain_labels(label, i)}#{merge_cmd}"
     end
     def range
       (@input ? @input[:range] : nil)
@@ -177,8 +187,6 @@ def trim_command(render_range)
       # puts "command_range_trim #{input_range}"
       cmd = ''
       if render_range && input_range && !input_range.equals?(render_range)
-        # puts "render_range #{render_range.inspect}"
-        # puts "input_range #{input_range.inspect}"
         range_start = render_range.start_seconds
         range_end = render_range.end_seconds
         input_start = input_range.start_seconds
@@ -204,8 +212,9 @@ def add_new_layer(input)
       @layers << layer
       layer
     end
-    def graph_command(*)
-      super
+    def graph_command(output, dont_set_input_index = false) # LayerTransition
+      FilterSourceRaw.input_index = 0 unless dont_set_input_index
+      @job_output = output
       graph_cmds = []
       layer_length = @layers.length
       layer_length.times do |i|
@@ -218,11 +227,7 @@ def graph_command(*)
       if 1 < layer_length
         (1..layer_length - 1).each do |i|
           layer = @layers[i]
-          cmd = (1 == i ? "[#{@label_name}0]" : "[#{@label_name}ed#{i - 1}]")
-          cmd += "[#{@label_name}#{i}]"
-          merge_cmd = layer.merger_command(graph_scope)
-          __raise_if_empty(merge_cmd, "merger produced nothing #{layer}")
-          cmd += merge_cmd
+          cmd = layer.merger_command(graph_scope, @label_name, i)
           cmd += "[#{@label_name}ed#{i}]" if i + 1 < layer_length
           graph_cmds << cmd
         end

lib/graphs/chains.rb

@@ -15,8 +15,7 @@ def initialize_filters
   class ChainModule < Chain
     attr_writer :input
     def chain_command(scope)
-      scope = input_scope(scope)
-      super
+      super(input_scope(scope))
     end
     def initialize(mod_input, mash_input, applied_input)
       # applied_input is same as mod_input for themes
@@ -149,4 +148,17 @@ def __pad_filter(w_scaled, h_scaled, orig_w_f, orig_h_f)
       )
     end
   end
+  # a merger chain supporting blend filter
+  class ChainBlend < ChainModule
+    def chain_labels(label, i)
+      label_1 = "#{label}#{i}"
+      label_2 = "#{label}#{1 == i ? '' : 'ed'}#{i - 1}"
+      cmds = []
+      cmds << "[#{label_1}]format=pix_fmts=rgba[#{label_1}_rgba]"
+      cmds << "[#{label_2}]format=pix_fmts=rgba[#{label_2}_rgba]"
+      cmds << "[#{label_1}_rgba][#{label_2}_rgba]"
+      puts "CHAIN_LABELS #{cmds.join(';')}"
+      cmds.join(';')
+    end
+  end
 end

lib/graphs/filters.rb

@@ -236,7 +236,7 @@ def initialize(expr = 'PTS-STARTPTS')
       super('setpts', expr: expr)
     end
   end
-  # raw input source
+  # base filter source
   class FilterSource < FilterHash
     def filter_command(scope)
       cmd = super
@@ -250,17 +250,41 @@ def initialize(id, hash, dimensions = nil)
       @dimensions = dimensions
     end
   end
-  # video source
-  class FilterSourceMovie < FilterSource
+  # base raw source
+  class FilterSourceRaw < FilterSource
+    class << self
+      attr_accessor :input_index
+    end
+    FilterSourceRaw.input_index = 0
     def filter_name
       "#{super} #{File.basename(@hash[:filename])}"
     end
     def initialize(input, job_input)
       @input = input
       @job_input = job_input
-      super('movie', { filename: input[:cached_file] }, input[:dimensions])
+      # filename: @input[:cached_file]
+      super('movie', {}, @input[:dimensions])
+    end
+    def filter_command(*)
+      Filter.__outsize['w'], Filter.__outsize['h'] = @dimensions.split('x')
+      index = FilterSourceRaw.input_index
+      FilterSourceRaw.input_index += 1
+      "[#{index}:v]"
     end
   end
+  # video source
+  class FilterSourceVideo < FilterSourceRaw
+    def inputs
+      [{ i: @input[:cached_file] }]
+    end
+  end
+  # image source
+  class FilterSourceImage < FilterSourceRaw
+    def inputs
+      [{ loop: 1, i: @input[:cached_file] }]
+    end
+  end
+
   # simple color source
   class FilterSourceColor < FilterSource
     def filter_command(scope)

lib/graphs/layers.rb

@@ -32,7 +32,7 @@ def layer_scope(scope)
   # base class for a video or image layer
   class LayerRaw < Layer # LayerRawVideo, LayerRawImage
     def inputs
-      [{ i: @input[:cached_file] }]
+      @filter_movie.inputs
     end
     def layer_command(scope)
       scope[:mm_input_dimensions] = @input[:dimensions]
@@ -47,15 +47,13 @@ def layer_command(scope)
   class LayerRawImage < LayerRaw
     def initialize_chains
       chain = Chain.new(nil, @job_input)
-      chain << FilterSourceMovie.new(@input, @job_input)
+      @filter_movie = FilterSourceImage.new(@input, @job_input)
+      chain << @filter_movie
       @filter_timestamps = FilterSetpts.new
       chain << @filter_timestamps
       @chains << chain
       super
     end
-    def inputs
-      [{ loop: 1, i: @input[:cached_file] }]
-    end
     def layer_command(scope)
       unless @input[:cached_file]
         raise(Error::JobInput, "no cached_file #{@input}")
@@ -69,7 +67,8 @@ class LayerRawVideo < LayerRaw
     def initialize_chains
       # puts "LayerRawVideo#initialize_chains"
       chain = Chain.new(nil, @job_input)
-      chain << FilterSourceMovie.new(@input, @job_input)
+      @filter_movie = FilterSourceVideo.new(@input, @job_input)
+      chain << @filter_movie
       # trim filter, if needed
       @trim_filter = __filter_trim_input
       chain << @trim_filter if @trim_filter
@@ -171,14 +170,14 @@ def layer_command(scope)
       @graphs.length.times do |i|
         graph = @graphs[i]
         layer_label = "#{layer_letter}_#{Type::TRANSITION}"
-        cmd = graph.graph_command(scope[:mm_output])
+        cmd = graph.graph_command(scope[:mm_output], true)
         layer_chain = @layer_chains[i]
-        cmd += ','
+        cmd += ',' unless cmd.end_with?(':v]')
         cmd += layer_chain[:scaler].chain_command(scope)
         if layer_chain[:filters]
           chain_cmd = layer_chain[:filters].chain_command(scope)
           unless chain_cmd.to_s.empty?
-            cmd += ','
+            cmd += ',' unless cmd.end_with?(':v]')
             cmd += chain_cmd
           end
         end

lib/job.rb

@@ -350,7 +350,7 @@ def __execute_and_log(options)
       result = ShellHelper.capture(command)
       log_entry(:debug) { result }
       @hash[:results] << result
-      logs = ShellHelper.raise_unless_rendered(result, options)
+      logs = ShellHelper.raise_unless_rendered(result, command, options)
       logs.each do |hash|
         hash.each do |sym, proc|
           log_entry(sym, &proc)

lib/output.rb

@@ -21,12 +21,13 @@ module MovieMasher
   # setting Job#error the problem is added to Job#log as a warning.
   #
   #   Output.create {
-  #     type: Type::VIDEO,
-  #     name: "video.mp4",                       # extension implies format
-  #     dimensions: "512x288",                   # ffmpeg -s switch
+  #     type: Type::VIDEO,                       # aka 'video'
+  #     name: 'video.mp4',                       # implied extension
+  #     dimensions: '512x288',                   # ffmpeg -s switch
   #     video_rate: 30,                          # ffmpeg -r:v switch
-  #     video_codec: "libx264 -preset medium",   # ffmpeg -c:v switch
-  #     video_bitrate: "2000K",                  # ffmpeg -b:v switch
+  #     video_codec: 'libx264 -preset medium',   # ffmpeg -c:v switch
+  #     video_bitrate: '2000K',                  # ffmpeg -b:v switch
+  #     pixel_format: 'yuv420p'                  # ffmpeg -pix_fmt switch
   #   }
   class Output < Hashable
     # Returns a new instance.
@@ -48,6 +49,7 @@ def self.init_hash(output)
         Hashable._init_key output, :extension, 'mp4'
         Hashable._init_key output, :fill, Fill::NONE
         Hashable._init_key output, :video_rate, 30
+        Hashable._init_key output, :pixel_format, 'yuv420p'
         Hashable._init_key output, :gain, Gain::None
         Hashable._init_key output, :precision, 1
         Hashable._init_key output, :video_bitrate, 2_000
@@ -61,7 +63,7 @@ def self.init_hash(output)
         Hashable._init_key output, :quality, 1
         output[:no_audio] = true
       when Type::IMAGE
-        # Hashable._init_key output, :video_rate, 1
+        Hashable._init_key output, :video_rate, 10
         Hashable._init_key output, :backcolor, 'black'
         Hashable._init_key output, :quality, 1
         Hashable._init_key output, :extension, 'jpg'