tootsie 0.9.0

data/lib/tootsie/image_metadata_extractor.rb

@@ -0,0 +1,64 @@
+require 'iconv'
+require 'time'
+
+module Tootsie
+
+  class ImageMetadataExtractor
+
+    def initialize
+      @metadata = {}
+    end
+
+    def extract_from_file(file_name)
+      run_exiv2("-pt :file", :file => file_name) do |line|
+        parse_exiv2_line(line)
+      end
+      run_exiv2("-pi :file", :file => file_name) do |line|
+        parse_exiv2_line(line)
+      end
+      run_exiv2("-px :file", :file => file_name) do |line|
+        parse_exiv2_line(line)
+      end
+      @metadata = Hash[*@metadata.entries.map { |key, values|
+        [key, values.length > 1 ? values : values.first]
+      }.flatten(1)]
+      @metadata
+    end
+
+    attr_reader :metadata
+
+    private
+
+      def run_exiv2(args, params, &block)
+        CommandRunner.new("exiv2 #{args}",
+          :output_encoding => 'binary',
+          :ignore_exit_code => true
+        ).run(params, &block)
+      end
+    
+      def parse_exiv2_line(line)
+        if line =~ /^([^\s]+)\s+([^\s]+)\s+\d+  (.*)$/
+          key, type, value = $1, $2, $3
+          unless value.blank?
+            case type
+              when 'Short', 'Long'
+                value = value.to_i
+              when 'Date'
+                value = Time.parse(value)
+              else
+                begin
+                  Iconv.iconv("utf-8", "utf-8", value)
+                rescue Iconv::IllegalSequence, Iconv::InvalidCharacter
+                  value = Iconv.iconv("utf-8", "iso-8859-1", value)[0]
+                else
+                  value.force_encoding 'utf-8'
+                end
+            end
+            entry = {:value => value, :type => type.underscore}
+            (@metadata[key] ||= []) << entry
+          end
+        end
+      end
+
+  end
+end

data/lib/tootsie/input.rb

@@ -0,0 +1,55 @@
+require 'httpclient'
+require 'tempfile'
+require 's3'
+
+module Tootsie
+
+  class InputNotFound < Exception; end
+
+  class Input
+
+    def initialize(url)
+      @url = url
+      @temp_file = Tempfile.new('tootsie')
+      @temp_file.close
+      @file_name = @temp_file.path
+      @logger = Application.get.logger
+    end
+
+    def get!
+      @logger.info("Fetching #{@url} as #{@temp_file.path}")
+      case @url
+        when /^file:(.*)/
+          @file_name = $1
+          raise InputNotFound, @url unless File.exist?(@file_name)
+        when /^s3:.*$/
+          s3_options = S3Utilities.parse_uri(@url)
+          bucket_name, path = s3_options[:bucket], s3_options[:key]
+          s3_service = Tootsie::Application.get.s3_service
+          begin
+            File.open(@temp_file.path, 'wb') do |f|
+              f << s3_service.buckets.find(bucket_name).objects.find(path).content
+            end
+          rescue ::S3::Error::NoSuchBucket, ::S3::Error::NoSuchKey
+            raise InputNotFound, @url
+          end
+        when /http(s?):\/\//
+          response = HTTPClient.new.get(@url)
+          File.open(@temp_file.path, 'wb') do |f|
+            f << response.body
+          end
+        else
+          raise ArgumentError, "Don't know to handle URL: #{@url}"
+      end
+    end
+
+    def close
+      @temp_file.unlink
+    end
+
+    attr_reader :url
+    attr_reader :file_name
+
+  end
+
+end

data/lib/tootsie/output.rb

@@ -0,0 +1,67 @@
+require 'httpclient'
+require 's3'
+
+module Tootsie
+  
+  class IncompatibleOutputError < Exception; end
+  
+  class Output
+    
+    def initialize(url)
+      @url = url
+      @temp_file = Tempfile.new('tootsie')
+      @temp_file.close
+      @file_name = @temp_file.path
+      @logger = Application.get.logger
+    end
+    
+    # Put data into the output. Options:
+    #
+    # * +:content_type+ - content type of the stored data.
+    #
+    def put!(options = {})
+      @logger.info("Storing #{@url}")
+      case @url
+        when /^file:(.*)/
+          FileUtils.cp(@temp_file.path, $1)
+        when /^s3:.*/
+          s3_options = S3Utilities.parse_uri(@url)
+          bucket_name, path = s3_options[:bucket], s3_options[:key]
+          File.open(@temp_file.path, 'r') do |file|
+            s3_service = Tootsie::Application.get.s3_service
+            begin
+              object = s3_service.buckets.find(bucket_name).objects.build(path)
+              object.acl = s3_options[:acl] || :private
+              object.content_type = s3_options[:content_type]
+              object.content_type ||= @content_type if @content_type
+              object.storage_class = s3_options[:storage_class] || :standard
+              object.content = file
+              object.save
+              @result_url = object.url
+            rescue ::S3::Error::NoSuchBucket
+              raise IncompatibleOutputError, "Bucket #{bucket_name} not found"
+            end
+          end
+        when /^http(s?):\/\//
+          File.open(@temp_file.path, 'wb') do |file|
+            HTTPClient.new.get_content(@url) do |chunk|
+              file << chunk
+            end
+          end
+        else
+          raise IncompatibleOutputError, "Don't know to store output URL: #{@url}"
+      end
+    end
+    
+    def close
+      @temp_file.unlink
+    end
+    
+    attr_reader :url
+    attr_reader :result_url
+    attr_reader :file_name
+    attr_accessor :content_type
+    
+  end
+
+end

