httpthumbnailer 1.2.0 → 1.3.0

data/lib/httpthumbnailer/plugin/thumbnailer/service.rb

@@ -0,0 +1,163 @@
+require_relative 'service/magick'
+require_relative 'service/images'
+require_relative 'service/built_in_plugins'
+
+module Plugin
+	module Thumbnailer
+		class Service
+			include ClassLogging
+
+			extend Stats
+			def_stats(
+				:total_images_loaded,
+				:total_images_reloaded,
+				:total_images_downsampled,
+				:total_thumbnails_created,
+				:images_loaded,
+				:max_images_loaded,
+				:max_images_loaded_worker,
+				:total_images_created,
+				:total_images_destroyed,
+				:total_images_created_from_blob,
+				:total_images_created_initialize,
+				:total_images_created_initialize_copy,
+				:total_images_created_resize,
+				:total_images_created_crop,
+				:total_images_created_sample,
+				:total_images_created_blur_image,
+				:total_images_created_composite,
+				:total_images_created_rotate
+			)
+
+			def self.input_formats
+				Magick.formats.select do |name, mode|
+					mode.include? 'r'
+				end.keys.map(&:downcase)
+			end
+
+			def self.output_formats
+				Magick.formats.select do |name, mode|
+					mode.include? 'w'
+				end.keys.map(&:downcase)
+			end
+
+			def self.rmagick_version
+				Magick::Version
+			end
+
+			def self.magick_version
+				Magick::Magick_version
+			end
+
+			def initialize(options = {})
+				InputImage.logger = logger_for(InputImage)
+				Thumbnail.logger = logger_for(Thumbnail)
+				Magick::Image.logger = logger_for(Magick::Image)
+
+				@thumbnailing_methods = {}
+				@edits = {}
+				@options = options
+				@images_loaded = 0
+
+				log.info "initializing thumbnailer: #{self.class.rmagick_version} #{self.class.magick_version}"
+
+				set_limit(:area, options[:limit_area]) if options.member?(:limit_area)
+				set_limit(:memory, options[:limit_memory]) if options.member?(:limit_memory)
+				set_limit(:map, options[:limit_map]) if options.member?(:limit_map)
+				set_limit(:disk, options[:limit_disk]) if options.member?(:limit_disk)
+
+				Magick.trace_proc = lambda do |which, description, id, method|
+					case which
+					when :c
+						Service.stats.incr_images_loaded
+						@images_loaded += 1
+						Service.stats.max_images_loaded = Service.stats.images_loaded if Service.stats.images_loaded > Service.stats.max_images_loaded
+						Service.stats.max_images_loaded_worker = @images_loaded if @images_loaded > Service.stats.max_images_loaded_worker
+						Service.stats.incr_total_images_created
+						case method
+						when :from_blob
+							Service.stats.incr_total_images_created_from_blob
+						when :initialize
+							Service.stats.incr_total_images_created_initialize
+						when :initialize_copy
+							Service.stats.incr_total_images_created_initialize_copy
+						when :resize
+							Service.stats.incr_total_images_created_resize
+						when :resize!
+							Service.stats.incr_total_images_created_resize
+						when :crop
+							Service.stats.incr_total_images_created_crop
+						when :crop!
+							Service.stats.incr_total_images_created_crop
+						when :sample
+							Service.stats.incr_total_images_created_sample
+						when :blur_image
+							Service.stats.incr_total_images_created_blur_image
+						when :composite
+							Service.stats.incr_total_images_created_composite
+						when :rotate
+							Service.stats.incr_total_images_created_rotate
+						else
+							log.warn "uncounted image creation method: #{method}"
+						end
+					when :d
+						Service.stats.decr_images_loaded
+						@images_loaded -= 1
+						Service.stats.incr_total_images_destroyed
+					end
+					log.debug{"image event: #{which}, #{description}, #{id}, #{method}: loaded images: #{Service.stats.images_loaded}"}
+				end
+			end
+
+			def load(io, options = {}, &block)
+				blob = io.read
+
+				old_memory_limit = nil
+				borrowed_memory_limit = nil
+				if options.member?(:limit_memory)
+					borrowed_memory_limit = options[:limit_memory].borrow(options[:limit_memory].limit, 'image magick')
+					old_memory_limit = set_limit(:memory, borrowed_memory_limit)
+				end
+
+				InputImage.from_blob(blob, @thumbnailing_methods, @edits, options, &block)
+			ensure
+				if old_memory_limit
+					set_limit(:memory, old_memory_limit)
+					options[:limit_memory].return(borrowed_memory_limit, 'image magick')
+				end
+			end
+
+			def thumbnailing_method(method, &impl)
+				log.info "adding thumbnailing method: #{method}"
+				@thumbnailing_methods[method] = impl
+			end
+
+			def edit(name, &impl)
+				log.info "adding edit: #{name}(#{impl.parameters.drop(1).reverse.drop(2).reverse.map{|p| p.last.to_s}.join(', ')})"
+				@edits[name] = impl
+			end
+
+			def set_limit(limit, value)
+				old = Magick.limit_resource(limit, value)
+				log.info "changed #{limit} limit from #{old} to #{value} bytes"
+				old
+			end
+
+			def load_plugin(plugin_context)
+				plugin_context.thumbnailing_methods.each do |name, block|
+					thumbnailing_method(name, &block)
+				end
+
+				plugin_context.edits.each do |name, block|
+					edit(name, &block)
+				end
+			end
+
+			def setup_built_in_plugins
+				log.info("loading built in plugins")
+				load_plugin(self.class.built_in_plugin)
+			end
+		end
+	end
+end
+

