oily_png 0.0.3 → 0.0.4

data/Gemfile.lock

@@ -1,13 +1,13 @@
 PATH
   remote: .
   specs:
-    oily_png (0.0.3)
-      chunky_png (~> 0.10.1)
+    oily_png (0.0.4)
+      chunky_png (~> 0.10.2)
 
 GEM
   remote: http://rubygems.org/
   specs:
-    chunky_png (0.10.1)
+    chunky_png (0.10.2)
     rake (0.8.7)
     rspec (1.3.0)
 
@@ -15,7 +15,7 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  chunky_png (~> 0.10.1)
+  chunky_png (~> 0.10.2)
   oily_png!
   rake
   rspec (>= 1.3)

data/README.rdoc

@@ -1,6 +1,7 @@
 = OilyPNG
 
-OilyPNG is a Ruby C extension to speed up the pure Ruby ChunkyPNG library. 
+OilyPNG is a Ruby C extension to speed up the pure Ruby ChunkyPNG library. It is a standalone
+module, so it does not require LibPNG, ImageMagick or any other library.
 
 Currently it has an alternative implementation of decoding PNGs, making that operation much 
 faster for PNG images that apply filtering. An alternative implementation for encoding is

data/ext/oily_png/extconf.rb

@@ -1,2 +1,2 @@
 require 'mkmf'
-create_makefile('oily_png/png_decoding')
+create_makefile('oily_png/oily_png_ext')

data/ext/oily_png/oily_png_ext.c

@@ -0,0 +1,26 @@
+#include "oily_png_ext.h"
+
+// Initialize the extension by creating the OilyPNG modules.
+void Init_oily_png_ext() {
+  VALUE OilyPNG = rb_define_module("OilyPNG");
+
+  // Setup decoding
+  VALUE OilyPNG_PNGDecoding = rb_define_module_under(OilyPNG, "PNGDecoding");
+  rb_define_method(OilyPNG_PNGDecoding, "decode_png_image_pass", oily_png_decode_png_image_pass, 5);
+  
+  // Setup encoding
+  VALUE OilyPNG_PNGEncoding = rb_define_module_under(OilyPNG, "PNGEncoding");
+  rb_define_method(OilyPNG_PNGEncoding, "encode_png_image_pass_to_stream", oily_png_encode_png_image_pass_to_stream, 3);
+}
+
+// Returns the number of bytes per pixel for a given color mode.
+int oily_png_pixel_size(int color_mode) {
+  switch (color_mode) {
+    case OILY_PNG_COLOR_GRAYSCALE:       return 1;
+    case OILY_PNG_COLOR_TRUECOLOR:       return 3;
+    case OILY_PNG_COLOR_INDEXED:         return 1;
+    case OILY_PNG_COLOR_GRAYSCALE_ALPHA: return 2;
+    case OILY_PNG_COLOR_TRUECOLOR_ALPHA: return 4;
+    default: return -1;
+  }
+}

data/ext/oily_png/oily_png_ext.h

@@ -0,0 +1,30 @@
+#ifndef OILY_PNG_EXT
+#define OILY_PNG_EXT
+
+#include "ruby.h"
+
+// PNG color mode constants
+#define OILY_PNG_COLOR_GRAYSCALE        0
+#define OILY_PNG_COLOR_TRUECOLOR        2
+#define OILY_PNG_COLOR_INDEXED          3
+#define OILY_PNG_COLOR_GRAYSCALE_ALPHA  4
+#define OILY_PNG_COLOR_TRUECOLOR_ALPHA  6
+
+// PNG filter constants
+#define OILY_PNG_FILTER_NONE    0
+#define OILY_PNG_FILTER_SUB     1
+#define OILY_PNG_FILTER_UP      2
+#define OILY_PNG_FILTER_AVERAGE 3
+#define OILY_PNG_FILTER_PAETH   4
+
+// Type definitions
+#define PIXEL unsigned int  // Pixels use 32 bits unsigned integers
+#define BYTE  unsigned char // Bytes use 8 bits unsigned integers
+
+#include "png_decoding.h"
+#include "png_encoding.h"
+
+void Init_oily_png_ext();
+int oily_png_pixel_size(int color_mode);
+
+#endif

data/ext/oily_png/png_decoding.c