data/lib/tootsie/processors/image_processor.rb

@@ -0,0 +1,181 @@
+module Tootsie
+  module Processors
+  
+    class ImageProcessor
+    
+      def initialize(params = {})
+        @input_url = params[:input_url]
+        @versions = [params[:versions] || {}].flatten
+        @logger = Application.get.logger
+      end
+    
+      def valid?
+        return @input_url && !@versions.blank?
+      end
+    
+      def params
+        return {
+          :input_url => @input_url,
+          :versions => @versions
+        }
+      end
+    
+      def execute!(&block)
+        result = {:outputs => []}
+        input, output = Input.new(@input_url), nil
+        begin
+          input.get!
+          begin
+            versions.each_with_index do |version_options, version_index|
+              version_options = version_options.with_indifferent_access
+              @logger.info("Handling version: #{version_options.inspect}")
+              
+              output = Output.new(version_options[:target_url])
+              begin
+                result[:metadata] ||= ImageMetadataExtractor.new.extract_from_file(input.file_name)
+                
+                original_depth = nil
+                original_width = nil
+                original_height = nil
+                original_type = nil
+                original_format = nil
+                original_orientation = nil
+                CommandRunner.new("identify -format '%z %w %h %r %m %[EXIF:Orientation]' :file").
+                  run(:file => input.file_name) do |line|
+                  if line =~ /(\d+) (\d+) (\d+) ([^\s]+) ([^\s]+) (\d+)?/
+                    original_depth, original_width, original_height = $~[1, 3].map(&:to_i)
+                    original_type = $4
+                    original_format = $5.downcase
+                    original_orientation = $6.try(:to_i)
+                  end
+                end
+                unless original_width and original_height
+                  raise "Unable to determine dimensions of input image"
+                end
+
+                # Correct for EXIF orientation
+                if [5, 6, 7, 8].include?(original_orientation)
+                  original_width, original_height = original_height, original_width
+                end
+
+                original_aspect = original_height / original_width.to_f
+
+                result[:width] = original_width
+                result[:height] = original_height
+                result[:depth] = original_depth
+                
+                medium = version_options[:medium]
+                medium &&= medium.to_sym
+
+                new_width, new_height = version_options[:width], version_options[:height]
+                if new_width
+                  new_height ||= (new_width * original_aspect).ceil
+                elsif new_height
+                  new_width ||= (new_height / original_aspect).ceil
+                else
+                  new_width, new_height = original_width, original_height
+                end
+
+                scale_width, scale_height = new_width, new_height
+                scale = (version_options[:scale] || 'down').to_sym
+                case scale
+                  when :up, :none
+                    # Do nothing
+                  when :down
+                    if scale_width > original_width
+                      scale_width = original_width
+                      scale_height = (scale_width * original_aspect).ceil
+                    elsif scale_height > original_height
+                      scale_height = original_height
+                      scale_width = (scale_height / original_aspect).ceil
+                    end
+                  when :fit
+                    if (scale_width * original_aspect).ceil < new_height
+                      scale_height = new_height
+                      scale_width = (new_height / original_aspect).ceil
+                    elsif (scale_height / original_aspect).ceil < new_width
+                      scale_width = new_width
+                      scale_height = (scale_width * original_aspect).ceil
+                    end
+                end
+                
+                convert_command = "convert"
+                convert_options = {:input_file => input.file_name}
+                case version_options[:format]
+                  when 'png', 'jpeg', 'gif'
+                    convert_options[:output_file] = "#{version_options[:format]}:#{output.file_name}"
+                  else
+                    convert_options[:output_file] = output.file_name
+                end
+                if scale != :none
+                  convert_command << " -resize :resize"
+                  convert_options[:resize] = "#{scale_width}x#{scale_height}"
+                end
+                if version_options[:crop]
+                  convert_command << " -gravity center -crop :crop"
+                  convert_options[:crop] = "#{new_width}x#{new_height}+0+0"
+                end
+                if version_options[:strip_metadata]
+                  convert_command << " +profile :remove_profiles -set comment ''"
+                  convert_options[:remove_profiles] = "8bim,iptc,xmp,exif"
+                end
+
+                convert_command << " -quality #{((version_options[:quality] || 1.0) * 100).ceil}%"
+
+                # Work around a problem with ImageMagick being too clever and "optimizing"
+                # the bit depth of RGB images that contain a single grayscale channel.
+                # Coincidentally, this avoids ImageMagick rewriting the ICC data and
+                # corrupting it in the process.
+                if original_type =~ /(?:Gray|RGB)(Matte)?$/ and original_format != 'png'
+                  convert_command << " -type TrueColor#{$1}"
+                end
+
+                # Fix CMYK images
+                if medium == :web and original_type =~ /CMYK$/
+                  convert_command << " -colorspace rgb"
+                end
+
+                # Auto-orient images when web or we're stripping EXIF
+                if medium == :web or version_options[:strip_metadata]
+                  convert_command << " -auto-orient"
+                end
+
+                convert_command << " :input_file :output_file"
+                CommandRunner.new(convert_command).run(convert_options)
+                
+                if version_options[:format] == 'png'
+                  Tempfile.open('tootsie') do |file|
+                    # TODO: Make less sloppy
+                    file.write(File.read(output.file_name))
+                    file.close
+                    CommandRunner.new('pngcrush :input_file :output_file').run(
+                      :input_file => file.path, :output_file => output.file_name)
+                  end
+                end
+                
+                output.content_type = version_options[:content_type] if version_options[:content_type]
+                output.content_type ||= case version_options[:format]
+                  when 'jpeg' then 'image/jpeg'
+                  when 'png' then 'image/png'
+                  when 'gif' then 'image/gif'
+                end
+                output.put!
+                result[:outputs] << {:url => output.result_url}
+              ensure
+                output.close
+              end
+            end
+          end
+        ensure
+          input.close
+        end
+        result
+      end
+    
+      attr_accessor :input_url
+      attr_accessor :versions
+
+    end
+
+  end  
+end

