oil 0.0.1 → 0.0.2

data/README.rdoc

@@ -4,34 +4,59 @@ http://github.com/ender672/oil
 
 == DESCRIPTION:
 
-Resize JPEG images.
+Oil resizes JPEG and PNG images.
+
+== INSTALLATION:
+
+  $ gem install oil
 
 == SYNOPSIS:
 
-  # Resize a JPEG image
   require 'oil'
-
   io = File.open('image.jpg', 'rb')
+
+  # prepare to resize JPEG to fit in a 200x300 box, preserving aspect ratio
   jpeg = Oil::JPEG.new(io, 200, 300)
-  jpeg.each do |data|
-    # yields successive parts of the jpeg file
-  end
+
+  # yield successive parts of the resized and compressed JPEG file
+  jpeg.each { |data| }
 
 == REQUIREMENTS:
 
-* IJG JPEG Library Version 6b or later.
+* IJG JPEG Library or libjpeg-turbo.
+* libpng
 
 Installing libjpeg headers (OSX):
 
   $ brew install libjpeg # requires homebrew (http://mxcl.github.com/homebrew/)
 
-Installing libjpeg headers (Debian/Ubuntu):
+Installing libjpeg and libpng headers (Debian/Ubuntu):
 
-  $ sudo apt-get install libjpeg-dev
+  $ sudo apt-get install libjpeg-dev libpng-dev
 
-== INSTALLATION:
+== COMPILING & TESTING:
 
-  $ gem install oil
+Compile & run unit tests. Should show no warnings and no failing tests:
+
+  $ rake compile
+  $ rake test
+
+Valgrind should not complain (ruby-1.9.3p125, compiled with -O3):
+
+  $ valgrind /path/to/ruby -Iext test/test_jpeg.rb
+  $ valgrind --suppressions=test/valgrind_suppressions.txt /path/to/ruby -Iext test/test_png.rb
+
+Tests should not leak memory:
+
+  $ ruby -Iext:test -e "require 'test_jpeg.rb'; require 'test_png.rb'; loop{ MiniTest::Unit.new.run }"
+
+Changes to the interpolator should be analyzed using ResampleScope:
+
+  https://github.com/jsummers/resamplescope
+
+== TODO:
+
+* JRuby
 
 == LICENSE:
 

data/Rakefile

@@ -13,13 +13,6 @@ file 'ext/oil.so' => FileList.new('ext/Makefile', 'ext/oil.c') do
   end
 end
 
-desc 'Clean up Rubinius .rbc files.'
-namespace :clean do
-  task :rbc do
-    system "find . -name *.rbc -delete"
-  end
-end
-
 Rake::TestTask.new do |t|
   t.libs = ['ext']
   t.test_files = FileList['test/test*.rb']
@@ -28,11 +21,6 @@ end
 CLEAN.add('ext/*{.o,.so,.log}', 'ext/Makefile')
 CLOBBER.add('*.gem')
 
-desc 'Build the gem'
-task :gem do
-  system "gem build oil.gemspec"
-end
-
 desc 'Compile the extension'
 task :compile => "ext/oil.so"
 

data/ext/extconf.rb

@@ -1,6 +1,16 @@
 require 'mkmf'
 
+# OSX by default keeps libpng in the X11 dirs
+if RUBY_PLATFORM =~ /darwin/
+  png_idefault = '/usr/X11/include'
+  png_ldefault = '/usr/X11/lib'
+else
+  png_idefault = nil
+  png_ldefault = nil
+end
+
 dir_config('jpeg')
+dir_config('png', png_idefault, png_ldefault)
 
 unless have_header('jpeglib.h')
   abort "libjpeg headers were not found."
@@ -10,4 +20,12 @@ unless have_library('jpeg')
   abort "libjpeg was not found."
 end
 
+unless have_header('png.h')
+  abort "libpng headers were not found."
+end
+
+unless have_library('png')
+  abort "libpng was not found."
+end
+
 create_makefile('oil')

data/ext/oil.c

@@ -1,5 +1,6 @@
 #include <ruby.h>
 #include <jpeglib.h>
+#include <png.h>
 
 #define BUF_LEN 8192
 
@@ -24,6 +25,22 @@ struct jpeg_src {
     VALUE buffer;
 };
 
+struct png_src {
+    VALUE io;
+    VALUE buffer;
+};
+
+struct interpolation {
+  long sw;
+  long sh;
+  long dw;
+  long dh;
+  int cmp;
+  void (*read)(char *, void *);
+  void (*write)(char *, void *);
+  void *data;
+};
+
 /* jpeglib error callbacks */
 
 static void output_message(j_common_ptr cinfo) {}
