oily_png 0.1.1 → 0.2.0

data/Gemfile

@@ -1,2 +1,10 @@
 source :rubyforge
 gemspec
+
+# # Use the following gem specification instead of the 'gemspec' statement
+# # to develop with a local chunky_png copy
+
+# gem 'chunky_png', :path => File.expand_path('../chunky_png', File.dirname(__FILE__))
+# gem 'oily_png', :path => File.dirname(__FILE__)
+# gem 'rake'
+# gem 'rspec'

data/Gemfile.lock

@@ -1,13 +1,13 @@
 PATH
   remote: .
   specs:
-    oily_png (0.1.1)
-      chunky_png (~> 0.10.4)
+    oily_png (0.2.0)
+      chunky_png (~> 0.11)
 
 GEM
   remote: http://rubygems.org/
   specs:
-    chunky_png (0.10.4)
+    chunky_png (0.11.0)
     diff-lcs (1.1.2)
     rake (0.8.7)
     rspec (2.0.0)
@@ -25,7 +25,7 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  chunky_png (~> 0.10.4)
+  chunky_png (~> 0.11)
   oily_png!
   rake
   rspec (~> 2.0)

data/ext/oily_png/oily_png_ext.c

@@ -5,14 +5,14 @@ void Init_oily_png_ext() {
 
   // 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);
+  rb_define_method(OilyPNG_PNGDecoding, "decode_png_image_pass", oily_png_decode_png_image_pass, 6);
   
   // 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);
 }
 
-int oily_png_pixel_size(int color_mode) {
+char oily_png_samples_per_pixel(char color_mode) {
   switch (color_mode) {
     case OILY_PNG_COLOR_GRAYSCALE:       return 1;
     case OILY_PNG_COLOR_TRUECOLOR:       return 3;
@@ -22,3 +22,19 @@ int oily_png_pixel_size(int color_mode) {
     default: rb_raise(rb_eRuntimeError, "Unsupported color mode: %d", color_mode);
   }
 }
+
+char oily_png_pixel_bitsize(char color_mode, char bit_depth) {
+  return oily_png_samples_per_pixel(color_mode) * bit_depth;
+}
+
+char oily_png_pixel_bytesize(char color_mode, char bit_depth) {
+  return (bit_depth < 8) ? 1 : (oily_png_pixel_bitsize(color_mode, bit_depth) + 7) >> 3;
+}
+
+long oily_png_scanline_bytesize(char color_mode, char bit_depth, long width) {
+  return (8 + ((oily_png_pixel_bitsize(color_mode, bit_depth) * width) + 7)) >> 3;
+}
+
+long oily_png_pass_bytesize(char color_mode, char bit_depth, long width, long height) {
+  return (width == 0 || height == 0) ? 0 : (oily_png_scanline_bytesize(color_mode, bit_depth, width)) * height;
+}

data/ext/oily_png/oily_png_ext.h

@@ -37,8 +37,28 @@
 void Init_oily_png_ext();
 
 /*
-  Returns the number of bytes per pixel for a given color mode.
+  Returns the number of samples per pixel for a given color mode
 */
-int oily_png_pixel_size(int color_mode);
+char oily_png_samples_per_pixel(char color_mode);
+
+/*
+  Returns the number of bits per pixel for a given color mode and bit depth.
+*/
+char oily_png_pixel_bitsize(char color_mode, char bit_depth);
+
+/*
+  Returns the number of bytes per pixel for a given color mode and bit depth.
+*/
+char oily_png_pixel_bytesize(char color_mode, char bit_depth);
+
+/*
+  Returns the number of bytes per scanline for a given width, color mode and bit depth.
+*/
+long oily_png_scanline_bytesize(char color_mode, char bit_depth, long width);
+
+/*
+  Returns the number of bytes in an image pass with the given properties.
+*/
+long oily_png_pass_bytesize(char color_mode, char bit_depth, long width, long height);
 
 #endif

data/ext/oily_png/png_decoding.c

@@ -2,16 +2,16 @@
 
 
 // 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;
+void oily_png_decode_filter_sub(BYTE* bytes, long pos, long line_length, char pixel_size) {
+  long i;
   for (i = 1 + pixel_size; i < line_length; i++) {
     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_size, int pixel_size) {
-  int i;
+void oily_png_decode_filter_up(BYTE* bytes, long pos, long line_size, char pixel_size) {
+  long i;
   // The first line is not filtered because there is no privous line
   if (pos >= line_size) {
     for (i = 1; i < line_size; i++) {
@@ -21,8 +21,8 @@ void oily_png_decode_filter_up(BYTE* bytes, int pos, int line_size, int pixel_si
 }
 
 // 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_size, int pixel_size) {
-  int i;
+void oily_png_decode_filter_average(BYTE* bytes, long pos, long line_size, char pixel_size) {
+  long i;
   BYTE a, b;
   for (i = 1; i < line_size; i++) {
     a = (i > pixel_size)     ? bytes[pos + i - pixel_size]  : 0;
@@ -32,103 +32,274 @@ void oily_png_decode_filter_average(BYTE* bytes, int pos, int line_size, int pix
 }
 
 // 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_size, int pixel_size) {
+void oily_png_decode_filter_paeth(BYTE* bytes, long pos, long line_size, char pixel_size) {
   BYTE a, b, c, pr;
-  int i, p, pa, pb, pc;
+  long i, p, pa, pb, pc;
   for (i = 1; i < line_size; i++) {
     a = (i > pixel_size) ? bytes[pos + i - 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);
+    pa = (p > a) ? p - a : a - p;
+    pb = (p > b) ? p - b : b - p;
+    pc = (p > c) ? p - c : c - p;
     pr = (pa <= pb) ? (pa <= pc ? a : c) : (pb <= pc ? b : c);
     UNFILTER_BYTE(bytes[pos + i], pr);
   }
 }
 
-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);
+BYTE oily_png_extract_1bit_element(BYTE* bytes, long start, long x) {
+  BYTE byte = bytes[start + 1 + (x >> 3)];
+  char bitshift = 7 - (x & (BYTE) 0x07);
+  return (byte & (0x01 << bitshift)) >> bitshift;
 }
 
-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);
+
+BYTE oily_png_extract_2bit_element(BYTE* bytes, long start, long x) {
+  BYTE byte = bytes[start + 1 + (x >> 2)];
+  char bitshift = (6 - ((x & (BYTE) 0x03) << 1));
+  return (byte & (0x03 << bitshift)) >> bitshift;
 }
 
-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])));
+BYTE oily_png_extract_4bit_element(BYTE* bytes, long start, long x) {
+  return ((x & 0x01) == 0) ? ((bytes[(start) + 1 + ((x) >> 1)] & (BYTE) 0xf0) >> 4) : (bytes[(start) + 1 + ((x) >> 1)] & (BYTE) 0x0f);
 }
 
-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]);
+BYTE oily_png_resample_1bit_element(BYTE* bytes, long start, long x) {
+  BYTE value = oily_png_extract_1bit_element(bytes, start, x);
+  return (value == 0) ? 0x00 : 0xff;
 }
 
-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]);
+BYTE oily_png_resample_2bit_element(BYTE* bytes, long start, long x) {
+  switch (oily_png_extract_2bit_element(bytes, start, x)) {
+    case 0x00: return 0x00;
+    case 0x01: return 0x55;
+    case 0x02: return 0xaa;
+    case 0x03: default: return 0xff;
+  }
 }
 
