video2gif 0.0.33 → 0.0.34

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4bff1ae338db86be23755a9bdf6bb4e5a877b942f3a48c32af28317e35c8508
-  data.tar.gz: d3aa41909f20f0ef78ca35fafa2efc4dc09932aa63372401a44efb65c3d315d2
+  metadata.gz: bc6e44b0ef580d23810cfaaae7449d4c0aa42e4e21a4a549f14cd549ed78a6e4
+  data.tar.gz: 229342c782db8a61f1e7706e13f00e25ad5a289bd796e9b2975482a16e2d8d31
 SHA512:
-  metadata.gz: d2608410cbbf81ab35a88825a66b5b9f11bfa9cbe00f42fdafa9c6a5f112ce8070595dabe4cba2cec879a7133a13defbcd633d3706b0f004f8b614c0eec28582
-  data.tar.gz: 2fe3759d6bc111f056b0f15f0c77c516d508186cedb5ca41a68281346b9428a0d0efa6ec8b1a101088d90f26990f0a41d308f51c47f4b6ee12d5e88a3753270a
+  metadata.gz: 18edb4ce95a5f30993cd2adddc22ade8bc1e135c322ad150bfa051590e46dc676b4ae5d611bc81addf1c521bc0143f755faa9381893120ccf894609d8635b69e
+  data.tar.gz: aeb1a6e3183f0e1c4b9c7fbac2015d8a8d289cf9f177b6e1ea18699301cd63e6c981ca2a2416fb9354b90fabb22363867c8c28d9e2b35dcdcffe2e743674fcc3

data/lib/video2gif/ffmpeg.rb

@@ -1,162 +1,185 @@
 # frozen_string_literal: true
 
+require_relative 'ffmpeg/subtitles'
+
 
 module Video2gif
   module FFmpeg
+    include Subtitles
+
     CROP_REGEX = /crop=([0-9]+\:[0-9]+\:[0-9]+\:[0-9]+)/
 
-    # TODO: This whole method needs to be broken up significantly.
-    def self.filtergraph(options)
-      filtergraph = []
+    def self.video_info(options)
+      options[:probe_infos][:streams].find { |s| s[:codec_type] == 'video' }
+    end
 
-      # If we want subtitles and *have* subtitles, we need some info to
-      # use them.
-      video_info = options[:probe_infos][:streams].find { |s| s[:codec_type] == 'video' }
-      if options[:subtitles] && options[:probe_infos][:streams].any? { |s| s[:codec_type] == 'subtitle' }
-        subtitle_info = options[:probe_infos][:streams]
-          .find_all { |s| s[:codec_type] == 'subtitle' }
-          .fetch(options[:subtitle_index], nil)
-      end
+    def self.rate(options)
+      "setpts=PTS/#{options[:rate]}" if options[:rate]
+    end
 
-      # Bitmap formatted subtitles go first so that they get scaled
-      # correctly.
-      if options[:subtitles] &&
-          options[:probe_infos][:streams].any? { |s| s[:codec_type] == 'subtitle' } &&
-          Subtitles::KNOWN_BITMAP_FORMATS.include?(subtitle_info[:codec_name])
-        filtergraph << "[0:s:#{options[:subtitle_index]}]scale=" + %W[
-          flags=lanczos
-          sws_dither=none
-          width=#{video_info[:width]}
-          height=#{video_info[:height]}
-        ].join(':') + '[subs]'
-        filtergraph << '[0:v][subs]overlay=format=auto'
-      end
+    def self.interpolate(options)
+      if options[:rate] && Float(options[:rate]) < 1  # only interpolate slowed down video
+        minterpolate_parameters = []
+
+        minterpolate_parameters << 'mi_mode=mci'
+        minterpolate_parameters << 'mc_mode=aobmc'
+        minterpolate_parameters << 'me_mode=bidir'
+        minterpolate_parameters << 'me=epzs'
+        minterpolate_parameters << 'vsbmc=1'
+        minterpolate_parameters << "fps=#{video_info(options)[:avg_frame_rate] }/#{options[:rate]}"
 
