libis-format 1.2.9 → 2.0.0

data/lib/libis/format/converter/audio_converter.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require_relative 'base'
 require 'libis/format/identifier'
 require 'chromaprint'
@@ -9,19 +7,24 @@ require 'fileutils'
 module Libis
   module Format
     module Converter
+
       class AudioConverter < Libis::Format::Converter::Base
+
         def self.input_types
-          %i[MP3 FLAC AC3 AAC WMA ALAC WAV AIFF AMR AU M4A]
+          [:MP3, :FLAC, :AC3, :AAC, :WMA, :ALAC, :WAV, :AIFF, :AMR, :AU, :M4A]
         end
 
         def self.output_types(format = nil)
-          return [] unless input_types.include?(format)
+          return [] unless format.nil? || input_types.include?(format)
+          [:MP3, :FLAC, :AC3, :AAC, :WMA, :ALAC, :WAV, :AIFF, :AMR, :AU, :M4A]
+        end
 
-          %i[MP3 FLAC AC3 AAC WMA ALAC WAV AIFF AMR AU M4A]
+        def initialize
+          super
         end
 
-        def quiet(value)
-          @flags[:quiet] = !!value
+        def quiet(v)
+          @flags[:quiet] = !!v
         end
 
         def format(format)
@@ -57,70 +60,38 @@ module Libis
         end
 
         def web_stream(value)
-          return unless value
-
-          @options[:codec] = 'mp3'
+          if value
+            @options[:codec] = 'mp3'
+          end
         end
 
         def preset(stream, name)
           (@options[:preset] ||= {})[stream] = name
         end
 
-        # def encoder(value)
-        #   @options[:encoder] = value
-        # end
-        #
-        # def encoder_options(value)
-        #   @options[:encoder_options] = value
-        # end
-
         def convert(source, target, _format, opts = {})
           super
 
           FileUtils.mkpath(File.dirname(target))
 
-          if source.is_a? Array
-
-            assemble_and_convert(source, target)
-
-          elsif File.directory?(source)
-
-            sources = Dir[File.join(source, '**', '*')].reject { |p| File.directory? p }
-            assemble_and_convert(sources, target)
-
-          else
+          convert_file(source, target)
 
-            convert_file(source, target)
-
-          end
-        end
-
-        def assemble_and_convert(sources, target)
-          result = {}
-          Tempfile.create(%w[list .txt]) do |f|
-            sources.each { |src| f.puts src }
-            opts[:global] ||= []
-            opts[:global] += %w[-f concat]
-            f.close
-            result = convert_file(f.to_path, target)
-          end
-          result
         end
 
         def self.sounds_like(file1, file2, threshold, rate, channels)
-          rate ||= 96_000
+          rate ||= 96000
           channels ||= 2
           threshold ||= 0.85
 
-          if File.exist?(file1) && File.exist?(file2)
+          if File.exists?(file1) && File.exists?(file2)
             # Convert input files into raw 16-bit signed audio (WAV) to process with Chramaprint
-            file1_raw = File.join('', 'tmp', "#{File.basename(file1)}.wav")
-            file2_raw = File.join('', 'tmp', "#{File.basename(file2)}.wav")
+            file1_raw = File.join('', 'tmp', File.basename(file1) + '.wav')
+            file2_raw = File.join('', 'tmp', File.basename(file2) + '.wav')
             FileUtils.rm(file1_raw, force: true)
             FileUtils.rm(file2_raw, force: true)
             cvt_cmd = Libis::Format::Config[:raw_audio_convert_cmd]
-            `#{format(cvt_cmd, file1, file1_raw, rate, channels)}`
-            `#{format(cvt_cmd, file2, file2_raw, rate, channels)}`
+            %x"#{cvt_cmd % [file1, file1_raw, rate, channels]}"
+            %x"#{cvt_cmd % [file2, file2_raw, rate, channels]}"
             file1_audio = File.binread(file1_raw)
             file2_audio = File.binread(file2_raw)
 
@@ -140,33 +111,37 @@ module Libis
           else
             false
           end
+
         rescue Exception => e
