bench9000 0.1

data/vendor/oily_png/ext/oily_png/color.c

@@ -0,0 +1,58 @@
+#include "oily_png_ext.h"
+
+PIXEL oily_png_compose_color(PIXEL fg, PIXEL bg) {
+  BYTE a_com, new_r, new_g, new_b, new_a;
+
+  // Check for simple cases first
+  if ((A_BYTE(fg) == 0xff) || (A_BYTE(bg) == 0x00)) return fg;
+  if (A_BYTE(fg) == 0x00) return bg;
+
+  // Calculate the new values using fast 8-bit multiplication
+  a_com = INT8_MULTIPLY(0xff - A_BYTE(fg), A_BYTE(bg));
+  new_r = INT8_MULTIPLY(A_BYTE(fg), R_BYTE(fg)) + INT8_MULTIPLY(a_com, R_BYTE(bg));
+  new_g = INT8_MULTIPLY(A_BYTE(fg), G_BYTE(fg)) + INT8_MULTIPLY(a_com, G_BYTE(bg));
+  new_b = INT8_MULTIPLY(A_BYTE(fg), B_BYTE(fg)) + INT8_MULTIPLY(a_com, B_BYTE(bg));
+  new_a = A_BYTE(fg) + a_com;
+
+  return BUILD_PIXEL(new_r, new_g, new_b, new_a);
+}
+
+PIXEL oily_png_color_interpolate_quick(PIXEL fg, PIXEL bg, int alpha) {
+  BYTE a_com, new_r, new_g, new_b, new_a;
+
+  if (alpha >= 255) return fg;
+  if (alpha <= 0) return bg;
+
+  a_com = 255 - alpha;
+  new_r = INT8_MULTIPLY(alpha, R_BYTE(fg)) + INT8_MULTIPLY(a_com, R_BYTE(bg));
+  new_g = INT8_MULTIPLY(alpha, G_BYTE(fg)) + INT8_MULTIPLY(a_com, G_BYTE(bg));
+  new_b = INT8_MULTIPLY(alpha, B_BYTE(fg)) + INT8_MULTIPLY(a_com, B_BYTE(bg));
+  new_a = INT8_MULTIPLY(alpha, A_BYTE(fg)) + INT8_MULTIPLY(a_com, A_BYTE(bg));
+
+  return BUILD_PIXEL(new_r, new_g, new_b, new_a);
+}
+
+VALUE oily_png_color_compose_quick(VALUE self, VALUE fg_color, VALUE bg_color) {
+  UNUSED_PARAMETER(self);
+  return UINT2NUM(oily_png_compose_color(NUM2UINT(fg_color), NUM2UINT(bg_color)));
+}
+
+VALUE oily_png_color_r(VALUE self, VALUE value) {
+  UNUSED_PARAMETER(self);
+  return INT2FIX(R_BYTE(NUM2UINT(value)));
+}
+
+VALUE oily_png_color_g(VALUE self, VALUE value) {
+  UNUSED_PARAMETER(self);
+  return INT2FIX(G_BYTE(NUM2UINT(value)));
+}
+
+VALUE oily_png_color_b(VALUE self, VALUE value) {
+  UNUSED_PARAMETER(self);
+  return INT2FIX(B_BYTE(NUM2UINT(value)));
+}
+
+VALUE oily_png_color_a(VALUE self, VALUE value) {
+  UNUSED_PARAMETER(self);
+  return INT2FIX(A_BYTE(NUM2UINT(value)));
+}

data/vendor/oily_png/ext/oily_png/color.h

@@ -0,0 +1,29 @@
+#ifndef OILY_PNG_COLOR_H
+#define OILY_PNG_COLOR_H
+
+#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 BUILD_PIXEL(r, g, b, a)  (((PIXEL) (r) << 24) + ((PIXEL) (g) << 16) + ((PIXEL) (b) << 8) + (PIXEL) (a))
+#define INT8_MULTIPLY(a, b)      (((((a) * (b) + 0x80) >> 8) + ((a) * (b) + 0x80)) >> 8)
+
+/*
+  Ruby replacement method for color composition using alpha transparency.
+
+  This method should replace ChunkyPNG::Color.compose_quick
+*/
+VALUE oily_png_color_compose_quick(VALUE self, VALUE fg_color, VALUE bg_color);
+
+/* Color composition using alpha transparency. */
+PIXEL oily_png_compose_color(PIXEL fg, PIXEL bg);
+PIXEL oily_png_color_interpolate_quick(PIXEL fg, PIXEL bg, int alpha);
+
+/* Accessors */
+VALUE oily_png_color_r(VALUE self, VALUE pixel);
+VALUE oily_png_color_g(VALUE self, VALUE pixel);
+VALUE oily_png_color_b(VALUE self, VALUE pixel);
+VALUE oily_png_color_a(VALUE self, VALUE pixel);
+
+#endif

