libis-format 2.0.0 → 2.0.5

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

@@ -0,0 +1,83 @@
+# encoding: utf-8
+
+require_relative 'base'
+
+require 'libis/format/tool/pdf_select'
+
+module Libis
+  module Format
+    module Converter
+
+      # noinspection DuplicatedCode
+      class PdfSelecter < Libis::Format::Converter::Base
+
+        def self.input_types
+          [:PDF]
+        end
+
+        def self.output_types(format = nil)
+          return [] unless input_types.include?(format) if format
+          [:PDF]
+        end
+
+        def pdf_select(_)
+          #force usage of this converter
+        end
+
+        def initialize
+          super
+          @options[:ranges] = []
+        end
+
+        # Select a partial list of pages
+        # @param [String] selection as described in com.itextpdf.text.pdf.SequenceList: [!][o][odd][e][even]start-end
+        def range(selection)
+          @options[:ranges] += selection.split(/\s*,\s*/) unless selection.blank?
+        end
+
+        # Select a partial list of pages
+        # @param [String|Array<String>] selection as described in com.itextpdf.text.pdf.SequenceList: [!][o][odd][e][even]start-end
+        def ranges(selection)
+          case selection
+          when Array
+            @options[:ranges] += selection.to_s unless selection.empty?
+          when String
+            range([selection])
+          else
+            # nothing
+          end
+        end
+
+        def convert(source, target, format, opts = {})
+          super
+
+          result = nil
+
+          unless @options.empty?
+            result = convert_pdf(source, target)
+            return nil unless result
+          end
+
+          result
+
+        end
+
+        def convert_pdf(source, target)
+
+          using_temp(target) do |tmpname|
+            opts = @options[:ranges].map { |range| ["-r", range] }.compact.flatten
+            result = Libis::Format::Tool::PdfSelect.run(source, tmpname, opts)
+            unless result[:err].empty?
+              error("Pdf selection encountered errors:\n%s", result[:err].join(join("\n")))
+              next nil
+            end
+            tmpname
+          end
+
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -17,20 +17,20 @@ module Libis
 
         def self.output_types(format = nil)
           return [] unless input_types.include?(format) if format
-          [:PDF]
-        end
-
-        def pdf_split(_)
-          #force usage of this converter
+          [:PDFA]
         end
 
         def self.category
           :splitter
         end
 
-        # Split at given page. If omitted or nil, the source PDF will be split at every page
+        def initialize
+          super
+        end
+
+        # Split at given page. If omitted, nil or 0, the source PDF will be split at every page
         def page(v)
-          @page = v unless v.blank
+          @options[:page] = v unless v.blank?
         end
 
         def convert(source, target, format, opts = {})
@@ -46,15 +46,20 @@ module Libis
 
         def split(source, target)
 
-          options = @page ? ['--page', @page] : ['--every_page']
-          using_temp(target) do |tmpname|
-            result = Libis::Format::Tool::PdfSplit.run(source, tmpname, *options)
-            unless result[:err].empty?
-              error("Pdf split encountered errors:\n%s", result[:err].join(join("\n")))
-              next nil
-            end
-            tmpname
+          result = Libis::Format::Tool::PdfSplit.run(
+            source, target,
+            @options.map { |k, v|
+              if v.nil?
+                nil
+              else
+                ["--#{k}", v.to_s]
+              end }.compact.flatten
+          )
+          unless result[:err].empty?
+            error("Pdf split encountered errors:\n%s", result[:err].join(join("\n")))
+            return nil
           end
+          result[:out]
 
         end
 

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