-      # Slow down or speed up video as early as possible so that we
-      # don't end up trying to interpolate frames in that we already
-      # dropped.
-      if options[:rate]
-        filtergraph << "setpts=PTS/#{options[:rate]}" if options[:rate]
-        if Float(options[:rate]) < 1  # interpolate slowed down video
-          minterpolate = []
-          minterpolate << 'mi_mode=mci'
-          minterpolate << 'mc_mode=aobmc'
-          minterpolate << 'me_mode=bidir'
-          minterpolate << 'me=epzs'
-          minterpolate << 'vsbmc=1'
-          minterpolate << "fps=#{video_info[:avg_frame_rate] }/#{options[:rate]}"
-          filtergraph << 'minterpolate=' + minterpolate.join(':')
-        end
+        'minterpolate=' + minterpolate_parameters.join(':')
       end
+    end
 
-      # Set 'fps' filter early, drop unneeded frames instead of
-      # processing those.
-      filtergraph << "fps=#{ options[:fps] || 10 }"
+    def self.rate_with_interpolation(options)
+      [
+        rate(options),
+        interpolate(options)
+      ]
+    end
 
-      # Apply automatic cropping discovered during the cropdetect run.
-      filtergraph << options[:autocrop] if options[:autocrop]
+    def self.fps(options)
+      "fps=#{ options[:fps] || 10 }"
+    end
 
-      crop = []
-      crop << "w=#{options[:wregion]}" if options[:wregion]
-      crop << "h=#{options[:hregion]}" if options[:hregion]
-      crop << "x=#{options[:xoffset]}" if options[:xoffset]
-      crop << "y=#{options[:yoffset]}" if options[:yoffset]
-      filtergraph << 'crop=' + crop.join(':') unless crop.empty?
+    def self.crop(options)
+      crop_parameters = []
 
-      # Scale here before other filters to avoid unnecessary processing.
+      crop_parameters << "w=#{options[:wregion]}" if options[:wregion]
+      crop_parameters << "h=#{options[:hregion]}" if options[:hregion]
+      crop_parameters << "x=#{options[:xoffset]}" if options[:xoffset]
+      crop_parameters << "y=#{options[:yoffset]}" if options[:yoffset]
+
+      'crop=' + crop_parameters.join(':') unless crop_parameters.empty?
+    end
+
+    def self.zscale(options)
+      zscale_parameters = []
+
+      zscale_parameters << 'dither=none'
+      zscale_parameters << 'filter=lanczos'
+      zscale_parameters << "width=#{ options[:width] || 400 }"
+      zscale_parameters << "height=trunc(#{ options[:width] || 400 }/dar)"
+
+      'zscale=' + zscale_parameters.join(':')
+    end
+
+    def self.tonemap(options)
+      %W[
+        zscale=transfer=linear:npl=100
+        zscale=npl=100
+        format=gbrpf32le
+        zscale=primaries=bt709
+        tonemap=tonemap=#{options[:tonemap]}:desat=0
+        zscale=transfer=bt709:matrix=bt709:range=tv
+        format=yuv420p
+      ]
+    end
+
+    def self.zscale_and_tonemap(options)
       if options[:tonemap]
