oily_png 0.0.5 → 0.0.6

data/.gitignore

@@ -5,4 +5,5 @@ Makefile
 /.bundle/
 /pkg
 oily_png-*.gem
-.DS_Store
+.DS_Store
+/spec/resources/_*.*

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    oily_png (0.0.5)
+    oily_png (0.0.6)
       chunky_png (~> 0.10.2)
 
 GEM

data/ext/oily_png/extconf.rb

@@ -1,2 +1,3 @@
 require 'mkmf'
+$CFLAGS << ' -Wall'
 create_makefile('oily_png/oily_png_ext')

data/ext/oily_png/oily_png_ext.c

@@ -1,6 +1,5 @@
 #include "oily_png_ext.h"
 
-// Initialize the extension by creating the OilyPNG modules.
 void Init_oily_png_ext() {
   VALUE OilyPNG = rb_define_module("OilyPNG");
 
@@ -13,7 +12,6 @@ void Init_oily_png_ext() {
   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;
@@ -21,6 +19,6 @@ int oily_png_pixel_size(int color_mode) {
     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;
+    default: rb_raise(rb_eRuntimeError, "Unsupported color mode: %d", color_mode);
   }
 }

data/ext/oily_png/oily_png_ext.h

@@ -24,7 +24,21 @@
 #include "png_decoding.h"
 #include "png_encoding.h"
 
+
+/*
+  Initialize the extension by creating the OilyPNG modules, and registering
+  the encoding and decoding replacement functions.
+  
+  Note, this does not actually replace functionality in ChunkyPNG; you will need
+  to extend the ChunkyPNG::Canvas class with the OilyPNG::PNGDecoding module to 
+  speed up decoding, and include OilyPNG::PNGEncoding into the same class to speed
+  up encoding. This is done in lib/oily_png.rb
+*/
 void Init_oily_png_ext();
+
+/*
+  Returns the number of bytes per pixel for a given color mode.
+*/
 int oily_png_pixel_size(int color_mode);
 
-#endif
+#endif

data/ext/oily_png/png_decoding.c

@@ -1,77 +1,73 @@
 #include "oily_png_ext.h"
 
-////////////////////////////////////////////////////////////////////////////
-
-// Decodes a pixel at the given position in the bytearray
-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;
-    case OILY_PNG_COLOR_TRUECOLOR:
-      return (bytes[byte_index] << 24) + (bytes[byte_index + 1] << 16) + (bytes[byte_index + 2] << 8) + 0xff;
-    case OILY_PNG_COLOR_INDEXED:
-      return NUM2UINT(rb_funcall(decoding_palette, rb_intern("[]"), 1, INT2FIX(bytes[byte_index])));
-    case OILY_PNG_COLOR_GRAYSCALE_ALPHA:
-      return (bytes[byte_index] << 24) + (bytes[byte_index] << 16) + (bytes[byte_index] << 8) + bytes[byte_index + 1];
-    case OILY_PNG_COLOR_TRUECOLOR_ALPHA:
-      return (bytes[byte_index] << 24) + (bytes[byte_index + 1] << 16) + (bytes[byte_index + 2] << 8) + bytes[byte_index + 3];
-    default: 
-      exit(1);
-  }
-}
 
 // Decodes a SUB filtered scanline at the given position in the byte array
 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 ???
+    UNFILTER_BYTE(bytes[pos + i], bytes[pos + i - pixel_size]);
   }
 }
 
 // Decodes an UP filtered scanline at the given position in the byte array