@@ -48,7 +65,7 @@ fill_input_buffer(j_decompress_ptr cinfo)
     VALUE ret, string = src->buffer;
     long len;
     char *buf;
-    
+
     ret = rb_funcall(src->io, id_read, 2, INT2FIX(BUF_LEN), string);
     len = RSTRING_LEN(string);
 
@@ -106,124 +123,173 @@ term_destination(j_compress_ptr cinfo)
     }
 }
 
-/* Helper functions */
+/* libpng error callbacks */
+
+static void png_warning_fn(png_structp png_ptr, png_const_charp message) {}
 
 static void
-advance_scanlines(struct jpeg_decompress_struct *dinfo, JSAMPROW *sl1,
-		  JSAMPROW *sl2, int n)
+png_error_fn(png_structp png_ptr, png_const_charp message)
+{
+    rb_raise(rb_eRuntimeError, "pnglib: %s", message);
+}
+
+/* libpng io callbacks */
+
+void png_flush_data(png_structp png_ptr){}
+
+void
+png_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+    if (!png_ptr) return;
+    rb_yield(rb_str_new(data, length));
+}
+
+void
+png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
 {
-    int i;
-    JSAMPROW tmp;
-    for (i = 0; i < n; i++) {
+    VALUE string;
+    png_size_t rlen;
+    struct png_src *io_ptr;
+
+    if (!png_ptr) return;
+    io_ptr = (struct png_src *)png_get_io_ptr(png_ptr);
+    string = io_ptr->buffer;
+    rb_funcall(io_ptr->io, id_read, 2, INT2FIX(length), string);
+    rlen = RSTRING_LEN(string);
+    if (rlen > length) rb_raise(rb_eRuntimeError, "IO return buffer is too big.");
+    memcpy(data, RSTRING_PTR(string), RSTRING_LEN(string));
+}
+
+/* png read/write callbacks */
+
+static void
+png_read(char *sl, void *data)
+{
+    void **data_ary = (void **)data;
+    png_read_row((png_structp)data_ary[2], (png_bytep)sl, (png_bytep)NULL);
+}
+
+static void
+png_write(char *sl, void *data)
+{
+    void **data_ary = (void **)data;
+    png_write_row((png_structp)*data_ary, (png_bytep)sl);
+}
+
+/* Bilinear Interpolation */
+
+static void
+bilinear_get_scanlines(struct interpolation *bi, char **sl1, char **sl2,
+		       size_t *next, double ysmp)
+{
+    int i, j, n, len=bi->cmp * bi->sw - 1;
+    int line=ysmp;
+    char *tmp;
+
+    n = line + 1 - *next;
+    if (line < bi->sh - 1) n++;
+    *next += n;
+    
+    for (i=0; i<n; i++) {
 	tmp = *sl1;
 	*sl1 = *sl2;
 	*sl2 = tmp;
-	jpeg_read_scanlines(dinfo, sl2, 1);
+	bi->read(*sl2, bi->data);
+
+	for (j=0; j<bi->cmp; j++)
+	    sl2[0][len + bi->cmp - j] = sl2[0][len - j];
     }
+
+    if (line >= bi->sh - 1) *sl1 = *sl2;
 }
 
 static void
-bilinear3(struct jpeg_compress_struct *cinfo, char *sl1, char *sl2,
-	  char *sl_out, double width_ratio_inv, double ty)
+bilinear3(char *sl1, char *sl2, char *sl_out, size_t sw, size_t dw, int cmp,
+	  double ysmp)
 {
-    double sample_x, tx, _tx, p00, p10, p01, p11;
-    unsigned char *c00, *c10, *c01, *c11;
-    size_t sample_x_i, i, j, cmp = cinfo->input_components;
+    double xsmp, tx, _tx, p1, p2, p3, p4;
+    unsigned char *c1, *c2, *c3, *c4;
+    size_t xsmp_i, i, j;
+    double xscale_inv, xscale_ctr, ty;
     
-    for (i = 0; i < cinfo->image_width; i++) {
-	sample_x = i * width_ratio_inv;
-	sample_x_i = (int)sample_x;
+    xscale_inv = sw / (float)dw;
+    xscale_ctr = (xscale_inv - 1) / 2;
+    ty = ysmp - (int)ysmp;
 
-	tx = sample_x - sample_x_i;
+    for (i = 0; i < dw; i++) {
+	xsmp = i * xscale_inv + xscale_ctr;
+	xsmp_i = (int)xsmp;
+
+	tx = xsmp - xsmp_i;
 	_tx = 1 - tx;
 
-	p11 =  tx * ty;
-	p01 = _tx * ty;
-	p10 =  tx - p11;
-	p00 = _tx - p01;
+	p4 =  tx * ty;
+	p3 = _tx * ty;
+	p2 =  tx - p4;
+	p1 = _tx - p3;
 
-	c00 = sl1 + sample_x_i * cmp;
-	c10 = c00 + cmp;
-	c01 = sl2 + sample_x_i * cmp;
-	c11 = c01 + cmp;
+	c1 = sl1 + xsmp_i * cmp;
+	c2 = c1 + cmp;
+	c3 = sl2 + xsmp_i * cmp;
+	c4 = c3 + cmp;
 
 	for (j = 0; j < cmp; j++)
-	    *sl_out++ = p00 * c00[j] + p10 * c10[j] + p01 * c01[j] +
-			 p11 * c11[j];
+	    *sl_out++ = p1 * c1[j] + p2 * c2[j] + p3 * c3[j] + p4 * c4[j];
     }
 }
 
 static VALUE
-bilinear2(VALUE *args)
+bilinear2(VALUE _args)
 {
-    struct jpeg_compress_struct *cinfo;
-    struct jpeg_decompress_struct *dinfo;
-    size_t i, smpy_i, smpy_last=0, sl_len;
-    double smpy, ty, inv_scale_y, inv_scale_x;
-    JSAMPROW sl1, sl2, sl_out;
-
-    cinfo = (struct jpeg_compress_struct *)args[0];
-    dinfo = (struct jpeg_decompress_struct *)args[1];
-    sl_len = *(size_t *)args[2];
-    sl1 = (JSAMPROW)args[3];
-    sl2 = (JSAMPROW)args[4];
-    sl_out = (JSAMPROW)args[5];
-
-    inv_scale_x = dinfo->output_width / (float)cinfo->image_width;
-    inv_scale_y = dinfo->output_height / (float)cinfo->image_height;
-    advance_scanlines(dinfo, &sl1, &sl2, 1);
-
-    for (i = 0; i < cinfo->image_height; i++) {
-	smpy = i * inv_scale_y;
-	smpy_i = (int)smpy;
-	ty = smpy - smpy_i;
-	
-	advance_scanlines(dinfo, &sl1, &sl2, smpy_i - smpy_last);
-	smpy_last = smpy_i;
-
-	sl1[sl_len - 1] = sl1[sl_len - 2];
-	sl2[sl_len - 1] = sl2[sl_len - 2];
-	bilinear3(cinfo, smpy_i ? sl1 : sl2, sl2, sl_out, inv_scale_x, ty);
-	jpeg_write_scanlines(cinfo, &sl_out, 1);
-    }
+    VALUE *args = (VALUE *)_args;
+    struct interpolation *bi=(struct interpolation *)args[0];
+    char *sl1=(char *)args[1], *sl2=(char *)args[2], *sl_out=(char *)args[3];
+    size_t i, line=0;
+    double ysmp, yscale_inv, yscale_ctr;
 
-    return Qnil;
-}
+    yscale_inv = bi->sh / (float)bi->dh;
+    yscale_ctr = (yscale_inv - 1) / 2;
+
+    for (i = 0; i<bi->dh; i++) {
+	ysmp = i * yscale_inv + yscale_ctr;
+
+	bilinear_get_scanlines(bi, &sl1, &sl2, &line, ysmp);
+	bilinear3(sl1, sl2, sl_out, bi->sw, bi->dw, bi->cmp, ysmp);
+	bi->write(sl_out, bi->data);
+    }
 
-static VALUE
-free_sl_bufs(VALUE *args)
-{
-    free((char *)args[3]);
-    free((char *)args[4]);
-    free((char *)args[5]);
     return Qnil;
 }
 
 static void
-bilinear(struct jpeg_compress_struct *cinfo,
-	 struct jpeg_decompress_struct *dinfo)
+bilinear(struct interpolation *bi)
 {
-    VALUE ensure_args[6];
-    size_t sl_len;
-    JSAMPROW sl1, sl2, sl_out;
-    
-    sl_len = (dinfo->output_width + 1) * dinfo->output_components;    
-    sl1 = (JSAMPROW)malloc(sl_len);
-    sl2 = (JSAMPROW)malloc(sl_len);
-    sl_out = (JSAMPROW)malloc(cinfo->image_width * cinfo->input_components);
-
-    ensure_args[0] = (VALUE)cinfo;
-    ensure_args[1] = (VALUE)dinfo;
-    ensure_args[2] = (VALUE)&sl_len;
-    ensure_args[3] = (VALUE)sl1;
-    ensure_args[4] = (VALUE)sl2;
-    ensure_args[5] = (VALUE)sl_out;
-    rb_ensure(bilinear2, (VALUE)ensure_args, free_sl_bufs, (VALUE)ensure_args);
+    VALUE args[4];
+    int state, in_len;
+    char *sl1, *sl2, *sl_out;
+
+    in_len = (bi->sw + 1) * bi->cmp;
+    sl1 = malloc(in_len);
+    sl2 = malloc(in_len);
+    sl_out = malloc(bi->dw * bi->cmp);
+
+    args[0] = (VALUE)bi;
+    args[1] = (VALUE)sl1;
+    args[2] = (VALUE)sl2;
+    args[3] = (VALUE)sl_out;
+    rb_protect(bilinear2, (VALUE)args, &state);
+
+    free(sl1);
+    free(sl2);
+    free(sl_out);
+ 
+    if (state) rb_jump_tag(state);
 }
 
+/* JPEG helper functions */
+
 static void
-fix_aspect_ratio(struct jpeg_compress_struct *cinfo,
-		 struct jpeg_decompress_struct *dinfo)
+jpeg_fix_aspect_ratio(j_compress_ptr cinfo, j_decompress_ptr dinfo)
 {
     double x, y;
 
@@ -235,22 +301,15 @@ fix_aspect_ratio(struct jpeg_compress_struct *cinfo,
 }
 
 static void
-set_header(VALUE self, struct jpeg_compress_struct *cinfo,
-	   struct jpeg_decompress_struct *dinfo)
+jpeg_set_output_header(j_compress_ptr cinfo, j_decompress_ptr dinfo)
 {
-    struct thumbdata *data;
-    Data_Get_Struct(self, struct thumbdata, data);
-    
-    cinfo->image_width = data->width;
-    cinfo->image_height = data->height;
     cinfo->input_components = dinfo->output_components;
     cinfo->in_color_space = dinfo->out_color_space;
     jpeg_set_defaults(cinfo);
 }
 
 static void
-pre_scale(struct jpeg_compress_struct *cinfo,
-	  struct jpeg_decompress_struct *dinfo)
+jpeg_pre_scale(j_compress_ptr cinfo, j_decompress_ptr dinfo)
 {
     int inv_scale = dinfo->output_width / cinfo->image_width;
 
@@ -260,6 +319,86 @@ pre_scale(struct jpeg_compress_struct *cinfo,
     jpeg_calc_output_dimensions(dinfo);
 }
 
+static void
+jpeg_read(char *sl, void *data)
+{
+    void **data_ary = (void **)data;
+    jpeg_read_scanlines((j_decompress_ptr)*data_ary, (JSAMPROW *)&sl, 1);
+}
+
+static void
+jpeg_write(char *sl, void *data)
+{
+    void **data_ary = (void **)data;
+    jpeg_write_scanlines((j_compress_ptr)data_ary[1], (JSAMPROW *)&sl, 1);
+}
+
+static VALUE
+jpeg_each3(VALUE _args)
+{
+    VALUE *args = (VALUE *)_args;
+    j_decompress_ptr dinfo = (j_decompress_ptr)args[0];
+    j_compress_ptr cinfo = (j_compress_ptr)args[1];
+    struct interpolation intrp;
+    void *data[2];
+
+    jpeg_read_header(dinfo, TRUE);
+    jpeg_calc_output_dimensions(dinfo);
+    jpeg_set_output_header(cinfo, dinfo);
+    jpeg_fix_aspect_ratio(cinfo, dinfo);
+    jpeg_pre_scale(cinfo, dinfo);
+
+    jpeg_start_compress(cinfo, TRUE);
+    jpeg_start_decompress(dinfo);
+
+    intrp.sw = dinfo->output_width;
+    intrp.sh = dinfo->output_height;
+    intrp.dw = cinfo->image_width;
+    intrp.dh = cinfo->image_height;
+    intrp.cmp = dinfo->output_components;
+    intrp.read = jpeg_read;
+    intrp.write = jpeg_write;
+    data[0] = dinfo;
+    data[1] = cinfo;
+    intrp.data = (void *)data;
+
+    bilinear(&intrp);
+    //nearest(&intrp);
+
+    jpeg_abort_decompress(dinfo);
+    jpeg_finish_compress(cinfo);
+
+    return Qnil;
+}
+
+static void
+jpeg_each2(struct thumbdata *data, struct jpeg_src *src, struct jpeg_dest *dest)
+{
+    int state;
+    VALUE args[2];
+    struct jpeg_decompress_struct dinfo;
+    struct jpeg_compress_struct cinfo;
+
+    dinfo.err = cinfo.err = &jerr;
+
+    jpeg_create_compress(&cinfo);
+    cinfo.dest = &dest->mgr;
+    cinfo.image_width = data->width;
+    cinfo.image_height = data->height;
+
+    jpeg_create_decompress(&dinfo);
+    dinfo.src = &src->mgr;
+
+    args[0] = (VALUE)&dinfo;
+    args[1] = (VALUE)&cinfo;
+    rb_protect(jpeg_each3, (VALUE)args, &state);
+
+    jpeg_destroy_decompress(&dinfo);
+    jpeg_destroy_compress(&cinfo);
+
+    if (state) rb_jump_tag(state);
+}
+
 /* Ruby allocator, deallocator, mark, and methods */
 
 static void
@@ -284,113 +423,151 @@ allocate(VALUE klass)
 
 /*
  *  call-seq:
- *     JPEGThumb.new(io, width, height) -> jpeg_thumb
+ *     Class.new(io, width, height) -> obj
  *
- *  Creates a new JPEG thumbnailer. +io_in+ must be an IO-like object that
- *  responds to #read(size).
+ *  Creates a new resizer. +io_in+ must be an IO-like object that responds to
+ *  #read(size, buffer) and #seek(size).
  * 
  *  The resulting image will be scaled to fit in the box given by +width+ and
- *  +height+ while preserving the aspect ratio.
- * 
- *  If both box dimensions are larger than the source image, then the image will
- *  be unchanged. The thumbnailer will not enlarge images.
+ *  +height+ while preserving the original aspect ratio.
  */
 
 static VALUE
-initialize(VALUE self, VALUE io, VALUE width, VALUE height)
+initialize(VALUE self, VALUE io, VALUE rb_width, VALUE rb_height)
 {
+    int width=FIX2INT(rb_width), height=FIX2INT(rb_height);
     struct thumbdata *data;
+    
+    if (width<1 || height<1) rb_raise(rb_eArgError, "Dimensions must be > 0");
 
     Data_Get_Struct(self, struct thumbdata, data);
     data->io = io;
-    data->width = FIX2INT(width);
-    data->height = FIX2INT(height);
+    data->width = width;
+    data->height = height;
 
     return self;
 }
 
-static VALUE
-each2(VALUE *args)
-{
-    VALUE self = args[0];
-    struct jpeg_decompress_struct *dinfo;
-    struct jpeg_compress_struct *cinfo;
-
-    dinfo = (struct jpeg_decompress_struct *)args[1];
-    cinfo = (struct jpeg_compress_struct *)args[2];
-
-    jpeg_read_header(dinfo, TRUE);
-    jpeg_calc_output_dimensions(dinfo);
-    set_header(self, cinfo, dinfo);
-    fix_aspect_ratio(cinfo, dinfo);
-    pre_scale(cinfo, dinfo);
-    
-    jpeg_start_compress(cinfo, TRUE);
-    jpeg_start_decompress(dinfo);
-
-    bilinear(cinfo, dinfo);
-
-    jpeg_abort_decompress(dinfo);
-    jpeg_finish_compress(cinfo);
-
-    return Qnil;
-}
-
-static VALUE
-destroy_info(VALUE *args)
-{
-    jpeg_destroy_decompress((struct jpeg_decompress_struct *)args[1]);
-    jpeg_destroy_compress((struct jpeg_compress_struct *)args[2]);
-    return Qnil;
-}
-
 /*
  *  call-seq:
- *     resized_jpeg.each(&block) -> self
+ *     jpeg.each(&block) -> self
  *
  *  Yields a series of binary strings that make up the resized JPEG image.
  */
 
 static VALUE
-each(VALUE self)
+jpeg_each(VALUE self)
 {
-    VALUE ensure_args[3];
     struct jpeg_src src;
-    struct jpeg_decompress_struct dinfo;
     struct jpeg_dest dest;
-    struct jpeg_compress_struct cinfo;
     struct thumbdata *data;
     Data_Get_Struct(self, struct thumbdata, data);
 
-    dinfo.err = cinfo.err = &jerr;
-    jpeg_create_decompress(&dinfo);
-    jpeg_create_compress(&cinfo);
-
     memset(&src, 0, sizeof(struct jpeg_src));
+    src.io = data->io;
+    src.buffer = rb_str_new(0, 0);
     src.mgr.init_source = init_source;
     src.mgr.fill_input_buffer = fill_input_buffer;
     src.mgr.skip_input_data = skip_input_data;
     src.mgr.resync_to_restart = jpeg_resync_to_restart;
     src.mgr.term_source = term_source;
-    src.io = data->io;
-    src.buffer = rb_str_new(0, BUF_LEN);
 
     memset(&dest, 0, sizeof(struct jpeg_dest));
+    dest.buffer = rb_str_new(0, BUF_LEN);    
+    dest.mgr.next_output_byte = RSTRING_PTR(dest.buffer);
+    dest.mgr.free_in_buffer = BUF_LEN;
     dest.mgr.init_destination = init_destination;
     dest.mgr.empty_output_buffer = empty_output_buffer;
     dest.mgr.term_destination = term_destination;
-    dest.buffer = rb_str_new(0, BUF_LEN);
-    dest.mgr.next_output_byte = RSTRING_PTR(dest.buffer);
-    dest.mgr.free_in_buffer = BUF_LEN;
 
-    dinfo.src = (struct jpeg_source_mgr *)&src;
-    cinfo.dest = (struct jpeg_destination_mgr *)&dest;
+    jpeg_each2(data, &src, &dest);
+
+    return self;
+}
+
+static VALUE
+png_each2(VALUE _args)
+{
+    VALUE *args = (VALUE *)_args;
+    png_structp write_ptr=(png_structp)args[0];
+    png_infop write_i_ptr=(png_infop)args[1];
+    png_structp read_ptr=(png_structp)args[2];
+    png_infop read_i_ptr=(png_infop)args[3];
+    struct thumbdata *thumb=(struct thumbdata *)args[4];
+    void *data[4];
+    struct interpolation intrp;
+
+    png_read_info(read_ptr, read_i_ptr);
+    png_set_IHDR(write_ptr, write_i_ptr, thumb->width, thumb->height, 8,
+		 PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE,
+		 PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+    png_write_info(write_ptr, write_i_ptr);
+
+    intrp.sw = png_get_image_width(read_ptr, read_i_ptr);
+    intrp.sh = png_get_image_height(read_ptr, read_i_ptr);
+    intrp.dw = thumb->width;
+    intrp.dh = thumb->height;
+    intrp.cmp = 3;
+    intrp.read = png_read;
+    intrp.write = png_write;
+    data[0] = write_ptr;
+    data[1] = write_i_ptr;
+    data[2] = read_ptr;
+    data[3] = read_i_ptr;
+    intrp.data = (void *)data;
+
+    bilinear(&intrp);
+    
+    png_read_end(read_ptr, (png_infop)NULL);
+    png_write_end(write_ptr, write_i_ptr);
+    
+    return Qnil;
+}
 
-    ensure_args[0] = self;
-    ensure_args[1] = (VALUE)&dinfo;
-    ensure_args[2] = (VALUE)&cinfo;
-    rb_ensure(each2, (VALUE)ensure_args, destroy_info, (VALUE)ensure_args);
+/*
+ *  call-seq:
+ *     png.each(&block) -> self
+ *
+ *  Yields a series of binary strings that make up the resized PNG image.
+ */
 
+static VALUE
+png_each(VALUE self)
+{
+    int state;
+    VALUE args[5];
+    png_structp read_ptr, write_ptr;
+    png_infop read_i_ptr, write_i_ptr;
+    struct png_src src;
+    struct thumbdata *thumb;
+    Data_Get_Struct(self, struct thumbdata, thumb);
+
+    write_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, (png_voidp)NULL,
+				      (png_error_ptr)png_error_fn,
+				      (png_error_ptr)png_warning_fn);
+    write_i_ptr = png_create_info_struct(write_ptr);
+    png_set_write_fn(write_ptr, NULL, png_write_data, png_flush_data);
+
+    src.io = thumb->io;
+    src.buffer = rb_str_new(0, 0);    
+
+    read_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, (png_voidp)NULL,
+				     (png_error_ptr)png_error_fn,
+				     (png_error_ptr)png_warning_fn);
+    read_i_ptr = png_create_info_struct(read_ptr);
+    png_set_read_fn(read_ptr, (void *)&src, png_read_data);
+
+    args[0] = (VALUE)write_ptr;
+    args[1] = (VALUE)write_i_ptr;
+    args[2] = (VALUE)read_ptr;
+    args[3] = (VALUE)read_i_ptr;
+    args[4] = (VALUE)thumb;
+    rb_protect(png_each2, (VALUE)args, &state);
+
+    png_destroy_read_struct(&read_ptr, &read_i_ptr, (png_info **)NULL);
+    png_destroy_write_struct(&write_ptr, &write_i_ptr);
+
+    if (state) rb_jump_tag(state);
     return self;
 }
 
@@ -398,10 +575,16 @@ void
 Init_oil()
 {
     VALUE mOil = rb_define_module("Oil");
+
     VALUE cJPEG = rb_define_class_under(mOil, "JPEG", rb_cObject);
     rb_define_alloc_func(cJPEG, allocate);
     rb_define_method(cJPEG, "initialize", initialize, 3);
-    rb_define_method(cJPEG, "each", each, 0);
+    rb_define_method(cJPEG, "each", jpeg_each, 0);
+    
+    VALUE cPNG = rb_define_class_under(mOil, "PNG", rb_cObject);
+    rb_define_alloc_func(cPNG, allocate);
+    rb_define_method(cPNG, "initialize", initialize, 3);
+    rb_define_method(cPNG, "each", png_each, 0);
 
     jpeg_std_error(&jerr);
     jerr.error_exit = error_exit;
@@ -410,4 +593,3 @@ Init_oil()
     id_read = rb_intern("read");
     id_seek = rb_intern("seek");
 }
-

data/test/test_jpeg.rb

@@ -16,21 +16,21 @@ module Oil
 \x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xDA\x00\x08\x01\x01\x00\x01\x3F\
 \x10\xFF\xD9"
 
-    def test_valid_jpeg
+    def test_valid
       validate_jpeg resize_string(JPEG_DATA)
     end
 
-    def test_jpeg_missing_eof
+    def test_missing_eof
       validate_jpeg resize_string(JPEG_DATA[0..-2])
     end
 
-    def test_jpeg_bogus_header_marker
+    def test_bogus_header_marker
       str = JPEG_DATA.dup
       str[3] = "\x10"
       assert_raises(RuntimeError) { resize_string(str) }
     end
 
-    def test_jpeg_bogus_body_marker
+    def test_bogus_body_marker
       str = JPEG_DATA.dup
       str[-1] = "\x10"
       assert_raises(RuntimeError) { resize_string(str) }
@@ -44,6 +44,21 @@ module Oil
       end
     end
     
+    def test_alloc_each
+      io = JPEG.allocate
+      assert_raises(NoMethodError){ io.each{ |f| } }
+    end
+    
+    # Test dimensions
+    
+    def test_zero_dim
+      assert_raises(ArgumentError){ resize_string(JPEG_DATA, 0, 0) }
+    end
+    
+    def test_neg_dim
+      assert_raises(ArgumentError){ resize_string(JPEG_DATA, -1231, -123) }
+    end
+    
     # Test io source handler
     
     def test_io_returns_too_much_data
@@ -52,7 +67,6 @@ module Oil
         buf << (io.read(size)[0..-2] * 2)
       end
       assert_raises(RuntimeError) { custom_io proc, JPEG_DATA }
-      #custom_io proc, JPEG_DATA
     end
     
     def test_io_does_nothing

data/test/test_png.rb

@@ -0,0 +1,197 @@
+require 'rubygems'
+require 'minitest/autorun'
+require 'oil'
+require 'stringio'
+
+module Oil
+  class TestPNG < MiniTest::Unit::TestCase
+    # http://garethrees.org/2007/11/14/pngcrush/
+    PNG_DATA = "\
+\x89\x50\x4E\x47\x0D\x0A\x1A\x0A\x00\x00\x00\x0D\x49\x48\x44\x52\x00\x00\x00\
+\x01\x00\x00\x00\x01\x01\x00\x00\x00\x00\x37\x6E\xF9\x24\x00\x00\x00\x10\x49\
+\x44\x41\x54\x78\x9C\x62\x60\x01\x00\x00\x00\xFF\xFF\x03\x00\x00\x06\x00\x05\
+\x57\xBF\xAB\xD4\x00\x00\x00\x00\x49\x45\x4E\x44\xAE\x42\x60\x82"
+
+    def test_valid
+      validate_png resize_string(PNG_DATA)
+    end
+
+    def test_bogus_header_chunk
+      str = PNG_DATA.dup
+      str[15] = "\x10"
+      assert_raises(RuntimeError) { resize_string(str) }
+    end
+
+    def test_bogus_body_chunk
+      str = PNG_DATA.dup
+      str[37] = "\x10"
+      assert_raises(RuntimeError) { resize_string(str) }
+    end
+
+    def test_bogus_end_chunk
+      str = PNG_DATA.dup
+      str[-6] = "\x10"
+      assert_raises(RuntimeError) { resize_string(str) }      
+    end
+
+    def test_calls_each_during_yield
+      io = StringIO.new(PNG_DATA)
+      j = PNG.new(io, 600, 600)
+      assert_raises(RuntimeError) do
+        j.each{ |d| j.each { |e| j.each { |f| } } }
+      end
+    end
+    
+    def test_alloc_each
+      io = PNG.allocate
+      assert_raises(NoMethodError){ io.each{ |f| } }
+    end
+
+    # Test dimensions
+    
+    def test_zero_dim
+      assert_raises(ArgumentError){ resize_string(PNG_DATA, 0, 0) }
+    end
+    
+    def test_neg_dim
+      assert_raises(ArgumentError){ resize_string(PNG_DATA, -1231, -123) }
+    end
+    
+    # Test io source handler
+    
+    def test_io_returns_too_much_data
+      proc = Proc.new do |io, size, buf|
+        buf.slice!(0,0)
+        buf << (io.read(size)[0..-2] * 2)
+      end
+      assert_raises(RuntimeError) { custom_io proc, PNG_DATA }
+    end
+    
+    def test_io_does_nothing
+      assert_raises(RuntimeError) { custom_io(nil) }
+    end
+
+    def test_io_raises_exception_immediately
+      proc = Proc.new{ raise CustomError }
+      assert_raises(CustomError) { custom_io proc }
+    end
+
+    def test_io_throws_immediately
+      proc = Proc.new{ throw(:foo) }
+      catch(:foo){ custom_io proc }
+    end
+    
+    def test_io_raises_exception_in_body
+      flag = false
+      proc = Proc.new do |parent, size, buf|
+        raise CustomError if flag
+        flag = true
+        parent.read(size, buf)
+      end
+      assert_raises(CustomError) { custom_io proc, big_png }
+    end
+
+    def test_io_throws_in_body
+      flag = false
+      proc = Proc.new do |parent, size, buf|
+        throw :foo if flag
+        flag = true
+        parent.read(size, buf)
+      end
+      catch(:foo){ custom_io proc, big_png }
+    end
+
+    def test_io_shrinks_buffer
+      proc = Proc.new do |parent, size, buf|
+        parent.read(size, buf)
+        buf.slice!(0, 10)
+      end
+      assert_raises(RuntimeError) { custom_io(proc, big_png) }
+    end
+
+    def test_io_enlarges_buffer
+      proc = Proc.new do |parent, size, buf|
+        res = parent.read(size, buf)
+        buf << res
+      end
+      assert_raises(RuntimeError) { validate_jpeg custom_io(proc, big_png) }
+    end
+
+    # Test yielding
+
+    def test_raise_in_each
+      assert_raises(CustomError) do
+        io = StringIO.new(PNG_DATA)
+        PNG.new(io, 200, 200).each { raise CustomError }
+      end
+    end
+
+    def test_throw_in_each
+      catch(:foo) do
+        io = StringIO.new(PNG_DATA)
+        PNG.new(io, 200, 200).each { throw :foo }
+      end
+    end
+
+    def test_each_shrinks_buffer
+      io = StringIO.new(PNG_DATA)
+      io_out = binary_stringio
+      PNG.new(io, 200, 200).each { |d| io_out << d; d.slice!(0, 4) }
+      validate_png(io_out.string)
+    end
+    
+    def test_each_enlarges_buffer
+      io = StringIO.new(PNG_DATA)
+      io_out = binary_stringio
+      PNG.new(io, 200, 200).each { |d| io_out << d; d << "foobar" }
+      validate_png(io_out.string)
+    end
+
+    private
+    
+    def io(io, width=nil, height=nil)
+      width ||= 100
+      height ||= 200
+      out = binary_stringio
+      PNG.new(io, width, height).each{ |d| out << d }
+      return out.string
+    end
+
+    def custom_io(*args)
+      io CustomIO.new(*args)
+    end
+
+    def resize_string(str, width=nil, height=nil)
+      io(StringIO.new(str), width, height)
+    end
+    
+    def validate_png(data)
+      assert_equal "\x89\x50\x4E\x47\x0D\x0A\x1A\x0A", data[0,8]
+      assert_equal "\x49\x45\x4E\x44\xAE\x42\x60\x82", data[-8, 8]
+    end
+
+    def big_png
+      resize_string(PNG_DATA, 200, 200)
+    end
+
+    def binary_stringio
+      io = StringIO.new
+      io.set_encoding 'ASCII-8BIT' if RUBY_VERSION >= '1.9'
+      io
+    end
+  end
+
+  class CustomError < RuntimeError; end
+
+  class CustomIO
+    def initialize(proc, *args)
+      @parent = StringIO.new(*args)
+      @proc = proc
+    end
+
+    def read(size, buf)
+      @proc.call(@parent, size, buf) if @proc
+    end
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: oil
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-27 00:00:00.000000000 Z
+date: 2012-03-08 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: tle@holymonkey.com
@@ -24,6 +24,7 @@ files:
 - ext/oil.c
 - ext/extconf.rb
 - test/test_jpeg.rb
+- test/test_png.rb
 homepage: http://github.com/ender672/oil
 licenses: []
 post_install_message: 
@@ -47,6 +48,7 @@ rubyforge_project:
 rubygems_version: 1.8.17
 signing_key: 
 specification_version: 3
-summary: Resize JPEG images.
+summary: Oil resizes JPEG and PNG images.
 test_files:
 - test/test_jpeg.rb
+- test/test_png.rb