@@ -0,0 +1,71 @@
+# encoding: utf-8
+
+require_relative 'base'
+
+require 'libis/format/tool/pdf_watermark'
+
+module Libis
+  module Format
+    module Converter
+
+      class PdfWatermarkerHeader < Libis::Format::Converter::Base
+
+        def self.input_types
+          [:PDF]
+        end
+
+        def self.output_types(format = nil)
+          return [] unless input_types.include?(format) if format
+          [:PDF]
+        end
+
+        def pdf_watermark_header(_)
+          #force usage of this converter
+        end
+
+        def initialize
+          super
+        end
+
+        def text(v)
+          @options[:text] = v.blank? ? nil : v
+        end
+
+        def convert(source, target, format, opts = {})
+          super
+
+          result = convert_pdf(source, target)
+          return nil unless result
+
+          result
+
+        end
+
+        # noinspection DuplicatedCode
+        def convert_pdf(source, target)
+
+          using_temp(target) do |tmpname|
+            result = Libis::Format::Tool::PdfWatermark.run(
+                source, tmpname, 'header',
+                @options.map {|k, v|
+                  if v.nil?
+                    nil
+                  else
+                    ["--#{k}", v.to_s]
+                  end
+                  }.compact.flatten
+            )
+            unless result[:err].empty?
+              error("Pdf conversion encountered errors:\n%s", result[:err].join(join("\n")))
+              next nil
+            end
+            tmpname
+          end
+
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# encoding: utf-8
+
+require_relative 'base'
+
+require 'libis/format/tool/pdf_watermark'
+
+module Libis
+  module Format
+    module Converter
+
+      class PdfWatermarkerImage < Libis::Format::Converter::Base
+
+        def self.input_types
+          [:PDF]
+        end
+
+        def self.output_types(format = nil)
+          return [] unless input_types.include?(format) if format
+          [:PDF]
+        end
+
+        def pdf_watermark_image(_)
+          #force usage of this converter
+        end
+
+        def initialize
+          super
+          @options[:opacity] = '0.3'
+        end
+
+        def file(v)
+          @file = v
+        end
+
+        def opacity(v)
+          @options[:opacity] = v unless v.blank?
+        end
+
+        def convert(source, target, format, opts = {})
+          super
+
+          result = convert_pdf(source, target)
+          return nil unless result
+
+          result
+
+        end
+
+        # noinspection DuplicatedCode
+        def convert_pdf(source, target)
+
+          using_temp(target) do |tmpname|
+            result = Libis::Format::Tool::PdfWatermark.run(
+                source, tmpname, 'image',
+                @options.map {|k, v|
+                  if v.nil?
+                    nil
+                  else
+                    ["--#{k}", v.to_s]
+                  end
+                  }.compact.flatten + [@file]
+            )
+            unless result[:err].empty?
+              error("Pdf conversion encountered errors:\n%s", result[:err].join(join("\n")))
+              next nil
+            end
+            tmpname
+          end
+
+        end
+
+      end
+
+    end
+  end
+end

data/lib/libis/format/converter/{pdf_watermarker.rb → pdf_watermarker_text.rb}

@@ -2,16 +2,13 @@
 
 require_relative 'base'
 
-require 'libis/tools/extend/hash'
-require 'libis/format/tool/pdf_copy'
-require 'libis/format/tool/pdf_to_pdfa'
-require 'libis/format/tool/pdf_optimizer'
+require 'libis/format/tool/pdf_watermark'
 
 module Libis
   module Format
     module Converter
 
-      class PdfWatermarker < Libis::Format::Converter::Base
+      class PdfWatermarkerText < Libis::Format::Converter::Base
 
         def self.input_types
           [:PDF]
@@ -22,22 +19,18 @@ module Libis
           [:PDF]
         end
 
-        def pdf_watermark(_)
+        def pdf_watermark_text(_)
           #force usage of this converter
         end
 
         def initialize
           super
-          @options[:text] = '© LIBIS'
+          @text = []
           @options[:opacity] = '0.3'
         end
 
-        def file(v)
-          @options[:file] = v.blank? ? nil : v
-        end
-
         def text(v)
-          @options[:text] = v
+          @text += v.split("\n")
         end
 
         def rotation(v)
@@ -52,12 +45,12 @@ module Libis
           @options[:opacity] = v unless v.blank?
         end
 
-        def gap_size(v)
-          @options[:gap_size] = v
+        def gap(v)
+          @options[:gap] = v
         end
 
-        def gap_ratio(v)
-          @options[:gap_ratio] = v
+        def padding(v)
+          @options[:padding] = v
         end
 
         def convert(source, target, format, opts = {})
@@ -70,29 +63,19 @@ module Libis
 
         end
 
-        OPTIONS_TABLE = {
-            file: 'wm_image',
-            text: 'wm_text',
-            rotation: 'wm_text_rotation',
-            size: 'wm_font_size',
-            opacity: 'wm_opacity',
-            gap_size: 'wm_gap_size',
-            gap_ratio: 'wm_gap_ratio'
-        }
         # noinspection DuplicatedCode
         def convert_pdf(source, target)
 
           using_temp(target) do |tmpname|