@@ -1,48 +1,9 @@
-#include "ruby.h"
-
-// PNG color mode constants
-#define OILY_PNG_COLOR_GRAYSCALE        0
-#define OILY_PNG_COLOR_TRUECOLOR        2
-#define OILY_PNG_COLOR_INDEXED          3
-#define OILY_PNG_COLOR_GRAYSCALE_ALPHA  4
-#define OILY_PNG_COLOR_TRUECOLOR_ALPHA  6
-
-// PNG filter constants
-#define OILY_PNG_FILTER_NONE    0
-#define OILY_PNG_FILTER_SUB     1
-#define OILY_PNG_FILTER_UP      2
-#define OILY_PNG_FILTER_AVERAGE 3
-#define OILY_PNG_FILTER_PAETH   4
-
-// Type definitions
-#define PIXEL unsigned int
-
-void Init_png_decoding();
-VALUE oily_png_decode_png_image_pass(VALUE self, VALUE stream, VALUE width, VALUE height, VALUE color_mode, VALUE start_pos);
+#include "oily_png_ext.h"
 
 ////////////////////////////////////////////////////////////////////////////
 
-// Initialize the extension by creating the OilyPNG::PNGDecoding module
-void Init_png_decoding() {
-  VALUE OilyPNG = rb_define_module("OilyPNG");
-  VALUE OilyPNGPNGDecoding = rb_define_module_under(OilyPNG, "PNGDecoding");
-  rb_define_method(OilyPNGPNGDecoding, "decode_png_image_pass", oily_png_decode_png_image_pass, 5);
-}
-
-// Returns the number of bytes per pixel for a given color mode.
-int oily_png_pixel_size(color_mode) {
-  switch (color_mode) {
-    case OILY_PNG_COLOR_GRAYSCALE:       return 1;
-    case OILY_PNG_COLOR_TRUECOLOR:       return 3;
-    case OILY_PNG_COLOR_INDEXED:         return 1;
-    case OILY_PNG_COLOR_GRAYSCALE_ALPHA: return 2;
-    case OILY_PNG_COLOR_TRUECOLOR_ALPHA: return 4;
-    default: return -1;
-  }
-}
-
 // Decodes a pixel at the given position in the bytearray