data/vendor/oily_png/ext/oily_png/extconf.rb

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

data/vendor/oily_png/ext/oily_png/oily_png_ext.c

@@ -0,0 +1,59 @@
+#include "oily_png_ext.h"
+
+void Init_oily_png() {
+  VALUE OilyPNG = rb_define_module("OilyPNG");
+
+  VALUE OilyPNG_Canvas = rb_define_module_under(OilyPNG, "Resampling");
+  rb_define_private_method(OilyPNG_Canvas, "steps_residues", oily_png_canvas_steps_residues, 2);
+  rb_define_private_method(OilyPNG_Canvas, "steps", oily_png_canvas_steps, 2);
+  rb_define_method(OilyPNG_Canvas, "resample_nearest_neighbor!", oily_png_canvas_resample_nearest_neighbor_bang, 2);
+  rb_define_method(OilyPNG_Canvas, "resample_bilinear!", oily_png_canvas_resample_bilinear_bang, 2);
+
+  // Setup decoding module
+  VALUE OilyPNG_PNGDecoding = rb_define_module_under(OilyPNG, "PNGDecoding");
+  rb_define_method(OilyPNG_PNGDecoding, "decode_png_image_pass", oily_png_decode_png_image_pass, 6);
+
+  // Setup encoding module
+  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, 4);
+
+  // Setup Color module
+  VALUE OilyPNG_Color = rb_define_module_under(OilyPNG, "Color");
+  rb_define_method(OilyPNG_Color, "compose_quick", oily_png_color_compose_quick, 2);
+  rb_define_method(OilyPNG_Color, "r", oily_png_color_r, 1);
+  rb_define_method(OilyPNG_Color, "g", oily_png_color_g, 1);
+  rb_define_method(OilyPNG_Color, "b", oily_png_color_b, 1);
+  rb_define_method(OilyPNG_Color, "a", oily_png_color_a, 1);
+
+  // Setup Operations module
+  VALUE OilyPNG_Operations = rb_define_module_under(OilyPNG, "Operations");
+  rb_define_method(OilyPNG_Operations, "compose!", oily_png_compose_bang, -1);
+  rb_define_method(OilyPNG_Operations, "replace!", oily_png_replace_bang, -1);
+}
+
+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;
+    case OILY_PNG_COLOR_INDEXED:         return 1;
+    case OILY_PNG_COLOR_GRAYSCALE_ALPHA: return 2;
+    case OILY_PNG_COLOR_TRUECOLOR_ALPHA: return 4;
+    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/vendor/oily_png/ext/oily_png/oily_png_ext.h