data/lib/httpthumbnailer/plugin/thumbnailer/service/built_in_plugins.rb

@@ -0,0 +1,134 @@
+module Plugin
+	module Thumbnailer
+		class Service
+			def self.built_in_plugin
+				PluginContext.new do
+					thumbnailing_method('crop') do |image, width, height, options|
+						image.resize_to_fill(width, height, float!('float-x', options['float-x'], 0.5), float!('float-y', options['float-y'], 0.5)) if image.width != width or image.height != height
+					end
+
+					thumbnailing_method('fit') do |image, width, height, options|
+						image.resize_to_fit(width, height) if image.width != width or image.height != height
+					end
+
+					thumbnailing_method('pad') do |image, width, height, options|
+						image.resize_to_fit(width, height).get do |resize|
+							resize.render_on_background(options['background-color'], width, height, float!('float-x', options['float-x'], 0.5), float!('float-y', options['float-y'], 0.5))
+						end if image.width != width or image.height != height
+					end
+
+					thumbnailing_method('limit') do |image, width, height, options|
+						image.resize_to_fit(width, height) if image.width > width or image.height > height
+					end
+
+					edit('resize_crop') do |image, width, height, options, thumbnail_spec|
+						width = float!('width', width)
+						height = float!('height', height)
+
+						image.resize_to_fill(width, height, ufloat!('float-x', options['float-x'], 0.5), ufloat!('float-y', options['float-y'], 0.5)) if image.width != width or image.height != height
+					end
+
+					edit('resize_fit') do |image, width, height, options, thumbnail_spec|
+						width = float!('width', width)
+						height = float!('height', height)
+
+						image.resize_to_fit(width, height) if image.width != width or image.height != height
+					end
+
+					edit('resize_limit') do |image, width, height, options, thumbnail_spec|
+						width = float!('width', width)
+						height = float!('height', height)
+
+						image.resize_to_fit(width, height) if image.width > width or image.height > height
+					end
+
+					edit('rotate') do |image, angle, options, thumbnail_spec|
+						angle = float!('angle', angle)
+						next image if angle % 360 == 0
+						image.with_background_color(options['background-color'] || thumbnail_spec.options['background-color']) do
+							image.rotate(angle)
+						end
+					end
+
+					edit('crop') do |image, x, y, width, height, options, thumbnail_spec|
+						x, y, width, height = normalize_region(
+							float!('x', x),
+							float!('y', y),
+							float!('width', width),
+							float!('height', height)
+						)
+
+						next image if [x, y, width, height] == [0.0, 0.0, 1.0, 1.0]
+
+						image.crop(
+							*image.rel_to_px_box(x, y, width, height),
+							true
+						)
+					end
+
+					edit('pixelate') do |image, box_x, box_y, box_width, box_height, options, thumbnail_spec|
+						x, y, width, height = normalize_region(
+							float!('box_x', box_x),
+							float!('box_y', box_y),
+							float!('box_width', box_width),
+							float!('box_height', box_height)
+						)
+						size = ufloat!('size', options['size'], 0.01)
+
+						image.pixelate_region(
+							*image.rel_to_px_box(x, y, width, height),
+							image.rel_to_diagonal(size)
+						)
+					end
+
+					edit('blur') do |image, box_x, box_y, box_width, box_height, options, thumbnail_spec|
+						x, y, width, height = normalize_region(
+							float!('box_x', box_x),
+							float!('box_y', box_y),
+							float!('box_width', box_width),
+							float!('box_height', box_height)
+						)
+
+						radius = ufloat!('radius', options['radius'], 0.0) # auto
+						sigma = ufloat!('sigma', options['sigma'], 0.01)
+
+						radius = image.rel_to_diagonal(radius)
+						sigma = image.rel_to_diagonal(sigma)
+
+						if radius > 50
+							log.warn "limiting effective radius from #{radius} down to 50"
+							radius = 50
+						end
+
+						if sigma > 50
+							log.warn "limiting effective sigma from #{sigma} down to 50"
+							sigma = 50
+						end
+
+						image.blur_region(
+							*image.rel_to_px_box(x, y, width, height),
+							radius, sigma
+						)
+					end
+
+					edit('rectangle') do |image, box_x, box_y, box_width, box_height, options, thumbnail_spec|
+						x, y, width, height = normalize_region(
+							float!('box_x', box_x),
+							float!('box_y', box_y),
+							float!('box_width', box_width),
+							float!('box_height', box_height)
+						)
+
+						color = options['color'] || 'black'
+
+						image.render_rectangle(
+							*image.rel_to_px_box(x, y, width, height),
+							color
+						)
+					end
+				end
+			end
+		end
+	end
+end
+