-void oily_png_decode_filter_up(BYTE* bytes, int pos, int line_length, int pixel_size) {
+void oily_png_decode_filter_up(BYTE* bytes, int pos, int line_size, int pixel_size) {
   int i;
   // The first line is not filtered because there is no privous line
-  if (pos >= line_length) {
-    for (i = 1; i < line_length; i++) {
-      bytes[pos + i] += bytes[pos + i - line_length]; // mod 256 ???
+  if (pos >= line_size) {
+    for (i = 1; i < line_size; i++) {
+      UNFILTER_BYTE(bytes[pos + i], bytes[pos + i - line_size]);
     }
   }
 }
 
 // Decodes an AVERAGE filtered scanline at the given position in the byte array
-void oily_png_decode_filter_average(BYTE* bytes, int pos, int line_length, int pixel_size) {
+void oily_png_decode_filter_average(BYTE* bytes, int pos, int line_size, int pixel_size) {
   int i;
   BYTE a, b;
-  for (i = 1; i < line_length; i++) {
+  for (i = 1; i < line_size; i++) {
     a = (i > pixel_size)     ? bytes[pos + i - pixel_size]  : 0;
-    b = (pos >= line_length) ? bytes[pos + i - line_length] : 0;
-    bytes[pos + i] += (a + b) >> 1; // mod 256 ???
+    b = (pos >= line_size) ? bytes[pos + i - line_size] : 0;
+    UNFILTER_BYTE(bytes[pos + i], (a + b) >> 1);
   }
 }
 
 // Decodes a PAETH filtered scanline at the given position in the byte array
-void oily_png_decode_filter_paeth(BYTE* bytes, int pos, int line_length, int pixel_size) {
+void oily_png_decode_filter_paeth(BYTE* bytes, int pos, int line_size, int pixel_size) {
   BYTE a, b, c, pr;
   int i, p, pa, pb, pc;
-  for (i = 1; i < line_length; i++) {
+  for (i = 1; i < line_size; i++) {
     a = (i > pixel_size) ? bytes[pos + i - pixel_size]  : 0;
-    b = (pos >= line_length) ? bytes[pos + i - line_length] : 0;
-    c = (pos >= line_length && i > pixel_size) ? bytes[pos + i - line_length - pixel_size] : 0;
+    b = (pos >= line_size) ? bytes[pos + i - line_size] : 0;
+    c = (pos >= line_size && i > pixel_size) ? bytes[pos + i - 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 : c) : (pb <= pc ? b : c);
-    bytes[pos + i] += pr; // mod 256 ???
+    UNFILTER_BYTE(bytes[pos + i], pr);
   }
 }
 
-/*
-  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.
-*/
+PIXEL oily_png_decode_pixel_grayscale(int color_mode, BYTE* bytes, int byte_index, VALUE decoding_palette) {
+  return BUILD_PIXEL(bytes[byte_index], bytes[byte_index], bytes[byte_index], 0xff);
+}
+
+PIXEL oily_png_decode_pixel_truecolor(int color_mode, BYTE* bytes, int byte_index, VALUE decoding_palette) {
+  return BUILD_PIXEL(bytes[byte_index], bytes[byte_index + 1], bytes[byte_index + 2], 0xff);
+}
+
+PIXEL oily_png_decode_pixel_indexed(int color_mode, BYTE* bytes, int byte_index, VALUE decoding_palette) {
+  return (PIXEL) NUM2UINT(rb_funcall(decoding_palette, rb_intern("[]"), 1, INT2FIX(bytes[byte_index])));
+}
+
+PIXEL oily_png_decode_pixel_grayscale_alpha(int color_mode, BYTE* bytes, int byte_index, VALUE decoding_palette) {
+  return BUILD_PIXEL(bytes[byte_index], bytes[byte_index], bytes[byte_index], bytes[byte_index + 1]);
+}
+
+PIXEL oily_png_decode_pixel_truecolor_alpha(int color_mode, BYTE* bytes, int byte_index, VALUE decoding_palette) {
+  return BUILD_PIXEL(bytes[byte_index], bytes[byte_index + 1], bytes[byte_index + 2], bytes[byte_index + 3]);
+}
+
 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));
@@ -80,8 +76,9 @@ VALUE oily_png_decode_png_image_pass(VALUE self, VALUE stream, VALUE width, VALU
   
   VALUE pixels = rb_ary_new();
   
+  // Make sure that the stream is large enough to contain out pass.
   if (RSTRING_LEN(stream) < pass_size + FIX2INT(start_pos)) {
-    exit(1);
+    rb_raise(rb_eRuntimeError, "The length of the stream is too short to contain the image!");
   }
 
   // Copy the bytes for this pass from the stream to a separate location
@@ -96,8 +93,18 @@ VALUE oily_png_decode_png_image_pass(VALUE self, VALUE stream, VALUE width, VALU
     decoding_palette = rb_funcall(self, rb_intern("decoding_palette"), 0);
   }
 
-  int y, x, line_start, prev_line_start, byte_index, pixel_index;
-  BYTE filter;
+  // Select the pixel decoder function for this color mode.
+  PIXEL (*pixel_decoder)(int, BYTE*, int, VALUE);
+  switch (FIX2INT(color_mode)) {
+    case OILY_PNG_COLOR_GRAYSCALE:       pixel_decoder = &oily_png_decode_pixel_grayscale; break;
+    case OILY_PNG_COLOR_TRUECOLOR:       pixel_decoder = &oily_png_decode_pixel_truecolor; break;
+    case OILY_PNG_COLOR_INDEXED:         pixel_decoder = &oily_png_decode_pixel_indexed; break;
+    case OILY_PNG_COLOR_GRAYSCALE_ALPHA: pixel_decoder = &oily_png_decode_pixel_grayscale_alpha; break;
+    case OILY_PNG_COLOR_TRUECOLOR_ALPHA: pixel_decoder = &oily_png_decode_pixel_truecolor_alpha; break;
+    default: rb_raise(rb_eRuntimeError, "Color mode not supported: %d", color_mode);
+  }
+  
+  int y, x, line_start, byte_index, pixel_index;
   PIXEL pixel;
   
   for (y = 0; y < FIX2INT(height); y++) {
@@ -110,7 +117,7 @@ VALUE oily_png_decode_png_image_pass(VALUE self, VALUE stream, VALUE width, VALU
       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);
+      default: rb_raise(rb_eRuntimeError, "Filter type not supported: %d", bytes[line_start]);
     }
     
     // Set the filter byte to 0 because the bytearray is now unfiltered.
@@ -120,7 +127,7 @@ VALUE oily_png_decode_png_image_pass(VALUE self, VALUE stream, VALUE width, VALU
     for (x = 0; x < FIX2INT(width); x++) {
       pixel_index = FIX2INT(width) * y + x;
       byte_index  = line_start + 1 + (x * pixel_size);
-      pixel = oily_png_decode_pixel(FIX2INT(color_mode), bytes, byte_index, decoding_palette); 
+      pixel = pixel_decoder(FIX2INT(color_mode), bytes, byte_index, decoding_palette); 
       rb_ary_store(pixels, pixel_index, INT2NUM(pixel));
     }
   }

data/ext/oily_png/png_decoding.h

@@ -1,7 +1,16 @@
 #ifndef PNG_DECODING_H
 #define PNG_DECODING_H
 
-// Function to overwrite ChunkyPNG::Canvas::PNGDecoding.decode_png_image_pass
+#define BUILD_PIXEL(r, g, b, a) (((PIXEL) r << 24) + ((PIXEL) g << 16) + ((PIXEL) b << 8) + (PIXEL) a)
+#define UNFILTER_BYTE(byte, adjustment)  byte = (BYTE) (((byte) + (adjustment)) & 0x000000ff)
+
+/*
+  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.
+  
+  This function shouild replace 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

@@ -1,42 +1,37 @@
 #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);
+      bytes[pos] = R_BYTE(pixel);
       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);
+      bytes[pos + 0] = R_BYTE(pixel);
+      bytes[pos + 1] = G_BYTE(pixel);
+      bytes[pos + 2] = B_BYTE(pixel);
       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));
+      bytes[pos + 0] = R_BYTE(pixel);
+      bytes[pos + 1] = A_BYTE(pixel);
       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));
+      bytes[pos + 0] = R_BYTE(pixel);
+      bytes[pos + 1] = G_BYTE(pixel);
+      bytes[pos + 2] = B_BYTE(pixel);
+      bytes[pos + 3] = A_BYTE(pixel);
       break;
     default: 
-      exit(1);
+      rb_raise(rb_eRuntimeError, "Unsupported color mode: %d", color_mode);
   }
 }
 
 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];
+    FILTER_BYTE(bytes[pos + x], bytes[pos + x - pixel_size]);
   }
 }
 
@@ -44,7 +39,7 @@ void oily_png_encode_filter_up(BYTE* bytes, int pos, int line_size, int pixel_si
   int x;
   if (pos >= line_size) {
     for (x = line_size - 1; x > 0; x--) {
-      bytes[pos + x] -= bytes[pos + x - line_size];
+      FILTER_BYTE(bytes[pos + x], bytes[pos + x - line_size]);
     }
   }
 }
@@ -54,7 +49,7 @@ void oily_png_encode_filter_average(BYTE* bytes, int pos, int line_size, int pix
   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);
+    FILTER_BYTE(bytes[pos + x], (a + b) >> 1);
   }
 }
 
@@ -69,18 +64,11 @@ void oily_png_encode_filter_paeth(BYTE* bytes, int pos, int line_size, int pixel
     pb = abs(p - b);
     pc = abs(p - c);
     pr = (pa <= pb && pa <= pc) ? a : (pb <= pc ? b : c);
-    bytes[pos + x] -= pr;
+    FILTER_BYTE(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
@@ -89,7 +77,7 @@ VALUE oily_png_encode_png_image_pass_to_stream(VALUE self, VALUE stream, VALUE c
   VALUE pixels   = rb_funcall(self, rb_intern("pixels"), 0);
   
   if (RARRAY_LEN(pixels) != width * height) {
-    exit(1);
+    rb_raise(rb_eRuntimeError, "The number of pixels does not match the canvas dimensions.");
   }
   
   VALUE palette = Qnil;
@@ -123,12 +111,11 @@ VALUE oily_png_encode_png_image_pass_to_stream(VALUE self, VALUE stream, VALUE c
         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);
+        default: rb_raise(rb_eRuntimeError, "Unsupported filter type: %d", FIX2INT(filtering));
       }
     }
   }
   
-  rb_str_cat(stream, bytes, pass_size);
-  
+  rb_str_cat(stream, (char*) bytes, pass_size);
   return Qnil;
-}
+}

data/ext/oily_png/png_encoding.h

@@ -1,7 +1,21 @@
 #ifndef PNG_ENCODING_H
 #define PNG_ENCODING_H
 
-// Function to overwrite ChunkyPNG::Canvas::PNGEncoding.encode_png_image_pass_to_stream
+#define R_BYTE(pixel)  ((BYTE) ((pixel & (PIXEL) 0xff000000) >> 24))
+#define G_BYTE(pixel)  ((BYTE) ((pixel & (PIXEL) 0x00ff0000) >> 16))
+#define B_BYTE(pixel)  ((BYTE) ((pixel & (PIXEL) 0x0000ff00) >> 8))
+#define A_BYTE(pixel)  ((BYTE) ((pixel & (PIXEL) 0x000000ff)))
+
+#define FILTER_BYTE(byte, adjustment)  byte = (BYTE) (((byte) - (adjustment)) & 0x000000ff)
+
+/*
+  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.
+  
+  This function should replace 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

@@ -2,7 +2,7 @@ require 'chunky_png'
 
 module OilyPNG
   
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 
   def self.included(base)
     base::Canvas.send(:extend, OilyPNG::PNGDecoding)

data/oily_png.gemspec

@@ -4,8 +4,8 @@ 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.5"
-  s.date    = "2010-10-05"
+  s.version = "0.0.6"
+  s.date    = "2010-10-06"
 
   s.summary     = "Native mixin to speed up ChunkyPNG"
   s.description = <<-EOT
@@ -19,7 +19,6 @@ Gem::Specification.new do |s|
   s.extensions    = ["ext/oily_png/extconf.rb"]
   s.require_paths = ["lib", "ext"]
 
-  s.required_rubygems_version = '1.3.7'
   s.add_runtime_dependency('chunky_png', '~> 0.10.2')
 
   s.add_development_dependency('rake')
@@ -30,6 +29,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/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.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/interlaced.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/decoding_spec.rb

@@ -12,6 +12,12 @@ describe OilyPNG::PNGDecoding do
     OilyCanvas.from_file(resource_file('operations.png'))
   end
   
+  it "should decode an interlaced image correctly" do
+    c1 = OilyCanvas.from_file(resource_file('interlaced.png'))
+    c2 = ChunkyPNG::Canvas.from_file(resource_file('interlaced.png'))
+    c2.should == c1
+  end
+  
   context 'decoding different filtering methods' do
     before(:all) { @reference = ChunkyPNG::Canvas.from_file(resource_file('operations.png'))}
     

data/spec/encoding_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe OilyPNG::PNGEncoding do
 
   context 'encoding different color modes' do
-    before do 
+    before do
       @canvas      = ChunkyPNG::Canvas.from_file(resource_file('gray.png'))
       @oily_canvas = OilyCanvas.from_canvas(@canvas)
     end
@@ -78,6 +78,14 @@ describe OilyPNG::PNGEncoding 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
+  
+  it "should encode an interlaced image correctly" do
+    canvas = ChunkyPNG::Canvas.from_file(resource_file('interlaced.png'))
+    data = OilyCanvas.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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: oily_png
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 19
   prerelease: false
   segments: 
   - 0
   - 0
-  - 5
-  version: 0.0.5
+  - 6
+  version: 0.0.6
 platform: ruby
 authors: 
 - Willem van Bergen
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-05 00:00:00 +02:00
+date: 2010-10-06 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -91,6 +91,7 @@ files:
 - spec/decoding_spec.rb
 - spec/encoding_spec.rb
 - spec/resources/gray.png
+- spec/resources/interlaced.png
 - spec/resources/operations.png
 - spec/spec_helper.rb
 - tasks/github-gem.rake
@@ -121,14 +122,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - "="
+  - - ">="
     - !ruby/object:Gem::Version 
-      hash: 21
+      hash: 3
       segments: 
-      - 1
-      - 3
-      - 7
-      version: 1.3.7
+      - 0
+      version: "0"
 requirements: []
 
 rubyforge_project: oily_png