aspera-cli 4.5.0 → 4.8.0

data/lib/aspera/preview/generator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'open3'
 require 'aspera/preview/options'
 require 'aspera/preview/utils'
@@ -8,7 +10,7 @@ module Aspera
     # generate one preview file for one format for one file at a time
     class Generator
       # values for preview_format : output format
-      PREVIEW_FORMATS=[:png,:mp4]
+      PREVIEW_FORMATS = %i[png mp4].freeze
 
       # CLI needs to know conversion type to know if need skip it
       attr_reader :conversion_type
@@ -26,25 +28,25 @@ module Aspera
       # the conversion video->mp4 is implemented in methods: convert_video_to_mp4_using_<video_conversion>
       #  -> conversion method is one of Generator::VIDEO_CONVERSION_METHODS
       def initialize(options,src,dst,main_temp_dir,api_mime_type)
-        @options=options
-        @source_file_path=src
-        @destination_file_path=dst
-        @temp_folder=File.join(main_temp_dir,@source_file_path.split('/').last.gsub(/\s/, '_').gsub(/\W/, ''))
+        @options = options
+        @source_file_path = src
+        @destination_file_path = dst
+        @temp_folder = File.join(main_temp_dir,@source_file_path.split('/').last.gsub(/\s/, '_').gsub(/\W/, ''))
         # extract preview format from extension of target file
-        @preview_format_symb=File.extname(@destination_file_path).gsub(/^\./,'').to_sym
-        @conversion_type=FileTypes.instance.conversion_type(@source_file_path,api_mime_type)
+        @preview_format_symb = File.extname(@destination_file_path).gsub(/^\./,'').to_sym
+        @conversion_type = FileTypes.instance.conversion_type(@source_file_path,api_mime_type)
       end
 
       # name of processing method in this object
       # combination of: conversion type and output format (and video_conversion for video)
       def processing_method_symb
-        name="convert_#{@conversion_type}_to_#{@preview_format_symb}"
+        name = "convert_#{@conversion_type}_to_#{@preview_format_symb}"
         if @conversion_type.eql?(:video)
           case @preview_format_symb
           when :mp4
-            name="#{name}_using_#{@options.video_conversion}"
+            name = "#{name}_using_#{@options.video_conversion}"
           when :png
-            name="#{name}_using_#{@options.video_png_conv}"
+            name = "#{name}_using_#{@options.video_png_conv}"
           end
         end
         Log.log.debug("method: #{name}")
@@ -60,20 +62,20 @@ module Aspera
 
       # create preview as specified in constructor
       def generate
-        raise "could not detect type of file" if @conversion_type.nil?
-        method_symb=processing_method_symb
+        raise 'could not detect type of file' if @conversion_type.nil?
+        method_symb = processing_method_symb
         Log.log.info("#{@source_file_path}->#{@destination_file_path} (#{method_symb})")
         begin
-          self.send(method_symb)
+          send(method_symb)
           # check that generated size does not exceed maximum
-          result_size=File.size(@destination_file_path)
+          result_size = File.size(@destination_file_path)
           if result_size > @options.max_size
             Log.log.warn("preview size exceeds maximum #{result_size} > #{@options.max_size}")
           end
-        rescue => e
-          Log.log.error("#{e.message}")
+        rescue StandardError => e
+          Log.log.error("Ignoging: #{e.message}")
           Log.log.debug(e.backtrace.join("\n").red)
-          FileUtils.cp(File.expand_path(@preview_format_symb.eql?(:mp4)?'video_error.png':'image_error.png',File.dirname(__FILE__)),@destination_file_path)
+          FileUtils.cp(File.expand_path(@preview_format_symb.eql?(:mp4) ? 'video_error.png' : 'image_error.png',File.dirname(__FILE__)),@destination_file_path)
         ensure
           FileUtils.rm_rf(@temp_folder)
         end
@@ -93,17 +95,18 @@ module Aspera
       # @param total_count of parts
       # @param index of part (start at 1)
       def get_offset(duration, start_offset, total_count, index)
