aspera-cli 4.0.0.pre1

data/lib/aspera/persistency_action_once.rb

@@ -0,0 +1,42 @@
+require 'json'
+require 'aspera/log'
+
+module Aspera
+  # Persist data on file system
+  class PersistencyActionOnce
+    # @param :manager  Mandatory Database
+    # @param :data     Mandatory object to persist, must be same object from begin to end (assume array by default)
+    # @param :ids      Mandatory identifiers
+    # @param :delete   Optional  delete persistency condition
+    # @param :parse    Optional  parse method (default to JSON)
+    # @param :format   Optional  dump method (default to JSON)
+    # @param :merge    Optional  merge data from file to current data
+    def initialize(options)
+      Log.log.debug("persistency: #{options}")
+      raise "options shall be Hash" unless options.is_a?(Hash)
+      raise "mandatory :manager" if options[:manager].nil?
+      raise "mandatory :data" if options[:data].nil?
+      raise "mandatory :ids (Array)" unless options[:ids].is_a?(Array)
+      raise "mandatory 1 element in :ids" unless options[:ids].length >= 1
+      @manager=options[:manager]
+      @persisted_object=options[:data]
+      @object_ids=options[:ids]
+      # by default , at save time, file is deleted if data is nil
+      @delete_condition=options[:delete] || lambda{|d|d.empty?}
+      @persist_format=options[:format] || lambda {|h| JSON.generate(h)}
+      persist_parse=options[:parse] || lambda {|t| JSON.parse(t)}
+      persist_merge=options[:merge] || lambda {|current,file| current.concat(file).uniq rescue current}
+      value=@manager.get(@object_ids)
+      persist_merge.call(@persisted_object,persist_parse.call(value)) unless value.nil?
+    end
+
+    def save
+      if @delete_condition.call(@persisted_object)
+        @manager.delete(@object_ids)
+      else
+        @manager.put(@object_ids,@persist_format.call(@persisted_object))
+      end
+    end
+
+  end
+end

data/lib/aspera/persistency_folder.rb