-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));
-  int line_size = pixel_size * FIX2INT(width) + 1;
-  int pass_size = line_size * FIX2INT(height);
+BYTE oily_png_resample_4bit_element(BYTE* bytes, long start, long x) {
+  switch(oily_png_extract_4bit_element(bytes, start, x)) {
+    case 0x00: return 0;
+    case 0x01: return 17;
+    case 0x02: return 34;
+    case 0x03: return 51;
+    case 0x04: return 68;
+    case 0x05: return 85;
+    case 0x06: return 102;
+    case 0x07: return 119;
+    case 0x08: return 137;
+    case 0x09: return 154;
+    case 0x0a: return 171;
+    case 0x0b: return 188;
+    case 0x0c: return 205;
+    case 0x0d: return 222;
+    case 0x0e: return 239;
+    case 0x0f: default: return 255;
+  }
+}
+
+
+PIXEL oily_png_decode_pixel_indexed_8bit(BYTE* bytes, long start, long x, VALUE decoding_palette) {
+  return (PIXEL) NUM2UINT(rb_funcall(decoding_palette, rb_intern("[]"), 1, INT2FIX(bytes[start + 1 + x])));
+}
+
+PIXEL oily_png_decode_pixel_indexed_4bit(BYTE* bytes, long start, long x, VALUE decoding_palette) {
+  return (PIXEL) NUM2UINT(rb_funcall(decoding_palette, rb_intern("[]"), 1, INT2FIX(oily_png_extract_4bit_element(bytes, start, x))));
+}
+
+PIXEL oily_png_decode_pixel_indexed_2bit(BYTE* bytes, long start, long x, VALUE decoding_palette) {
+  return (PIXEL) NUM2UINT(rb_funcall(decoding_palette, rb_intern("[]"), 1, INT2FIX(oily_png_extract_2bit_element(bytes, start, x))));
+}
+
+PIXEL oily_png_decode_pixel_indexed_1bit(BYTE* bytes, long start, long x, VALUE decoding_palette) {
+  return (PIXEL) NUM2UINT(rb_funcall(decoding_palette, rb_intern("[]"), 1, INT2FIX(oily_png_extract_1bit_element(bytes, start, x))));
+}
+
+
+PIXEL oily_png_decode_pixel_grayscale_8bit(BYTE* bytes, long start, long x, VALUE decoding_palette) {
+  return BUILD_PIXEL( bytes[start + 1 + x], 
+                      bytes[start + 1 + x], 
+                      bytes[start + 1 + x], 
+                      0xff);
+}
+
+PIXEL oily_png_decode_pixel_grayscale_1bit(BYTE* bytes, long start, long x, VALUE decoding_palette) {
+  return BUILD_PIXEL( oily_png_resample_1bit_element(bytes, start, x), 
+                      oily_png_resample_1bit_element(bytes, start, x), 
+                      oily_png_resample_1bit_element(bytes, start, x), 
+                      0xff);
+}
+
+PIXEL oily_png_decode_pixel_grayscale_2bit(BYTE* bytes, long start, long x, VALUE decoding_palette) {
+  return BUILD_PIXEL( oily_png_resample_2bit_element(bytes, start, x), 
+                      oily_png_resample_2bit_element(bytes, start, x), 
+                      oily_png_resample_2bit_element(bytes, start, x), 
+                      0xff);
+}
+
+PIXEL oily_png_decode_pixel_grayscale_4bit(BYTE* bytes, long start, long x, VALUE decoding_palette) {
+  return BUILD_PIXEL( oily_png_resample_4bit_element(bytes, start, x), 
+                      oily_png_resample_4bit_element(bytes, start, x), 
+                      oily_png_resample_4bit_element(bytes, start, x), 
+                      0xff);
+}
+
+PIXEL oily_png_decode_pixel_truecolor_8bit(BYTE* bytes, long start, long x, VALUE decoding_palette) {
+  return BUILD_PIXEL( bytes[start + 1 + (x * 3) + 0], 
+                      bytes[start + 1 + (x * 3) + 1], 
+                      bytes[start + 1 + (x * 3) + 2], 
+                      0xff);
+}
+
+PIXEL oily_png_decode_pixel_grayscale_alpha_8bit(BYTE* bytes, long start, long x, VALUE decoding_palette) {
+  return BUILD_PIXEL( bytes[start + 1 + (x * 2) + 0], 
+                      bytes[start + 1 + (x * 2) + 0], 
+                      bytes[start + 1 + (x * 2) + 0], 
+                      bytes[start + 1 + (x * 2) + 1]);
+}
+
+PIXEL oily_png_decode_pixel_truecolor_alpha_8bit(BYTE* bytes, long start, long x, VALUE decoding_palette) {
+  return BUILD_PIXEL( bytes[start + 1 + (x * 4) + 0], 
+                      bytes[start + 1 + (x * 4) + 1], 
+                      bytes[start + 1 + (x * 4) + 2], 
+                      bytes[start + 1 + (x * 4) + 3]);
+}
+
+PIXEL oily_png_decode_pixel_grayscale_16bit(BYTE* bytes, long start, long x, VALUE decoding_palette) {
+  return BUILD_PIXEL( bytes[start + 1 + (x * 2)], 
+                      bytes[start + 1 + (x * 2)], 
+                      bytes[start + 1 + (x * 2)], 
+                      0xff);
+}
+
+PIXEL oily_png_decode_pixel_truecolor_16bit(BYTE* bytes, long start, long x, VALUE decoding_palette) {
+  return BUILD_PIXEL( bytes[start + 1 + (x * 6) + 0], 
+                      bytes[start + 1 + (x * 6) + 2], 
+                      bytes[start + 1 + (x * 6) + 4], 
+                      0xff);
+}
+
+PIXEL oily_png_decode_pixel_grayscale_alpha_16bit(BYTE* bytes, long start, long x, VALUE decoding_palette) {
+  return BUILD_PIXEL( bytes[start + 1 + (x * 4) + 0], 
+                      bytes[start + 1 + (x * 4) + 0], 
+                      bytes[start + 1 + (x * 4) + 0], 
+                      bytes[start + 1 + (x * 4) + 2]);
+}
+
+PIXEL oily_png_decode_pixel_truecolor_alpha_16bit(BYTE* bytes, long start, long x, VALUE decoding_palette) {
+  return BUILD_PIXEL( bytes[start + 1 + (x * 8) + 0], 
+                      bytes[start + 1 + (x * 8) + 2], 
+                      bytes[start + 1 + (x * 8) + 4], 
+                      bytes[start + 1 + (x * 8) + 6]);
+}
+
+
+pixel_decoder_func oily_png_decode_pixel_func(int color_mode, int bit_depth) {
+  switch (color_mode) {
+    case OILY_PNG_COLOR_GRAYSCALE:
+      switch (bit_depth) {
+        case  1: return &oily_png_decode_pixel_grayscale_1bit;
+        case  2: return &oily_png_decode_pixel_grayscale_2bit;
+        case  4: return &oily_png_decode_pixel_grayscale_4bit;
+        case  8: return &oily_png_decode_pixel_grayscale_8bit;
+        case 16: return &oily_png_decode_pixel_grayscale_16bit;
+        default: return NULL;
+      }
+
+    case OILY_PNG_COLOR_TRUECOLOR:
+      switch (bit_depth) {
+        case  8: return &oily_png_decode_pixel_truecolor_8bit;
+        case 16: return &oily_png_decode_pixel_truecolor_16bit;
+        default: return NULL;
+      }
+      
+    case OILY_PNG_COLOR_INDEXED:
+      switch (bit_depth) {
+        case 1: return &oily_png_decode_pixel_indexed_1bit;
+        case 2: return &oily_png_decode_pixel_indexed_2bit;
+        case 4: return &oily_png_decode_pixel_indexed_4bit;
+        case 8: return &oily_png_decode_pixel_indexed_8bit;
+        default: return NULL;
+      }
+      
+    case OILY_PNG_COLOR_GRAYSCALE_ALPHA: 
+      switch (bit_depth) {
+        case  8: return &oily_png_decode_pixel_grayscale_alpha_8bit;
+        case 16: return &oily_png_decode_pixel_grayscale_alpha_16bit;
+        default: return NULL;
+      }
+
+    case OILY_PNG_COLOR_TRUECOLOR_ALPHA:
+      switch (bit_depth) {
+        case  8: return &oily_png_decode_pixel_truecolor_alpha_8bit;
+        case 16: return &oily_png_decode_pixel_truecolor_alpha_16bit;
+        default: return NULL;
+      }
+    
+    default: return NULL;
+  }
+}
+
+VALUE oily_png_decode_png_image_pass(VALUE self, VALUE stream, VALUE width, VALUE height, VALUE color_mode, VALUE depth, VALUE start_pos) {
   
   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)) {
-    rb_raise(rb_eRuntimeError, "The length of the stream is too short to contain the image!");
-  }
+  if ((FIX2LONG(height) > 0) && (FIX2LONG(width) > 0)) {
 
-  // Copy the bytes for this pass from the stream to a separate location
-  // so we can work on this byte array directly.
-  BYTE* pixelstream = (BYTE*) RSTRING_PTR(stream);
-  BYTE* bytes = ALLOCA_N(BYTE, pass_size);
-  memcpy(bytes, pixelstream + FIX2INT(start_pos), pass_size);
+    char pixel_size = oily_png_pixel_bytesize(FIX2INT(color_mode), FIX2INT(depth));
+    long line_size  = oily_png_scanline_bytesize(FIX2INT(color_mode), FIX2INT(depth), FIX2LONG(width));
+    long pass_size  = oily_png_pass_bytesize(FIX2INT(color_mode), FIX2INT(depth), FIX2LONG(width), FIX2LONG(height));
+      
+    // Make sure that the stream is large enough to contain our pass.
+    if (RSTRING_LEN(stream) < pass_size + FIX2LONG(start_pos)) {
+      rb_raise(rb_eRuntimeError, "The length of the stream is too short to contain the image!");
+    }
 
-  // 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);
-  }
+    // Copy the bytes for this pass from the stream to a separate location
+    // so we can work on this byte array directly.
+    BYTE* bytes = ALLOCA_N(BYTE, pass_size);
+    memcpy(bytes, RSTRING_PTR(stream) + FIX2LONG(start_pos), pass_size);
 
