bench9000 0.1

data/vendor/oily_png/ext/oily_png/resampling.h

@@ -0,0 +1,25 @@
+#ifndef OILY_PNG_RESAMPLING_H
+#define OILY_PNG_RESAMPLING_H
+
+/*
+ * Generates the interpolation steps (nearest neighbour) through two values.
+ */
+void oily_png_generate_steps_residues(long width, long new_width, long *steps, long *residues);
+
+/*
+ * Generates the interpolation steps through two values.
+ *
+ * Returns a Ruby Array
+ */
+VALUE oily_png_canvas_steps_residues(VALUE self, VALUE width, VALUE new_width);
+VALUE oily_png_canvas_steps(VALUE self, VALUE width, VALUE new_width);
+
+
+/*
+ * Performs nearest neighbor interpolation on the Canvas
+ */
+VALUE oily_png_canvas_resample_nearest_neighbor_bang(VALUE self, VALUE new_width, VALUE new_height);
+
+VALUE oily_png_canvas_resample_bilinear_bang(VALUE self, VALUE new_width, VALUE new_height);
+
+#endif

data/vendor/oily_png/lib/oily_png.rb

@@ -0,0 +1,21 @@
+require 'chunky_png'
+
+module OilyPNG
+  def self.included(base)
+    base::Canvas.send(:extend, OilyPNG::PNGDecoding)
+    base::Canvas.send(:include, OilyPNG::PNGEncoding)
+
+
+    base::Color.send(:include, OilyPNG::Color)
+    
+    base::Color.extend OilyPNG::Color
+    base::Canvas.send(:include, OilyPNG::Resampling)
+  end
+end
+
+require 'oily_png/version'
+require 'oily_png/oily_png'
+require 'oily_png/canvas'
+
+# Include mixin into ChunkyPNG
+ChunkyPNG.send(:include, OilyPNG)

data/vendor/oily_png/lib/oily_png/canvas.rb

@@ -0,0 +1,15 @@
+require 'chunky_png'
+require 'oily_png/oily_png'
+
+module OilyPNG
+  class Canvas < ChunkyPNG::Canvas
+    extend OilyPNG::PNGDecoding
+    include OilyPNG::PNGEncoding
+    include OilyPNG::Operations
+    include OilyPNG::Resampling
+  end
+  
+  module Color
+    extend self
+  end
+end

data/vendor/oily_png/lib/oily_png/version.rb

@@ -0,0 +1,3 @@
+module OilyPNG
+  VERSION = "1.1.1"
+end

data/vendor/oily_png/oily_png.gemspec

@@ -0,0 +1,39 @@
+# -*- encoding: utf-8 -*-
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'oily_png/version'
+
+Gem::Specification.new do |s|
+  s.name = 'oily_png'
+  s.rubyforge_project = s.name
+
+  # Do not change the version and date fields by hand. This will be done
+  # automatically by the gem release script.
+  s.version = OilyPNG::VERSION
+
+  s.summary     = "Native mixin to speed up ChunkyPNG"
+  s.description = <<-EOT
+    This Ruby C extenstion defines a module that can be included into ChunkyPNG to improve its speed.
+  EOT
+
+  s.license  = 'MIT'
+  s.authors  = ['Willem van Bergen']
+  s.email    = ['willem@railsdoctors.com']
+  s.homepage = 'http://wiki.github.com/wvanbergen/oily_png'
+
+  s.extensions    = ["ext/oily_png/extconf.rb"]
+  s.require_paths = ["lib", "ext"]
+
+  s.add_runtime_dependency('chunky_png', '~> 1.3.0')
+
+  s.add_development_dependency('rake')
+  s.add_development_dependency('rake-compiler')
+  s.add_development_dependency('rspec', '~> 2')
+
+  s.rdoc_options << '--title' << s.name << '--main' << 'README.rdoc' << '--line-numbers' << '--inline-source'
+  s.extra_rdoc_files = ['README.rdoc']
+
+  s.files = `git ls-files`.split($/)
+  s.test_files = s.files.grep(%r{^(test|spec|features)/})
+end