-        return start_offset + (index-1)*(1.0*duration - start_offset) / total_count
+        raise 'duration must be Float' unless duration.is_a?(Float)
+        return start_offset + ((index - 1) * (duration - start_offset) / total_count)
       end
 
-      def convert_video_to_mp4_using_blend()
+      def convert_video_to_mp4_using_blend
         p_duration = Utils.video_get_duration(@source_file_path)
         p_start_offset = @options.video_start_sec.to_i
         p_keyframecount = @options.blend_keyframes.to_i
         last_keyframe = nil
         current_index = 1
         1.upto(p_keyframecount) do |i|
-          offset_seconds=get_offset(p_duration,p_start_offset,p_keyframecount,i)
+          offset_seconds = get_offset(p_duration,p_start_offset,p_keyframecount,i)
           Utils.video_dump_frame(@source_file_path, offset_seconds, @options.video_scale, this_tmpdir, current_index)
           Utils.video_dupe_frame(this_tmpdir, current_index, @options.blend_pauseframes)
           Utils.video_blend_frames(this_tmpdir,last_keyframe, current_index) unless last_keyframe.nil?
@@ -113,95 +116,95 @@ module Aspera
           current_index = last_keyframe + 1 + @options.blend_transframes
         end
         Utils.ffmpeg(
-        in_f: Utils.ffmpeg_fmt(this_tmpdir),
-        in_p: ['-framerate',@options.blend_fps],
-        out_f: @destination_file_path,
-        out_p: [
-          '-filter:v',"scale='trunc(iw/2)*2:trunc(ih/2)*2'",
-          '-codec:v','libx264',
-          '-r',30,
-          '-pix_fmt','yuv420p'])
+          in_f: Utils.ffmpeg_fmt(this_tmpdir),
+          in_p: ['-framerate',@options.blend_fps],
+          out_f: @destination_file_path,
+          out_p: [
+            '-filter:v',"scale='trunc(iw/2)*2:trunc(ih/2)*2'",
+            '-codec:v','libx264',
+            '-r',30,
+            '-pix_fmt','yuv420p'])
       end
 
       # generate n clips starting at offset
-      def convert_video_to_mp4_using_clips()
+      def convert_video_to_mp4_using_clips
         p_duration = Utils.video_get_duration(@source_file_path)
         filelist = File.join(this_tmpdir,'clip_files.txt')
         File.open(filelist, 'w+') do |f|
           1.upto(@options.clips_count.to_i) do |i|
-            offset_seconds=get_offset(p_duration,@options.video_start_sec.to_i,@options.clips_count.to_i,i)
-            tmpfilename=sprintf("clip%04d.mp4",i)
+            offset_seconds = get_offset(p_duration,@options.video_start_sec.to_i,@options.clips_count.to_i,i)
+            tmpfilename = format('clip%04d.mp4',i)
             Utils.ffmpeg(
-            in_f: @source_file_path,
-            in_p: ['-ss',0.9*offset_seconds],
-            out_f: File.join(this_tmpdir,tmpfilename),
-            out_p: [
-              '-ss',0.1*offset_seconds,
-              '-t',@options.clips_length,
-              '-filter:v',"scale=#{@options.video_scale}",
-              '-codec:a','libmp3lame'])
+              in_f: @source_file_path,
+              in_p: ['-ss',0.9 * offset_seconds],
+              out_f: File.join(this_tmpdir,tmpfilename),
+              out_p: [
+                '-ss',0.1 * offset_seconds,
+                '-t',@options.clips_length,
+                '-filter:v',"scale=#{@options.video_scale}",
+                '-codec:a','libmp3lame'])
             f.puts("file '#{tmpfilename}'")
           end
         end
         # concat clips
         Utils.ffmpeg(
-        in_f: filelist,
-        in_p: ['-f','concat'],
-        out_f: @destination_file_path,
-        out_p: ['-codec','copy'])
+          in_f: filelist,
+          in_p: ['-f','concat'],
+          out_f: @destination_file_path,
+          out_p: ['-codec','copy'])
       end
 
       # do a simple reencoding