@@ -0,0 +1,91 @@
+require 'fileutils'
+require 'aspera/log'
+
+# search: persistency_folder PersistencyFolder
+
+module Aspera
+  # Persist data on file system
+  class PersistencyFolder
+    WINDOWS_PROTECTED_CHAR=%r{[/:"<>\\\*\?]}
+    PROTECTED_CHAR_REPLACE='_'
+    ID_SEPARATOR='_'
+    FILE_SUFFIX='.txt'
+    private_constant :PROTECTED_CHAR_REPLACE,:FILE_SUFFIX,:WINDOWS_PROTECTED_CHAR,:ID_SEPARATOR
+    def initialize(folder)
+      @cache={}
+      set_folder(folder)
+    end
+
+    def set_folder(folder)
+      @folder=folder
+      Log.log.debug("persistency folder: #{@folder}")
+    end
+
+    # @return String or nil string on existing persist, else nil
+    def get(object_id)
+      object_id=marshalled_id(object_id)
+      Log.log.debug("persistency get: #{object_id}")
+      if @cache.has_key?(object_id)
+        Log.log.debug("got from memory cache")
+      else
+        persist_filepath=id_to_filepath(object_id)
+        Log.log.debug("persistency = #{persist_filepath}")
+        if File.exist?(persist_filepath)
+          Log.log.debug("got from file cache")
+          @cache[object_id]=File.read(persist_filepath)
+        end
+      end
+      return @cache[object_id]
+    end
+
+    def put(object_id,value)
+      raise "only String supported" unless value.is_a?(String)
+      object_id=marshalled_id(object_id)
+      persist_filepath=id_to_filepath(object_id)
+      Log.log.debug("saving: #{persist_filepath}")
+      File.write(persist_filepath,value)
+      @cache[object_id]=value
+    end
+
+    def delete(object_id)
+      object_id=marshalled_id(object_id)
+      persist_filepath=id_to_filepath(object_id)
+      Log.log.debug("empty data, deleting: #{persist_filepath}")
+      File.delete(persist_filepath) if File.exist?(persist_filepath)
+      @cache.delete(object_id)
+    end
+
+    def flush_by_prefix(persist_category)
+      persist_files=Dir[File.join(@folder,persist_category+'*'+FILE_SUFFIX)]
+      persist_files.each do |filepath|
+        File.delete(filepath)
+      end
+      return persist_files
+    end
+
+    private
+
+    # @param object_id String or Array
+    def id_to_filepath(object_id)
+      FileUtils.mkdir_p(@folder)
+      return File.join(@folder,"#{object_id}#{FILE_SUFFIX}")
+      #.gsub(/[^a-z]+/,FILE_FIELD_SEPARATOR)
+    end
+
+    def marshalled_id(object_id)
+      if object_id.is_a?(Array)
+        # special case, url in second position: TODO: check any position
+        if object_id[1].is_a?(String) and object_id[1] =~ URI::ABS_URI
+          object_id=object_id.clone
+          object_id[1]=URI.parse(object_id[1]).host
+        end
+        object_id=object_id.join(ID_SEPARATOR)
+      end
+      raise "id must be a String" unless object_id.is_a?(String)
+      return object_id.
+      gsub(WINDOWS_PROTECTED_CHAR,PROTECTED_CHAR_REPLACE). # remove windows forbidden chars
+      gsub('.',PROTECTED_CHAR_REPLACE).  # keep dot for extension only (nicer)
+      downcase
+    end
+  end # PersistencyFolder
+end # Aspera

data/lib/aspera/preview/file_types.rb

@@ -0,0 +1,300 @@
+require 'mimemagic'
+require 'mimemagic/overlay'
+
+module Aspera
+  module Preview
+    class FileTypes
+      # values for conversion_type : input format
+      CONVERSION_TYPES=[
+        :image,
+        :office,
+        :pdf,
+        :plaintext,
+        :video
+      ]
+
+      # define how files are processed based on mime type
+      SUPPORTED_MIME_TYPES={
+        'application/json' => :plaintext,
+        'application/mac-binhex40' => :office,
+        'application/msword' => :office,
+        'application/pdf' => :pdf,
+        'application/postscript' => :image,
+        'application/rtf' => :office,
+        'application/vnd.3gpp.pic-bw-small' => :image,
+        'application/vnd.hp-hpgl' => :image,
+        'application/vnd.hp-pcl' => :image,
+        'application/vnd.lotus-wordpro' => :office,
+        'application/vnd.mobius.msl' => :image,
+        'application/vnd.mophun.certificate' => :image,
+        'application/vnd.ms-excel' => :office,
+        'application/vnd.ms-excel.sheet.binary.macroenabled.12' => :office,
+        'application/vnd.ms-excel.sheet.macroenabled.12' => :office,
+        'application/vnd.ms-excel.template.macroenabled.12' => :office,
+        'application/vnd.ms-powerpoint' => :office,
+        'application/vnd.ms-powerpoint.presentation.macroenabled.12' => :office,
+        'application/vnd.ms-powerpoint.template.macroenabled.12' => :office,
+        'application/vnd.ms-word.document.macroenabled.12' => :office,
+        'application/vnd.ms-word.template.macroenabled.12' => :office,
+        'application/vnd.ms-works' => :office,
+        'application/vnd.oasis.opendocument.chart' => :office,
+        'application/vnd.oasis.opendocument.formula' => :office,
+        'application/vnd.oasis.opendocument.graphics' => :office,
+        'application/vnd.oasis.opendocument.graphics-template' => :office,
+        'application/vnd.oasis.opendocument.presentation' => :office,
+        'application/vnd.oasis.opendocument.presentation-template' => :office,
+        'application/vnd.oasis.opendocument.spreadsheet' => :office,
+        'application/vnd.oasis.opendocument.spreadsheet-template' => :office,
+        'application/vnd.oasis.opendocument.text' => :office,
+        'application/vnd.oasis.opendocument.text-template' => :office,
+        'application/vnd.openxmlformats-officedocument.presentationml.presentation' => :office,
+        'application/vnd.openxmlformats-officedocument.presentationml.slideshow' => :office,
+        'application/vnd.openxmlformats-officedocument.presentationml.template' => :office,
+        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' => :office,
+        'application/vnd.openxmlformats-officedocument.spreadsheetml.template' => :office,
+        'application/vnd.openxmlformats-officedocument.wordprocessingml.document' => :office,
+        'application/vnd.openxmlformats-officedocument.wordprocessingml.template' => :office,
+        'application/vnd.palm' => :office,
+        'application/vnd.sun.xml.calc' => :office,
+        'application/vnd.sun.xml.calc.template' => :office,
+        'application/vnd.sun.xml.draw' => :office,
+        'application/vnd.sun.xml.draw.template' => :office,
+        'application/vnd.sun.xml.impress' => :office,
+        'application/vnd.sun.xml.impress.template' => :office,
+        'application/vnd.sun.xml.math' => :office,
+        'application/vnd.sun.xml.writer' => :office,
+        'application/vnd.sun.xml.writer.template' => :office,
+        'application/vnd.wordperfect' => :office,
+        'application/x-abiword' => :office,
+        'application/x-director' => :image,
+        'application/x-font-type1' => :image,
+        'application/x-msmetafile' => :image,
+        'application/x-mspublisher' => :office,
+        'application/x-xfig' => :image,
+        'audio/ogg' => :video,
+        'font/ttf' => :image,
+        'image/bmp' => :image,
+        'image/cgm' => :image,
+        'image/gif' => :image,
+        'image/jpeg' => :image,
+        'image/png' => :image,
+        'image/sgi' => :image,
+        'image/svg+xml' => :image,
+        'image/tiff' => :image,
+        'image/vnd.adobe.photoshop' => :image,
+        'image/vnd.djvu' => :image,
+        'image/vnd.dxf' => :office,
+        'image/vnd.fpx' => :image,
+        'image/vnd.ms-photo' => :image,
+        'image/vnd.wap.wbmp' => :image,
+        'image/webp' => :image,
+        'image/x-cmx' => :office,
+        'image/x-freehand' => :office,
+        'image/x-icon' => :image,
+        'image/x-mrsid-image' => :image,
+        'image/x-pcx' => :image,
+        'image/x-pict' => :office,
+        'image/x-portable-anymap' => :image,
+        'image/x-portable-bitmap' => :image,
+        'image/x-portable-graymap' => :image,
+        'image/x-portable-pixmap' => :image,
+        'image/x-rgb' => :image,
+        'image/x-tga' => :image,
+        'image/x-xbitmap' => :image,
+        'image/x-xpixmap' => :image,
+        'image/x-xwindowdump' => :image,
+        'text/csv' => :office,
+        'text/html' => :office,
+        'text/plain' => :plaintext,
+        'text/troff' => :image,
+        'video/h261' => :video,
+        'video/h263' => :video,
+        'video/h264' => :video,
+        'video/mp4' => :video,
+        'video/mpeg' => :video,
+        'video/quicktime' => :video,
+        'video/x-flv' => :video,
+        'video/x-m4v' => :video,
+        'video/x-matroska' => :video,
+        'video/x-mng' => :image,
+        'video/x-ms-wmv' => :video,
+        'video/x-msvideo' => :video}
+
+      # this is a way to add support for extensions that are otherwise not known by node api (mime type)
+      SUPPORTED_EXTENSIONS={
+        'aai' => :image,
+        'art' => :image,
+        'arw' => :image,
+        'avs' => :image,
+        'bmp2' => :image,
+        'bmp3' => :image,
+        'bpg' => :image,
+        'cals' => :image,
+        'cdr' => :office,
+        'cin' => :image,
+        'clipboard' => :image,
+        'cmyk' => :image,
+        'cmyka' => :image,
+        'cr2' => :image,
+        'crw' => :image,
+        'cur' => :image,
+        'cut' => :image,
+        'cwk' => :office,
+        'dbf' => :office,
+        'dcm' => :image,
+        'dcx' => :image,
+        'dds' => :image,
+        'dib' => :image,
+        'dif' => :office,
+        'divx' => :video,
+        'dng' => :image,
+        'dpx' => :image,
+        'epdf' => :image,
+        'epi' => :image,
+        'eps2' => :image,
+        'eps3' => :image,
+        'epsf' => :image,
+        'epsi' => :image,
+        'ept' => :image,
+        'exr' => :image,
+        'fax' => :image,
+        'fb2' => :office,
+        'fits' => :image,
+        'fodg' => :office,
+        'fodp' => :office,
+        'fods' => :office,
+        'fodt' => :office,
+        'gplt' => :image,
+        'gray' => :image,
+        'hdr' => :image,
+        'hpw' => :office,
+        'hrz' => :image,
+        'info' => :image,
+        'inline' => :image,
+        'j2c' => :image,
+        'j2k' => :image,
+        'jbig' => :image,
+        'jng' => :image,
+        'jp2' => :image,
+        'jpt' => :image,
+        'jxr' => :image,
+        'key' => :office,
+        'log' => :plaintext,
+        'mat' => :image,
+        'mcw' => :office,
+        'met' => :office,
+        'miff' => :image,
+        'mml' => :office,
+        'mono' => :image,
+        'mpr' => :image,
+        'mrsid' => :image,
+        'mrw' => :image,
+        'mtv' => :image,
+        'mvg' => :image,
+        'mw' => :office,
+        'mwd' => :office,
+        'mxf' => :video,
+        'nef' => :image,
+        'numbers' => :office,
+        'orf' => :image,
+        'otb' => :image,
+        'p7' => :image,
+        'pages' => :office,
+        'palm' => :image,
+        'pam' => :image,
+        'pcd' => :image,
+        'pcds' => :image,
+        'pef' => :image,
+        'picon' => :image,
+        'pict' => :image,
+        'pix' => :image,
+        'pm' => :office,
+        'pm6' => :office,
+        'pmd' => :office,
+        'png00' => :image,
+        'png24' => :image,
+        'png32' => :image,
+        'png48' => :image,
+        'png64' => :image,
+        'png8' => :image,
+        'ps2' => :image,
+        'ps3' => :image,
+        'ptif' => :image,
+        'pwp' => :image,
+        'rad' => :image,
+        'raf' => :image,
+        'rfg' => :image,
+        'rgba' => :image,
+        'rla' => :image,
+        'rle' => :image,
+        'sct' => :image,
+        'sfw' => :image,
+        'sgf' => :office,
+        'sgv' => :office,
+        'slk' => :office,
+        'sparse-color' => :image,
+        'sun' => :image,
+        'svm' => :office,
+        'sylk' => :office,
+        'tim' => :image,
+        'txt' => :plaintext,
+        'uil' => :image,
+        'uof' => :office,
+        'uop' => :office,
+        'uos' => :office,
+        'uot' => :office,
+        'uyvy' => :image,
+        'vds' => :office,
+        'vdx' => :office,
+        'vicar' => :image,
+        'viff' => :image,
+        'vsdx' => :office,
+        'webm' => :video,
+        'wb2' => :office,
+        'wk1' => :office,
+        'wk3' => :office,
+        'wn' => :office,
+        'wpg' => :image,
+        'wq1' => :office,
+        'wq2' => :office,
+        'x' => :image,
+        'x3f' => :image,
+        'xcf' => :image,
+        'xlk' => :office,
+        'ycbcr' => :image,
+        'ycbcra' => :image,
+        'yuv' => :image,
+        'zabw' => :office}
+
+      #private_constant :SUPPORTED_MIME_TYPES, :SUPPORTED_EXTENSIONS
+
+      def self.mime_from_file(filepath)
+        detected_mime=MimeMagic.by_magic(File.open(filepath)).to_s
+        detected_mime=MimeMagic.by_path(filepath).to_s if detected_mime.empty?
+        detected_mime=nil if detected_mime.empty?
+        return detected_mime
+      end
+
+      def self.conversion_type(filepath,mimetype,try_local_mime)
+        detected_mime=nil
+        if try_local_mime
+          detected_mime=mime_from_file(filepath)
+          if mimetype.eql?(detected_mime)
+            Log.log.debug("matching mime type per magic number")
+          else
+            # note: detected can be nil
+            Log.log.debug("non matching mime types: node=[#{mimetype}], magic=[#{detected_mime}]")
+          end
+        end
+        # 1- get type from provided mime type
+        result=FileTypes::SUPPORTED_MIME_TYPES[mimetype] unless mimetype.nil?
+        # 2- else, from computed mime type
+        result||=FileTypes::SUPPORTED_MIME_TYPES[detected_mime] unless detected_mime.nil?
+        extension = File.extname(filepath).downcase.gsub(/^\./,'')
+        # 3- else, from local extensions
+        result||=FileTypes::SUPPORTED_EXTENSIONS[extension]
+        return result
+      end
+    end
+  end
+end

data/lib/aspera/preview/generator.rb

@@ -0,0 +1,258 @@
+require 'open3'
+require 'aspera/preview/options'
+require 'aspera/preview/utils'
+require 'aspera/preview/file_types'
+
+module Aspera
+  module Preview
+    # 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]
+
+      # CLI needs to know conversion type to know if need skip it
+      attr_reader :conversion_type
+
+      # @param src source file path
+      # @param dst destination file path
+      # @param api_mime_type optional mime type as provided by node api
+      # node API mime types are from: http://svn.apache.org/repos/asf/httpd/httpd/trunk/docs/conf/mime.types
+      # supported preview type is one of Preview::PREVIEW_FORMATS
+      # the resulting preview file type is taken from destination file extension.
+      # conversion methods are provided by private methods: convert_<conversion_type>_to_<preview_format>
+      # (combi = combination of source file type and destination format)
+      #   -> conversion_type is one of FileTypes::CONVERSION_TYPES
+      #   -> preview_format is one of Generator::PREVIEW_FORMATS
+      # 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=nil,try_local_mime=true)
+        @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.conversion_type(@source_file_path,api_mime_type,try_local_mime)
+      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}"
+        if @conversion_type.eql?(:video)
+          case @preview_format_symb
+          when :mp4
+            name="#{name}_using_#{@options.video_conversion}"
+          when :png
+            name="#{name}_using_#{@options.video_png_conv}"
+          end
+        end
+        Log.log.debug("method: #{name}")
+        return name.to_sym
+      end
+
+      # @return true if conversion is supported.
+      # for instance, plaintext to mp4 is not supported
+      def supported?
+        return false if @conversion_type.nil?
+        return respond_to?(processing_method_symb,true)
+      end
+
+      # create preview as specified in constructor
+      def generate
+        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)
+          # check that generated size does not exceed maximum
+          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}")
+          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)
+        ensure
+          FileUtils.rm_rf(@temp_folder)
+        end
+      end
+
+      private
+
+      # creates a unique temp folder for file
+      def this_tmpdir
+        FileUtils.mkdir_p(@temp_folder)
+        return @temp_folder
+      end
+
+      # @return offset in seconds suitable for ffmpeg -ss option
+      # @param duration of video
+      # @param start_offset of parts
+      # @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
+      end
+
+      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)
+          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?
+          # go to last dupe frame
+          last_keyframe = current_index + @options.blend_pauseframes
+          # go after last dupe frame and keep space to blend
+          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'])
+      end
+
+      # generate n clips starting at offset
+      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)
+            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'])
+            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'])
+      end
+
+      # do a simple reencoding
+      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'])
+      end
+
+      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)
+      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()
+        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'
+        ])
+      end
+
+      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,
+          @source_file_path])
+        convert_pdf_to_png(tmp_pdf_file)
+      end
+
+      def convert_pdf_to_png(source_file_path=nil)
+        source_file_path||=@source_file_path
+        Utils.external_command(:convert,[
+
+          '-size',"x#{@options.thumb_img_size}",
+          '-background','white',
+          '-flatten',
+          "#{source_file_path}[0]",
+          @destination_file_path])
+      end
+
+      def convert_image_to_png()
+        Utils.external_command(:convert,[
+
+          '-auto-orient',
+          '-thumbnail',"#{@options.thumb_img_size}x#{@options.thumb_img_size}>",
+          '-quality',95,
+          '+dither',
+          '-posterize',40,
+          "#{@source_file_path}[0]",
+          @destination_file_path])
+        Utils.external_command(:optipng,[@destination_file_path])
+      end
+
+      # text 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
+        Utils.external_command(:convert,[
+
+          '-size',"#{@options.thumb_img_size}x#{@options.thumb_img_size}",
+          'xc:white',
+          '-font','Courier',
+          '-pointsize',12,
+          '-fill','black',
+          '-annotate','+15+15',first_lines,
+          '-trim',
+          '-bordercolor','#FFF',
+          '-border',10,
+          '+repage',
+          @destination_file_path])
+      end
+
+    end # Generator
+  end # Preview
+end # Aspera