-PIXEL oily_png_decode_pixel(int color_mode, unsigned char* bytes, int byte_index, VALUE decoding_palette) {
+PIXEL oily_png_decode_pixel(int color_mode, BYTE* bytes, int byte_index, VALUE decoding_palette) {
   switch (color_mode) {
     case OILY_PNG_COLOR_GRAYSCALE:
       return (bytes[byte_index] << 24) + (bytes[byte_index] << 16) + (bytes[byte_index] << 8) + 0xff;
@@ -60,7 +21,7 @@ PIXEL oily_png_decode_pixel(int color_mode, unsigned char* bytes, int byte_index
 }
 
 // Decodes a SUB filtered scanline at the given position in the byte array
-void oily_png_filter_sub(unsigned char* bytes, int pos, int line_length, int pixel_size) {
+void oily_png_decode_filter_sub(BYTE* bytes, int pos, int line_length, int pixel_size) {
   int i;
   for (i = 1 + pixel_size; i < line_length; i++) {
     bytes[pos + i] += bytes[pos + i - pixel_size]; // mod 256 ???
@@ -68,7 +29,7 @@ void oily_png_filter_sub(unsigned char* bytes, int pos, int line_length, int pix
 }
 
 // Decodes an UP filtered scanline at the given position in the byte array
-void oily_png_filter_up(unsigned char* bytes, int pos, int line_length, int pixel_size) {
+void oily_png_decode_filter_up(BYTE* bytes, int pos, int line_length, int pixel_size) {
   int i;
   // The first line is not filtered because there is no privous line
   if (pos >= line_length) {
@@ -79,9 +40,9 @@ void oily_png_filter_up(unsigned char* bytes, int pos, int line_length, int pixe
 }
 
 // Decodes an AVERAGE filtered scanline at the given position in the byte array
-void oily_png_filter_average(unsigned char* bytes, int pos, int line_length, int pixel_size) {
+void oily_png_decode_filter_average(BYTE* bytes, int pos, int line_length, int pixel_size) {
   int i;
-  unsigned char a, b;
+  BYTE a, b;
   for (i = 1; i < line_length; i++) {
     a = (i > pixel_size)     ? bytes[pos + i - pixel_size]  : 0;
     b = (pos >= line_length) ? bytes[pos + i - line_length] : 0;
@@ -90,8 +51,8 @@ void oily_png_filter_average(unsigned char* bytes, int pos, int line_length, int
 }
 
 // Decodes a PAETH filtered scanline at the given position in the byte array
-void oily_png_filter_paeth(unsigned char* bytes, int pos, int line_length, int pixel_size) {
-  unsigned char a, b, c, pr;
+void oily_png_decode_filter_paeth(BYTE* bytes, int pos, int line_length, int pixel_size) {
+  BYTE a, b, c, pr;
   int i, p, pa, pb, pc;
   for (i = 1; i < line_length; i++) {
     a = (i > pixel_size) ? bytes[pos + i - pixel_size]  : 0;
@@ -106,9 +67,11 @@ void oily_png_filter_paeth(unsigned char* bytes, int pos, int line_length, int p
   }
 }
 
-// Decodes an image pass from the given byte stream at the given position.
-// A normal PNG will only have one pass that consumes the entire stream, while an
-// interlaced image requires 7 passes which are loaded from different starting positions.
+/*
+  Decodes an image pass from the given byte stream at the given position.
+  A normal PNG will only have one pass that consumes the entire stream, while an
+  interlaced image requires 7 passes which are loaded from different starting positions.
+*/
 VALUE oily_png_decode_png_image_pass(VALUE self, VALUE stream, VALUE width, VALUE height, VALUE color_mode, VALUE start_pos) {
   
   int pixel_size = oily_png_pixel_size(FIX2INT(color_mode));
@@ -117,19 +80,24 @@ VALUE oily_png_decode_png_image_pass(VALUE self, VALUE stream, VALUE width, VALU
   
   VALUE pixels = rb_ary_new();
   
-  VALUE decoding_palette = Qnil;
-  if (FIX2INT(color_mode) == OILY_PNG_COLOR_INDEXED) {
-    decoding_palette = rb_funcall(self, rb_intern("decoding_palette"), 0);
+  if (RSTRING_LEN(stream) < pass_size + FIX2INT(start_pos)) {
+    exit(1);
   }
-  
+
   // Copy the bytes for this pass from the stream to a separate location
   // so we can work on this byte array directly.
-  unsigned char* pixelstream = RSTRING_PTR(stream);
-  unsigned char* bytes = malloc(pass_size);
+  BYTE* pixelstream = (BYTE*) RSTRING_PTR(stream);
+  BYTE* bytes = ALLOCA_N(BYTE, pass_size);
   memcpy(bytes, pixelstream + FIX2INT(start_pos), pass_size);
 
+  // Get the decoding palette for indexed images.
+  VALUE decoding_palette = Qnil;
+  if (FIX2INT(color_mode) == OILY_PNG_COLOR_INDEXED) {
+    decoding_palette = rb_funcall(self, rb_intern("decoding_palette"), 0);
+  }
+
   int y, x, line_start, prev_line_start, byte_index, pixel_index;
-  unsigned char filter;
+  BYTE filter;
   PIXEL pixel;
   
   for (y = 0; y < FIX2INT(height); y++) {
@@ -138,10 +106,10 @@ VALUE oily_png_decode_png_image_pass(VALUE self, VALUE stream, VALUE width, VALU
     // Apply filering to the line
     switch (bytes[line_start]) {
       case OILY_PNG_FILTER_NONE:    break;
-      case OILY_PNG_FILTER_SUB:     oily_png_filter_sub(     bytes, line_start, line_size, pixel_size); break;
-      case OILY_PNG_FILTER_UP:      oily_png_filter_up(      bytes, line_start, line_size, pixel_size); break;
-      case OILY_PNG_FILTER_AVERAGE: oily_png_filter_average( bytes, line_start, line_size, pixel_size); break;
-      case OILY_PNG_FILTER_PAETH:   oily_png_filter_paeth(   bytes, line_start, line_size, pixel_size); break;
+      case OILY_PNG_FILTER_SUB:     oily_png_decode_filter_sub(     bytes, line_start, line_size, pixel_size); break;
+      case OILY_PNG_FILTER_UP:      oily_png_decode_filter_up(      bytes, line_start, line_size, pixel_size); break;
+      case OILY_PNG_FILTER_AVERAGE: oily_png_decode_filter_average( bytes, line_start, line_size, pixel_size); break;
+      case OILY_PNG_FILTER_PAETH:   oily_png_decode_filter_paeth(   bytes, line_start, line_size, pixel_size); break;
       default: exit(1);
     }
     
@@ -157,9 +125,6 @@ VALUE oily_png_decode_png_image_pass(VALUE self, VALUE stream, VALUE width, VALU
     }
   }
   
-  // Get rid of the byte array.
-  free(bytes);
-  
   // Now, return a new ChunkyPNG::Canvas instance with the decoded pixels.
   return rb_funcall(self, rb_intern("new"), 3, width, height, pixels);
 }

data/ext/oily_png/png_decoding.h

@@ -0,0 +1,7 @@
+#ifndef PNG_DECODING_H
+#define PNG_DECODING_H
+
+// Function to overwrite ChunkyPNG::Canvas::PNGDecoding.decode_png_image_pass
+VALUE oily_png_decode_png_image_pass(VALUE self, VALUE stream, VALUE width, VALUE height, VALUE color_mode, VALUE start_pos);
+
+#endif

data/ext/oily_png/png_encoding.c

@@ -0,0 +1,130 @@
+#include "oily_png_ext.h"
+
+PIXEL oily_png_encode_get_pixel(VALUE self, long index) {
+  VALUE pixels = rb_funcall(self, rb_intern("pixels"), 0);
+  return NUM2UINT(rb_ary_entry(pixels, index));
+}
+
+void oily_png_encode_pixel(PIXEL pixel, int color_mode, BYTE* bytes, int pos, VALUE palette) {
+  switch (color_mode) {
+    case OILY_PNG_COLOR_GRAYSCALE:
+      bytes[pos] = (BYTE) ((pixel & (PIXEL) 0xff000000) >> 24);
+      break;
+    case OILY_PNG_COLOR_TRUECOLOR:
+      bytes[pos + 0] = (BYTE) ((pixel & (PIXEL) 0xff000000) >> 24);
+      bytes[pos + 1] = (BYTE) ((pixel & (PIXEL) 0x00ff0000) >> 16);
+      bytes[pos + 2] = (BYTE) ((pixel & (PIXEL) 0x0000ff00) >>  8);
+      break;
+    case OILY_PNG_COLOR_INDEXED:
+      bytes[pos] = (BYTE) NUM2UINT(rb_funcall(palette, rb_intern("index"), 1, UINT2NUM(pixel)));
+      break;
+    case OILY_PNG_COLOR_GRAYSCALE_ALPHA:
+      bytes[pos + 0] = (BYTE) ((pixel & (PIXEL) 0xff000000) >> 24);
+      bytes[pos + 1] = (BYTE) ((pixel & (PIXEL) 0x000000ff));
+      break;
+    case OILY_PNG_COLOR_TRUECOLOR_ALPHA:
+      bytes[pos + 0] = (BYTE) ((pixel & (PIXEL) 0xff000000) >> 24);
+      bytes[pos + 1] = (BYTE) ((pixel & (PIXEL) 0x00ff0000) >> 16);
+      bytes[pos + 2] = (BYTE) ((pixel & (PIXEL) 0x0000ff00) >>  8);
+      bytes[pos + 3] = (BYTE) ((pixel & (PIXEL) 0x000000ff));
+      break;
+    default: 
+      exit(1);
+  }
+}
+
+void oily_png_encode_filter_sub(BYTE* bytes, int pos, int line_size, int pixel_size) {
+  int x;
+  for (x = line_size - 1; x > pixel_size; x--) {
+    bytes[pos + x] -= bytes[pos + x - pixel_size];
+  }
+}
+
+void oily_png_encode_filter_up(BYTE* bytes, int pos, int line_size, int pixel_size) {
+  int x;
+  if (pos >= line_size) {
+    for (x = line_size - 1; x > 0; x--) {
+      bytes[pos + x] -= bytes[pos + x - line_size];
+    }
+  }
+}
+
+void oily_png_encode_filter_average(BYTE* bytes, int pos, int line_size, int pixel_size) {
+  int x; BYTE a, b;
+  for (x = line_size - 1; x > 0; x--) {
+    a = (x > pixel_size)   ? bytes[pos + x - pixel_size] : 0;
+    b = (pos >= line_size) ? bytes[pos + x - line_size]  : 0;
+    bytes[pos + x] -= ((a + b) >> 1);
+  }
+}
+
+void oily_png_encode_filter_paeth(BYTE* bytes, int pos, int line_size, int pixel_size) {
+  int x, p, pa, pb, pc; BYTE a, b, c, pr;
+  for (x = line_size - 1; x > 0; x--) {
+    a = (x > pixel_size) ? bytes[pos + x - pixel_size] : 0;
+    b = (pos >= line_size) ? bytes[pos + x - line_size] : 0;
+    c = (pos >= line_size && x > pixel_size) ? bytes[pos + x - line_size - pixel_size] : 0;
+    p  = a + b - c;
+    pa = abs(p - a);
+    pb = abs(p - b);
+    pc = abs(p - c);
+    pr = (pa <= pb && pa <= pc) ? a : (pb <= pc ? b : c);
+    bytes[pos + x] -= pr;
+  }
+  
+}
+
+
+/*
+  Encodes an image and append it to the stream.
+  A normal PNG will only have one pass and call this method once, while interlaced
+  images are split up in 7 distinct images. This method will be called for every one
+  of these images, reusing the stream.
+*/
+VALUE oily_png_encode_png_image_pass_to_stream(VALUE self, VALUE stream, VALUE color_mode, VALUE filtering) {
+  
+  // Get the data
+  int width      = FIX2INT(rb_funcall(self, rb_intern("width"), 0));
+  int height     = FIX2INT(rb_funcall(self, rb_intern("height"), 0));
+  VALUE pixels   = rb_funcall(self, rb_intern("pixels"), 0);
+  
+  VALUE palette = Qnil;
+  if (FIX2INT(color_mode) == OILY_PNG_COLOR_INDEXED) {
+    palette = rb_funcall(self, rb_intern("encoding_palette"), 0);
+  }
+  
+  int pixel_size = oily_png_pixel_size(FIX2INT(color_mode));
+  int line_size = 1 + pixel_size * width;
+  int pass_size = line_size * height;
+
+  // Allocate memory for the byte array.
+  BYTE* bytes = ALLOCA_N(BYTE, pass_size);
+
+  PIXEL pixel;
+  int x, y, pos;
+  for (y = 0; y < height; y++) {
+    bytes[line_size * y] = FIX2INT(filtering);
+    
+    for (x = 0; x < width; x++) {
+      pixel = NUM2UINT(rb_ary_entry(pixels, y * height + x));
+      pos   = (line_size * y) + (pixel_size * x) + 1;
+      oily_png_encode_pixel(pixel, FIX2INT(color_mode), bytes, pos, palette);
+    }
+  }
+  
+  if (FIX2INT(filtering) != OILY_PNG_FILTER_NONE) {
+    for (y = height - 1; y >= 0; y--) {
+      switch (FIX2INT(filtering)) {
+        case OILY_PNG_FILTER_SUB:     oily_png_encode_filter_sub(     bytes, line_size * y, line_size, pixel_size); break;
+        case OILY_PNG_FILTER_UP:      oily_png_encode_filter_up(      bytes, line_size * y, line_size, pixel_size); break;
+        case OILY_PNG_FILTER_AVERAGE: oily_png_encode_filter_average( bytes, line_size * y, line_size, pixel_size); break;
+        case OILY_PNG_FILTER_PAETH:   oily_png_encode_filter_paeth(   bytes, line_size * y, line_size, pixel_size); break;
+        default: exit(1);
+      }
+    }
+  }
+  
+  rb_str_cat(stream, bytes, pass_size);
+  
+  return Qnil;
+}

data/ext/oily_png/png_encoding.h

@@ -0,0 +1,7 @@
+#ifndef PNG_ENCODING_H
+#define PNG_ENCODING_H
+
+// Function to overwrite ChunkyPNG::Canvas::PNGEncoding.encode_png_image_pass_to_stream
+VALUE oily_png_encode_png_image_pass_to_stream(VALUE self, VALUE stream, VALUE color_mode, VALUE filtering);
+
+#endif

data/lib/oily_png.rb

@@ -1,14 +1,17 @@
 require 'chunky_png'
-require 'oily_png/png_decoding'
 
 module OilyPNG
   
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 
   def self.included(base)
     base::Canvas.extend OilyPNG::PNGDecoding
+    base::Canvas.include OilyPNG::PNGEncoding
   end
 
 end
 
+require 'oily_png/oily_png_ext'
+
+# Include mixin into ChunkyPNG
 ChunkyPNG.send(:include, OilyPNG)

data/oily_png.gemspec

@@ -4,7 +4,7 @@ Gem::Specification.new do |s|
   
   # Do not change the version and date fields by hand. This will be done
   # automatically by the gem release script.
-  s.version = "0.0.3"
+  s.version = "0.0.4"
   s.date    = "2010-10-05"
 
   s.summary     = "Native mixin to speed up ChunkyPNG"
@@ -20,7 +20,7 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib", "ext"]
 
   s.required_rubygems_version = '1.3.7'
-  s.add_runtime_dependency('chunky_png', '~> 0.10.1')
+  s.add_runtime_dependency('chunky_png', '~> 0.10.2')
 
   s.add_development_dependency('rake')
   s.add_development_dependency('rspec', '>= 1.3')
@@ -30,6 +30,6 @@ Gem::Specification.new do |s|
 
   # Do not change the files and test_files fields by hand. This will be done
   # automatically by the gem release script.
-  s.files      = %w(.gitignore Gemfile Gemfile.lock LICENSE README.rdoc Rakefile ext/oily_png/extconf.rb ext/oily_png/png_decoding.c lib/oily_png.rb oily_png.gemspec spec/decoding_spec.rb spec/resources/gray.png spec/resources/operations.png spec/spec_helper.rb tasks/github-gem.rake)
-  s.test_files = %w(spec/decoding_spec.rb)
+  s.files      = %w(.gitignore Gemfile Gemfile.lock LICENSE README.rdoc Rakefile ext/oily_png/extconf.rb ext/oily_png/oily_png_ext.c ext/oily_png/oily_png_ext.h ext/oily_png/png_decoding.c ext/oily_png/png_decoding.h ext/oily_png/png_encoding.c ext/oily_png/png_encoding.h lib/oily_png.rb oily_png.gemspec spec/decoding_spec.rb spec/encoding_spec.rb spec/resources/gray.png spec/resources/operations.png spec/spec_helper.rb tasks/github-gem.rake)
+  s.test_files = %w(spec/decoding_spec.rb spec/encoding_spec.rb)
 end

data/spec/encoding_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe OilyPNG::PNGEncoding do
+
+  context 'encoding different color modes' do
+    before do 
+      @canvas      = ChunkyPNG::Canvas.from_file(resource_file('gray.png'))
+      @oily_canvas = OilyCanvas.from_canvas(@canvas)
+    end
+    
+    it "should encode an image using grayscale correctly" do
+      @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = "", ChunkyPNG::COLOR_GRAYSCALE, ChunkyPNG::FILTER_NONE)
+      @canvas.send(:encode_png_image_pass_to_stream,      stream2 = "", ChunkyPNG::COLOR_GRAYSCALE, ChunkyPNG::FILTER_NONE)
+      stream1.should == stream2
+    end
+    
+    it "should encode an image using grayscale alpha correctly" do
+      @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = "", ChunkyPNG::COLOR_GRAYSCALE_ALPHA, ChunkyPNG::FILTER_NONE)
+      @canvas.send(:encode_png_image_pass_to_stream,      stream2 = "", ChunkyPNG::COLOR_GRAYSCALE_ALPHA, ChunkyPNG::FILTER_NONE)
+      stream1.should == stream2
+    end
+    
+    it "should encode an image using truecolor correctly" do
+      @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = "", ChunkyPNG::COLOR_TRUECOLOR, ChunkyPNG::FILTER_NONE)
+      @canvas.send(:encode_png_image_pass_to_stream,      stream2 = "", ChunkyPNG::COLOR_TRUECOLOR, ChunkyPNG::FILTER_NONE)
+      stream1.should == stream2
+    end
+    
+    it "should encode an image using truecolor alpha correctly" do
+      @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = "", ChunkyPNG::COLOR_TRUECOLOR_ALPHA, ChunkyPNG::FILTER_NONE)
+      @canvas.send(:encode_png_image_pass_to_stream,      stream2 = "", ChunkyPNG::COLOR_TRUECOLOR_ALPHA, ChunkyPNG::FILTER_NONE)
+      stream1.should == stream2
+    end
+    
+    it "should encode an image using indexed colors correctly" do
+      # Setup an encoding palette first
+      mock_palette = mock('palette', :index => 0xab)
+      @canvas.stub(:encoding_palette).and_return(mock_palette)
+      @oily_canvas.stub(:encoding_palette).and_return(mock_palette)
+      
+      @canvas.send(:encode_png_image_pass_to_stream,      stream2 = "", ChunkyPNG::COLOR_INDEXED, ChunkyPNG::FILTER_NONE)
+      @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = "", ChunkyPNG::COLOR_INDEXED, ChunkyPNG::FILTER_NONE)
+      stream1.should == stream2
+    end
+  end
+  
+  context 'encoding different filters' do
+    before do 
+      @canvas      = ChunkyPNG::Canvas.from_file(resource_file('operations.png'))
+      @oily_canvas = OilyCanvas.from_canvas(@canvas)
+    end
+    
+    it "should encode correctly with no filtering" do
+      @oily_canvas.send(:encode_png_image_pass_to_stream, stream1 = "", ChunkyPNG::COLOR_TRUECOLOR, ChunkyPNG::FILTER_NONE)
+      @canvas.send(:encode_png_image_pass_to_stream,      stream2 = "", ChunkyPNG::COLOR_TRUECOLOR, 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::COLOR_TRUECOLOR, ChunkyPNG::FILTER_SUB)
+      @canvas.send(:encode_png_image_pass_to_stream,      stream2 = "", ChunkyPNG::COLOR_TRUECOLOR, 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::COLOR_TRUECOLOR, ChunkyPNG::FILTER_UP)
+      @canvas.send(:encode_png_image_pass_to_stream,      stream2 = "", ChunkyPNG::COLOR_TRUECOLOR, 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::COLOR_TRUECOLOR, ChunkyPNG::FILTER_AVERAGE)
+      @canvas.send(:encode_png_image_pass_to_stream,      stream2 = "", ChunkyPNG::COLOR_TRUECOLOR, 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::COLOR_TRUECOLOR, ChunkyPNG::FILTER_PAETH)
+      @canvas.send(:encode_png_image_pass_to_stream,      stream2 = "", ChunkyPNG::COLOR_TRUECOLOR, ChunkyPNG::FILTER_PAETH)
+      stream1.should == stream2
+    end    
+  end
+end

data/spec/spec_helper.rb

@@ -5,10 +5,11 @@ Bundler.setup
 
 require 'spec'
 require 'chunky_png'
-require 'oily_png/png_decoding'
+require 'oily_png/oily_png_ext'
 
 class OilyCanvas < ChunkyPNG::Canvas
   extend OilyPNG::PNGDecoding
+  include OilyPNG::PNGEncoding
 end
 
 module ResourceHelper

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: oily_png
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 23
   prerelease: false
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - Willem van Bergen
@@ -24,12 +24,12 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 53
+        hash: 51
         segments: 
         - 0
         - 10
-        - 1
-        version: 0.10.1
+        - 2
+        version: 0.10.2
   requirement: *id001
   name: chunky_png
   prerelease: false
@@ -80,10 +80,16 @@ files:
 - README.rdoc
 - Rakefile
 - ext/oily_png/extconf.rb
+- ext/oily_png/oily_png_ext.c
+- ext/oily_png/oily_png_ext.h
 - ext/oily_png/png_decoding.c
+- ext/oily_png/png_decoding.h
+- ext/oily_png/png_encoding.c
+- ext/oily_png/png_encoding.h
 - lib/oily_png.rb
 - oily_png.gemspec
 - spec/decoding_spec.rb
+- spec/encoding_spec.rb
 - spec/resources/gray.png
 - spec/resources/operations.png
 - spec/spec_helper.rb
@@ -132,3 +138,4 @@ specification_version: 3
 summary: Native mixin to speed up ChunkyPNG
 test_files: 
 - spec/decoding_spec.rb
+- spec/encoding_spec.rb