-      def convert_video_to_mp4_using_reencode()
+      def convert_video_to_mp4_using_reencode
         Utils.ffmpeg(
-        in_f: @source_file_path,
-        out_f: @destination_file_path,
-        out_p: [
-          '-t','60',
-          '-codec:v','libx264',
-          '-profile:v','high',
-          '-pix_fmt','yuv420p',
-          '-preset','slow',
-          '-b:v','500k',
-          '-maxrate','500k',
-          '-bufsize','1000k',
-          '-filter:v',"scale=#{@options.video_scale}",
-          '-threads','0',
-          '-codec:a','libmp3lame',
-          '-ac','2',
-          '-b:a','128k',
-          '-movflags','faststart'])
+          in_f: @source_file_path,
+          out_f: @destination_file_path,
+          out_p: [
+            '-t','60',
+            '-codec:v','libx264',
+            '-profile:v','high',
+            '-pix_fmt','yuv420p',
+            '-preset','slow',
+            '-b:v','500k',
+            '-maxrate','500k',
+            '-bufsize','1000k',
+            '-filter:v',"scale=#{@options.video_scale}",
+            '-threads','0',
+            '-codec:a','libmp3lame',
+            '-ac','2',
+            '-b:a','128k',
+            '-movflags','faststart'])
       end
 
-      def convert_video_to_png_using_fixed()
+      def convert_video_to_png_using_fixed
         Utils.video_dump_frame(
-        @source_file_path,
-        Utils.video_get_duration(@source_file_path)*@options.thumb_vid_fraction,
-        @options.thumb_vid_scale,
-        @destination_file_path)
+          @source_file_path,
+          Utils.video_get_duration(@source_file_path) * @options.thumb_vid_fraction,
+          @options.thumb_vid_scale,
+          @destination_file_path)
       end
 
       # https://trac.ffmpeg.org/wiki/SponsoringPrograms/GSoC/2015#AnimatedPortableNetworkGraphicsAPNG
       # ffmpeg -h muxer=apng
       # thumb is 32x32
       # ffmpeg  output.png
-      def convert_video_to_png_using_animated()
+      def convert_video_to_png_using_animated
         Utils.ffmpeg(
-        in_f: @source_file_path,
-        in_p: [
-          '-ss',10, # seek to input position
-          '-t',20, # max seconds
-        ],
-        out_f: @destination_file_path,
-        out_p: [
-          '-vf','fps=5,scale=120:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse',
-          '-loop',0,
-          '-f','gif'
-        ])
+          in_f: @source_file_path,
+          in_p: [
+            '-ss',10, # seek to input position
+            '-t',20 # max seconds
+          ],
+          out_f: @destination_file_path,
+          out_p: [
+            '-vf','fps=5,scale=120:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse',
+            '-loop',0,
+            '-f','gif'
+          ])
       end
 