@@ -0,0 +1,72 @@
+#ifndef OILY_PNG_OILY_PNG_EXT
+#define OILY_PNG_OILY_PNG_EXT
+
+#include "ruby.h"
+
+#define RSTRING_NOT_MODIFIED
+
+// 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
+
+// Macro to surpress warnings about unused parameters.
+#define UNUSED_PARAMETER(param) (void) param
+
+// Type definitions
+typedef uint32_t PIXEL; // Pixels use 32 bits unsigned integers
+typedef unsigned char BYTE; // Bytes use 8 bits unsigned integers
+
+
+#include "png_decoding.h"
+#include "png_encoding.h"
+#include "color.h"
+#include "operations.h"
+#include "resampling.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();
+
+/*
+  Returns the number of samples per pixel for a given 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/vendor/oily_png/ext/oily_png/operations.c

@@ -0,0 +1,122 @@
+#include "oily_png_ext.h"
+
+void oily_png_check_size_constraints(long self_width, long self_height, long other_width, long other_height, long offset_x, long offset_y){
+  // For now, these raise a standard runtime error. They should however raise custom exception classes (OutOfBounds)
+  if(self_width  < other_width  + offset_x){
+    rb_raise(rb_eRuntimeError, "Background image width is too small!");
+  }
+  if(self_height < other_height + offset_y){
+    rb_raise(rb_eRuntimeError, "Background image height is too small!");
+  }
+}
+
+VALUE oily_png_compose_bang(int argc, VALUE *argv, VALUE self) {
+  // Corresponds to the other image(foreground) that we want to compose onto this one(background).
+  VALUE other;
+  
+  // The offsets are optional arguments, so these may or may not be null pointers.
+  // We'll prefix them with 'opt' to identify this.
+  VALUE opt_offset_x;
+  VALUE opt_offset_y;
+  
+  // Scan the passed in arguments, and populate the above-declared variables. Notice that '12'
+  // specifies that oily_png_compose_bang takes in 1 required parameter, and 2 optional ones (the offsets)
+  rb_scan_args(argc, argv, "12", &other,&opt_offset_x,&opt_offset_y);
+  
+  // Regardless of whether offsets were provided, we must specify a default value for them since they will
+  // be used in calculating the position of the composed element.
+  long offset_x = 0;
+  long offset_y = 0;
+
+  // If offsets were provided, then the opt_offset_* variables will not be null pointers. FIXNUM_P checks
+  // whether they point to a fixnum object. If they do, then we can safely assign our offset_* variables to the values.
+  if(FIXNUM_P(opt_offset_x)){
+    offset_x = FIX2LONG(opt_offset_x);
+  }
+  if(FIXNUM_P(opt_offset_y)){
+    offset_y = FIX2LONG(opt_offset_y);
+  }
+  
+  // Get the dimension data for both foreground and background images.
+  long self_width        = FIX2LONG(rb_funcall(self, rb_intern("width"), 0));
+  long self_height       = FIX2LONG(rb_funcall(self, rb_intern("height"), 0));
+  long other_width       = FIX2LONG(rb_funcall(other, rb_intern("width"), 0));
+  long other_height      = FIX2LONG(rb_funcall(other, rb_intern("height"), 0));
+  
+  // Make sure that the 'other' image fits within the current image. If it doesn't, an exception is raised
+  // and the operation should be aborted.
+  oily_png_check_size_constraints( self_width, self_height, other_width, other_height, offset_x, offset_y );
+  
+  // Get the pixel data for both the foreground(other) and background(self) pixels. 
+  VALUE* bg_pixels = RARRAY_PTR(rb_funcall(self, rb_intern("pixels"), 0));
+  VALUE* fg_pixels = RARRAY_PTR(rb_funcall(other, rb_intern("pixels"), 0));
+
+  long x = 0;
+  long y = 0;
+  long bg_index = 0; // corresponds to the current index in the bg_pixels array.
+  for( y = 0; y < other_height; y++ ){
+    for( x = 0; x < other_width; x++ ){
+      // We need to find the value of bg_index twice, so we only calculate and store it once.
+      bg_index = ( x + offset_x ) + ( y + offset_y ) * self_width;
+      // Replace the background pixel with the composition of background + foreground
+      bg_pixels[bg_index] = UINT2NUM( oily_png_compose_color( NUM2UINT( fg_pixels[x+ y * other_width] ), NUM2UINT( bg_pixels[bg_index] ) ) );
+    }
+  }
+  return self;
+}
+
+
+VALUE oily_png_replace_bang(int argc, VALUE *argv, VALUE self) {
+  // Corresponds to the other image(foreground) that we want to compose onto this one(background).
+  VALUE other;
+  
+  // The offsets are optional arguments, so these may or may not be null pointers.
+  // We'll prefix them with 'opt' to identify this.
+  VALUE opt_offset_x;
+  VALUE opt_offset_y;
+  
+  // Scan the passed in arguments, and populate the above-declared variables. Notice that '12'
+  // specifies that oily_png_compose_bang takes in 1 required parameter, and 2 optional ones (the offsets)
+  rb_scan_args(argc, argv, "12", &other,&opt_offset_x,&opt_offset_y);
+  
+  // Regardless of whether offsets were provided, we must specify a default value for them since they will
+  // be used in calculating the position of the composed element.
+  long offset_x = 0;
+  long offset_y = 0;
+
+  // If offsets were provided, then the opt_offset_* variables will not be null pointers. FIXNUM_P checks
+  // whether they point to a fixnum object. If they do, then we can safely assign our offset_* variables to the values.
+  if(FIXNUM_P(opt_offset_x)){
+    offset_x = FIX2LONG(opt_offset_x);
+  }
+  if(FIXNUM_P(opt_offset_y)){
+    offset_y = FIX2LONG(opt_offset_y);
+  }
+  
+  // Get the dimension data for both foreground and background images.
+  long self_width        = FIX2LONG(rb_funcall(self, rb_intern("width"), 0));
+  long self_height       = FIX2LONG(rb_funcall(self, rb_intern("height"), 0));
+  long other_width       = FIX2LONG(rb_funcall(other, rb_intern("width"), 0));
+  long other_height      = FIX2LONG(rb_funcall(other, rb_intern("height"), 0));
+  
+  // Make sure that the 'other' image fits within the current image. If it doesn't, an exception is raised
+  // and the operation should be aborted.
+  oily_png_check_size_constraints( self_width, self_height, other_width, other_height, offset_x, offset_y );
+  
+  // Get the pixel data for both the foreground(other) and background(self) pixels. 
+  VALUE* bg_pixels = RARRAY_PTR(rb_funcall(self, rb_intern("pixels"), 0));
+  VALUE* fg_pixels = RARRAY_PTR(rb_funcall(other, rb_intern("pixels"), 0));
+
+  long x = 0;
+  long y = 0;
+  long bg_index = 0; // corresponds to the current index in the bg_pixels array.
+  for( y = 0; y < other_height; y++ ){
+    for( x = 0; x < other_width; x++ ){
+      // We need to find the value of bg_index twice, so we only calculate and store it once.
+      bg_index = ( x + offset_x ) + ( y + offset_y ) * self_width;
+      // Replace the background pixel with the composition of background + foreground
+      bg_pixels[bg_index] = fg_pixels[x+ y * other_width];
+    }
+  }
+  return self;
+}

data/vendor/oily_png/ext/oily_png/operations.h

@@ -0,0 +1,36 @@
+#ifndef OILY_PNG_OPERATIONS_H
+#define OILY_PNG_OPERATIONS_H
+
+/* 
+  Checks whether an image 'other' can fits into 'self'. Takes offset into account.
+  An exception is raised if the check fails.
+  
+  Instead of taking in an object 'self' and an object 'other' and then calculating their parameters,
+  we ask for the respective height and width directly. This is because these variables will need to be calculated 
+  by 'rb_intern()' within the method calling oily_png_check_size_constraints (ex: oily_png_compose), so there's no 
+  use in calculating them twice.
+  
+*/
+void oily_png_check_size_constraints(long self_width, long self_height, long other_width, long other_height, long offset_x, long offset_y);
+
+/* 
+  C replacement method for composing another image onto this image using alpha blending.
+  
+  TODO: Implement functionality with ChunkyPNG and OilyPNG so that an image can be composited onto another
+  regardless of its size: however, only the intersecting elements of both images should be mixed.
+  
+  This method should replace ChunkyPNG::Canvas.compose!
+*/
+VALUE oily_png_compose_bang(int argc, VALUE *argv, VALUE c);
+
+/* 
+  C replacement method for composing another image onto this image by simply replacing pixels.
+  
+  TODO: Implement functionality with ChunkyPNG and OilyPNG so that an image can be composited onto another
+  regardless of its size: however, only the intersecting elements of both images should be mixed.
+  
+  This method should replace ChunkyPNG::Canvas.replace!
+*/
+VALUE oily_png_replace_bang(int argc, VALUE *argv, VALUE c);
+
+#endif