-        # If we're attempting to convert HDR to SDR, use a set of
-        # 'zscale' filters, 'format' filters, and the 'tonemap' filter.
-        # The 'zscale' will do the resize for us as well.
-        filtergraph << 'zscale=' + %W[
-          dither=none
-          filter=lanczos
-          width=#{ options[:width] || 400 }
-          height=trunc(#{ options[:width] || 400 }/dar)
-        ].join(':')
-        filtergraph << 'zscale=transfer=linear:npl=100'
-        filtergraph << 'zscale=npl=100'
-        filtergraph << 'format=gbrpf32le'
-        filtergraph << 'zscale=primaries=bt709'
-        filtergraph << "tonemap=tonemap=#{options[:tonemap]}:desat=0"
-        filtergraph << 'zscale=transfer=bt709:matrix=bt709:range=tv'
-        filtergraph << 'format=yuv420p'
-      else
-        # If we're not attempting to convert HDR to SDR, the standard
-        # 'scale' filter is preferred (if we're resizing at all).
-        filtergraph << 'scale=' + %W[
-          flags=lanczos
-          sws_dither=none
-          width=#{ options[:width] || 400 }
-          height=trunc(#{ options[:width] || 400 }/dar)
-        ].join(':') unless options[:tonemap]
+        [
+          zscale(options),
+          tonemap(options)
+        ]
       end
+    end
+
+    def self.scale(options)
+      unless options[:tonemap]
+        scale_parameters = []
+
+        scale_parameters << 'flags=lanczos'
+        scale_parameters << 'sws_dither=none'
+        scale_parameters << "width=#{ options[:width] || 400 }"
+        scale_parameters << "height=trunc(#{ options[:width] || 400 }/dar)"
 
-      # Perform any desired equalization before we overlay text so that
-      # it won't be affected.
-      filtergraph << "eq=contrast=#{options[:contrast]}"     if options[:contrast]
-      filtergraph << "eq=brightness=#{options[:brightness]}" if options[:brightness]
-      filtergraph << "eq=saturation=#{options[:saturation]}" if options[:saturation]
-      filtergraph << "eq=gamma=#{options[:gamma]}"           if options[:gamma]
-      filtergraph << "eq=gamma_r=#{options[:gamma_r]}"       if options[:gamma_r]
-      filtergraph << "eq=gamma_g=#{options[:gamma_g]}"       if options[:gamma_g]
-      filtergraph << "eq=gamma_b=#{options[:gamma_b]}"       if options[:gamma_b]
-
-      # Embed text subtitles later so that they don't get processed by
-      # cropping, etc., which might accidentally crop them out.
-      if options[:subtitles] &&
-          options[:probe_infos][:streams].any? { |s| s[:codec_type] == 'subtitle' } &&
-          Subtitles::KNOWN_TEXT_FORMATS.include?(subtitle_info[:codec_name])
-        filtergraph << "setpts=PTS+#{Utils.duration_to_seconds(options[:seek])}/TB"
-        filtergraph << "subtitles='#{options[:input_filename]}':si=#{options[:subtitle_index]}"
-        filtergraph << 'setpts=PTS-STARTPTS'
+        'scale=' + scale_parameters.join(':')
       end
+    end
+
+    def self.eq(options)
+      eq_parameters = []
+
+      eq_parameters << "contrast=#{options[:contrast]}"     if options[:contrast]
+      eq_parameters << "brightness=#{options[:brightness]}" if options[:brightness]
+      eq_parameters << "saturation=#{options[:saturation]}" if options[:saturation]
+      eq_parameters << "gamma=#{options[:gamma]}"           if options[:gamma]
+      eq_parameters << "gamma_r=#{options[:gamma_r]}"       if options[:gamma_r]
+      eq_parameters << "gamma_g=#{options[:gamma_g]}"       if options[:gamma_g]
+      eq_parameters << "gamma_b=#{options[:gamma_b]}"       if options[:gamma_b]
+
+      'eq=' + eq_parameters.join(":")
+    end
+
+    def self.text(options)
+      options[:text].gsub(/\\n/,                                                        '')
+                    .gsub(/([:])/,                                                      '\\\\\\\\\\1')
+                    .gsub(/([,])/,                                                      '\\\\\\1')
+                    .gsub(/\b'\b/,                                                      "\u2019")
+                    .gsub(/\B"\b([^"\u201C\u201D\u201E\u201F\u2033\u2036\r\n]+)\b?"\B/, "\u201C\\1\u201D")
+                    .gsub(/\B'\b([^'\u2018\u2019\u201A\u201B\u2032\u2035\r\n]+)\b?'\B/, "\u2018\\1\u2019")
+    end
 
-      # If there is text to superimpose, do it here before palette
-      # generation to ensure the color looks appropriate.
+    def self.drawtext(options)
       if options[:text]
         count_of_lines = options[:text].scan(/\\n/).count + 1
-        text = options[:text]
-          .gsub(/\\n/,                                                        '')
-          .gsub(/([:])/,                                                      '\\\\\\\\\\1')
-          .gsub(/([,])/,                                                      '\\\\\\1')
-          .gsub(/\b'\b/,                                                      "\u2019")
-          .gsub(/\B"\b([^"\u201C\u201D\u201E\u201F\u2033\u2036\r\n]+)\b?"\B/, "\u201C\\1\u201D")
-          .gsub(/\B'\b([^'\u2018\u2019\u201A\u201B\u2032\u2035\r\n]+)\b?'\B/, "\u2018\\1\u2019")
-
-        filtergraph << 'drawtext=' + %W[
-          x='#{ options[:xpos] || '(main_w/2-text_w/2)' }'
-          y='#{ options[:ypos] || "(main_h-line_h*1.5*#{count_of_lines})" }'
-          fontsize='#{ options[:textsize] || 32 }'
-          fontcolor='#{ options[:textcolor] || 'white' }'
-          borderw='#{ options[:textborder] || 1 }'
-          fontfile='#{ options[:textfont] || 'Arial'}'\\\\:style='#{options[:textvariant] || 'Bold' }'
-          text='#{text}'
-        ].join(':')
+
+        drawtext_parameters = []
+        drawtext_parameters << "x='#{ options[:xpos] || '(main_w/2-text_w/2)' }'"
+        drawtext_parameters << "y='#{ options[:ypos] || "(main_h-line_h*1.5*#{count_of_lines})" }'"
+        drawtext_parameters << "fontsize='#{ options[:textsize] || 32 }'"
+        drawtext_parameters << "fontcolor='#{ options[:textcolor] || 'white' }'"
+        drawtext_parameters << "borderw='#{ options[:textborder] || 1 }'"
+        drawtext_parameters << "fontfile='#{ options[:textfont] || 'Arial'}'\\\\:style='#{options[:textvariant] || 'Bold' }'"
+        drawtext_parameters << "text='#{text(options)}'"
+
+        'drawtext=' + drawtext_parameters.join(':')
       end
+    end
+
+    def self.split
+      'split[palettegen][paletteuse]'
+    end
 
-      # Split the stream into two copies, labeled with output pads for
-      # the palettegen/paletteuse filters to use.
-      filtergraph << 'split[palettegen][paletteuse]'
-
-      # Using a copy of the stream created above labeled "palettegen",
-      # generate a palette from the stream using the specified number of
-      # colors and optimizing for moving objects in the stream. Label
-      # this stream's output as "palette."
-      filtergraph << '[palettegen]palettegen=' + %W[
-        #{options[:palette] || 256}
-        stats_mode=#{options[:palettemode] || 'diff'}
-      ].join(':') + '[palette]'
-
-      # Using a copy of the stream from the 'split' filter and the
-      # generated palette as inputs, apply the final palette to the GIF.
-      # For non-moving parts of the GIF, attempt to reuse the same
-      # palette from frame to frame.
-      filtergraph << '[paletteuse][palette]paletteuse=' + %W[
-        dither=#{options[:dither] || 'floyd_steinberg'}
-        diff_mode=rectangle
-        #{options[:palettemode] == 'single' ? 'new=1' : ''}
-      ].join(':')
+    def self.palettegen(options)
+      palettegen_parameters = []
+
+      palettegen_parameters << "#{ options[:palette] || 256 }"
+      palettegen_parameters << "stats_mode=#{options[:palettemode] || 'diff'}"
+
+      '[palettegen]palettegen=' + palettegen_parameters.join(':') + '[palette]'
+    end
+
+    def self.paletteuse(options)
+      paletteuse_parameters = []
+
+      paletteuse_parameters << "dither=#{options[:dither] || 'floyd_steinberg'}"
+      paletteuse_parameters << 'diff_mode=rectangle'
+      paletteuse_parameters << "#{options[:palettemode] == 'single' ? 'new=1' : ''}"
+
+      '[paletteuse][palette]paletteuse=' + paletteuse_parameters.join(':')
+    end
+
+    def self.filtergraph(options)
+      filtergraph = []
+
+      filtergraph << bitmap_subtitles_scale_overlay(options)
+      filtergraph << rate_with_interpolation(options)
+      filtergraph << fps(options)
+      filtergraph << options[:autocrop] if options[:autocrop]
+      filtergraph << crop(options)
+      filtergraph << zscale_and_tonemap(options)
+      filtergraph << scale(options)
+      filtergraph << eq(options)
+      filtergraph << text_subtitles(options)
+      filtergraph << drawtext(options)
+      filtergraph << split
+      filtergraph << palettegen(options)
+      filtergraph << paletteuse(options)
+
+      filtergraph.flatten.compact
     end
 
     def self.ffprobe_command(options, logger, executable: 'ffprobe')

data/lib/video2gif/ffmpeg/subtitles.rb

@@ -26,15 +26,73 @@ module Video2gif
         ttml
         vplayer
         webvtt
-      ]
+      ].freeze
 
       KNOWN_BITMAP_FORMATS = %w[
         dvb_subtitle
         dvd_subtitle
         hdmv_pgs_subtitle
         xsub
-      ]
+      ].freeze
+
+      def self.included(m)
+        m.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def has_subtitles(options)
+          options[:subtitles] && options[:probe_infos][:streams].any? { |s| s[:codec_type] == 'subtitle' }
+        end
+
+        def subtitle_info(options)
+          if has_subtitles(options)
+            options[:probe_infos][:streams].find_all { |s| s[:codec_type] == 'subtitle' }
+                                           .fetch(options[:subtitle_index], nil)
+          end
+        end
+
+        def has_bitmap_subtitles(options)
+          has_subtitles(options) && KNOWN_BITMAP_FORMATS.include?(subtitle_info(options)[:codec_name])
+        end
+
+        def has_text_subtitles(options)
+          has_subtitles(options) && KNOWN_TEXT_FORMATS.include?(subtitle_info(options)[:codec_name])
+        end
+
+        def subtitles_scale(options)
+          scale_parameters = []
+
+          scale_parameters << 'flags=lanczos'
+          scale_parameters << 'sws_dither=none'
+          scale_parameters << "width=#{video_info(options)[:width]}"
+          scale_parameters << "height=#{video_info(options)[:height]}"
+
+          "[0:s:#{options[:subtitle_index]}]scale=#{scale_parameters.join(':')}[subs]"
+        end
+
+        def subtitles_overlay
+          '[0:v][subs]overlay=format=auto'
+        end
+
+        def bitmap_subtitles_scale_overlay(options)
+          if has_bitmap_subtitles(options)
+            [
+              subtitles_scale(options),
+              subtitles_overlay
+            ]
+          end
+        end
+
+        def text_subtitles(options)
+          if has_text_subtitles(options)
+            %W[
+              setpts=PTS+#{Utils.duration_to_seconds(options[:seek])}/TB
+              subtitles='#{options[:input_filename]}':si=#{options[:subtitle_index]}
+              setpts=PTS-STARTPTS
+            ]
+          end
+        end
+      end
     end
   end
 end
-

data/lib/video2gif/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Video2gif
-  VERSION = '0.0.33'
+  VERSION = '0.0.34'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: video2gif
 version: !ruby/object:Gem::Version
-  version: 0.0.33
+  version: 0.0.34
 platform: ruby
 authors:
 - Emily St.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-06-14 00:00:00.000000000 Z
+date: 2019-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler