bench9000 0.1

data/vendor/oily_png/ext/oily_png/png_decoding.h

@@ -0,0 +1,27 @@
+#ifndef OILY_PNG_PNG_DECODING_H
+#define OILY_PNG_PNG_DECODING_H
+
+#define UNFILTER_BYTE(byte, adjustment)  byte = (BYTE) (((byte) + (adjustment)) & 0x000000ff)
+
+#define ADD_PIXEL_FROM_PALLETE(pixels, decoding_palette, palette_entry) \
+    if (RARRAY_LEN(decoding_palette) > (palette_entry)) { \
+      rb_ary_push(pixels, rb_ary_entry(decoding_palette, (palette_entry))); \
+    } else { \
+      rb_raise(rb_eRuntimeError, "The decoding palette does not have %d entries!", (palette_entry)); \
+    }
+    
+#define ADD_PIXEL_FROM_RGBA(pixels, r, g, b, a) rb_ary_push(pixels, UINT2NUM(BUILD_PIXEL(r,g,b,a)));
+
+
+typedef void(*scanline_decoder_func)(VALUE, 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
+  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 depth, VALUE start_pos);
+
+#endif

data/vendor/oily_png/ext/oily_png/png_encoding.c

@@ -0,0 +1,302 @@
+#include "oily_png_ext.h"
+
+///// Scanline filtering functions //////////////////////////////////////////
+
+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, long pos, long line_size, char pixel_size) {
+  UNUSED_PARAMETER(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]);
+    }
+  }
+}
+
+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;
+    FILTER_BYTE(bytes[pos + x], (a + b) >> 1);
+  }
+}
+
+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;
+    c = (pos >= line_size && x > pixel_size) ? bytes[pos + x - line_size - pixel_size] : 0;
+    p  = a + b - c;
+    pa = abs(p - a);
+    pb = abs(p - b);
+    pc = abs(p - c);
+    pr = (pa <= pb && pa <= pc) ? a : (pb <= pc ? b : c);
+    FILTER_BYTE(bytes[pos + x], pr);
+  }
+}
+
+///// Scanline encoding functions //////////////////////////////////////////
+
+// Assume R == G == B. ChunkyPNG uses the B byte fot performance reasons. 
+// We'll uses the same to remain compatible with ChunkyPNG.
+void oily_png_encode_scanline_grayscale_1bit(BYTE* bytes, VALUE pixels, long y, long width, VALUE encoding_palette) {
+  UNUSED_PARAMETER(encoding_palette);
+  long x; BYTE p1, p2, p3, p4, p5, p6, p7, p8;
+  for (x = 0; x < width; x += 8) {
+    p1 = (x + 0 >= width) ? 0 : (B_BYTE(NUM2UINT(rb_ary_entry(pixels, y * width + x + 0))) >> 7);
+    p2 = (x + 1 >= width) ? 0 : (B_BYTE(NUM2UINT(rb_ary_entry(pixels, y * width + x + 1))) >> 7);
+    p3 = (x + 2 >= width) ? 0 : (B_BYTE(NUM2UINT(rb_ary_entry(pixels, y * width + x + 2))) >> 7);
+    p4 = (x + 3 >= width) ? 0 : (B_BYTE(NUM2UINT(rb_ary_entry(pixels, y * width + x + 3))) >> 7);
+    p5 = (x + 4 >= width) ? 0 : (B_BYTE(NUM2UINT(rb_ary_entry(pixels, y * width + x + 4))) >> 7);
+    p6 = (x + 5 >= width) ? 0 : (B_BYTE(NUM2UINT(rb_ary_entry(pixels, y * width + x + 5))) >> 7);
+    p7 = (x + 6 >= width) ? 0 : (B_BYTE(NUM2UINT(rb_ary_entry(pixels, y * width + x + 6))) >> 7);
+    p8 = (x + 7 >= width) ? 0 : (B_BYTE(NUM2UINT(rb_ary_entry(pixels, y * width + x + 7))) >> 7);
+    bytes[x >> 3] = (BYTE) ((p1 << 7) | (p2 << 6) | (p3 << 5) | (p4 << 4) | (p5 << 3) | (p6 << 2) | (p7 << 1) | (p8));
+  }
+}
+
+
+// Assume R == G == B. ChunkyPNG uses the B byte fot performance reasons. 
+// We'll uses the same to remain compatible with ChunkyPNG.
+void oily_png_encode_scanline_grayscale_2bit(BYTE* bytes, VALUE pixels, long y, long width, VALUE encoding_palette) {
+  UNUSED_PARAMETER(encoding_palette);
+  long x; BYTE p1, p2, p3, p4;
+  for (x = 0; x < width; x += 4) {
+    p1 = (x + 0 >= width) ? 0 : (B_BYTE(NUM2UINT(rb_ary_entry(pixels, y * width + x + 0))) >> 6);
+    p2 = (x + 1 >= width) ? 0 : (B_BYTE(NUM2UINT(rb_ary_entry(pixels, y * width + x + 1))) >> 6);
+    p3 = (x + 2 >= width) ? 0 : (B_BYTE(NUM2UINT(rb_ary_entry(pixels, y * width + x + 2))) >> 6);
+    p4 = (x + 3 >= width) ? 0 : (B_BYTE(NUM2UINT(rb_ary_entry(pixels, y * width + x + 3))) >> 6);
+    bytes[x >> 2] = (BYTE) ((p1 << 6) | (p2 << 4) | (p3 << 2) | (p4));
+  }
+}
+
+// Assume R == G == B. ChunkyPNG uses the B byte fot performance reasons. 
+// We'll uses the same to remain compatible with ChunkyPNG.
+void oily_png_encode_scanline_grayscale_4bit(BYTE* bytes, VALUE pixels, long y, long width, VALUE encoding_palette) {
+  UNUSED_PARAMETER(encoding_palette);
+  long x; BYTE p1, p2;
+  for (x = 0; x < width; x += 2) {
+    p1 = (x + 0 >= width) ? 0 : (B_BYTE(NUM2UINT(rb_ary_entry(pixels, y * width + x + 0))) >> 4);
+    p2 = (x + 1 >= width) ? 0 : (B_BYTE(NUM2UINT(rb_ary_entry(pixels, y * width + x + 1))) >> 4);
+    bytes[x >> 1] = (BYTE) ((p1 << 4) | (p2));
+  }
+}
+
+// Assume R == G == B. ChunkyPNG uses the B byte fot performance reasons. 
+// We'll uses the same to remain compatible with ChunkyPNG.
+void oily_png_encode_scanline_grayscale_8bit(BYTE* bytes, VALUE pixels, long y, long width, VALUE encoding_palette) {
+  UNUSED_PARAMETER(encoding_palette);
+  long x; PIXEL pixel;
+  for (x = 0; x < width; x++) {
+    pixel = NUM2UINT(rb_ary_entry(pixels, y * width + x));
+    bytes[x] = B_BYTE(pixel);
+  }
+}
+
+// Assume R == G == B. ChunkyPNG uses the B byte fot performance reasons. 
+// We'll uses the same to remain compatible with ChunkyPNG.
+void oily_png_encode_scanline_grayscale_alpha_8bit(BYTE* bytes, VALUE pixels, long y, long width, VALUE encoding_palette) {
+  UNUSED_PARAMETER(encoding_palette);
+  long x; PIXEL pixel;
+  for (x = 0; x < width; x++) {
+    pixel = NUM2UINT(rb_ary_entry(pixels, y * width + x));
+    bytes[x * 2 + 0] = B_BYTE(pixel);
+    bytes[x * 2 + 1] = A_BYTE(pixel);
+  }
+}
+
+void oily_png_encode_scanline_indexed_8bit(BYTE* bytes, VALUE pixels, long y, long width, VALUE encoding_palette) {
+  long x;
+  for (x = 0; x < width; x++) {
+    bytes[x] = ENCODING_PALETTE_INDEX(encoding_palette, pixels, width, y, x);
+  }
+}
+
+void oily_png_encode_scanline_indexed_4bit(BYTE* bytes, VALUE pixels, long y, long width, VALUE encoding_palette) {
+  long x; BYTE p1, p2;
+  for (x = 0; x < width; x += 2) {
+    p1 = ENCODING_PALETTE_INDEX(encoding_palette, pixels, width, y, x + 0);
+    p2 = ENCODING_PALETTE_INDEX(encoding_palette, pixels, width, y, x + 1);
+    bytes[x >> 1] = (BYTE) ((p1 << 4) | (p2));
+  }
+}
+
+void oily_png_encode_scanline_indexed_2bit(BYTE* bytes, VALUE pixels, long y, long width, VALUE encoding_palette) {
+  long x; BYTE p1, p2, p3, p4;
+  for (x = 0; x < width; x += 4) {
+    p1 = ENCODING_PALETTE_INDEX(encoding_palette, pixels, width, y, x + 0);
+    p2 = ENCODING_PALETTE_INDEX(encoding_palette, pixels, width, y, x + 1);
+    p3 = ENCODING_PALETTE_INDEX(encoding_palette, pixels, width, y, x + 2);
+    p4 = ENCODING_PALETTE_INDEX(encoding_palette, pixels, width, y, x + 3);
+    bytes[x >> 2] = (BYTE) ((p1 << 6) | (p2 << 4) | (p3 << 2) | (p4));
+  }
+}
+
+void oily_png_encode_scanline_indexed_1bit(BYTE* bytes, VALUE pixels, long y, long width, VALUE encoding_palette) {
+  long x; BYTE p1, p2, p3, p4, p5, p6, p7, p8;
+  for (x = 0; x < width; x += 8) {
+    p1 = ENCODING_PALETTE_INDEX(encoding_palette, pixels, width, y, x + 0);
+    p2 = ENCODING_PALETTE_INDEX(encoding_palette, pixels, width, y, x + 1);
+    p3 = ENCODING_PALETTE_INDEX(encoding_palette, pixels, width, y, x + 2);
+    p4 = ENCODING_PALETTE_INDEX(encoding_palette, pixels, width, y, x + 3);
+    p5 = ENCODING_PALETTE_INDEX(encoding_palette, pixels, width, y, x + 4);
+    p6 = ENCODING_PALETTE_INDEX(encoding_palette, pixels, width, y, x + 5);
+    p7 = ENCODING_PALETTE_INDEX(encoding_palette, pixels, width, y, x + 6);
+    p8 = ENCODING_PALETTE_INDEX(encoding_palette, pixels, width, y, x + 7);
+    bytes[x >> 3] = (BYTE) ((p1 << 7) | (p2 << 6) | (p3 << 5) | (p4 << 4) | (p5 << 3) | (p6 << 2) | (p7 << 1) | (p8));
+  }
+}
+ 
+void oily_png_encode_scanline_truecolor_8bit(BYTE* bytes, VALUE pixels, long y, long width, VALUE encoding_palette) {
+  UNUSED_PARAMETER(encoding_palette);
+  long x; PIXEL pixel;
+  for (x = 0; x < width; x++) {
+    pixel = NUM2UINT(rb_ary_entry(pixels, y * width + x));
+    bytes[x * 3 + 0] = R_BYTE(pixel);
+    bytes[x * 3 + 1] = G_BYTE(pixel);
+    bytes[x * 3 + 2] = B_BYTE(pixel);
+  }
+}
+
+void oily_png_encode_scanline_truecolor_alpha_8bit(BYTE* bytes, VALUE pixels, long y, long width, VALUE encoding_palette) {
+  UNUSED_PARAMETER(encoding_palette);
+  long x; PIXEL pixel;
+  for (x = 0; x < width; x++) {
+    pixel = NUM2UINT(rb_ary_entry(pixels, y * width + x));
+    bytes[x * 4 + 0] = R_BYTE(pixel);
+    bytes[x * 4 + 1] = G_BYTE(pixel);
+    bytes[x * 4 + 2] = B_BYTE(pixel);
+    bytes[x * 4 + 3] = A_BYTE(pixel);
+  }
+}
+
+
+scanline_encoder_func oily_png_encode_scanline_func(char color_mode, char bit_depth) {
+  switch (color_mode) {
+
+    case OILY_PNG_COLOR_GRAYSCALE:
+      switch (bit_depth) {
+        case 8:  return &oily_png_encode_scanline_grayscale_8bit;
+        case 4:  return &oily_png_encode_scanline_grayscale_4bit;
+        case 2:  return &oily_png_encode_scanline_grayscale_2bit;
+        case 1:  return &oily_png_encode_scanline_grayscale_1bit;
+        default: return NULL;
+      }
+      
+    case OILY_PNG_COLOR_GRAYSCALE_ALPHA:
+      switch (bit_depth) {
+        case 8:  return &oily_png_encode_scanline_grayscale_alpha_8bit;
+        default: return NULL;
+      }
+    
+    case OILY_PNG_COLOR_INDEXED:
+      switch (bit_depth) {
+        case 8:  return &oily_png_encode_scanline_indexed_8bit;
+        case 4:  return &oily_png_encode_scanline_indexed_4bit;
+        case 2:  return &oily_png_encode_scanline_indexed_2bit;
+        case 1:  return &oily_png_encode_scanline_indexed_1bit;
+        default: return NULL;
+      }
+      
+    case OILY_PNG_COLOR_TRUECOLOR:
+      switch (bit_depth) {
+        case 8:  return &oily_png_encode_scanline_truecolor_8bit;
+        default: return NULL;
+      }
+      
+    case OILY_PNG_COLOR_TRUECOLOR_ALPHA:
+      switch (bit_depth) {
+        case 8:  return &oily_png_encode_scanline_truecolor_alpha_8bit;
+        default: return NULL;
+      }
+
+    default: return NULL;
+  }
+}
+
+/////////////////////////////////////////////////////////////////////
+// ENCODING AN IMAGE PASS
+/////////////////////////////////////////////////////////////////////
+
+VALUE oily_png_encode_palette(VALUE self) {
+  VALUE palette_instance = rb_funcall(self, rb_intern("encoding_palette"), 0);
+  if (palette_instance != Qnil) {
+    VALUE encoding_map = rb_iv_get(palette_instance, "@encoding_map");
+    if (rb_funcall(encoding_map, rb_intern("kind_of?"), 1, rb_cHash) == Qtrue) {
+      return encoding_map;
+    }
+  }
+  rb_raise(rb_eRuntimeError, "Could not retrieve a decoding palette for this image!");
+}
+
+VALUE oily_png_encode_png_image_pass_to_stream(VALUE self, VALUE stream, VALUE color_mode, VALUE bit_depth, VALUE filtering) {
+  
+  UNUSED_PARAMETER(bit_depth);
+  
+  // Get the data
+  char depth      = (char) FIX2INT(bit_depth);
+  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) {
+    rb_raise(rb_eRuntimeError, "The number of pixels does not match the canvas dimensions.");
+  }
+
+  // Get the encoding palette if we're encoding to an indexed bytestream.
+  VALUE encoding_palette = Qnil;
+  if (FIX2INT(color_mode) == OILY_PNG_COLOR_INDEXED) {
+    encoding_palette = oily_png_encode_palette(self);
+  }
+  
+  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 = ALLOC_N(BYTE, pass_size);
+  
+  // Get the scanline encoder function.
+  scanline_encoder_func scanline_encoder = oily_png_encode_scanline_func(FIX2INT(color_mode), depth);
+  if (scanline_encoder == NULL) {
+    rb_raise(rb_eRuntimeError, "No encoder for color mode %d and bit depth %d", FIX2INT(color_mode), depth);
+  }
+
+  long y, pos;
+  for (y = height - 1; y >= 0; y--) {
+    pos = line_size * y;
+    bytes[pos] = (BYTE) FIX2INT(filtering);
+    scanline_encoder(bytes + pos + 1, pixels, y, width, encoding_palette);
+  }
+  
+  if (FIX2INT(filtering) != OILY_PNG_FILTER_NONE) {
+
+    // Get the scanline filter function
+    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: %d", FIX2INT(filtering));
+    }
+
+    for (y = height - 1; y >= 0; y--) {
+      scanline_filter(bytes, line_size * y, line_size, pixel_size);
+    }
+  }
+  
+  // Append to encoded image pass to the output stream.
+  rb_str_cat(stream, (char*) bytes, pass_size);
+  xfree(bytes);
+  return Qnil;
+}