-          puts "Error comparing sound file #{file1} and #{file2}: #{e.message} @ #{e.backtrace.first}"
+          error "Error comparing sound file #{file1} and #{file2}: #{e.message} @ #{e.backtrace.first}"
           false
         end
 
         protected
 
         def convert_file(source, target)
-          opts = { global: [], input: [], filter: [], output: [] }
-
+          opts = {global: [], input: [], filter: [], output: []}
           opts[:global] << '-hide_banner'
           opts[:global] << '-loglevel' << (@options[:quiet] ? 'fatal' : 'warning')
           opts[:output] << '-vn' # disable input video stream in case it exists
           opts[:output] << '-codec:a' << @options[:codec] if @options[:codec]
           opts[:output] << '-map_metadata:g' << '0:g' # Copy global metadata
           opts[:output] << '-map_metadata:s:a' << '0:s:a' # Copy audio metadata
-          opts[:input] << '-accurate_seek' << (@options[:start].to_i.negative? ? '-sseof' : '-ss') << @options[:start] if @options[:start]
+          opts[:input] << '-accurate_seek' << (@options[:start].to_i < 0 ? '-sseof' : '-ss') << @options[:start] if @options[:start]
           opts[:input] << '-t' << @options[:duration] if @options[:duration]
           opts[:output] << '-q:a' << @options[:quality] if @options[:quality]
           opts[:output] << '-b:a' << @options[:bit_rate] if @options[:bit_rate]
           opts[:output] << '-ar' << @options[:sampling_freq] if @options[:sampling_freq]
           opts[:output] << '-ac' << @options[:channels] if @options[:channels]
           opts[:output] << '-f' << @options[:format] if @options[:format]
-
-          Libis::Format::Tool::FFMpeg.run(source, target, opts)
+          result = Libis::Format::Tool::FFMpeg.run(source, target, opts)
+          info "FFMpeg output: #{result}"
+          result
+          target
         end
+
       end
+
     end
   end
-end
+end

data/lib/libis/format/converter/base.rb

@@ -4,7 +4,7 @@
 require 'tmpdir'
 require 'libis/tools/logger'
 require 'libis/tools/temp_file'
-require 'libis/format/type_database'
+require 'libis/format/library'
 
 require_relative 'repository'
 
@@ -22,10 +22,23 @@ module Libis
           @flags = {}
         end
 
+        def self.category
+          :converter
+        end
+
+        def check_file_exist(file)
+          unless File.exist? file
+            error "Cannot find file '#{file}'."
+            return false
+          end
+          true
+        end
+
         def convert(source, target, format, opts = {})
-          unless File.exist? source
-            error "Cannot find file '#{source}'."
-            return nil
+          if source.is_a?(Array)
+            return nil unless source.map { |f| check_file_exist(f) }.reduce(:&)
+          else
+            return nil unless check_file_exist(source)
           end
           @options.merge!(opts[:options]) if opts[:options]
           @flags.merge!(opts[:flags]) if opts[:flags]
@@ -51,7 +64,7 @@ module Libis
           target
         end
 
-        def Base.inherited( klass )
+        def Base.inherited(klass)
 
           Repository.register klass
 
@@ -73,12 +86,12 @@ module Libis
             end
 
             def input_mimetype?(mimetype)
-              type_id = TypeDatabase.instance.mime_types(mimetype).first
+              type_id = Libis::Format::Library.get_field_by(:mimetype, mimetype, :format)
               input_type? type_id
             end
 
             def output_mimetype?(mimetype)
-              type_id = TypeDatabase.instance.mime_types(mimetype).first
+              type_id = Libis::Format::Library.get_field_by(:mimetype, mimetype, :format)
               output_type? type_id
             end
 
@@ -91,7 +104,7 @@ module Libis
             end
 
             def extension?(extension)
-              !TypeDatabase.ext_types(extension).first.nil?
+              !Libis::Format::Library.get_field_by(:extension, extension, :format).nil?
             end
 
           end

data/lib/libis/format/converter/chain.rb

@@ -5,7 +5,7 @@ require 'deep_dive'
 
 require 'libis/tools/logger'
 require 'libis/tools/extend/hash'