data/lib/tootsie/processors/video_processor.rb

@@ -0,0 +1,85 @@
+require 'json'
+
+module Tootsie
+  module Processors
+  
+    class VideoProcessor
+    
+      def initialize(params = {})
+        @input_url = params[:input_url]
+        @thumbnail_options = (params[:thumbnail] || {}).with_indifferent_access
+        @versions = [params[:versions] || {}].flatten
+        @thread_count = Application.get.configuration.ffmpeg_thread_count
+      end
+    
+      def valid?
+        return @input_url && !@versions.blank?
+      end
+    
+      def params
+        return {
+          :input_url => @input_url,
+          :thumbnail => @thumbnail_options,
+          :versions => @versions
+        }
+      end
+    
+      def execute!(&block)
+        result = {:urls => []}
+        input, output, thumbnail_output = Input.new(@input_url), nil, nil
+        begin
+          input.get!
+          begin
+            versions.each_with_index do |version_options, version_index|
+              version_options = version_options.with_indifferent_access
+              
+              if version_index == 0 and @thumbnail_options[:target_url]
+                thumbnail_output = Output.new(@thumbnail_options[:target_url])
+              else
+                thumbnail_output = nil
+              end
+              begin              
+                output = Output.new(version_options[:target_url])
+                begin
+                  adapter_options = version_options.dup
+                  adapter_options.delete(:target_url)
+                  adapter_options[:thumbnail] = @thumbnail_options.merge(:filename => thumbnail_output.file_name) if thumbnail_output
+
+                  adapter = Tootsie::FfmpegAdapter.new(:thread_count => @thread_count)
+                  if block
+                    adapter.progress = lambda { |seconds, total_seconds|
+                      yield(:progress => (seconds + (total_seconds * version_index)) / (total_seconds * versions.length).to_f)
+                    }
+                  end
+                  adapter.transcode(input.file_name, output.file_name, adapter_options)
+
+                  output.content_type = version_options[:content_type] if version_options[:content_type]
+                  output.put!
+
+                  result[:urls].push output.result_url
+                ensure
+                  output.close
+                end
+                if thumbnail_output
+                  thumbnail_output.put!
+                  result[:thumbnail_url] = thumbnail_output.result_url
+                end
+              ensure
+                thumbnail_output.close if thumbnail_output
+              end
+            end
+          end
+        ensure
+          input.close
+        end
+        result
+      end
+    
+      attr_accessor :input_url
+      attr_accessor :versions
+      attr_accessor :thumbnail_options
+    
+    end
+
+  end  
+end