data/vendor/oily_png/ext/oily_png/png_decoding.c

@@ -0,0 +1,374 @@
+#include "oily_png_ext.h"
+
+
+/////////////////////////////////////////////////////////////////////
+// UNFILTERING SCANLINES
+/////////////////////////////////////////////////////////////////////
+
+
+// Decodes a SUB filtered scanline at the given position in the byte array
+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, long pos, long line_size, char pixel_size) {
+  UNUSED_PARAMETER(pixel_size);
+  long i;
+  if (pos >= line_size) { // The first line is not filtered because there is no privous line
+    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, 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;
+    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, long pos, long line_size, char pixel_size) {
+  BYTE a, b, c, pr;
+  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 = (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);
+  }
+}
+
+/////////////////////////////////////////////////////////////////////
+// BIT HANDLING
+/////////////////////////////////////////////////////////////////////
+
+
+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;
+}
+
+
+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;
+}
+
+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);
+}
+
+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;
+}
+
+BYTE oily_png_resample_2bit_element(BYTE* bytes, long start, long x) {
+  return oily_png_extract_2bit_element(bytes, start, x) * 85;
+}
+
+BYTE oily_png_resample_4bit_element(BYTE* bytes, long start, long x) {
+  return oily_png_extract_4bit_element(bytes, start, x) * 17;
+}
+
+/////////////////////////////////////////////////////////////////////
+// PIXEL DECODING SCANLINES
+/////////////////////////////////////////////////////////////////////
+
+
+void oily_png_decode_scanline_grayscale_1bit(VALUE pixels, BYTE* bytes, long start, long width, VALUE decoding_palette) {
+  UNUSED_PARAMETER(decoding_palette);
+  long x;
+  for (x = 0; x < width; x++) {
+    ADD_PIXEL_FROM_RGBA(pixels,
+                    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);
+  }
+}
+
+void oily_png_decode_scanline_grayscale_2bit(VALUE pixels, BYTE* bytes, long start, long width, VALUE decoding_palette) {
+  UNUSED_PARAMETER(decoding_palette);
+  long x;
+  for (x = 0; x < width; x++) {
+    ADD_PIXEL_FROM_RGBA(pixels,
+                    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);
+  }
+}
+
+void oily_png_decode_scanline_grayscale_4bit(VALUE pixels, BYTE* bytes, long start, long width, VALUE decoding_palette) {
+  UNUSED_PARAMETER(decoding_palette);
+  long x;
+  for (x = 0; x < width; x++) {
+    ADD_PIXEL_FROM_RGBA(pixels,
+                    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);
+  }
+}
+
+void oily_png_decode_scanline_grayscale_8bit(VALUE pixels, BYTE* bytes, long start, long width, VALUE decoding_palette) {
+  UNUSED_PARAMETER(decoding_palette);
+  long x;
+  for (x = 0; x < width; x++) {
+    ADD_PIXEL_FROM_RGBA(pixels,
+                    bytes[start + 1 + x], 
+                    bytes[start + 1 + x], 
+                    bytes[start + 1 + x], 
+                    0xff);
+  }
+}
+
+void oily_png_decode_scanline_grayscale_16bit(VALUE pixels, BYTE* bytes, long start, long width, VALUE decoding_palette) {
+  UNUSED_PARAMETER(decoding_palette);
+  long x;
+  for (x = 0; x < width; x++) {
+    ADD_PIXEL_FROM_RGBA(pixels,
+                    bytes[start + 1 + (x * 2)], 
+                    bytes[start + 1 + (x * 2)], 
+                    bytes[start + 1 + (x * 2)], 
+                    0xff);
+  }
+}
+
+void oily_png_decode_scanline_grayscale_alpha_8bit(VALUE pixels, BYTE* bytes, long start, long width, VALUE decoding_palette) {
+  UNUSED_PARAMETER(decoding_palette);
+  long x;
+  for (x = 0; x < width; x++) {
+    ADD_PIXEL_FROM_RGBA(pixels,
+                    bytes[start + 1 + (x * 2) + 0], 
+                    bytes[start + 1 + (x * 2) + 0], 
+                    bytes[start + 1 + (x * 2) + 0], 
+                    bytes[start + 1 + (x * 2) + 1]);
+  }
+}
+
+void oily_png_decode_scanline_grayscale_alpha_16bit(VALUE pixels, BYTE* bytes, long start, long width, VALUE decoding_palette) {
+  UNUSED_PARAMETER(decoding_palette);
+  long x;
+  for (x = 0; x < width; x++) {
+    ADD_PIXEL_FROM_RGBA(pixels,
+                    bytes[start + 1 + (x * 4) + 0], 
+                    bytes[start + 1 + (x * 4) + 0], 
+                    bytes[start + 1 + (x * 4) + 0], 
+                    bytes[start + 1 + (x * 4) + 2]);
+  }
+}
+
+void oily_png_decode_scanline_indexed_1bit(VALUE pixels, BYTE* bytes, long start, long width, VALUE decoding_palette) {
+  long x;
+  for (x = 0; x < width; x++) {
+    ADD_PIXEL_FROM_PALLETE(pixels, decoding_palette, oily_png_extract_1bit_element(bytes, start, x));
+  }
+}
+
+void oily_png_decode_scanline_indexed_2bit(VALUE pixels, BYTE* bytes, long start, long width, VALUE decoding_palette) {
+  long x;
+  for (x = 0; x < width; x++) {
+    ADD_PIXEL_FROM_PALLETE(pixels, decoding_palette, oily_png_extract_2bit_element(bytes, start, x));
+  }
+}
+
+void oily_png_decode_scanline_indexed_4bit(VALUE pixels, BYTE* bytes, long start, long width, VALUE decoding_palette) {
+  long x;
+  for (x = 0; x < width; x++) {
+    ADD_PIXEL_FROM_PALLETE(pixels, decoding_palette, oily_png_extract_4bit_element(bytes, start, x));
+  }
+}
+
+void oily_png_decode_scanline_indexed_8bit(VALUE pixels, BYTE* bytes, long start, long width, VALUE decoding_palette) {
+  long x;
+  for (x = 0; x < width; x++) {
+    ADD_PIXEL_FROM_PALLETE(pixels, decoding_palette, bytes[start + 1 + x]);
+  }
+}
+
+void oily_png_decode_scanline_truecolor_8bit(VALUE pixels, BYTE* bytes, long start, long width, VALUE decoding_palette) {
+  UNUSED_PARAMETER(decoding_palette);
+  long x;
+  for (x = 0; x < width; x++) {
+    ADD_PIXEL_FROM_RGBA(pixels,
+                    bytes[start + 1 + (x * 3) + 0], 
+                    bytes[start + 1 + (x * 3) + 1], 
+                    bytes[start + 1 + (x * 3) + 2], 
+                    0xff);
+  }
+}
+
+void oily_png_decode_scanline_truecolor_16bit(VALUE pixels, BYTE* bytes, long start, long width, VALUE decoding_palette) {
+  UNUSED_PARAMETER(decoding_palette);
+  long x;
+  for (x = 0; x < width; x++) {
+    ADD_PIXEL_FROM_RGBA(pixels,
+                    bytes[start + 1 + (x * 6) + 0], 
+                    bytes[start + 1 + (x * 6) + 2], 
+                    bytes[start + 1 + (x * 6) + 4], 
+                    0xff);
+  }
+}
+
+void oily_png_decode_scanline_truecolor_alpha_8bit(VALUE pixels, BYTE* bytes, long start, long width, VALUE decoding_palette) {
+  UNUSED_PARAMETER(decoding_palette);
+  long x;
+  for (x = 0; x < width; x++) {
+    ADD_PIXEL_FROM_RGBA(pixels,
+                    bytes[start + 1 + (x * 4) + 0], 
+                    bytes[start + 1 + (x * 4) + 1], 
+                    bytes[start + 1 + (x * 4) + 2], 
+                    bytes[start + 1 + (x * 4) + 3]);    
+  }
+}
+
+void oily_png_decode_scanline_truecolor_alpha_16bit(VALUE pixels, BYTE* bytes, long start, long width, VALUE decoding_palette) {
+  UNUSED_PARAMETER(decoding_palette);
+  long x;
+  for (x = 0; x < width; x++) {
+    ADD_PIXEL_FROM_RGBA(pixels,    
+                    bytes[start + 1 + (x * 8) + 0], 
+                    bytes[start + 1 + (x * 8) + 2], 
+                    bytes[start + 1 + (x * 8) + 4], 
+                    bytes[start + 1 + (x * 8) + 6]);
+  }
+}
+
+scanline_decoder_func oily_png_decode_scanline_func(int color_mode, int bit_depth) {
+  switch (color_mode) {
+    case OILY_PNG_COLOR_GRAYSCALE:
+      switch (bit_depth) {
+        case  1: return &oily_png_decode_scanline_grayscale_1bit;
+        case  2: return &oily_png_decode_scanline_grayscale_2bit;
+        case  4: return &oily_png_decode_scanline_grayscale_4bit;
+        case  8: return &oily_png_decode_scanline_grayscale_8bit;
+        case 16: return &oily_png_decode_scanline_grayscale_16bit;
+        default: return NULL;
+      }
+
+    case OILY_PNG_COLOR_TRUECOLOR:
+      switch (bit_depth) {
+        case  8: return &oily_png_decode_scanline_truecolor_8bit;
+        case 16: return &oily_png_decode_scanline_truecolor_16bit;
+        default: return NULL;
+      }
+      
+    case OILY_PNG_COLOR_INDEXED:
+      switch (bit_depth) {
+        case 1: return &oily_png_decode_scanline_indexed_1bit;
+        case 2: return &oily_png_decode_scanline_indexed_2bit;
+        case 4: return &oily_png_decode_scanline_indexed_4bit;
+        case 8: return &oily_png_decode_scanline_indexed_8bit;
+        default: return NULL;
+      }
+      
+    case OILY_PNG_COLOR_GRAYSCALE_ALPHA:
+      switch (bit_depth) {
+        case  8: return &oily_png_decode_scanline_grayscale_alpha_8bit;
+        case 16: return &oily_png_decode_scanline_grayscale_alpha_16bit;
+        default: return NULL;
+      }
+
+    case OILY_PNG_COLOR_TRUECOLOR_ALPHA:
+      switch (bit_depth) {
+        case  8: return &oily_png_decode_scanline_truecolor_alpha_8bit;
+        case 16: return &oily_png_decode_scanline_truecolor_alpha_16bit;
+        default: return NULL;
+      }
+    
+    default: return NULL;
+  }
+}
+
+/////////////////////////////////////////////////////////////////////
+// DECODING AN IMAGE PASS
+/////////////////////////////////////////////////////////////////////
+
+VALUE oily_png_decode_palette(VALUE self) {
+  VALUE palette_instance = rb_funcall(self, rb_intern("decoding_palette"), 0);
+  if (palette_instance != Qnil) {
+    VALUE decoding_map = rb_iv_get(palette_instance, "@decoding_map");
+    if (rb_funcall(decoding_map, rb_intern("kind_of?"), 1, rb_cArray) == Qtrue) {  
+      return decoding_map;
+    }
+  }
+  rb_raise(rb_eRuntimeError, "Could not retrieve a decoding palette for this image!");  
+}
+
+
+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();
+  
+  if ((FIX2LONG(height) > 0) && (FIX2LONG(width) > 0)) {
+
+    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!");
+    }
+
+    // Copy the bytes for this pass from the stream to a separate location
+    // so we can work on this byte array directly.
+    BYTE* bytes = ALLOC_N(BYTE, pass_size);
+    memcpy(bytes, RSTRING_PTR(stream) + FIX2LONG(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 = oily_png_decode_palette(self);
+    }
+
+    // Select the scanline decoder function for this color mode and bit depth.
+    scanline_decoder_func scanline_decoder = oily_png_decode_scanline_func(FIX2INT(color_mode), FIX2INT(depth));
+    if (scanline_decoder == NULL) {
+      rb_raise(rb_eRuntimeError, "No decoder for color mode %d and bit depth %d", FIX2INT(color_mode), FIX2INT(depth));
+    }
+  
+    long y, line_start;
+    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]);
+      }
+    
+      // Set the filter byte to 0 because the bytearray is now unfiltered.
+      bytes[line_start] = OILY_PNG_FILTER_NONE;
+      scanline_decoder(pixels, bytes, line_start, FIX2LONG(width), decoding_palette);
+    }
+    
+    xfree(bytes);
+  }
+
+  // Now, return a new ChunkyPNG::Canvas instance with the decoded pixels.
+  return rb_funcall(self, rb_intern("new"), 3, width, height, pixels);
+}