data/vendor/oily_png/spec/color_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe OilyPNG::Color do
+
+  include OilyPNG::Color
+
+  before(:each) do
+    @white             = 0xffffffff
+    @black             = 0x000000ff
+    @opaque            = 0x0a6496ff
+    @non_opaque        = 0x0a649664
+    @fully_transparent = 0x0a649600
+  end
+
+  describe '#compose_quick' do
+
+    it "should use the foregorund color as is when the background color is fully transparent" do
+      compose_quick(@non_opaque, @fully_transparent).should == @non_opaque
+    end
+
+    it "should use the foregorund color as is when an opaque color is given as foreground color" do
+      compose_quick(@opaque, @white).should == @opaque
+    end
+
+    it "should use the background color as is when a fully transparent pixel is given as foreground color" do
+      compose_quick(@fully_transparent, @white).should == @white
+    end
+
+    it "should compose pixels correctly" do
+      compose_quick(@non_opaque, @white).should == 0x9fc2d6ff
+    end
+    
+    it "should compose colors exactly the same as ChunkyPNG" do
+      fg, bg = rand(0xffffffff), rand(0xffffffff)
+      compose_quick(fg, bg).should == ChunkyPNG::Color.compose_quick(fg, bg)
+    end
+  end
+end

data/vendor/oily_png/spec/decoding_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe OilyPNG::PNGDecoding do
+
+  it "should call ChunkyPNG::Color.pixel_bytesize in the pure ruby version" do
+    ChunkyPNG::Color.should_receive(:pixel_bytesize).and_return(3)
+    ChunkyPNG::Canvas.from_file(resource_file('square.png'))
+  end
+
+  it "should not call ChunkyPNG::Color.pixel_bytesize in the native version" do
+    ChunkyPNG::Color.should_not_receive(:pixel_bytesize)
+    OilyPNG::Canvas.from_file(resource_file('square.png'))
+  end
+  
+  context 'decoding different filtering methods' do
+    before(:all) { @reference = ChunkyPNG::Canvas.from_file(resource_file('nonsquare.png'))}
+    
+    it "should decode NONE filtering exactly the same as ChunkyPNG" do
+      filtered_data = @reference.to_blob(:filtering => ChunkyPNG::FILTER_NONE)
+      ChunkyPNG::Canvas.from_blob(filtered_data).should == OilyPNG::Canvas.from_blob(filtered_data)
+    end
+    
+    it "should decode SUB filtering exactly the same as ChunkyPNG" do
+      filtered_data = @reference.to_blob(:filtering => ChunkyPNG::FILTER_SUB)
+      ChunkyPNG::Canvas.from_blob(filtered_data).should == OilyPNG::Canvas.from_blob(filtered_data)
+    end
+    
+    it "should decode UP filtering exactly the same as ChunkyPNG" do
+      filtered_data = @reference.to_blob(:filtering => ChunkyPNG::FILTER_UP)
+      ChunkyPNG::Canvas.from_blob(filtered_data).should == OilyPNG::Canvas.from_blob(filtered_data)
+    end
+    
+    it "should decode AVERAGE filtering exactly the same as ChunkyPNG" do
+      filtered_data = @reference.to_blob(:filtering => ChunkyPNG::FILTER_AVERAGE)
+      ChunkyPNG::Canvas.from_blob(filtered_data).should == OilyPNG::Canvas.from_blob(filtered_data)
+    end
+    
+    it "should decode PAETH filtering exactly the same as ChunkyPNG" do
+      filtered_data = @reference.to_blob(:filtering => ChunkyPNG::FILTER_PAETH)
+      ChunkyPNG::Canvas.from_blob(filtered_data).should == OilyPNG::Canvas.from_blob(filtered_data)
+    end
+  end
+  
+  context 'decoding compatibility with ChunkyPNG' do
+    resource_files.each do |file|
+      it "should #{File.basename(file)} the same as ChunkyPNG" do
+        OilyPNG::Canvas.from_file(file).pixels.should == ChunkyPNG::Canvas.from_file(file).pixels
+      end
+    end
+  end
+end