-require 'libis/format/type_database'
+require 'libis/format/library'
 
 module Libis
   module Format
@@ -68,18 +68,14 @@ module Libis
           end
 
           temp_files = []
-          xtra_files = []
-
-          result = { commands: [] }
 
           # noinspection RubyParenthesesAroundConditionInspection
-          conversion_success = @converter_chain.each_with_index do |node, i|
+          result = @converter_chain.each_with_index do |node, i|
 
             target_type = node[:output]
             converter_class = node[:converter]
             converter = converter_class.new
 
-
             node[:operations].each do |operation|
               converter.send operation[:method], operation[:argument]
             end if node[:operations]
@@ -87,32 +83,24 @@ module Libis
             target = target_file
 
             if i < size - 1
-              target += ".temp.#{TypeDatabase.type_extentions(target_type).first}"
-              target += ".#{TypeDatabase.type_extentions(target_type).first}" while File.exist? target
+              target += ".temp.#{Libis::Format::Library.get_field(target_type, :extensions).first}"
+              target += ".#{Libis::Format::Library.get_field(target_type, :extensions).first}" while File.exist? target
               temp_files << target
             end
 
             FileUtils.mkdir_p File.dirname(target)
 
-            r = converter.convert(src_file, target, target_type)
+            src_file = converter.convert(src_file, target, target_type)
 
-            src_file = r[:files].first
-            xtra_files += r[:files][1..]
             break :failed unless src_file
 
-            result[:commands] << r.merge(converter: converter_class.name)
-
-            :success
-
           end
 
-          result[:files] = [src_file] + xtra_files
-
           temp_files.each do |f|
             FileUtils.rm(f, force: true)
           end
 
-          conversion_success == :failed ? nil : result
+          result == :failed ? nil : target_file
 
         end
 

data/lib/libis/format/converter/fop_pdf_converter.rb

@@ -31,6 +31,8 @@ module Libis
 
           Libis::Format::Tool::FopPdf.run(source, target)
 
+          target
+
         end
 
       end

data/lib/libis/format/converter/image_assembler.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+
+require_relative 'base'
+require 'libis/format/identifier'
+
+require 'mini_magick'
+
+MiniMagick.logger.level = ::Logger::UNKNOWN
+
+MiniMagick.configure do |config|
+  # config.cli = :graphicsmagick
+  config.validate_on_create = false
+  config.validate_on_write = false
+  config.whiny = false
+end
+
+module Libis
+  module Format
+    module Converter
+
+      # noinspection RubyTooManyInstanceVariablesInspection,DuplicatedCode
+      class ImageAssembler < Libis::Format::Converter::Base
+
+        def self.input_types
+          [:TIFF, :JPG, :PNG, :BMP, :GIF, :PDF, :JP2]
+        end
+
+        def self.output_types(format = nil)
+          return [] unless input_types.include?(format) if format
+          [:PDF, :TIFF, :GIF, :PBM, :PGM, :PPM]
+        end
+
+        def self.category
+          :assembler
+        end
+
+        def image_assemble(_)
+          #force usage of this converter
+        end
+
+        def quiet(v)
+          @quiet = !!v
+        end
+
+        def convert(source, target, format, opts = {})
+          super
+
+          FileUtils.mkpath(File.dirname(target))
+
+          if source.is_a? Array
+            assemble(source, target, format)
+          elsif File.directory?(source)
+            source_list = Dir[File.join(source, '**', '*')].reject {|p| File.directory? p}
+            assemble(source_list, target, format)
+          else
+            image = MiniMagick::Image.open(source) {|b| b.quiet}
+            if image.pages.size > 1
+              assemble(image.pages.map {|page| page.path}, target, format)
+            else
+              assemble([source], target, format)
+            end
+          end
+
+          target
+
+        end
+
+        private
+
+        def assemble(sources, target, format)
+          MiniMagick::Tool::Convert.new do |b|
+            sources.each {|source| b << source}
+            convert.format(format)
+            b << target
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/libis/format/converter/image_converter.rb

@@ -4,7 +4,6 @@ require_relative 'base'
 require 'libis/format/identifier'
 
 require 'mini_magick'