-      def convert_office_to_png()
-        tmp_pdf_file=File.join(this_tmpdir,File.basename(@source_file_path,File.extname(@source_file_path))+'.pdf')
+      def convert_office_to_png
+        tmp_pdf_file = File.join(this_tmpdir,File.basename(@source_file_path,File.extname(@source_file_path)) + '.pdf')
         Utils.external_command(:unoconv,[
           '-f','pdf',
           '-o',tmp_pdf_file,
@@ -210,7 +213,7 @@ module Aspera
       end
 
       def convert_pdf_to_png(source_file_path=nil)
-        source_file_path||=@source_file_path
+        source_file_path ||= @source_file_path
         Utils.external_command(:convert,[
           '-size',"x#{@options.thumb_img_size}",
           '-background','white',
@@ -219,7 +222,7 @@ module Aspera
           @destination_file_path])
       end
 
-      def convert_image_to_png()
+      def convert_image_to_png
         Utils.external_command(:convert,[
           '-auto-orient',
           '-thumbnail',"#{@options.thumb_img_size}x#{@options.thumb_img_size}>",
@@ -232,23 +235,22 @@ module Aspera
       end
 
       # text to png
-      def convert_plaintext_to_png()
+      def convert_plaintext_to_png
         # get 100 first lines of text file
-        first_lines=File.open(@source_file_path){|f|100.times.map{f.readline rescue ''}}.join
+        first_lines = File.open(@source_file_path){|f|Array.new(100){f.readline rescue ''}.join}
         Utils.external_command(:convert,[
           '-size',"#{@options.thumb_img_size}x#{@options.thumb_img_size}",
-          'xc:white',
-          '-font','Courier',
+          'xc:white', # define canvas with background color (xc, or canvas) of preceding size
+          '-font',@options.thumb_text_font,
           '-pointsize',12,
-          '-fill','black',
-          '-annotate','+15+15',first_lines,
-          '-trim',
-          '-bordercolor','#FFF',
-          '-border',10,
+          '-fill','black', # font color
+          '-annotate','+0+0',first_lines,
+          '-trim', # avoid large blank regions
+          '-bordercolor','white',
+          '-border',8,
           '+repage',
           @destination_file_path])
       end
-
     end # Generator
   end # Preview
 end # Aspera

data/lib/aspera/preview/options.rb

@@ -1,31 +1,34 @@
+# frozen_string_literal: true
+
 module Aspera
   module Preview
     # generator options. Used as parameter to preview generator object.
     # also settable by command line.
     class Options
       # types of generation for video files
-      VIDEO_CONVERSION_METHODS=[:reencode,:blend,:clips]
-      VIDEO_THUMBNAIL_METHODS=[:fixed,:animated]
+      VIDEO_CONVERSION_METHODS = %i[reencode blend clips].freeze
+      VIDEO_THUMBNAIL_METHODS = %i[fixed animated].freeze
       # options used in generator
       # for scaling see: https://trac.ffmpeg.org/wiki/Scaling
       # iw/ih : input width or height
       # -x : keep aspect ratio, having value a multiple of x
       DESCRIPTIONS = [
-        { name: :max_size,             default: 1<<24,              description: "maximum size (in bytes) of preview file" },
-        { name: :thumb_vid_scale,      default: "-1:'min(ih,100)'", description: "png: video: size (ffmpeg scale argument)" },
-        { name: :thumb_vid_fraction,   default: 0.1,                description: "png: video: position of snapshot" },
-        { name: :thumb_img_size,       default: 800,                description: "png: non-video: height (and width)" },
-        { name: :video_conversion,     default: :reencode,          description: "mp4: method for preview generation", :values => VIDEO_CONVERSION_METHODS },
-        { name: :video_png_conv,       default: :fixed,             description: "mp4: method for thumbnail generation", :values => VIDEO_THUMBNAIL_METHODS },
-        { name: :video_start_sec,      default: 10,                 description: "mp4: start offset (seconds) of video preview" },
-        { name: :video_scale,          default: "'min(iw,360)':-2", description: "mp4: video scale (ffmpeg)" },
-        { name: :blend_keyframes,      default: 30,                 description: "mp4: blend: # key frames" },
-        { name: :blend_pauseframes,    default: 3,                  description: "mp4: blend: # pause frames" },
-        { name: :blend_transframes,    default: 5,                  description: "mp4: blend: # transition blend frames" },
-        { name: :blend_fps,            default: 15,                 description: "mp4: blend: frame per second" },
-        { name: :clips_count,          default: 5,                  description: "mp4: clips: number of clips" },
-        { name: :clips_length,         default: 5,                  description: "mp4: clips: length in seconds of each clips" },
-      ]
+        { name: :max_size,             default: 1 << 24,            description: 'maximum size (in bytes) of preview file' },
+        { name: :thumb_vid_scale,      default: "-1:'min(ih,100)'", description: 'png: video: size (ffmpeg scale argument)' },
+        { name: :thumb_vid_fraction,   default: 0.1,                description: 'png: video: time percent position of snapshot' },
+        { name: :thumb_img_size,       default: 800,                description: 'png: non-video: height (and width)' },
+        { name: :thumb_text_font,      default: 'Courier',          description: 'png: plaintext: font to render text with imagemagick convert (identify -list font)'},
+        { name: :video_conversion,     default: :reencode,          description: 'mp4: method for preview generation', values: VIDEO_CONVERSION_METHODS },
+        { name: :video_png_conv,       default: :fixed,             description: 'mp4: method for thumbnail generation', values: VIDEO_THUMBNAIL_METHODS },
+        { name: :video_start_sec,      default: 10,                 description: 'mp4: start offset (seconds) of video preview' },
+        { name: :video_scale,          default: "'min(iw,360)':-2", description: 'mp4: video scale (ffmpeg)' },
+        { name: :blend_keyframes,      default: 30,                 description: 'mp4: blend: # key frames' },
+        { name: :blend_pauseframes,    default: 3,                  description: 'mp4: blend: # pause frames' },
+        { name: :blend_transframes,    default: 5,                  description: 'mp4: blend: # transition blend frames' },
+        { name: :blend_fps,            default: 15,                 description: 'mp4: blend: frame per second' },
+        { name: :clips_count,          default: 5,                  description: 'mp4: clips: number of clips' },
+        { name: :clips_length,         default: 5,                  description: 'mp4: clips: length in seconds of each clips' }
+      ].freeze
       # add accessors
       DESCRIPTIONS.each do |opt|
         attr_accessor opt[:name]

data/lib/aspera/preview/utils.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+require 'English'
 require 'tmpdir'
 require 'fileutils'
 require 'aspera/log'
@@ -7,124 +10,118 @@ module Aspera
   module Preview
     class Utils
       # from bash manual: meta-character need to be escaped
-      BASH_SPECIAL_CHARACTERS="|&;()<> \t#\n"
+      BASH_SPECIAL_CHARACTERS = "|&;()<> \t#\n"
       # shell exit code when command is not found
-      BASH_EXIT_NOT_FOUND=127
+      BASH_EXIT_NOT_FOUND = 127
       # external binaries used
-      EXPERNAL_TOOLS=[:ffmpeg,:ffprobe,:convert,:composite,:optipng,:unoconv]
-      private_constant :BASH_SPECIAL_CHARACTERS,:BASH_EXIT_NOT_FOUND,:EXPERNAL_TOOLS
-
-      # returns string with single quotes suitable for bash if there is any bash metacharacter
-      def self.shell_quote(argument)
-        return argument unless argument.split('').any?{|c|BASH_SPECIAL_CHARACTERS.include?(c)}
-        return "'"+argument.gsub(/'/){|s| "'\"'\"'"}+"'"
-      end
+      EXPERNAL_TOOLS = %i[ffmpeg ffprobe convert composite optipng unoconv].freeze
+      TMPFMT = 'img%04d.jpg'
+      private_constant :BASH_SPECIAL_CHARACTERS,:BASH_EXIT_NOT_FOUND,:EXPERNAL_TOOLS,:TMPFMT
 
-      # check that external tools can be executed
-      def self.check_tools(skip_types=[])
-        EXPERNAL_TOOLS.delete(:unoconv) if skip_types.include?(:office)
-        # Check for binaries
-        EXPERNAL_TOOLS.map{|i|i.to_s}.each do |bin|
-          `#{bin} -h 2>&1`
-          raise "Error: #{bin} is not in the PATH" if $?.exitstatus.eql?(BASH_EXIT_NOT_FOUND)
+      class << self
+        # returns string with single quotes suitable for bash if there is any bash metacharacter
+        def shell_quote(argument)
+          return argument unless argument.chars.any?{|c|BASH_SPECIAL_CHARACTERS.include?(c)}
+          return "'" + argument.gsub(/'/){|_s| "'\"'\"'"} + "'"
         end
-      end
 
-      # execute external command
-      # one could use "system", but we would need to redirect stdout/err
-      # @return true if su
-      def self.external_command(command_symb,command_args,stdout_return=nil)
-        raise "unexpected command #{command_symb}" unless EXPERNAL_TOOLS.include?(command_symb)
-        # build command line, and quote special characters
-        command=command_args.clone.unshift(command_symb).map{|i| shell_quote(i.to_s)}.join(' ')
-        Log.log.debug("cmd=#{command}".blue)
-        # capture3: only in ruby2+
-        if Open3.respond_to?('capture3') then
-          stdout, stderr, exit_status = Open3.capture3(command)
-        else
-          stderr='<merged with stdout>'
-          stdout=%x[#{command} 2>&1]
-          exit_status=$?
-        end
-        if BASH_EXIT_NOT_FOUND.eql?(exit_status)
-          raise "Error: #{bin} is not in the PATH"
-        end
-        unless exit_status.success?
-          Log.log.error("commandline: #{command}")
-          Log.log.error("Error code: #{exit_status}")
-          Log.log.error("stdout: #{stdout}")
-          Log.log.error("stderr: #{stderr}")
-          raise "command returned error"
+        # check that external tools can be executed
+        def check_tools(skip_types=[])
+          tools_to_check=EXPERNAL_TOOLS.dup
+          tools_to_check.delete(:unoconv) if skip_types.include?(:office)
+          # Check for binaries
+          tools_to_check.each do |command_symb|
+            external_command(command_symb,['-h'])
+          end
         end
-        stdout_return.replace(stdout) unless stdout_return.nil?
-        return exit_status.success?
-      end
-
-      def self.ffmpeg(a)
-        raise "error: hash expected" unless a.is_a?(Hash)
-        #input_file,input_args,output_file,output_args
-        a[:gl_p]||=[
-          '-y', # overwrite output without asking
-          '-loglevel','error', # show only errors and up]
-        ]
-        a[:in_p]||=[]
-        a[:out_p]||=[]
-        raise "wrong params (#{a.keys.sort})" unless [:gl_p, :in_f, :in_p, :out_f, :out_p].eql?(a.keys.sort)
-        external_command(:ffmpeg,[a[:gl_p],a[:in_p],'-i',a[:in_f],a[:out_p],a[:out_f]].flatten)
-      end
 
-      def self.video_get_duration(input_file)
-        result = String.new
-        external_command(:ffprobe,[
-          '-loglevel','error',
-          '-show_entries','format=duration',
-          '-print_format','default=noprint_wrappers=1:nokey=1',
-          input_file],result)
-        result.to_f
-      end
+        # execute external command
+        # one could use "system", but we would need to redirect stdout/err
+        # @return true if su
+        def external_command(command_symb,command_args)
+          raise "unexpected command #{command_symb}" unless EXPERNAL_TOOLS.include?(command_symb)
+          # build command line, and quote special characters
+          command = command_args.clone.unshift(command_symb).map{|i| shell_quote(i.to_s)}.join(' ')
+          Log.log.debug("cmd=#{command}".blue)
+          # capture3: only in ruby2+
+          if Open3.respond_to?(:capture3)
+            stdout, stderr, exit_status = Open3.capture3(command)
+          else
+            stderr = '<merged with stdout>'
+            stdout = %x(#{command} 2>&1)
+            exit_status = $CHILD_STATUS
+          end
+          if BASH_EXIT_NOT_FOUND.eql?(exit_status)
+            raise "Error: #{command_symb} is not in the PATH"
+          end
+          unless exit_status.success?
+            Log.log.error("commandline: #{command}")
+            Log.log.error("Error code: #{exit_status}")
+            Log.log.error("stdout: #{stdout}")
+            Log.log.error("stderr: #{stderr}")
+            raise "#{command_symb} error #{exit_status}"
+          end
+          return {status: exit_status, stdout: stdout}
+        end
 
-      TMPFMT='img%04d.jpg'
+        def ffmpeg(a)
+          raise 'error: hash expected' unless a.is_a?(Hash)
+          #input_file,input_args,output_file,output_args
+          a[:gl_p] ||= [
+            '-y', # overwrite output without asking
+            '-loglevel','error' # show only errors and up]
+          ]
+          a[:in_p] ||= []
+          a[:out_p] ||= []
+          raise "wrong params (#{a.keys.sort})" unless %i[gl_p in_f in_p out_f out_p].eql?(a.keys.sort)
+          external_command(:ffmpeg,[a[:gl_p],a[:in_p],'-i',a[:in_f],a[:out_p],a[:out_f]].flatten)
+        end
 
-      def self.ffmpeg_fmt(temp_folder)
-        return File.join(temp_folder,TMPFMT)
-      end
+        # @return Float in seconds
+        def video_get_duration(input_file)
+          result = external_command(:ffprobe,[
+            '-loglevel','error',
+            '-show_entries','format=duration',
+            '-print_format','default=noprint_wrappers=1:nokey=1',
+            input_file])
+          return result[:stdout].to_f
+        end
 
-      def self.get_tmp_num_filepath(temp_folder, file_number)
-        return File.join(temp_folder,sprintf(TMPFMT,file_number))
-      end
+        def ffmpeg_fmt(temp_folder)
+          return File.join(temp_folder,TMPFMT)
+        end
 
-      def self.video_dupe_frame(temp_folder, index, count)
-        input_file=get_tmp_num_filepath(temp_folder,index)
-        1.upto(count) do |i|
-          FileUtils.ln_s(input_file,get_tmp_num_filepath(temp_folder,index+i))
+        def get_tmp_num_filepath(temp_folder, file_number)
+          return File.join(temp_folder,format(TMPFMT,file_number))
         end
-      end
 
-      def self.video_blend_frames(temp_folder, index1, index2)
-        img1=get_tmp_num_filepath(temp_folder,index1)
-        img2=get_tmp_num_filepath(temp_folder,index2)
-        count=index2-index1-1
-        1.upto(count) do |i|
-          percent = 100 * i / (count + 1)
-          filename = get_tmp_num_filepath(temp_folder, index1 + i)
-          external_command(:composite,['-blend',percent,img2,img1,filename])
+        def video_dupe_frame(temp_folder, index, count)
+          input_file = get_tmp_num_filepath(temp_folder,index)
+          1.upto(count) do |i|
+            FileUtils.ln_s(input_file,get_tmp_num_filepath(temp_folder,index + i))
+          end
         end
-      end
 
-      def self.video_dump_frame(input_file, offset_seconds, scale, output_file, index=nil)
-        output_file=get_tmp_num_filepath(output_file,index) unless index.nil?
-        ffmpeg(
-        in_f: input_file,
-        in_p: ['-ss',offset_seconds],
-        out_f: output_file,
-        out_p: ['-frames:v',1,'-filter:v',"scale=#{scale}"])
-        return output_file
-      end
+        def video_blend_frames(temp_folder, index1, index2)
+          img1 = get_tmp_num_filepath(temp_folder,index1)
+          img2 = get_tmp_num_filepath(temp_folder,index2)
+          count = index2 - index1 - 1
+          1.upto(count) do |i|
+            percent = 100 * i / (count + 1)
+            filename = get_tmp_num_filepath(temp_folder, index1 + i)
+            external_command(:composite,['-blend',percent,img2,img1,filename])
+          end
+        end
 
-      def message_to_png(message)
-        # convert -size 400x  -background '#666666' -fill '#ffffff'  -interword-spacing 10 -kerning 4 -pointsize 10 -gravity West -size x22 label:"Lorem dolor sit amet" -flatten xxx.png
-        external_command(:convert,[
-        ])
+        def video_dump_frame(input_file, offset_seconds, scale, output_file, index=nil)
+          output_file = get_tmp_num_filepath(output_file,index) unless index.nil?
+          ffmpeg(
+            in_f: input_file,
+            in_p: ['-ss',offset_seconds],
+            out_f: output_file,
+            out_p: ['-frames:v',1,'-filter:v',"scale=#{scale}"])
+          return output_file
+        end
       end
     end # Options
   end # Preview