data/vendor/oily_png/spec/encoding_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+describe OilyPNG::PNGEncoding do
+
+  context 'encoding different color settings without palette' do
+    before do
+      @canvas      = ChunkyPNG::Canvas.from_file(resource_file('gray.png'))
+      @oily_canvas = OilyPNG::Canvas.from_canvas(@canvas)
+    end
+    
+    it "should encode an image using 8-bit grayscale correctly" do
+      @canvas.send(:encode_png_image_pass_to_stream,      stream2 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_GRAYSCALE, 8, ChunkyPNG::FILTER_NONE)
+      @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_GRAYSCALE, 8, ChunkyPNG::FILTER_NONE)
+      stream1.should == stream2
+    end
+    
+    it "should encode an image using 4-bit grayscale correctly" do
+      @canvas.send(:encode_png_image_pass_to_stream,      stream2 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_GRAYSCALE, 4, ChunkyPNG::FILTER_NONE)
+      @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_GRAYSCALE, 4, ChunkyPNG::FILTER_NONE)
+      stream1.should == stream2
+    end
+    
+    it "should encode an image using 2-bit grayscale correctly" do
+      @canvas.send(:encode_png_image_pass_to_stream,      stream2 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_GRAYSCALE, 2, ChunkyPNG::FILTER_NONE)
+      @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_GRAYSCALE, 2, ChunkyPNG::FILTER_NONE)
+      stream1.should == stream2
+    end
+    
+    it "should encode an image using 1-bit grayscale correctly" do
+      @canvas.send(:encode_png_image_pass_to_stream,      stream2 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_GRAYSCALE, 1, ChunkyPNG::FILTER_NONE)
+      @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_GRAYSCALE, 1, ChunkyPNG::FILTER_NONE)
+      stream1.should == stream2
+    end
+    
+    it "should encode an image using 8-bit grayscale alpha correctly" do
+      @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_GRAYSCALE_ALPHA, 8, ChunkyPNG::FILTER_NONE)
+      @canvas.send(:encode_png_image_pass_to_stream,      stream2 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_GRAYSCALE_ALPHA, 8, ChunkyPNG::FILTER_NONE)
+      stream1.should == stream2
+    end
+
+    it "should encode an image using 8-bit truecolor correctly" do
+      @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR, 8, ChunkyPNG::FILTER_NONE)
+      @canvas.send(:encode_png_image_pass_to_stream,      stream2 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR, 8, ChunkyPNG::FILTER_NONE)
+      stream1.should == stream2
+    end
+    
+    it "should encode an image using 8-bit truecolor alpha correctly" do
+      @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR_ALPHA, 8, ChunkyPNG::FILTER_NONE)
+      @canvas.send(:encode_png_image_pass_to_stream,      stream2 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR_ALPHA, 8, ChunkyPNG::FILTER_NONE)
+      stream1.should == stream2
+    end
+  end
+
+  context 'encoding with paletted images using different bitrates' do
+    before do
+      @canvas      = ChunkyPNG::Canvas.from_file(resource_file('gray.png'))
+      @oily_canvas = OilyPNG::Canvas.from_canvas(@canvas)
+      
+      @canvas.encoding_palette = @canvas.palette
+      @canvas.encoding_palette.to_plte_chunk
+      
+      @oily_canvas.encoding_palette = @oily_canvas.palette
+      @oily_canvas.encoding_palette.to_plte_chunk
+    end
+    
+    it "should encode an image using 8-bit indexed colors correctly" do
+      @canvas.send(:encode_png_image_pass_to_stream,      stream2 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_INDEXED, 8, ChunkyPNG::FILTER_NONE)
+      @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_INDEXED, 8, ChunkyPNG::FILTER_NONE)
+      stream1.should == stream2
+    end
+
+    it "should encode an image using 4-bit indexed colors correctly" do
+      @canvas.send(:encode_png_image_pass_to_stream,      stream2 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_INDEXED, 4, ChunkyPNG::FILTER_NONE)
+      @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_INDEXED, 4, ChunkyPNG::FILTER_NONE)
+      stream1.should == stream2
+    end
+
+    it "should encode an image using 2-bit indexed colors correctly" do
+      @canvas.send(:encode_png_image_pass_to_stream,      stream2 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_INDEXED, 2, ChunkyPNG::FILTER_NONE)
+      @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_INDEXED, 2, ChunkyPNG::FILTER_NONE)
+      stream1.should == stream2
+    end
+
+    it "should encode an image using 1-bit indexed colors correctly" do
+      @canvas.send(:encode_png_image_pass_to_stream,      stream2 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_INDEXED, 1, ChunkyPNG::FILTER_NONE)
+      @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_INDEXED, 1, ChunkyPNG::FILTER_NONE)
+      stream1.should == stream2
+    end
+  end
+  
+  context 'encoding different filters' do
+    before do 
+      @canvas      = ChunkyPNG::Canvas.from_file(resource_file('nonsquare.png'))
+      @oily_canvas = OilyPNG::Canvas.from_canvas(@canvas)
+    end
+    
+    it "should encode correctly with no filtering" do
+      @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR, 8, ChunkyPNG::FILTER_NONE)
+      @canvas.send(:encode_png_image_pass_to_stream,      stream2 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR, 8, ChunkyPNG::FILTER_NONE)
+      stream1.should == stream2
+    end
+    
+    it "should encode correctly with sub filtering" do
+      @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR, 8, ChunkyPNG::FILTER_SUB)
+      @canvas.send(:encode_png_image_pass_to_stream,      stream2 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR, 8, ChunkyPNG::FILTER_SUB)
+      stream1.should == stream2
+    end
+    
+    it "should encode correctly with up filtering" do
+      @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR, 8, ChunkyPNG::FILTER_UP)
+      @canvas.send(:encode_png_image_pass_to_stream,      stream2 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR, 8, ChunkyPNG::FILTER_UP)
+      stream1.should == stream2
+    end
+    
+    it "should encode correctly with average filtering" do
+      @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR, 8, ChunkyPNG::FILTER_AVERAGE)
+      @canvas.send(:encode_png_image_pass_to_stream,      stream2 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR, 8, ChunkyPNG::FILTER_AVERAGE)
+      stream1.should == stream2
+    end
+    
+    it "should encode correctly with paeth filtering" do
+      @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR, 8, ChunkyPNG::FILTER_PAETH)
+      @canvas.send(:encode_png_image_pass_to_stream,      stream2 = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR, 8, ChunkyPNG::FILTER_PAETH)
+      stream1.should == stream2
+    end
+  end
+  
+  it "should encode an interlaced image correctly" do
+    canvas = ChunkyPNG::Canvas.from_file(resource_file('interlaced.png'))
+    data = OilyPNG::Canvas.from_canvas(canvas).to_blob(:interlace => true)
+    ds = ChunkyPNG::Datastream.from_blob(data)
+    ds.header_chunk.interlace.should == ChunkyPNG::INTERLACING_ADAM7
+    ChunkyPNG::Canvas.from_datastream(ds).should == canvas
+  end
+end

