bulldog 0.0.1

data/lib/bulldog/missing_file.rb

@@ -0,0 +1,12 @@
+module Bulldog
+  class MissingFile
+    def initialize(options={})
+      @attachment_type = attachment_type
+      @file_name = options[:file_name] || 'missing-file'
+      @content_type = options[:content_type]
+      @path = options[:path] || '/dev/null'
+    end
+
+    attr_reader :attachment_type, :file_name, :content_type, :path
+  end
+end

data/lib/bulldog/processor.rb

@@ -0,0 +1,5 @@
+require 'bulldog/processor/argument_tree'
+require 'bulldog/processor/base'
+require 'bulldog/processor/one_shot'
+require 'bulldog/processor/image_magick'
+require 'bulldog/processor/ffmpeg'

data/lib/bulldog/processor/argument_tree.rb

@@ -0,0 +1,116 @@
+module Bulldog
+  module Processor
+    class ArgumentTree
+      def initialize(styles)
+        @styles = styles
+        @root = Node.new(styles)
+        @heads = {}
+        styles.each{|s| @heads[s] = @root}
+      end
+
+      attr_reader :styles, :root, :heads
+
+      def add(style, arguments, &callback)
+        # Assume that if the arguments are the same for a node, the
+        # callback will be identical.
+        child = heads[style].children.find do |node|
+          node.arguments == arguments
+        end
+        if child
+          child.styles << style
+        else
+          child = Node.new([style], arguments, &callback)
+          heads[style].children << child
+        end
+        heads[style] = child
+      end
+
+      def output(style, path)
+        heads[style].outputs << path
+      end
+
+      def inspect
+        io = StringIO.new
+        inspect_node(io, @root)
+        io.string
+      end
+
+      #
+      # Return the list of arguments the tree represents.
+      #
+      def arguments
+        arguments = visit_node_for_arguments([], root, false)
+        # Don't specify -write for the last output file.
+        arguments[-2] == '-write' or
+          raise "[BULLDOG BUG]: expected second last argument to be -write in: #{arguments.inspect}"
+        arguments.delete_at(-2)
+        arguments
+      end
+
+      #
+      # Yield each callback, along with the styles they apply to, in
+      # the order they appear in the tree.
+      #
+      def each_callback(&block)
+        visit_node_for_callbacks(root, block)
+      end
+
+      private  # ---------------------------------------------------
+
+      def inspect_node(io, node, margin='')
+        puts "#{margin}* #{node.styles.map(&:name).join(', ')}: #{node.arguments.join(' ')}"
+        node.children.each do |child|
+          inspect_node(io, child, margin + '  ')
+        end
+      end
+
+      def visit_node_for_arguments(arguments, node, clone)
+        if clone
+          arguments << '(' << '+clone'
+          visit_node_for_arguments(arguments, node, false)
+          arguments << '+delete' << ')'
+        else
+          arguments.concat(node.arguments)
+          node.outputs.each{|path| arguments << '-write' << path}
+
+          num_children = node.children.size
+          node.children.each_with_index do |child, i|
+            # No need to clone the image for the last child.
+            visit_node_for_arguments(arguments, child, i < num_children - 1)
+          end
+        end
+        arguments
+      end
+
+      def visit_node_for_callbacks(node, block)
+        if node.callback
+          block.call(node.styles, node.callback)
+        end
+        node.children.each do |child|
+          visit_node_for_callbacks(child, block)
+        end
+      end
+
+      class Node
+        def initialize(styles, arguments=[], &callback)
+          @styles = styles
+          @arguments = arguments
+          @callback = callback
+          @outputs = []
+          @children = []
+        end
+
+        def add_child(child)
+          children << child
+        end
+
+        def remove_child(child)
+          children.delete(child)
+        end
+
+        attr_accessor :outputs
+        attr_reader :styles, :arguments, :callback, :children
+      end
+    end
+  end
+end

data/lib/bulldog/processor/base.rb