data/lib/httpthumbnailer/plugin/thumbnailer/service/images.rb

@@ -0,0 +1,295 @@
+require 'forwardable'
+
+module Plugin
+	module Thumbnailer
+		class Service
+			module MimeType
+				# ImageMagick Image.mime_type is absolutely bunkers! It goes over file system to look for some strange files WTF?!
+				# Also it cannot be used for thumbnails since they are not yet rendered to desired format
+				# Here is stupid implementation
+				def mime_type
+					#TODO: how do I do it better?
+					mime = case format
+						when 'JPG' then 'jpeg'
+						else format.downcase
+					end
+					"image/#{mime}"
+				end
+			end
+
+			class InputImage
+				UpscaledError = Class.new RuntimeError
+
+				include ClassLogging
+				include PerfStats
+				extend PerfStats
+				extend Forwardable
+
+				def initialize(image, thumbnailing_methods, edits)
+					@image = image
+					@thumbnailing_methods = thumbnailing_methods
+					@edits = edits
+				end
+
+				def self.from_blob(blob, thumbnailing_methods, edits, options = {}, &block)
+					mw = options[:max_width]
+					mh = options[:max_height]
+
+					begin
+						image = measure "loading original image" do
+							image = measure "loading image form blob" do
+								begin
+									images =
+										if mw and mh
+											measure "loading image form blob with size hint", "#{mw}x#{mh}" do
+												log.info "using max size hint of: #{mw}x#{mh}"
+												Magick::Image.from_blob(blob) do |info|
+													# actual hint is 2x the max thumbnail dimensions so we don't loose too much quality
+													define('jpeg', 'size', "#{mw*2}x#{mh*2}")
+													define('jbig', 'size', "#{mw*2}x#{mh*2}")
+												end
+											end
+										else
+											measure "loading image form blob without size hint" do
+												Magick::Image.from_blob(blob)
+											end
+										end
+									begin
+										image = images.shift
+										begin
+											if image.columns > image.base_columns or image.rows > image.base_rows
+												log.warn "input image got upscaled from: #{image.base_columns}x#{image.base_rows} to #{image.columns}x#{image.rows}"
+												if not options[:no_upscale_fix]
+													raise UpscaledError if options[:reload]
+													measure "downsampling input image to base size", "#{image.base_columns}x#{image.base_rows}" do
+														log.warn "downsampling input image to base size: #{image.base_columns}x#{image.base_rows}"
+														image = image.get do |image|
+															image.sample(image.base_columns, image.base_rows)
+														end
+													end
+												end
+											end
+											image
+										rescue
+											image.destroy!
+											raise
+										end
+									ensure
+										images.each do |other|
+											other.destroy!
+										end
+									end
+								rescue UpscaledError
+									log.warn "reloading input image without max size hint!"
+									Service.stats.incr_total_images_reloaded
+									mw = mh = nil
+									retry
+								end
+							end
+							image.get do |image|
+								blob = nil
+
+								log.info "loaded image: #{image.inspect.strip}"
+								Service.stats.incr_total_images_loaded
+
+								# clean up the image
+								image.strip!
+								image.properties do |key, value|
+									log.debug "deleting user propertie '#{key}'"
+									image[key] = nil
+								end
+								image
+							end.get do |image|
+								if mw and mh and not options[:no_downsample]
+									f = image.find_downsample_factor(mw, mh)
+									if f > 1
+										measure "downsampling", image.inspect.strip do
+											image = image.downsample(f)
+											log.info "downsampled image by factor of #{f}: #{image.inspect.strip}"
+											Service.stats.incr_total_images_downsampled
+											image
+										end
+									end
+								end
+							end
+						end
+						image.get do |image|
+							yield self.new(image, thumbnailing_methods, edits)
+							true # make sure it is destroyed
+						end
+					rescue Magick::ImageMagickError => error
+						raise ImageTooLargeError, error if error.message =~ /cache resources exhausted/
+						raise UnsupportedMediaTypeError, error
+					end
+				end
+
+				def thumbnail!(spec, &block)
+					# it is OK if the image get's destroyed in the process
+					@image.get do |image|
+						_thumbnail(image, spec, &block)
+					end
+				end
+
+				def thumbnail(spec, &block)
+					# we don't want to destory the input image after we have generated the thumbnail so we can generate another one
+					@image.borrow do |image|
+						_thumbnail(image, spec, &block)
+					end
+				end
+
+				def _thumbnail(image, spec)
+					spec = spec.dup
+					# default background is white
+					spec.options['background-color'] = spec.options.fetch('background-color', 'white').sub(/^0x/, '#')
+
+					width = spec.width == :input ? @image.columns : spec.width
+					height = spec.height == :input ? @image.rows : spec.height
+					image_format = spec.format == :input ? @image.format : spec.format
+
+					raise ZeroSizedImageError.new(width, height) if width == 0 or height == 0
+
+					begin
+						measure "generating thumbnail to spec", spec do
+							image.get do |image|
+								if image.alpha?
+									measure "rendering image on background", image.inspect.strip  do
+										log.info 'image has alpha, rendering on background'
+										image.render_on_background(spec.options['background-color'])
+									end
+								else
+									image
+								end
+							end.get do |image|
+								spec.edits.each do |edit|
+									log.debug "applying edit '#{edit}'"
+									image = image.get do |image|
+										measure "edit", edit do
+											edit_image(image, edit.name, *edit.args, edit.options, spec)
+										end
+									end
+								end
+								image
+							end.get do |image|
+								log.debug "thumbnailing with method '#{spec.method} #{width}x#{height} #{spec.options}'"
+								measure "thumbnailing with method", "#{spec.method} #{width}x#{height} #{spec.options}" do
+									thumbnail_image(image, spec.method, width, height, spec.options)
+								end
+							end.get do |image|
+								if image.alpha?
+									measure "rendering thumbnail on background", image.inspect.strip do
+										log.info 'thumbnail has alpha, rendering on background'
+										image.render_on_background(spec.options['background-color'])
+									end
+								else
+									image
+								end
+							end.get do |image|
+								Service.stats.incr_total_thumbnails_created
+								yield Thumbnail.new(image, image_format, spec.options)
+							end
+						end
+					rescue Magick::ImageMagickError => error
+						raise ImageTooLargeError, error.message if error.message =~ /cache resources exhausted/
+						raise
+					end
+				end
+
+				def edit_image(image, name, *args, options, spec)
+					impl = @edits[name] or raise UnsupportedEditError, name
+
+					# make sure we pass as many args as expected (filling with nil)
+					args_no = impl.arity - 3 # for image, optioins and spec
+					args = args.dup
+					args.fill(nil, (args.length)...args_no)
+					if args.length > args_no
+						log.warn "extra arguments to edit '#{name}': #{args[args_no..-1].join(', ')}"
+						args = args[0...args_no]
+					end
+
+					ret = impl.call(image, *args, options, spec)
+
+					fail "edit '#{name}' returned '#{ret.class.name}' - expecting nil or Magick::Image" unless ret.nil? or ret.kind_of? Magick::Image
+					ret or image
+				rescue PluginContext::PluginArgumentError => error
+					raise EditArgumentError.new(name, error.message)
+				end
+
+				def thumbnail_image(image, method, width, height, options)
+					impl = @thumbnailing_methods[method] or raise UnsupportedMethodError, method
+					ret = impl.call(image, width, height, options)
+					fail "thumbnailing method '#{name}' returned '#{ret.class.name}' - expecting nil or Magick::Image" unless ret.nil? or ret.kind_of? Magick::Image
+					ret or image
+				rescue PluginContext::PluginArgumentError => error
+					raise ThumbnailArgumentError.new(method, error.message)
+				end
+
+				def_delegators :@image, :format, :width, :height
+
+				include MimeType
+
+				# We use base values since it might have been loaded with size hint and prescaled
+				def width
+					@image.base_columns
+				end
+
+				def height
+					@image.base_rows
+				end
+			end
+
+			class Thumbnail
+				include ClassLogging
+				extend Forwardable
+				include PerfStats
+
+				def initialize(image, format, options = {})
+					@image = image
+					@format = format
+
+					@quality = (options['quality'] or default_quality(format))
+					@quality &&= @quality.to_i
+
+					@interlace = (options['interlace'] or 'NoInterlace')
+					fail "unsupported interlace: #{@interlace}" unless Magick::InterlaceType.values.map(&:to_s).include? @interlace
+					@interlace = Magick.const_get @interlace.to_sym
+				end
+
+				attr_reader :format
+				def_delegators :@image, :width, :height
+
+				#def_delegators :@image, :format
+
+				def data
+					# export class variables to local scope
+					format = @format
+					quality = @quality
+					interlace = @interlace
+
+					measure "to blob", "#{@format} (quality: #{@quality} interlace: #{@interlace})" do
+						@image.to_blob do
+							self.format = format
+							self.quality = quality if quality
+							self.interlace = interlace
+						end
+					end
+				end
+
+				include MimeType
+
+				private
+
+				def default_quality(format)
+					case format
+					when /png/i
+						95 # max zlib compression, adaptive filtering (photo)
+					when /jpeg|jpg/i
+						85
+					else
+						nil
+					end
+				end
+			end
+		end
+	end
+end
+