data/vendor/oily_png/spec/operations_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe OilyPNG::Operations do
+  
+  describe '#compose!' do
+    subject { oily_reference_canvas('operations') } 
+
+    it "should compose two images without offset exactly the same way as ChunkyPNG" do
+      subcanvas = ChunkyPNG::Canvas.new(4, 8, ChunkyPNG::Color.rgba(0, 0, 0, 75))
+      subject.compose!(subcanvas)
+      ChunkyPNG::Canvas.from_canvas(subject).should == reference_canvas('operations').compose(subcanvas)
+    end
+
+    it "should compose two images with offset exactly the same way as ChunkyPNG" do
+      subject.compose!(ChunkyPNG::Canvas.new(4, 8, ChunkyPNG::Color.rgba(0, 0, 0, 75)), 8, 4) 
+      subject.should == oily_reference_canvas('composited')
+    end
+
+    it "should return itself" do
+      subject.compose!(OilyPNG::Canvas.new(1,1)).should equal(subject)
+    end
+
+    it "should raise an exception when the pixels to compose fall outside the image" do
+      # For now this raises a runtime error, but it should probably raise a ChunkyPNG::OutOfBounds error
+      lambda { subject.compose!(OilyPNG::Canvas.new(1,1), 16, 16) }.should raise_error
+    end
+  end
+  
+  describe '#replace!' do
+    subject { oily_reference_canvas('operations') } 
+
+    it "should compose two images without offset exactly the same way as ChunkyPNG" do
+      subcanvas = ChunkyPNG::Canvas.new(3, 2, ChunkyPNG::Color.rgb(200, 255, 0))
+      subject.replace!(subcanvas)
+      ChunkyPNG::Canvas.from_canvas(subject).should == reference_canvas('operations').replace(subcanvas)
+    end
+
+    it "should compose two images with offset exactly the same way as ChunkyPNG" do
+      subject.replace!(ChunkyPNG::Canvas.new(3, 2, ChunkyPNG::Color.rgb(200, 255, 0)), 5, 4) 
+      subject.should == oily_reference_canvas('replaced')
+    end
+
+    it "should return itself" do
+      subject.replace!(OilyPNG::Canvas.new(1,1)).should equal(subject)
+    end
+
+    it "should raise an exception when the pixels to compose fall outside the image" do
+      # For now this raises a runtime error, but it should probably raise a ChunkyPNG::OutOfBounds error
+      lambda { subject.replace!(OilyPNG::Canvas.new(1,1), 16, 16) }.should raise_error
+    end
+  end
+end