@@ -0,0 +1,124 @@
+module Bulldog
+  module Processor
+    class Base
+      def initialize(attachment, styles, input_file)
+        @attachment = attachment
+        @styles = styles
+        @input_file = input_file
+      end
+
+      #
+      # The attachment object being processed.
+      #
+      attr_reader :attachment
+
+      #
+      # The styles to run this processor for.
+      #
+      attr_reader :styles
+
+      #
+      # The record being processed.
+      #
+      def record
+        attachment.record
+      end
+
+      #
+      # The name of the attachment being processed.
+      #
+      def name
+        attachment.name
+      end
+
+      #
+      # The name of the original file.
+      #
+      attr_reader :input_file
+
+      #
+      # The name of the output file for the given style.
+      #
+      def output_file(style_name)
+        overrides = {}
+        if (format = styles[style_name][:format])
+          overrides[:extension] = format
+        end
+        attachment.interpolate_path(style_name, overrides)
+      end
+
+      #
+      # Return the value of the attachment.
+      #
+      def value
+        record.send(name).value
+      end
+
+      #
+      # Run the given block in the context of this processor, once for
+      # each style.
+      #
+      # #style will be set to the current style each time the block is
+      # called.
+      #
+      def process(*args, &block)
+        return if styles.empty?
+        styles.each do |style|
+          @style = style
+          begin
+            process_style(*args, &block)
+          ensure
+            @style = nil
+          end
+        end
+      end
+
+      #
+      # The current style being processed.
+      #
+      attr_reader :style
+
+      protected  # ---------------------------------------------------
+
+      #
+      # Run the given block with #style set to one of the styles to
+      # process.
+      #
+      # This is called by #process for each output style.
+      #
+      def process_style(*args, &block)
+        # Avoid #instance_exec if possible for ruby 1.8.
+        evaluator = args.empty? ? :instance_eval : :instance_exec
+        send(evaluator, *args, &block) if block
+      end
+
+      def log(level, message)
+        logger = Bulldog.logger
+        logger.send(level, message) unless logger.nil?
+      end
+
+      def shell_escape(str)
+        if RUBY_VERSION >= '1.9'
+          Shellwords.shellescape(str)
+        else
+          # Taken from ruby 1.9.
+
+          # An empty argument will be skipped, so return empty quotes.
+          return "''" if str.empty?
+
+          str = str.dup
+
+          # Process as a single byte sequence because not all shell
+          # implementations are multibyte aware.
+          str.gsub!(/([^A-Za-z0-9_\-.,:\/@\n])/n, "\\\\\\1")
+
+          # A LF cannot be escaped with a backslash because a backslash + LF
+          # combo is regarded as line continuation and simply ignored.
+          str.gsub!(/\n/, "'\n'")
+
+          return str
+        end
+      end
+    end
+  end
+end

data/lib/bulldog/processor/ffmpeg.rb

@@ -0,0 +1,172 @@
+module Bulldog
+  module Processor
+    class Ffmpeg < Base
+      class << self
+        attr_accessor :ffmpeg_command
+      end
+
+      self.ffmpeg_command = Bulldog.find_in_path('ffmpeg')
+
+      def initialize(*args)
+        super
+        @operation = nil
+        @arguments = style_list_map
+        @still_frame_callbacks = style_list_map
+      end
+
+      def process(*args)
+        return if styles.empty?
+        super
+        run_ffmpeg
+        run_still_frame_callbacks
+      end
+
+      def process_style(*args)
+        super
+        run_default_operation
+      end
+
+      def use_threads(num_threads)
+        operate '-threads', num_threads
+      end
+
+      def encode(params={})
+        @operation = :encode
+        params = style.attributes.merge(params)
+        parse_video_option(params)
+        parse_audio_option(params)
+        style_option '-vcodec', params[:video_codec]
+        style_option '-acodec', params[:audio_codec]
+        preset_option '-vpre', params[:video_preset]
+        preset_option '-apre', params[:audio_preset]
+        operate '-s', attachment.dimensions(style.name).join('x') if params[:size]
+        style_option '-r', params[:frame_rate]
+        style_option '-b', params[:video_bit_rate]
+        style_option '-ar', params[:sampling_rate]
+        style_option '-ab', params[:audio_bit_rate]
+        style_option '-ac', params[:channels]
+        operate '-deinterlace' if params[:deinterlaced]
+        style_option '-pix_fmt', params[:pixel_format]
+        style_option '-b_strategy', params[:b_strategy]
+        style_option '-bufsize', params[:buffer_size]
+        style_option '-coder', params[:coder]
+        style_option '-v', params[:verbosity]
+        style_option '-flags', params[:flags]
+        preset_option '-spre', params[:subtitle_preset]
+        style_option '-y', output_file(style.name)
+      end
+
+      def record_frame(params={}, &block)
+        @operation = :record_frame
+        params = style.attributes.merge(params)
+        operate '-vframes', 1
+        operate '-ss', params[:position] || attachment.duration.to_i / 2
+        operate '-f', 'image2'
+        operate '-vcodec', params[:codec] || default_frame_codec(params)
+
+        if (attribute = params[:assign_to])
+          basename = "recorded_frame.#{params[:format]}"
+          output_path = record.send(attribute).interpolate_path(:original, :basename => basename)
+          @still_frame_callbacks[style] << lambda do
+            file = SavedFile.new(output_path, :file_name => basename)
+            record.update_attribute(attribute, file)
+          end
+        else
+          output_path = output_file(style.name)
+        end
+
+        operate '-y', output_path
+        if block
+          @still_frame_callbacks[style] << lambda{instance_exec(output_path, &block)}
+        end
+      end
+
+      private  # -----------------------------------------------------
+
+      def style_list_map
+        hash = {}
+        styles.each{|s| hash[s] = []}
+        hash
+      end
+
+      def operate(*args)
+        @arguments[style].concat args.map(&:to_s)
+      end
+
+      def run_default_operation
+        encode if @operation.nil?
+      end
+
+      def parse_video_option(params)
+        value = params.delete(:video) or
+          return
+        value.split.each do |word|
+          case word
+          when /fps\z/i
+            params[:frame_rate] = $`
+          when /bps\z/i
+            params[:video_bit_rate] = $`
+          else
+            params[:video_codec] = word
+          end
+        end
+      end
+
+      def parse_audio_option(params)
+        value = params.delete(:audio) or
+          return
+        value.split.each do |word|
+          case word
+          when /hz\z/i
+            params[:sampling_rate] = $`
+          when /bps\z/i
+            params[:audio_bit_rate] = $`
+          when 'mono'
+            params[:channels] = 1
+          when 'stereo'
+            params[:channels] = 2
+          else
+            params[:audio_codec] = word
+          end
+        end
+      end
+
+      def style_option(option, *args)
+        operate(option, *args) if args.all?
+      end
+
+      def preset_option(option, value)
+        Array(value).each do |preset|
+          operate option, preset
+        end
+      end
+
+      def default_frame_codec(params)
+        case params[:format].to_s
+        when /jpe?g/i
+          'mjpeg'
+        when /png/i
+          'png'
+        else
+          format = params[:format]
+          raise ProcessingError, "no default codec for '#{format}' - please use :codec to specify"
+        end
+      end
+
+      def run_ffmpeg
+        @arguments.each do |style, arguments|
+          command = [self.class.ffmpeg_command]
+          command << '-i' << input_file
+          command.concat(arguments)
+          Bulldog.run(*command)
+        end
+      end
+
+      def run_still_frame_callbacks
+        @still_frame_callbacks.each do |style, callbacks|
+          callbacks.each{|c| c.call}
+        end
+      end
+    end
+  end
+end