-            result = Libis::Format::Tool::PdfCopy.run(
-                source, tmpname,
+            result = Libis::Format::Tool::PdfWatermark.run(
+                source, tmpname, 'text',
                 @options.map {|k, v|
                   if v.nil?
                     nil
                   else
-                    v = v.split('\n') unless v.blank? if k == :text
-                    k = OPTIONS_TABLE[k] || k
-                    ["--#{k}", (v.is_a?(Array) ? v : v.to_s)]
-                  end}.compact.flatten
+                    ["--#{k}", v.to_s]
+                  end
+                  }.compact.flatten + @text
             )
             unless result[:err].empty?
               error("Pdf conversion encountered errors:\n%s", result[:err].join(join("\n")))

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

@@ -31,7 +31,7 @@ module Libis
         end
 
         def audio_channels(value)
-          @options[:audio_channels] = value.to_s
+          @options[:audio_channels] = value
         end
 
         def audio_codec(codec)
@@ -43,39 +43,39 @@ module Libis
         end
 
         def start(seconds)
-          @options[:start] = seconds.to_s
+          @options[:start] = seconds
         end
 
         def duration(seconds)
-          @options[:duration] = seconds.to_s
+          @options[:duration] = seconds
         end
 
         def audio_quality(value)
-          @options[:audio_quality] = value.to_s
+          @options[:audio_quality] = value
         end
 
         def video_quality(value)
-          @options[:video_quality] = value.to_s
+          @options[:video_quality] = value
         end
 
         def audio_bitrate(value)
-          @options[:audio_bitrate] = value.to_s
+          @options[:audio_bitrate] = value
         end
 
         def video_bitrate(value)
-          @options[:video_bitrate] = value.to_s
+          @options[:video_bitrate] = value
         end
 
         def constant_rate_factor(value)
-          @options[:crf] = value.to_s
+          @options[:crf] = value
         end
 
         def frame_rate(value)
-          @options[:frame_rate] = value.to_s
+          @options[:frame_rate] = value
         end
 
         def sampling_freq(value)
-          @options[:sampling_freq] = value.to_s
+          @options[:sampling_freq] = value
         end
 
         def scale(width_x_height)
@@ -239,21 +239,21 @@ module Libis
                 ] if @options[:watermark_text_shadow_offset] > 0
             opts[:filter] << '-vf' << filter_text
           end
-          opts[:output] << '-ac' << @options[:audio_channels] if @options[:audio_channels]
-          opts[:output] << '-c:a' << @options[:audio_codec] if @options[:audio_codec]
-          opts[:output] << '-c:v' << @options[:video_codec] if @options[:video_codec]
-          opts[:output] << '-b:a' << @options[:audio_bitrate] if @options[:audio_bitrate]
-          opts[:output] << '-b:v' << @options[:video_bitrate] if @options[:video_bitrate]
-          opts[:output] << '-crf' << @options[:crf] if @options[:crf]
+          opts[:output] << '-ac' << @options[:audio_channels].to_s if @options[:audio_channels]
+          opts[:output] << '-c:a' << @options[:audio_codec].to_s if @options[:audio_codec]
+          opts[:output] << '-c:v' << @options[:video_codec].to_s if @options[:video_codec]
+          opts[:output] << '-b:a' << @options[:audio_bitrate].to_s if @options[:audio_bitrate]
+          opts[:output] << '-b:v' << @options[:video_bitrate].to_s if @options[:video_bitrate]
+          opts[:output] << '-crf' << @options[:crf].to_s if @options[:crf]
           opts[:output] << '-map_metadata:g' << '0:g' # Copy global metadata
           opts[:output] << '-map_metadata:s:a' << '0:s:a' # Copy audio metadata
           opts[:output] << '-map_metadata:s:v' << '0:s:v' # Copy video metadata
-          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] << '-qscale' << @options[:video_quality] if @options[:video_quality]
-          opts[:output] << '-q:a' << @options[:audio_quality] if @options[:audio_quality]
-          opts[:output] << '-r' << @options[:frame_rate] if @options[:frame_rate]
-          opts[:output] << '-ar' << @options[:sampling_freq] if @options[:sampling_freq]
+          opts[:input] << '-accurate_seek' << (@options[:start].to_i < 0 ? '-sseof' : '-ss') << @options[:start].to_s if @options[:start]
+          opts[:input] << '-t' << @options[:duration].to_s if @options[:duration]
+          opts[:output] << '-qscale' << @options[:video_quality].to_s if @options[:video_quality]
+          opts[:output] << '-q:a' << @options[:audio_quality].to_s if @options[:audio_quality]
+          opts[:output] << '-r' << @options[:frame_rate].to_s if @options[:frame_rate]
+          opts[:output] << '-ar' << @options[:sampling_freq].to_s if @options[:sampling_freq]
           if @options[:scale]
             scale = @options[:scale].split('x')
             width = scale[0]