data/vendor/oily_png/spec/resampling_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe OilyPNG::Resampling do
+
+  include OilyPNG::Resampling
+
+  describe '#steps' do
+    it "should generate the steps from 4 to 8 as [0,0,1,1,2,2,3,3]" do
+      steps(4,8).should == [0,0,1,1,2,2,3,3]
+    end
+
+    it "should generate the steps the same as ChunkyPNG" do
+      image = ChunkyPNG::Image.new(1,1)
+      steps(2,8).should == image.send(:steps,2,8)
+      steps(2,11).should == image.send(:steps,2,11)
+      steps(11,5).should == image.send(:steps,11,5)
+    end
+  end
+
+  describe '#resample_nearest_neighbor!' do
+    before(:all) { @reference = ChunkyPNG::Canvas.from_file(resource_file('nonsquare.png'))}
+
+    it "should resample [0,1,2,3] to 4x4 properly" do
+      OilyPNG::Canvas.new(2,2,[0,1,2,3]).resample_nearest_neighbor(4,4).should == OilyPNG::Canvas.new(4,4,[0,0,1,1,0,0,1,1,2,2,3,3,2,2,3,3])
+    end
+
+    it "should resample [0,1,2,3] to 99x45 as ChunkyPNG does" do
+      ChunkyPNG::Canvas.new(2,2,[0,1,2,3]).resample_nearest_neighbor(99,45).should == OilyPNG::Canvas.new(2,2,[0,1,2,3]).resample_nearest_neighbor(99,45)
+    end
+
+    it "should resample an image to 10x20 as ChunkyPNG does" do
+      @reference.resample_nearest_neighbor(10,20).should == OilyPNG::Canvas.from_canvas(@reference).resample_nearest_neighbor(10,20)
+    end
+
+    it "should resample an image to 11x19 as ChunkyPNG does" do
+      @reference.resample_nearest_neighbor(11,19).should == OilyPNG::Canvas.from_canvas(@reference).resample_nearest_neighbor(11,19)
+    end
+  end
+
+  describe '#resample_bilinear!' do
+    before(:all) { @reference = ChunkyPNG::Canvas.from_file(resource_file('nonsquare.png'))}
+
+    it "should resample an image to 10x20 as ChunkyPNG does" do
+      @reference.resample_bilinear(10,20).should == OilyPNG::Canvas.from_canvas(@reference).resample_bilinear(10,20)
+    end
+
+    it "should resample an image to 11x19 as ChunkyPNG does" do
+      @reference.resample_bilinear(11,19).should == OilyPNG::Canvas.from_canvas(@reference).resample_bilinear(11,19)
+    end
+  end
+end