data/lib/bulldog/processor/image_magick.rb

@@ -0,0 +1,134 @@
+require 'stringio'
+
+module Bulldog
+  module Processor
+    class ImageMagick < Base
+      class << self
+        attr_accessor :convert_command
+        attr_accessor :identify_command
+      end
+
+      self.convert_command = Bulldog.find_in_path('convert')
+      self.identify_command = Bulldog.find_in_path('identify')
+
+      def initialize(*args)
+        super
+        @tree = ArgumentTree.new(styles)
+      end
+
+      def process(*args, &block)
+        return if styles.empty?
+        super
+        run_convert
+      end
+
+      # Input image attributes  --------------------------------------
+
+      #
+      # Yield the dimensions of the generated file at this point in
+      # the pipeline.
+      #
+      # The block is called when `convert' is run after the processor
+      # block is evaluated for all styles.  If you just need the
+      # dimensions of the input file, see Attribute::Photo#dimensions.
+      #
+      def dimensions(&block)
+        operate '-format', '%w %h'
+        operate '-identify' do |styles, output|
+          width, height = output.gets.split.map(&:to_i)
+          block.call(styles, width, height)
+        end
+      end
+
+      private  # -----------------------------------------------------
+
+      # Image operations  --------------------------------------------
+
+      def resize
+        operate '-resize', style[:size]
+      end
+
+      def auto_orient
+        operate '-auto-orient'
+      end
+
+      def strip
+        operate '-strip'
+      end
+
+      def flip
+        operate '-flip'
+      end
+
+      def flop
+        operate '-flop'
+      end
+
+      def rotate(angle)
+        unless angle.to_i.zero?
+          operate '-rotate', angle.to_s
+        end
+      end
+
+      def crop(params)
+        operate '-crop', geometry(params[:size], params[:origin])
+        operate '+repage'
+      end
+
+      def thumbnail
+        if style[:filled]
+          operate '-resize', "#{style[:size]}^"
+          operate '-gravity', 'Center'
+          operate '-crop', "#{style[:size]}+0+0"
+          operate '+repage'
+        else
+          operate '-resize', "#{style[:size]}"
+        end
+      end
+
+      private  # -----------------------------------------------------
+
+      def geometry(size, origin=nil)
+        size = Vector2.new(size)
+        geometry = '%dx%d' % [size.x, size.y]
+        if origin
+          origin = Vector2.new(origin)
+          geometry << ('%+d%+d' % [origin.x, origin.y])
+        end
+        geometry
+      end
+
+      def operate(*arguments, &block)
+        @tree.add(style, arguments, &block)
+      end
+
+      def run_convert
+        add_final_style_arguments
+        output = run_convert_command and
+        run_convert_callbacks(output)
+      end
+
+      def add_final_style_arguments
+        styles.each do |style|
+          @tree.add(style, ['-quality', style[:quality].to_s]) if style[:quality]
+          @tree.add(style, ['-colorspace', style[:colorspace]]) if style[:colorspace]
+          path = output_file(style.name)
+          FileUtils.mkdir_p(File.dirname(path))
+          @tree.output(style, path)
+        end
+      end
+
+      def run_convert_command
+        command = [self.class.convert_command, "#{input_file}[0]", *@tree.arguments].flatten
+        Bulldog.run(*command)
+      end
+
+      def run_convert_callbacks(output)
+        io = StringIO.new(output)
+        @tree.each_callback do |styles, callback|
+          callback.call(styles, io)
+        end
+      end
+    end
+  end
+end