-require 'fileutils'
 
 MiniMagick.logger.level = ::Logger::UNKNOWN
 
@@ -23,11 +22,11 @@ module Libis
       class ImageConverter < Libis::Format::Converter::Base
 
         def self.input_types
-          [:TIFF, :JPG, :PNG, :BMP, :GIF, :PDF, :JP2]
+          [:TIFF, :JPG, :PNG, :BMP, :GIF, :PDF, :JP2, :PBM, :PGM, :PPM]
         end
 
         def self.output_types(format = nil)
-          return [] unless input_types.include?(format)
+          return [] unless input_types.include?(format) if format
           [:TIFF, :JPG, :PNG, :BMP, :GIF, :PDF, :JP2]
         end
 
@@ -46,109 +45,57 @@ module Libis
 
         def quiet(v)
           @quiet = !!v
+          self
         end
 
         def page(nr)
           @page = nr
+          self
         end
 
         def scale(percent)
           @options[:scale] = percent
+          self
         end
 
         def resize(geometry)
           @options[:resize] = geometry
+          self
         end
 
         def quality(value)
           @options[:quality] = value
+          self
         end
 
         def dpi(value)
           @options[:density] = value
+          self
         end
 
         def resample(value)
           @options[:resample] = value
+          self
         end
 
         def flatten(value = true)
-          @options[:flatten] = !!value
+          @options[:flatten] = value
+          self
         end
 
         def colorspace(value)
           @options[:colorspace] = value
+          self
         end
 
         def delete_date(value = true)
-          @delete_date = !!value
+          @delete_date = value
+          self
         end
 
         def profile(icc)
           @profile = icc
-        end
-
-        # Create or use a watermark image.
-        #
-        # The watermark options are:
-        #     - file: watermark image to use
-        #     - text: text to create a watermark from
-        #     - rotation: rotation of the watermark text (counter clockwise in degrees; integer number) - default 30
-        #     - tiles: number of tiles of the watermark - default 4
-        #       - 0: no tiling, so only 1 watermark will be placed with the original size
-        #       - 1: 1 tile, so the watermark will be scaled up to fill the image
-        #       - n > 1: minimum n tiles in both directions
-        #       - n < 0: tile without scaling the watermark
-        #     - size: same as tiles - for backwards compatibility
-        #     - resize: fraction 0.0 - 1.0
-        #     - gap: size of the gap between watermark instances. Fractions as percentage of widht/height. - default 0.2
-        #     - opacity: opacity of the watermark (fraction 0.0 - 1.0) - default 0.1
-        #     - gravity: center point of the overlay - default 'center'
-        # If both options are given, the file will be used as-is if it exists and is a valid image file. Otherwise the
-        # file will be created or overwritten with a newly created watermark image.
-        #
-        # The created watermark file will be a PNG image with transparent background containing the supplied text
-        # slanted by 30 degrees counter-clockwise.
-        #
-        # @param [Hash] options Hash of options for watermark creation.
-        def watermark(options = {})
-          text = options[:text] || '© LIBIS'
-          @wm_tiles = (options[:tiles] || '4').to_i
-          @wm_tiles ||= (options[:size] || '4').to_i
-          @wm_resize = ((options[:resize]).to_f * 100).to_i if options[:resize]
-          @wm_opacity = ((options[:opacity] || 0.1).to_f * 100).to_i
-          @wm_composition = options[:composition] || 'modulate'
-          @wm_gravity = options[:gravity] || 'center'
-          @wm_gap = ((options[:gap] || 0.2).to_f * 100).to_i
-          rotation = 360 - (options[:rotation] || 30).to_i
-          @wm_image = MiniMagick::Image.new(options[:file]) if options[:file]
-          unless @wm_image && @wm_image.valid?
-            image = options[:file] || (Dir::Tmpname.create(%w(wm_image .png)) {|_|})
-            # noinspection RubyResolve
-            MiniMagick::Tool::Convert.new do |convert|
-              # noinspection RubyLiteralArrayInspection
-              convert.quiet
-              convert.background 'transparent'
-              convert.size('2000x2000')
-              convert.gravity 'Center'
-              convert.font('Helvetica').fill('black').pointsize(72) #.stroke('black').strokewidth(1)
-              convert << "label:#{text}"
-              convert.rotate rotation
-              convert.trim.repage.+
-              convert << image
-            end
-            if options[:file]
-              @wm_image = MiniMagick::Image.new(image)
-            else
-              @wm_image = MiniMagick::Image.open(image)
-              File.delete(image)
-            end
-            # noinspection RubyResolve
-            unless @wm_image.valid?
-              error "Problem creating watermark image '#{image}'."
-              @wm_image = nil
-            end
-          end
+          self
         end
 
         def convert(source, target, format, opts = {})