data/vendor/oily_png/ext/oily_png/png_encoding.h

@@ -0,0 +1,19 @@
+#ifndef OILY_PNG_PNG_ENCODING_H
+#define OILY_PNG_PNG_ENCODING_H
+
+#define FILTER_BYTE(byte, adjustment)  byte = (BYTE) (((byte) - (adjustment)) & 0x000000ff)
+#define ENCODING_PALETTE_INDEX(encoding_palette, pixels, width, y, x) (((x) < (width)) ? ((BYTE) NUM2UINT(rb_hash_aref(encoding_palette, rb_ary_entry(pixels, (y) * (width) + (x))))) : 0)
+
+typedef void(*scanline_encoder_func)(BYTE*, VALUE, long, long, VALUE);
+
+/*
+  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 bit_depth, VALUE filtering);
+
+#endif

data/vendor/oily_png/ext/oily_png/resampling.c

@@ -0,0 +1,213 @@
+#include "oily_png_ext.h"
+#include <math.h>
+
+void oily_png_generate_steps_residues(long width, long new_width, long *steps, long *residues) {
+  long base_step = width / new_width;
+  long err_step = (width % new_width) << 1;
+  long denominator = new_width << 1;
+
+  long index;
+  long err;
+  /* We require an arithmetic modolus and rounding to the left of zero
+   * This is standard Ruby behaviour (I hope!) but differs with how C/Java
+   * typically handle integer division and modulo. But since we are workig
+   * in mixed numbers, Ruby's convention is especially convienent */
+  if (width >= new_width) {
+    index = (width - new_width) / denominator;
+    err = (width - new_width) % denominator;
+  } else {
+    index = (width - new_width) / denominator - 1;
+    err = denominator - ((new_width - width) % denominator);
+  }
+
+  long i;
+  for (i=0; i < new_width; i++){
+    if (residues != NULL) {
+      steps[i] = index;
+      residues[i] = (long) round(255.0 * (float) err / (float) denominator);
+    } else {
+      /* If residues aren't requested, we round to the nearest pixel */
+      if (err < new_width) {
+        steps[i] = index;
+      } else {
+        steps[i] = index + 1;
+      }
+    }
+
+    index += base_step;
+    err += err_step;
+    if (err >= denominator) {
+      index += 1;
+      err -= denominator;
+    }
+  }
+}
+
+VALUE oily_png_canvas_steps(VALUE self, VALUE v_width, VALUE v_new_width) {
+  UNUSED_PARAMETER(self);
+  long width = NUM2LONG(v_width);
+  long new_width = NUM2LONG(v_new_width);
+
+  long *steps = ALLOC_N(long, new_width);
+
+  VALUE ret = rb_ary_new2(new_width);
+
+  oily_png_generate_steps_residues(width, new_width, steps, NULL);
+
+  long i;
+  for (i=0; i < new_width; i++) {
+    rb_ary_store(ret, i, LONG2FIX(steps[i]));
+  }
+
+  /* This is an unprotected allocation; it will leak on exception.
+   * However, rb_ary_store should not generate one as we have
+   * pre-allocated the array.
+   */
+  xfree(steps);
+  steps = NULL;
+
+  return ret;
+}
+
+
+VALUE oily_png_canvas_steps_residues(VALUE self, VALUE v_width, VALUE v_new_width) {
+  UNUSED_PARAMETER(self);
+  long width = NUM2LONG(v_width);
+  long new_width = NUM2LONG(v_new_width);
+
+
+  VALUE ret_steps = rb_ary_new2(new_width);
+  VALUE ret_residues = rb_ary_new2(new_width);
+
+
+  long *steps = ALLOC_N(long, new_width);
+  long *residues = ALLOC_N(long, new_width);
+
+  oily_png_generate_steps_residues(width, new_width, steps, residues);
+
+
+  long i;
+  for (i=0; i < new_width; i++) {
+    rb_ary_store(ret_steps, i, LONG2FIX(steps[i]));
+    rb_ary_store(ret_residues, i, LONG2FIX(residues[i]));
+  }
+
+  /* This is an unprotected allocation; it will leak on exception.
+   * However, rb_ary_store should not generate one as we have
+   * pre-allocated the array.
+   */
+  xfree(steps);
+  steps = NULL;
+
+  xfree(residues);
+  residues = NULL;
+
+
+  /* We return multiple values */
+  VALUE ret = rb_ary_new2(2);
+  rb_ary_store(ret, 0, ret_steps);
+  rb_ary_store(ret, 1, ret_residues);
+
+  return ret;
+}
+
+VALUE oily_png_canvas_resample_nearest_neighbor_bang(VALUE self, VALUE v_new_width, VALUE v_new_height) {
+  long new_width = NUM2LONG(v_new_width);
+  long new_height = NUM2LONG(v_new_height);
+
+  long self_width = NUM2LONG(rb_funcall(self, rb_intern("width"), 0));
+  long self_height = NUM2LONG(rb_funcall(self, rb_intern("height"), 0));
+
+  VALUE pixels = rb_ary_new2(new_width*new_height);
+  VALUE source = rb_iv_get(self, "@pixels");
+
+  long *steps_x = ALLOC_N(long, new_width);
+  long *steps_y = ALLOC_N(long, new_height);
+
+  oily_png_generate_steps_residues(self_width, new_width, steps_x, NULL);
+  oily_png_generate_steps_residues(self_height, new_height, steps_y, NULL);
+
+  long index = 0;
+  long x, y;
+  long src_index;
+  for (y=0; y < new_height; y++) {
+    for (x = 0; x < new_width; x++) {
+      src_index = steps_y[y] * self_width + steps_x[x];
+      VALUE pixel = rb_ary_entry(source, src_index);
+      rb_ary_store(pixels, index, pixel);
+      index++;
+    }
+  }
+
+  xfree(steps_x);
+  steps_x = NULL;
+
+  xfree(steps_y);
+  steps_y = NULL;
+
+  rb_iv_set(self, "@pixels", pixels);
+  rb_iv_set(self, "@width", LONG2NUM(new_width));
+  rb_iv_set(self, "@height", LONG2NUM(new_height));
+
+  return self;
+}
+
+VALUE oily_png_canvas_resample_bilinear_bang(VALUE self, VALUE v_new_width, VALUE v_new_height) {
+  long new_width = NUM2LONG(v_new_width);
+  long new_height = NUM2LONG(v_new_height);
+
+  long self_width = NUM2LONG(rb_funcall(self, rb_intern("width"), 0));
+  long self_height = NUM2LONG(rb_funcall(self, rb_intern("height"), 0));
+
+  VALUE pixels = rb_ary_new2(new_width*new_height);
+  VALUE source = rb_iv_get(self, "@pixels");
+
+  long *index_x = ALLOC_N(long, new_width);
+  long *index_y = ALLOC_N(long, new_height);
+  long *interp_x = ALLOC_N(long, new_width);
+  long *interp_y = ALLOC_N(long, new_height);
+
+  oily_png_generate_steps_residues(self_width, new_width, index_x, interp_x);
+  oily_png_generate_steps_residues(self_height, new_height, index_y, interp_y);
+
+  long index = 0;
+  long x, y;
+  long y1, y2, x1, x2;
+  PIXEL y_residue, x_residue;
+  PIXEL pixel_11, pixel_21, pixel_12, pixel_22;
+  PIXEL pixel_top, pixel_bot;
+  for (y = 0; y < new_height; y++) {
+    y1 = index_y[y] < 0 ? 0 : index_y[y];
+    y2 = y1+1 >= self_height ? self_height-1 : y1+1;
+    y_residue = interp_y[y];
+
+    for (x = 0; x < new_width; x++) {
+      x1 = index_x[x] < 0 ? 0 : index_x[x];
+      x2 = x1+1 >= self_width ? self_height-1 : x1+1;
+      x_residue = interp_x[x];
+
+      pixel_11 = NUM2UINT(rb_ary_entry(source, y1*self_width + x1));
+      pixel_21 = NUM2UINT(rb_ary_entry(source, y1*self_width + x2));
+      pixel_12 = NUM2UINT(rb_ary_entry(source, y2*self_width + x1));
+      pixel_22 = NUM2UINT(rb_ary_entry(source, y2*self_width + x2));
+
+      pixel_top = oily_png_color_interpolate_quick(pixel_21, pixel_11, x_residue);
+      pixel_bot = oily_png_color_interpolate_quick(pixel_22, pixel_12, x_residue);
+
+      rb_ary_store(pixels, index++, UINT2NUM(oily_png_color_interpolate_quick(pixel_bot, pixel_top, y_residue)));
+    }
+  }
+
+  xfree(index_x);
+  xfree(index_y);
+  xfree(interp_x);
+  xfree(interp_y);
+  interp_x = NULL;
+  interp_y = NULL;
+
+  rb_iv_set(self, "@pixels", pixels);
+  rb_iv_set(self, "@width", LONG2NUM(new_width));
+  rb_iv_set(self, "@height", LONG2NUM(new_height));
+
+  return self;
+}