-  // Select the pixel decoder function for this color mode.
-  PIXEL (*pixel_decoder)(int, BYTE*, int, VALUE) = NULL;
-  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: %ld", FIX2INT(color_mode));
-  }
+    // 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);
+    }
+
+    // Select the pixel decoder function for this color mode.
+    PIXEL (*pixel_decoder)(BYTE*, long, long, VALUE) = NULL;
+    pixel_decoder = oily_png_decode_pixel_func(FIX2INT(color_mode), FIX2INT(depth));
   
-  int y, x, line_start, byte_index, pixel_index;
-  PIXEL pixel;
+    if (pixel_decoder == NULL) {
+      rb_raise(rb_eRuntimeError, "No decoder for color mode %d and bit depth %d", FIX2INT(color_mode), FIX2INT(depth));
+    }
+  
+    long y, x, line_start;
+    PIXEL pixel;
   
-  for (y = 0; y < FIX2INT(height); y++) {
-    line_start = y * line_size;
+    for (y = 0; y < FIX2LONG(height); y++) {
+      line_start = y * line_size;
     
-    // Apply filering to the line
-    switch (bytes[line_start]) {
-      case OILY_PNG_FILTER_NONE:    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: rb_raise(rb_eRuntimeError, "Filter type not supported: %d", bytes[line_start]);
-    }
+      // Apply filering to the line
+      switch (bytes[line_start]) {
+        case OILY_PNG_FILTER_NONE:    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: rb_raise(rb_eRuntimeError, "Filter type not supported: %d", bytes[line_start]);
+      }
     
-    // Set the filter byte to 0 because the bytearray is now unfiltered.
-    bytes[line_start] = OILY_PNG_FILTER_NONE;
+      // Set the filter byte to 0 because the bytearray is now unfiltered.
+      bytes[line_start] = OILY_PNG_FILTER_NONE;
     
-    // Now, iterate over all bytes in this line and combine them into pixels
-    for (x = 0; x < FIX2INT(width); x++) {
-      pixel_index = FIX2INT(width) * y + x;
-      byte_index  = line_start + 1 + (x * pixel_size);
-      pixel = pixel_decoder(FIX2INT(color_mode), bytes, byte_index, decoding_palette); 
-      rb_ary_store(pixels, pixel_index, INT2NUM(pixel));
+      // Now, iterate over all bytes in this line and convert them into pixels
+      for (x = 0; x < FIX2LONG(width); x++) {
+        pixel = pixel_decoder(bytes, line_start, x, decoding_palette); 
+        rb_ary_store(pixels, FIX2LONG(width) * y + x, UINT2NUM(pixel));
+      }
     }
   }
   

data/ext/oily_png/png_decoding.h

@@ -4,6 +4,9 @@
 #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)
 
+typedef PIXEL(*pixel_decoder_func)(BYTE*, long, long, VALUE);
+
+
 /*
   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
@@ -11,6 +14,6 @@
   
   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);
+VALUE oily_png_decode_png_image_pass(VALUE self, VALUE stream, VALUE width, VALUE height, VALUE color_mode, VALUE depth, VALUE start_pos);
 
 #endif

data/ext/oily_png/png_encoding.c

@@ -2,47 +2,47 @@
 
 ///// Pixel encoding functions //////////////////////////////////////////
 
-void oily_png_encode_pixel_grayscale(PIXEL pixel, BYTE* bytes, int pos, VALUE palette) {
+void oily_png_encode_pixel_grayscale(PIXEL pixel, BYTE* bytes, long pos, VALUE palette) {
   // Assume R == G == B. ChunkyPNG uses the B byte fot performance reasons. 
   // We'll uses the same to reomain compatible with ChunkyPNG.
   bytes[pos] = B_BYTE(pixel);
 }
 
-void oily_png_encode_pixel_grayscale_alpha(PIXEL pixel, BYTE* bytes, int pos, VALUE palette) {
+void oily_png_encode_pixel_grayscale_alpha(PIXEL pixel, BYTE* bytes, long pos, VALUE palette) {
   // Assume R == G == B. ChunkyPNG uses the B byte fot performance reasons. 
   // We'll uses the same to reomain compatible with ChunkyPNG.
   bytes[pos + 0] = B_BYTE(pixel);
   bytes[pos + 1] = A_BYTE(pixel);
 }
 
-void oily_png_encode_pixel_truecolor(PIXEL pixel, BYTE* bytes, int pos, VALUE palette) {
+void oily_png_encode_pixel_truecolor(PIXEL pixel, BYTE* bytes, long pos, VALUE palette) {
   bytes[pos + 0] = R_BYTE(pixel);
   bytes[pos + 1] = G_BYTE(pixel);
   bytes[pos + 2] = B_BYTE(pixel);
 }
 
-void oily_png_encode_pixel_truecolor_alpha(PIXEL pixel, BYTE* bytes, int pos, VALUE palette) {
+void oily_png_encode_pixel_truecolor_alpha(PIXEL pixel, BYTE* bytes, long pos, VALUE palette) {
   bytes[pos + 0] = R_BYTE(pixel);
   bytes[pos + 1] = G_BYTE(pixel);
   bytes[pos + 2] = B_BYTE(pixel);
   bytes[pos + 3] = A_BYTE(pixel);
 }
 
-void oily_png_encode_pixel_indexed(PIXEL pixel, BYTE* bytes, int pos, VALUE palette) {
+void oily_png_encode_pixel_indexed(PIXEL pixel, BYTE* bytes, long pos, VALUE palette) {
   bytes[pos] = (BYTE) NUM2UINT(rb_funcall(palette, rb_intern("index"), 1, UINT2NUM(pixel)));
 }
 
 ///// Scanline filtering functions //////////////////////////////////////////
 
-void oily_png_encode_filter_sub(BYTE* bytes, int pos, int line_size, int pixel_size) {
-  int x;
+void oily_png_encode_filter_sub(BYTE* bytes, long pos, long line_size, char pixel_size) {
+  long x;
   for (x = line_size - 1; x > pixel_size; x--) {
     FILTER_BYTE(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;
+void oily_png_encode_filter_up(BYTE* bytes, long pos, long line_size, char pixel_size) {
+  long x;
   if (pos >= line_size) {
     for (x = line_size - 1; x > 0; x--) {
       FILTER_BYTE(bytes[pos + x], bytes[pos + x - line_size]);
@@ -50,8 +50,8 @@ void oily_png_encode_filter_up(BYTE* bytes, int pos, int line_size, int pixel_si
   }
 }
 
-void oily_png_encode_filter_average(BYTE* bytes, int pos, int line_size, int pixel_size) {
-  int x; BYTE a, b;
+void oily_png_encode_filter_average(BYTE* bytes, long pos, long line_size, char pixel_size) {
+  long 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;
@@ -59,8 +59,8 @@ void oily_png_encode_filter_average(BYTE* bytes, int pos, int line_size, int pix
   }
 }
 
-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;
+void oily_png_encode_filter_paeth(BYTE* bytes, long pos, long line_size, char pixel_size) {
+  long x; int 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;
@@ -77,8 +77,9 @@ void oily_png_encode_filter_paeth(BYTE* bytes, int pos, int line_size, int pixel
 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));
+  char depth      = 8;
+  long width      = FIX2LONG(rb_funcall(self, rb_intern("width"), 0));
+  long height     = FIX2LONG(rb_funcall(self, rb_intern("height"), 0));
   VALUE pixels   = rb_funcall(self, rb_intern("pixels"), 0);
   
   if (RARRAY_LEN(pixels) != width * height) {
@@ -91,27 +92,27 @@ VALUE oily_png_encode_png_image_pass_to_stream(VALUE self, VALUE stream, VALUE c
     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;
+  char pixel_size = oily_png_pixel_bytesize(FIX2INT(color_mode), depth);
+  long line_size  = oily_png_scanline_bytesize(FIX2INT(color_mode), depth, width);
+  long pass_size  = oily_png_pass_bytesize(FIX2INT(color_mode), depth, width, height);
 
   // Allocate memory for the byte array.
   BYTE* bytes = ALLOCA_N(BYTE, pass_size);
 
   // Select out pixel encoder function based on the color mode.
-  void (*pixel_encoder)(PIXEL, BYTE*, int, VALUE) = NULL;
+  void (*pixel_encoder)(PIXEL, BYTE*, long, VALUE) = NULL;
   switch (FIX2INT(color_mode)) {
     case OILY_PNG_COLOR_GRAYSCALE:       pixel_encoder = &oily_png_encode_pixel_grayscale; break;
     case OILY_PNG_COLOR_TRUECOLOR:       pixel_encoder = &oily_png_encode_pixel_truecolor; break;
     case OILY_PNG_COLOR_INDEXED:         pixel_encoder = &oily_png_encode_pixel_indexed; break;
     case OILY_PNG_COLOR_GRAYSCALE_ALPHA: pixel_encoder = &oily_png_encode_pixel_grayscale_alpha; break;
     case OILY_PNG_COLOR_TRUECOLOR_ALPHA: pixel_encoder = &oily_png_encode_pixel_truecolor_alpha; break;
-    default: rb_raise(rb_eRuntimeError, "Unsupported color mode: %ld", FIX2INT(color_mode));
+    default: rb_raise(rb_eRuntimeError, "Unsupported color mode: %d", FIX2INT(color_mode));
   }
 
   // Loop over all the pixels to encode them into the byte array.
   PIXEL pixel;
-  int x, y, pos;
+  long x, y, pos;
   for (y = 0; y < height; y++) {
     bytes[line_size * y] = (BYTE) FIX2INT(filtering);
     
@@ -126,13 +127,13 @@ VALUE oily_png_encode_png_image_pass_to_stream(VALUE self, VALUE stream, VALUE c
   if (FIX2INT(filtering) != OILY_PNG_FILTER_NONE) {
     
     // Assign the chosen filter function to the scanline_filter variable.
-    void (*scanline_filter)(BYTE*, int, int, int) = NULL;
+    void (*scanline_filter)(BYTE*, long, long, char) = NULL;
     switch (FIX2INT(filtering)) {
       case OILY_PNG_FILTER_SUB:     scanline_filter = &oily_png_encode_filter_sub; break;
       case OILY_PNG_FILTER_UP:      scanline_filter = &oily_png_encode_filter_up; break;
       case OILY_PNG_FILTER_AVERAGE: scanline_filter = &oily_png_encode_filter_average; break;
       case OILY_PNG_FILTER_PAETH:   scanline_filter = &oily_png_encode_filter_paeth; break;
-      default: rb_raise(rb_eRuntimeError, "Unsupported filter type: %ld", FIX2INT(filtering));
+      default: rb_raise(rb_eRuntimeError, "Unsupported filter type: %d", FIX2INT(filtering));
     }
     
     // Now, apply the scanline_filter function to every line, backwards.

data/lib/oily_png.rb

@@ -2,7 +2,7 @@ require 'chunky_png'
 
 module OilyPNG
   
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 
   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.1.1"
-  s.date    = "2010-10-18"
+  s.version = "0.2.0"
+  s.date    = "2010-11-01"
 
   s.summary     = "Native mixin to speed up ChunkyPNG"
   s.description = <<-EOT
@@ -19,7 +19,7 @@ Gem::Specification.new do |s|
   s.extensions    = ["ext/oily_png/extconf.rb"]
   s.require_paths = ["lib", "ext"]
 
-  s.add_runtime_dependency('chunky_png', '~> 0.10.4')
+  s.add_runtime_dependency('chunky_png', '~> 0.11')
 
   s.add_development_dependency('rake')
   s.add_development_dependency('rspec', '~> 2.0')
@@ -29,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/interlaced.png spec/resources/nonsquare.png spec/resources/square.png spec/spec_helper.rb tasks/github-gem.rake tasks/testing.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/basi0g01.png spec/resources/basi0g02.png spec/resources/basi0g04.png spec/resources/basi0g08.png spec/resources/basi0g16.png spec/resources/basi2c08.png spec/resources/basi2c16.png spec/resources/basi3p01.png spec/resources/basi3p02.png spec/resources/basi3p04.png spec/resources/basi3p08.png spec/resources/basi4a08.png spec/resources/basi4a16.png spec/resources/basi6a08.png spec/resources/basi6a16.png spec/resources/basn0g01.png spec/resources/basn0g02.png spec/resources/basn0g04.png spec/resources/basn0g08.png spec/resources/basn0g16.png spec/resources/basn2c08.png spec/resources/basn2c16.png spec/resources/basn3p01.png spec/resources/basn3p02.png spec/resources/basn3p04.png spec/resources/basn3p08.png spec/resources/basn4a08.png spec/resources/basn4a16.png spec/resources/basn6a08.png spec/resources/basn6a16.png spec/resources/gray.png spec/resources/interlaced.png spec/resources/nonsquare.png spec/resources/s01i3p01.png spec/resources/s01n3p01.png spec/resources/s02i3p01.png spec/resources/s02n3p01.png spec/resources/s03i3p01.png spec/resources/s03n3p01.png spec/resources/s04i3p01.png spec/resources/s04n3p01.png spec/resources/s05i3p02.png spec/resources/s05n3p02.png spec/resources/s06i3p02.png spec/resources/s06n3p02.png spec/resources/s07i3p02.png spec/resources/s07n3p02.png spec/resources/s08i3p02.png spec/resources/s08n3p02.png spec/resources/s09i3p02.png spec/resources/s09n3p02.png spec/resources/s32i3p04.png spec/resources/s32n3p04.png spec/resources/s33i3p04.png spec/resources/s33n3p04.png spec/resources/s34i3p04.png spec/resources/s34n3p04.png spec/resources/s35i3p04.png spec/resources/s35n3p04.png spec/resources/s36i3p04.png spec/resources/s36n3p04.png spec/resources/s37i3p04.png spec/resources/s37n3p04.png spec/resources/s38i3p04.png spec/resources/s38n3p04.png spec/resources/s39i3p04.png spec/resources/s39n3p04.png spec/resources/s40i3p04.png spec/resources/s40n3p04.png spec/resources/square.png spec/spec_helper.rb tasks/github-gem.rake tasks/testing.rake)
   s.test_files = %w(spec/decoding_spec.rb spec/encoding_spec.rb)
 end

data/spec/decoding_spec.rb

@@ -2,20 +2,14 @@ require 'spec_helper'
 
 describe OilyPNG::PNGDecoding do
 
-  it "should call Color.bytesize in the pure ruby version" do
-    ChunkyPNG::Color.should_receive(:bytesize).and_return(3)
+  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 Color.bytesize in the native version" do
-    ChunkyPNG::Color.should_not_receive(:bytesize)
-    OilyCanvas.from_file(resource_file('square.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
+  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
@@ -23,56 +17,35 @@ describe OilyPNG::PNGDecoding do
     
     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 == OilyCanvas.from_blob(filtered_data)
+      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 == OilyCanvas.from_blob(filtered_data)
+      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 == OilyCanvas.from_blob(filtered_data)
+      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 == OilyCanvas.from_blob(filtered_data)
+      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 == OilyCanvas.from_blob(filtered_data)
+      ChunkyPNG::Canvas.from_blob(filtered_data).should == OilyPNG::Canvas.from_blob(filtered_data)
     end
   end
   
-  context 'decoding different color modes' do
-    before(:all) { @reference = ChunkyPNG::Canvas.from_file(resource_file('gray.png'))}
-    
-    it "should decode RGBA images the same as ChunkyPNG" do
-      filtered_data = @reference.to_blob(:color_mode => ChunkyPNG::COLOR_TRUECOLOR_ALPHA)
-      ChunkyPNG::Canvas.from_blob(filtered_data).should == OilyCanvas.from_blob(filtered_data)
-    end
-    
-    it "should decode RGB images exactly the same as ChunkyPNG" do
-      filtered_data = @reference.to_blob(:color_mode => ChunkyPNG::COLOR_TRUECOLOR)
-      ChunkyPNG::Canvas.from_blob(filtered_data).should == OilyCanvas.from_blob(filtered_data)
-    end
-    
-    it "should decode indexed images exactly the same as ChunkyPNG" do
-      filtered_data = @reference.to_blob(:color_mode => ChunkyPNG::COLOR_INDEXED)
-      ChunkyPNG::Canvas.from_blob(filtered_data).should == OilyCanvas.from_blob(filtered_data)
-    end
-    
-    it "should decode grayscale images exactly the same as ChunkyPNG" do
-      filtered_data = @reference.to_blob(:color_mode => ChunkyPNG::COLOR_GRAYSCALE)
-      ChunkyPNG::Canvas.from_blob(filtered_data).should == OilyCanvas.from_blob(filtered_data)
-    end
-    
-    it "should decode grayscale images with transparency the same as ChunkyPNG" do
-      filtered_data = @reference.to_blob(:color_mode => ChunkyPNG::COLOR_GRAYSCALE_ALPHA)
-      ChunkyPNG::Canvas.from_blob(filtered_data).should == OilyCanvas.from_blob(filtered_data)
+  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/spec/encoding_spec.rb

@@ -5,7 +5,7 @@ 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)
+      @oily_canvas = OilyPNG::Canvas.from_canvas(@canvas)
     end
     
     it "should encode an image using grayscale correctly" do
@@ -47,7 +47,7 @@ describe OilyPNG::PNGEncoding do
   context 'encoding different filters' do
     before do 
       @canvas      = ChunkyPNG::Canvas.from_file(resource_file('nonsquare.png'))
-      @oily_canvas = OilyCanvas.from_canvas(@canvas)
+      @oily_canvas = OilyPNG::Canvas.from_canvas(@canvas)
     end
     
     it "should encode correctly with no filtering" do
@@ -83,7 +83,7 @@ describe OilyPNG::PNGEncoding do
   
   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)
+    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

data/spec/spec_helper.rb

@@ -7,9 +7,12 @@ require 'rspec'
 require 'chunky_png'
 require 'oily_png/oily_png_ext'
 
-class OilyCanvas < ChunkyPNG::Canvas
-  extend OilyPNG::PNGDecoding
-  include OilyPNG::PNGEncoding
+
+module OilyPNG
+  class Canvas < ChunkyPNG::Canvas
+    extend OilyPNG::PNGDecoding
+    include OilyPNG::PNGEncoding
+  end
 end
 
 module ResourceHelper
@@ -20,6 +23,10 @@ end
 
 module CanvasHelper
   
+  def resource_files(pattern = "*.png")
+    Dir[File.join(File.dirname(__FILE__), 'resources', pattern)]
+  end
+  
   def resource_file(name)
     File.join(File.dirname(__FILE__), 'resources', name)
   end

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: oily_png
 version: !ruby/object:Gem::Version 
-  hash: 25
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 1
-  version: 0.1.1
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Willem van Bergen
@@ -15,54 +14,50 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-18 00:00:00 +02:00
+date: 2010-11-01 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id001 !ruby/object:Gem::Requirement 
+  name: chunky_png
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 63
         segments: 
         - 0
-        - 10
-        - 4
-        version: 0.10.4
-  requirement: *id001
+        - 11
+        version: "0.11"
   type: :runtime
-  name: chunky_png
   prerelease: false
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id002 !ruby/object:Gem::Requirement 
+  name: rake
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 0
         version: "0"
-  requirement: *id002
   type: :development
-  name: rake
   prerelease: false
+  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id003 !ruby/object:Gem::Requirement 
+  name: rspec
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 2
         - 0
         version: "2.0"
-  requirement: *id003
   type: :development
-  name: rspec
   prerelease: false
+  version_requirements: *id003
 description: "    This Ruby C extenstion defines a module that can be included into ChunkyPNG to improve its speed.\n"
 email: 
 - willem@railsdoctors.com
@@ -90,9 +85,75 @@ files:
 - oily_png.gemspec
 - spec/decoding_spec.rb
 - spec/encoding_spec.rb
+- spec/resources/basi0g01.png
+- spec/resources/basi0g02.png
+- spec/resources/basi0g04.png
+- spec/resources/basi0g08.png
+- spec/resources/basi0g16.png
+- spec/resources/basi2c08.png
+- spec/resources/basi2c16.png
+- spec/resources/basi3p01.png
+- spec/resources/basi3p02.png
+- spec/resources/basi3p04.png
+- spec/resources/basi3p08.png
+- spec/resources/basi4a08.png
+- spec/resources/basi4a16.png
+- spec/resources/basi6a08.png
+- spec/resources/basi6a16.png
+- spec/resources/basn0g01.png
+- spec/resources/basn0g02.png
+- spec/resources/basn0g04.png
+- spec/resources/basn0g08.png
+- spec/resources/basn0g16.png
+- spec/resources/basn2c08.png
+- spec/resources/basn2c16.png
+- spec/resources/basn3p01.png
+- spec/resources/basn3p02.png
+- spec/resources/basn3p04.png
+- spec/resources/basn3p08.png
+- spec/resources/basn4a08.png
+- spec/resources/basn4a16.png
+- spec/resources/basn6a08.png
+- spec/resources/basn6a16.png
 - spec/resources/gray.png
 - spec/resources/interlaced.png
 - spec/resources/nonsquare.png
+- spec/resources/s01i3p01.png
+- spec/resources/s01n3p01.png
+- spec/resources/s02i3p01.png
+- spec/resources/s02n3p01.png
+- spec/resources/s03i3p01.png
+- spec/resources/s03n3p01.png
+- spec/resources/s04i3p01.png
+- spec/resources/s04n3p01.png
+- spec/resources/s05i3p02.png
+- spec/resources/s05n3p02.png
+- spec/resources/s06i3p02.png
+- spec/resources/s06n3p02.png
+- spec/resources/s07i3p02.png
+- spec/resources/s07n3p02.png
+- spec/resources/s08i3p02.png
+- spec/resources/s08n3p02.png
+- spec/resources/s09i3p02.png
+- spec/resources/s09n3p02.png
+- spec/resources/s32i3p04.png
+- spec/resources/s32n3p04.png
+- spec/resources/s33i3p04.png
+- spec/resources/s33n3p04.png
+- spec/resources/s34i3p04.png
+- spec/resources/s34n3p04.png
+- spec/resources/s35i3p04.png
+- spec/resources/s35n3p04.png
+- spec/resources/s36i3p04.png
+- spec/resources/s36n3p04.png
+- spec/resources/s37i3p04.png
+- spec/resources/s37n3p04.png
+- spec/resources/s38i3p04.png
+- spec/resources/s38n3p04.png
+- spec/resources/s39i3p04.png
+- spec/resources/s39n3p04.png
+- spec/resources/s40i3p04.png
+- spec/resources/s40n3p04.png
 - spec/resources/square.png
 - spec/spec_helper.rb
 - tasks/github-gem.rake
@@ -117,7 +178,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: -58392216600872723
       segments: 
       - 0
       version: "0"
@@ -126,7 +187,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: -58392216600872723
       segments: 
       - 0
       version: "0"