@@ -156,92 +103,25 @@ module Libis
 
           FileUtils.mkpath(File.dirname(target))
 
-          if source.is_a? Array
-
-            assemble_and_convert(source, target, format)
-
-          elsif File.directory?(source)
-            source_list = Dir[File.join(source, '**', '*')].reject {|p| File.directory? p}
-
-            assemble_and_convert(source_list, target, format)
-
-          else
-
-            image = MiniMagick::Image.open(source) { |b| b.quiet }
-
-            if image.pages.size > 1
-              if @page
-                convert_image(image.pages[@page].path, target, format)
-              else
-                # noinspection RubyBlockToMethodReference
-                assemble_and_convert(image.pages.map {|page| page.path}, target, format)
-              end
-            else
-              convert_image(source, target, format)
-            end
-          end
-          
-          { 
-            files: [target],
-            converter: self.class.name
-          }
-        end
+          convert_image(source, target, format)
 
-        def assemble_and_convert(sources, target, format)
+          target
 
-          warn 'Received multiple images as input and single page format as target.' unless self.class.multipage?(format)
-          converted_pages = sources.inject([]) do |list, path|
-            # noinspection RubyArgCount
-            converted = Tempfile.new(['page-', ".#{Libis::Format::TypeDatabase.type_extentions(format).first}"])
-            convert_image(path, converted.path, format)
-            list << converted
-          end
-          MiniMagick::Tool::Convert.new do |b|
-            b.append unless self.class.multipage?(format)
-            converted_pages.each {|page| b << page.path}
-            b << target
-          end
-          converted_pages.each do |temp_file|
-            temp_file.close
-            temp_file.unlink
-          end
         end
 
         protected
 
         def convert_image(source, target, format)
 
-          image_info = nil
-          image_info = MiniMagick::Image::Info.new(source) {|b| b.quiet} if @wm_image
+          if @page
+            image = MiniMagick::Image.open(source) { |b| b.quiet }
+            source = image.pages[@page].path if image.pages.size > 1
+          end
 
           MiniMagick::Tool::Convert.new do |convert|
-            convert.quiet if @quiet
-            if @wm_image
-              convert << @wm_image.path
-              convert.bordercolor('transparent').border("#{@wm_gap}%") if @wm_gap > 0
-              convert.filter('Lagrange')
-              convert.resize("#{image_info['width'] / @wm_tiles}x#{image_info['height'] / @wm_tiles}") if @wm_tiles > 0
-              convert.resize("#{@wm_resize}%") if @wm_resize
-              convert.write('mpr:watermark').delete.+
-            end
-
             convert.quiet if @quiet
             convert << source
             convert.flatten if @options[:flatten].nil? && format == :JPG
-            if @wm_image
-              if @wm_tiles >= 0 and @wm_tiles <= 1
-                convert << 'mpr:watermark'
-              else
-                convert.stack do |stack|
-                  stack.size("#{image_info['width']}x#{image_info['height']}")
-                  stack << 'xc:transparent'
-                  stack.tile('mpr:watermark')
-                  stack.draw "rectangle 0,0,#{image_info['width']},#{image_info['height']}"
-                end
-              end
-              convert.compose(@wm_composition).gravity(@wm_gravity).define("compose:args=#{@wm_opacity}%").composite
-            end
-
             @flags.each {|f, v| v.is_a?(TrueClass) ? convert.send(f).+ : convert.send(f)}
             if @delete_date
               convert << '+set' << 'modify-date' << '+set' << 'create-date'