oil 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fd14ee7146af851bb1e18d91cd713a70245ccd18
-  data.tar.gz: 7f7821f5b3d7f93e916783fdd1d4373a1e7ca9c8
+  metadata.gz: b39dd91704802e2731a0f67da4743ae67c0535ed
+  data.tar.gz: 9f7767d654f542c11a9fec84f3dc4c097004755c
 SHA512:
-  metadata.gz: 3eb3e7645f3a4930ef96932615f06d3802fb5aa200319e22c015d4568cfb2448cbf21e966b5a6cc0775c3ab22d41cca77215a5e23caa203d219310808e71e22d
-  data.tar.gz: 25c9425aff69764f680a521808db27ab76418a1d4bec6428689885ea4d718f47e87d37b79cdd095edc51c2c9fb6616ed9ccdf862fd37a44ed070f7ace61456f4
+  metadata.gz: 2a862073a15ee977727398689263311dd9868c6c66d518cc840a1e5c7a81f638246b62b1d5d32a4dc2a28d8205a36f4327463a025b4dcb67f491711c19f5d2d5
+  data.tar.gz: 14da2b6aea208767826869a19c6fe8ba4824f15fba435ca1e8862adfe8d19603ce3e7e5a48e66cd693a3afa65c9ee923f6834ac49515c7a6751cd8f23b4e12dd

data/README.rdoc

@@ -27,8 +27,6 @@ performance and low memory use.
 
 == REQUIREMENTS:
 
-These requirements do not apply to the JRuby gem.
-
   * libjpeg-turbo
   * libpng
 
@@ -48,10 +46,6 @@ Valgrind should not complain (ruby-1.9.3p125, compiled with -O3):
   $ valgrind /path/to/ruby -Iext:test test/test_jpeg.rb
   $ valgrind /path/to/ruby -Iext:test test/test_png.rb
 
-Tests should not leak memory:
-
-  $ ruby -Iext:test -e "require 'test_jpeg.rb'; require 'test_png.rb'; loop{ MiniTest.run }"
-
 Changes to the interpolator should be analyzed using ResampleScope:
 
   https://github.com/jsummers/resamplescope

data/Rakefile

@@ -6,7 +6,7 @@ Rake::ExtensionTask.new('oil') do |ext|
   ext.lib_dir = 'lib/oil'
 end
 
-s = Gem::Specification.new('oil', '0.1.1') do |s|
+s = Gem::Specification.new('oil', '0.1.2') do |s|
   s.license = 'MIT'
   s.summary = 'Resize JPEG and PNG images.'
   s.description = 'Resize JPEG and PNG images, aiming for fast performance and low memory use.'

data/ext/oil/jpeg.c

@@ -7,7 +7,7 @@
 #define READ_SIZE 1024
 #define WRITE_SIZE 1024
 
-static ID id_GRAYSCALE, id_RGB, id_YCbCr, id_CMYK, id_YCCK, id_UNKNOWN;
+static ID id_GRAYSCALE, id_RGB, id_YCbCr, id_CMYK, id_YCCK, id_RGBX, id_UNKNOWN;
 static ID id_APP0, id_APP1, id_APP2, id_APP3, id_APP4, id_APP5, id_APP6,
 	id_APP7, id_APP8, id_APP9, id_APP10, id_APP11, id_APP12, id_APP13,
 	id_APP14, id_APP15, id_COM;
@@ -49,6 +49,8 @@ static J_COLOR_SPACE sym_to_j_color_space(VALUE sym)
 		return JCS_CMYK;
 	} else if (rb == id_YCCK) {
 		return JCS_YCCK;
+	} else if (rb == id_RGBX) {
+		return JCS_EXT_RGBX;
 	}
 	rb_raise(rb_eRuntimeError, "Color space not recognized.");
 }
@@ -293,10 +295,11 @@ static VALUE initialize(int argc, VALUE *argv, VALUE self)
 	 */
 	if (reader->source_io) {
 		jpeg_abort_decompress(dinfo);
+	} else {
+		jpeg_create_decompress(dinfo);
 	}
 
-	jpeg_create_decompress(&reader->dinfo);
-	reader->dinfo.src = &reader->mgr;
+	dinfo->src = &reader->mgr;
 
 	rb_scan_args(argc, argv, "11", &io, &markers);
 	reader->source_io = io;
@@ -305,13 +308,16 @@ static VALUE initialize(int argc, VALUE *argv, VALUE self)
 	if(!NIL_P(markers)) {
 		Check_Type(markers, T_ARRAY);
 		for (i=0; i<RARRAY_LEN(markers); i++) {
+			if (!SYMBOL_P(RARRAY_PTR(markers)[i])) {
+				rb_raise(rb_eTypeError, "Marker code is not a symbol.");
+			}
 			marker_code = sym_to_marker_code(RARRAY_PTR(markers)[i]);
 			jpeg_save_markers(dinfo, marker_code, 0xFFFF);
 		}
 	}
 
 	/* Be warned that this can raise a ruby exception and longjmp away. */
-	jpeg_read_header(&reader->dinfo, TRUE);
+	jpeg_read_header(dinfo, TRUE);
 
 	jpeg_calc_output_dimensions(dinfo);
 
@@ -320,12 +326,16 @@ static VALUE initialize(int argc, VALUE *argv, VALUE self)
 
 /*
  *  call-seq:
- *     reader.components -> number
+ *     reader.num_components -> number
  *
- *  Retrieve the number of components as stored in the JPEG image.
+ *  Retrieve the number of components per pixel as indicated by the image
+ *  header.
+ *
+ *  This may differ from the number of components that will be returned by the
+ *  decompressor if we ask for a color space transformation.
  */
 
-static VALUE components(VALUE self)
+static VALUE num_components(VALUE self)
 {
 	struct jpeg_decompress_struct * dinfo;
 	Data_Get_Struct(self, struct jpeg_decompress_struct, dinfo);
@@ -334,18 +344,53 @@ static VALUE components(VALUE self)
 
 /*
  *  call-seq:
- *     reader.color_space -> symbol
+ *     reader.output_components -> number
+ *
+ *  Retrieve the number of bytes per pixel that will be in the output image.
  *
- *  Returns a symbol representing the color model in which the JPEG is stored.
+ *  Not all bytes will necessarily have data, since some color spaces have
+ *  padding.
+ */
+
+static VALUE output_components(VALUE self)
+{
+	struct jpeg_decompress_struct * dinfo;
+	Data_Get_Struct(self, struct jpeg_decompress_struct, dinfo);
+	return INT2FIX(dinfo->output_components);
+}
+
+/*
+ *  call-seq:
+ *     reader.out_color_components -> number
  *
- *  This does not have to be set explicitly and can be relied upon when the file
- *  conforms to JFIF or Adobe conventions. Otherwise it is guessed.
+ *  Retrieve the number of components in the output color space.
+ *
+ *  Some color spaces have padding, so this may not accurately represent the
+ *  size of output pixels.
+ */
+
+static VALUE out_color_components(VALUE self)
+{
+	struct jpeg_decompress_struct * dinfo;
+	Data_Get_Struct(self, struct jpeg_decompress_struct, dinfo);
+	return INT2FIX(dinfo->out_color_components);
+}
+
+/*
+ *  call-seq:
+ *     reader.jpeg_color_space -> symbol
+ *
+ *  Returns a symbol representing the color model in which the JPEG is stored,
+ *  as indicated by the image header.
  *
  *  Possible color models are: :GRAYSCALE, :RGB, :YCbCr, :CMYK, and :YCCK. This
  *  method will return :UNKNOWN if the color model is not recognized.
+ *
+ *  This may differ from the color space that will be returned by the
+ *  decompressor if we ask for a color space transformation.
  */
 
-static VALUE color_space(VALUE self)
+static VALUE jpeg_color_space(VALUE self)
 {
 	struct jpeg_decompress_struct * dinfo;
 	ID id;
@@ -370,7 +415,7 @@ static VALUE out_color_space(VALUE self)
 	ID id;
 
 	Data_Get_Struct(self, struct jpeg_decompress_struct, dinfo);
-	id = j_color_space_to_id(dinfo->jpeg_color_space);
+	id = j_color_space_to_id(dinfo->out_color_space);
 
 	return ID2SYM(id);
 }
@@ -379,7 +424,7 @@ static VALUE out_color_space(VALUE self)
  *  call-seq:
  *     reader.out_color_space = symbol
  *
- *  Set the color model to which teh image will be converted on decompress.
+ *  Set the color model to which the image will be converted on decompress.
  */
 
 static VALUE set_out_color_space(VALUE self, VALUE cs)
@@ -389,19 +434,22 @@ static VALUE set_out_color_space(VALUE self, VALUE cs)
 	Data_Get_Struct(self, struct readerdata, reader);
 	raise_if_locked(reader);
 
-	reader->dinfo.jpeg_color_space = sym_to_j_color_space(cs);
+	reader->dinfo.out_color_space = sym_to_j_color_space(cs);
 	jpeg_calc_output_dimensions(&reader->dinfo);
 	return cs;
 }
 
 /*
  *  call-seq:
- *     reader.width -> number
+ *     reader.image_width -> number
  *
- *  Retrieve the width of the image.
+ *  The width of the of the image as indicated by the header.
+ *
+ *  This may differ from the width of the image that will be returned by the
+ *  decompressor if we request DCT scaling.
  */
 
-static VALUE width(VALUE self)
+static VALUE image_width(VALUE self)
 {
 	struct jpeg_decompress_struct * dinfo;
 	Data_Get_Struct(self, struct jpeg_decompress_struct, dinfo);
@@ -410,18 +458,49 @@ static VALUE width(VALUE self)
 
 /*
  *  call-seq:
- *     reader.height -> number
+ *     reader.image_height -> number
+ *
+ *  The height of the image as indicated by the header.
  *
- *  Retrieve the height of the image.
+ *  This may differ from the height of the image that will be returned by the
+ *  decompressor if we request DCT scaling.
  */
 
-static VALUE height(VALUE self)
+static VALUE image_height(VALUE self)
 {
 	struct jpeg_decompress_struct * dinfo;
 	Data_Get_Struct(self, struct jpeg_decompress_struct, dinfo);
 	return INT2FIX(dinfo->image_height);
 }
 
+/*
+ *  call-seq:
+ *     reader.output_width -> number
+ *
+ *  The width of the of the image that will be output by the decompressor.
+ */
+
+static VALUE output_width(VALUE self)
+{
+	struct jpeg_decompress_struct * dinfo;
+	Data_Get_Struct(self, struct jpeg_decompress_struct, dinfo);
+	return INT2FIX(dinfo->output_width);
+}
+
+/*
+ *  call-seq:
+ *     reader.image_height -> number
+ *
+ *  The height of the image that will be output by the decompressor.
+ */
+
+static VALUE output_height(VALUE self)
+{
+	struct jpeg_decompress_struct * dinfo;
+	Data_Get_Struct(self, struct jpeg_decompress_struct, dinfo);
+	return INT2FIX(dinfo->output_height);
+}
+
 /*
  *  call-seq:
  *     reader.markers -> hash
@@ -710,7 +789,12 @@ static VALUE each2(struct write_jpeg_args *args)
 		if (!NIL_P(quality)) {
 			jpeg_set_quality(cinfo, FIX2INT(quality), FALSE);
 		}
+	}
 
+	jpeg_start_compress(cinfo, TRUE);
+	jpeg_start_decompress(dinfo);
+
+	if (!NIL_P(args->opts)) {
 		markers = rb_hash_aref(args->opts, sym_markers);
 		if (!NIL_P(markers)) {
 			Check_Type(markers, T_HASH);
@@ -718,9 +802,6 @@ static VALUE each2(struct write_jpeg_args *args)
 		}
 	}
 
-	jpeg_start_compress(cinfo, TRUE);
-	jpeg_start_decompress(dinfo);
-
 	for(i=0; i<scaley; i++) {
 		while ((yinbuf = yscaler_next(ys))) {
 			jpeg_read_scanlines(dinfo, (JSAMPARRAY)&inwidthbuf, 1);
@@ -816,12 +897,16 @@ void Init_jpeg()
 	rb_define_alloc_func(cJPEGReader, allocate);
 	rb_define_method(cJPEGReader, "initialize", initialize, -1);
 	rb_define_method(cJPEGReader, "markers", markers, 0);
-	rb_define_method(cJPEGReader, "color_space", color_space, 0);
+	rb_define_method(cJPEGReader, "jpeg_color_space", jpeg_color_space, 0);
 	rb_define_method(cJPEGReader, "out_color_space", out_color_space, 0);
-	rb_define_method(cJPEGReader, "color_space=", set_out_color_space, 1);
-	rb_define_method(cJPEGReader, "components", components, 0);
-	rb_define_method(cJPEGReader, "width", width, 0);
-	rb_define_method(cJPEGReader, "height", height, 0);
+	rb_define_method(cJPEGReader, "out_color_space=", set_out_color_space, 1);
+	rb_define_method(cJPEGReader, "num_components", num_components, 0);
+	rb_define_method(cJPEGReader, "output_components", output_components, 0);
+	rb_define_method(cJPEGReader, "out_color_components", out_color_components, 0);
+	rb_define_method(cJPEGReader, "image_width", image_width, 0);
+	rb_define_method(cJPEGReader, "image_height", image_height, 0);
+	rb_define_method(cJPEGReader, "output_width", output_width, 0);
+	rb_define_method(cJPEGReader, "output_height", output_height, 0);
 	rb_define_method(cJPEGReader, "each", each, -1);
 	rb_define_method(cJPEGReader, "scale_num", scale_num, 0);
 	rb_define_method(cJPEGReader, "scale_num=", set_scale_num, 1);
@@ -837,6 +922,7 @@ void Init_jpeg()
 	id_YCbCr = rb_intern("YCbCr");
 	id_CMYK = rb_intern("CMYK");
 	id_YCCK = rb_intern("YCCK");
+	id_RGBX = rb_intern("RGBX");
 	id_UNKNOWN = rb_intern("UNKNOWN");
 	id_APP0 = rb_intern("APP0");
 	id_APP1 = rb_intern("APP1");

data/ext/oil/png.c

@@ -54,6 +54,7 @@ static void write_data_fn(png_structp png_ptr, png_bytep data, png_size_t length
 static void deallocate(struct readerdata *reader)
 {
 	png_destroy_read_struct(&reader->png, &reader->info, NULL);
+	free(reader);
 }
 
 static void mark(struct readerdata *reader)
@@ -63,13 +64,19 @@ static void mark(struct readerdata *reader)
 	}
 }
 
+static void allocate2(struct readerdata *reader)
+{
+	reader->png = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, (png_error_ptr)error, (png_error_ptr)warning);
+	reader->info = png_create_info_struct(reader->png);
+}
+
 static VALUE allocate(VALUE klass)
 {
 	struct readerdata *reader;
 	VALUE self;
 
 	self = Data_Make_Struct(klass, struct readerdata, mark, deallocate, reader);
-	reader->png = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, (png_error_ptr)error, (png_error_ptr)warning);
+	allocate2(reader);
 	return self;
 }
 
@@ -88,16 +95,23 @@ static VALUE initialize(VALUE self, VALUE io)
 
 	Data_Get_Struct(self, struct readerdata, reader);
 
-	if (reader->source_io) {
+	if (reader->info) {
 		png_destroy_read_struct(&reader->png, &reader->info, NULL);
-		reader->png = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, (png_error_ptr)error, (png_error_ptr)warning);
+		allocate2(reader);
 		reader->locked = 0;
 	}
 
 	reader->source_io = io;
-	reader->info = png_create_info_struct(reader->png);
 	png_set_read_fn(reader->png, (void*)io, read_data);
 	png_read_info(reader->png, reader->info);
+
+	png_set_packing(reader->png);
+	png_set_strip_16(reader->png);
+	png_set_expand(reader->png);
+	png_read_update_info(reader->png, reader->info);
+
+	reader->scale_width = png_get_image_width(reader->png, reader->info);
+	reader->scale_height = png_get_image_height(reader->png, reader->info);
 	return self;
 }
 
@@ -193,54 +207,75 @@ static VALUE set_scale_height(VALUE self, VALUE scale_height)
 	return scale_height;
 }
 
-struct write_png_args {
-	VALUE opts;
+struct each_args {
 	struct readerdata *reader;
+	png_structp wpng;
+	png_infop winfo;
 	unsigned char *inwidthbuf;
 	unsigned char *outwidthbuf;
-	struct yscaler *ys;
-	png_structp png;
-	png_infop info;
+	unsigned char **scanlines;
+	struct yscaler ys;
 };
 
-static VALUE each2(struct write_png_args *args)
+static VALUE each_interlace(struct each_args *args)
+{
+	struct readerdata *reader;
+	unsigned char *inwidthbuf, *outwidthbuf;
+	uint32_t i, width, height, scalex, scaley;
+	int cmp;
+
+	reader = args->reader;
+	inwidthbuf = args->inwidthbuf;
+	outwidthbuf = args->outwidthbuf;
+	scalex = reader->scale_width;
+	scaley = reader->scale_height;
+	cmp = png_get_channels(reader->png, reader->info);
+	width = png_get_image_width(reader->png, reader->info);
+	height = png_get_image_height(reader->png, reader->info);
+
+	png_write_info(args->wpng, args->winfo);
+	png_read_image(args->reader->png, (png_bytepp)args->scanlines);
+
+	for (i=0; i<scaley; i++) {
+		yscaler_prealloc_scale(height, scaley,
+			(uint8_t **)args->scanlines, (uint8_t *)inwidthbuf,
+			i, width, cmp, 0);
+		xscale(inwidthbuf, width, outwidthbuf, scalex, cmp, 0);
+		png_write_row(args->wpng, outwidthbuf);
+	}
+	png_write_end(args->wpng, args->winfo);
+	return Qnil;
+}
+
+static VALUE each_interlace_none(struct each_args *args)
 {
-	png_structp png;
-	png_infop info;
-	png_byte ctype;
 	struct readerdata *reader;
 	unsigned char *inwidthbuf, *outwidthbuf, *yinbuf;
 	struct yscaler *ys;
-	uint32_t i, scalex, scaley;
+	uint32_t i, width, scalex, scaley;
 	int cmp;
 
 	reader = args->reader;
-	png = args->png;
-	info = args->info;
 	inwidthbuf = args->inwidthbuf;
 	outwidthbuf = args->outwidthbuf;
-	ys = args->ys;
-	scalex = args->reader->scale_width;
-	scaley = args->reader->scale_height;
-
+	ys = &args->ys;
+	scalex = reader->scale_width;
+	scaley = reader->scale_height;
 	cmp = png_get_channels(reader->png, reader->info);
-	png_set_write_fn(png, 0, write_data_fn, flush_data_fn);
-	ctype = png_get_color_type(reader->png, reader->info);
+	width = png_get_image_width(reader->png, reader->info);
 
-	png_set_IHDR(png, info, scalex, scaley, 8, ctype, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
-	png_write_info(png, info);
+	png_write_info(args->wpng, args->winfo);
 
 	for(i=0; i<scaley; i++) {
 		while ((yinbuf = yscaler_next(ys))) {
 			png_read_row(reader->png, inwidthbuf, NULL);
-			xscale(inwidthbuf, png_get_image_width(reader->png, reader->info), yinbuf, scalex, cmp, 0);
+			xscale(inwidthbuf, width, yinbuf, scalex, cmp, 0);
 		}
 		yscaler_scale(ys, outwidthbuf, scalex, cmp, 0);
-		png_write_row(png, outwidthbuf);
+		png_write_row(args->wpng, outwidthbuf);
 	}
 
-	png_write_end(png, info);
-
+	png_write_end(args->wpng, args->winfo);
 	return Qnil;
 }
 
@@ -261,13 +296,15 @@ static VALUE each2(struct write_png_args *args)
 static VALUE each(int argc, VALUE *argv, VALUE self)
 {
 	struct readerdata *reader;
-	int cmp, state;
-	struct write_png_args args;
-	unsigned char *inwidthbuf, *outwidthbuf;
-	struct yscaler ys;
+	png_infop winfo;
+	png_structp wpng;
 	VALUE opts;
-	png_structp png;
-	png_infop info;
+	int cmp, state;
+	struct each_args args;
+	uint32_t i, height;
+	png_byte ctype;
+	unsigned char **scanlines;
+	size_t row_bytes;
 
 	rb_scan_args(argc, argv, "01", &opts);
 
@@ -276,41 +313,50 @@ static VALUE each(int argc, VALUE *argv, VALUE self)
 	raise_if_locked(reader);
 	reader->locked = 1;
 
-	png_set_packing(reader->png);
-	png_set_strip_16(reader->png);
-	png_set_expand(reader->png);
-	png_read_update_info(reader->png, reader->info);
-
-	if (!reader->scale_width) {
-		reader->scale_width = png_get_image_width(reader->png, reader->info);
-	}
-	if (!reader->scale_height) {
-		reader->scale_height = png_get_image_height(reader->png, reader->info);
-	}
-
-	png = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL,
+	wpng = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL,
 		(png_error_ptr)error, (png_error_ptr)warning);
-	info = png_create_info_struct(png);
+	winfo = png_create_info_struct(wpng);
+	png_set_write_fn(wpng, 0, write_data_fn, flush_data_fn);
 
-	inwidthbuf = malloc(png_get_rowbytes(reader->png, reader->info));
 	cmp = png_get_channels(reader->png, reader->info);
-	outwidthbuf = malloc(reader->scale_width * cmp);
-	yscaler_init(&ys, png_get_image_height(reader->png, reader->info),
-		reader->scale_height, reader->scale_width * cmp);
+	ctype = png_get_color_type(reader->png, reader->info);
+
+	png_set_IHDR(wpng, winfo, reader->scale_width, reader->scale_height, 8,
+		ctype, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT,
+		PNG_FILTER_TYPE_DEFAULT);
+
+	height = png_get_image_height(reader->png, reader->info);
+	row_bytes = png_get_rowbytes(reader->png, reader->info);
 
 	args.reader = reader;
-	args.opts = opts;
-	args.png = png;
-	args.info = info;
-	args.inwidthbuf = inwidthbuf;
-	args.outwidthbuf = outwidthbuf;
-	args.ys = &ys;
-	rb_protect((VALUE(*)(VALUE))each2, (VALUE)&args, &state);
-
-	yscaler_free(&ys);
-	free(inwidthbuf);
-	free(outwidthbuf);
-	png_destroy_write_struct(&png, &info);
+	args.wpng = wpng;
+	args.winfo = winfo;
+	args.inwidthbuf = malloc(row_bytes);
+	args.outwidthbuf = malloc(reader->scale_width * cmp);
+
+	if (png_get_interlace_type(reader->png, reader->info) == PNG_INTERLACE_NONE) {
+		yscaler_init(&args.ys, height, reader->scale_height,
+			reader->scale_width * cmp);
+		rb_protect((VALUE(*)(VALUE))each_interlace_none, (VALUE)&args, &state);
+		yscaler_free(&args.ys);
+	} else {
+		scanlines = malloc(height * sizeof(unsigned char *));
+		for (i=0; i<height; i++) {
+			scanlines[i] = malloc(row_bytes);
+		}
+
+		args.scanlines = scanlines;
+		rb_protect((VALUE(*)(VALUE))each_interlace, (VALUE)&args, &state);
+
+		for (i=0; i<height; i++) {
+			free(scanlines[i]);
+		}
+		free(scanlines);
+	}
+
+	free(args.inwidthbuf);
+	free(args.outwidthbuf);
+	png_destroy_write_struct(&wpng, &winfo);
 
 	if (state) {
 		rb_jump_tag(state);

data/ext/oil/yscaler.c

@@ -1,4 +1,5 @@
 #include "yscaler.h"
+#include "resample.h"
 #include <stdlib.h>
 #include <stdint.h>
 
@@ -136,3 +137,31 @@ void yscaler_scale(struct yscaler *ys, uint8_t *out, uint32_t width,
 	ys->out_pos++;
 	yscaler_map_pos(ys);
 }
+
+void yscaler_prealloc_scale(uint32_t in_height, uint32_t out_height,
+	uint8_t **in, uint8_t *out, uint32_t pos, uint32_t width, uint8_t cmp,
+	uint8_t opts)
+{
+	uint32_t i, taps;
+	int32_t smp_i, strip_pos;
+	uint8_t **virt;
+	float ty;
+
+	taps = calc_taps(in_height, out_height);
+	virt = malloc(taps * sizeof(uint8_t *));
+	smp_i = split_map(in_height, out_height, pos, &ty);
+	strip_pos = smp_i + 1 - taps / 2;
+
+	for (i=0; i<taps; i++) {
+		if (strip_pos < 0) {
+			virt[i] = in[0];
+		} else if ((uint32_t)strip_pos > in_height - 1) {
+			virt[i] = in[in_height - 1];
+		} else {
+			virt[i] = in[strip_pos];
+		}
+		strip_pos++;
+	}
+
+	strip_scale((void **)virt, taps, width, (void *)out, ty, cmp, opts);
+}

data/ext/oil/yscaler.h

@@ -1,7 +1,6 @@
 #ifndef YSCALER_H
 #define YSCALER_H
 
-#include "resample.h"
 #include <stdint.h>
 
 struct strip {
@@ -27,5 +26,8 @@ void yscaler_free(struct yscaler *ys);
 unsigned char *yscaler_next(struct yscaler *ys);
 void yscaler_scale(struct yscaler *ys, uint8_t *out,  uint32_t width,
 	uint8_t cmp, uint8_t opts);
+void yscaler_prealloc_scale(uint32_t in_height, uint32_t out_height,
+	uint8_t **in, uint8_t *out, uint32_t pos, uint32_t width, uint8_t cmp,
+	uint8_t opts);
 
 #endif

data/lib/oil.rb

@@ -1,5 +1,31 @@
 module Oil
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
+
+  def self.sniff_signature(io)
+    a = io.getc
+    b = io.getc
+    io.ungetc(b)
+    io.ungetc(a)
+
+    if (a == "\xFF".b && b == "\xD8".b)
+      return :JPEG
+    elsif (a == "\x89".b && b == "P".b)
+      return :PNG
+    end
+  end
+
+  def self.new(io, box_width, box_height)
+    case sniff_signature(io)
+    when :JPEG
+      return new_jpeg_reader(io, box_width, box_height)
+    when :PNG
+      return new_png_reader(io, box_width, box_height)
+    else
+      raise "Unknown image file format."
+    end
+  end
+
+  private
 
   def self.fix_ratio(sw, sh, boxw, boxh)
     x = boxw / sw.to_f
@@ -25,52 +51,52 @@ module Oil
     return destw, desth
   end
 
-  # JPEG Pre-scaling is equivalent to a box filter at an integer scale factor.
-  # We don't use this to scale down past 4x the target image size in order to
-  # get proper bicubic scaling in the final image.
-  def self.pre_scale(sw, sh, dw, dh)
-    inv_scale = sw / dw
+  def self.new_jpeg_reader(io, box_width, box_height)
+    o = JPEGReader.new(io, [:COM, :APP1, :APP2])
+
+    # bump RGB images to RGBX
+    if (o.out_color_space == :RGB)
+      o.out_color_space = :RGBX
+    end
+
+    # JPEG Pre-scaling is equivalent to a box filter at an integer scale factor.
+    # We don't use this to scale down past 4x the target image size in order to
+    # get proper bicubic scaling in the final image.
+    inv_scale = o.image_width / box_width
     inv_scale /= 4
 
     if inv_scale >= 8
-      return 8
+      o.scale_denom = 8
     elsif inv_scale >= 4
-      return 4
+      o.scale_denom = 4
     elsif inv_scale >= 2
-      return 2
-    else
-      return 0
+      o.scale_denom = 2
     end
-  end
 
-  def self.new(io, box_width, box_height)
-    a = io.getc
-    b = io.getc
-    io.ungetc(b)
-    io.ungetc(a)
+    destw, desth = self.fix_ratio(o.output_width, o.output_height, box_width, box_height)
+    o.scale_width = destw
+    o.scale_height = desth
 
-    if (a == "\xFF".b && b == "\xD8".b)
-      o = JPEGReader.new(io, [:COM, :APP1, :APP2])
-      if (o.color_space == :RGB)
-        o.out_color_space = :RGBX
-      end
-    elsif (a == "\x89".b && b == "P".b)
-      o = PNGReader.new(io)
-    else
-      raise "Unknown image file format."
-    end
+    return JPEGReaderWrapper.new(o, { markers: o.markers, quality: 95 })
+  end
 
+  def self.new_png_reader(io, box_width, box_height)
+    o = PNGReader.new(io)
     destw, desth = self.fix_ratio(o.width, o.height, box_width, box_height)
-    pre = self.pre_scale(o.width, o.height, box_width, box_height)
-
     o.scale_width = destw
     o.scale_height = desth
+    return o
+  end
+end
 
-    if o.respond_to?(:scale_denom) and pre > 0
-      o.scale_denom = pre
-    end
+class JPEGReaderWrapper
+  def initialize(reader, opts)
+    @reader = reader
+    @opts = opts
+  end
 
-    return o
+  def each(&block)
+    @reader.each(@opts, &block)
   end
 end
 

data/test/helper.rb

@@ -72,19 +72,3 @@ class NotStringIO < CustomIO
     return 78887
   end
 end
-
-def resize_string(str, width=nil, height=nil)
-  io = StringIO.new(str)
-  width ||= 100
-  height ||= 200
-  out = binary_stringio
-  o = Oil.new(io, width, height).each{ |d| out << d }
-  out.string
-end
-
-def binary_stringio
-  io = StringIO.new
-  io.set_encoding 'ASCII-8BIT' if RUBY_VERSION >= '1.9'
-  io
-end
-

data/test/test_jpeg.rb

@@ -16,32 +16,46 @@ class TestJPEG < MiniTest::Test
 \x01\x01\x00\x00\x3f\x00\xd2\xcf\x20\xff\xd9".b
 
   BIG_JPEG = begin
-    resize_string(JPEG_DATA, 2000, 2000)
+    s = ""
+    r = Oil::JPEGReader.new(StringIO.new(JPEG_DATA))
+    r.scale_width = 2000
+    r.scale_height = 2000
+    r.each{ |a| s << a }
+    s
   end
 
   def test_valid
     o = Oil::JPEGReader.new(jpeg_io)
-    assert_equal 1, o.width
-    assert_equal 1, o.height
+    assert_equal 1, o.image_width
+    assert_equal 1, o.image_height
   end
 
   def test_missing_eof
     io = StringIO.new(JPEG_DATA[0..-2])
     o = Oil::JPEGReader.new(io)
-    assert_equal 1, o.width
-    assert_equal 1, o.height
+    assert_equal 1, o.image_width
+    assert_equal 1, o.image_height
   end
 
   def test_bogus_header_marker
     str = JPEG_DATA.dup
     str[3] = "\x10"
-    assert_raises(RuntimeError) { resize_string(str) }
+    assert_raises(RuntimeError) { drain_string(str) }
   end
 
   def test_bogus_body_marker
     str = JPEG_DATA.dup
     str[-22] = "\x10"
-    assert_raises(RuntimeError) { resize_string(str) }
+    assert_raises(RuntimeError) { drain_string(str) }
+  end
+
+  def test_color_space
+    o = Oil::JPEGReader.new(jpeg_io)
+    assert_equal :GRAYSCALE, o.jpeg_color_space
+    assert_equal :GRAYSCALE, o.out_color_space
+    assert_equal 1, o.num_components
+    assert_equal 1, o.output_components
+    assert_equal 1, o.out_color_components
   end
 
   # Allocation tests
@@ -67,7 +81,10 @@ class TestJPEG < MiniTest::Test
   end
 
   def resize(io)
-    o = Oil.new(io, 20, 10).each{ |d| }
+    o = Oil::JPEGReader.new(io)
+    o.scale_width = 10
+    o.scale_height = 20
+    o.each{ |d| }
   end
 
   def test_io_too_much_data
@@ -112,18 +129,18 @@ class TestJPEG < MiniTest::Test
 
   def test_raise_in_each
     assert_raises(CustomError) do
-      Oil.new(jpeg_io, 10, 20).each{ raise CustomError }
+      Oil::JPEGReader.new(jpeg_io).each{ raise CustomError }
     end
   end
 
   def test_throw_in_each
     catch(:foo) do
-      Oil.new(jpeg_io, 10, 20).each{ throw :foo }
+      Oil::JPEGReader.new(jpeg_io).each{ throw :foo }
     end
   end
 
   def test_each_in_each
-    o = Oil.new(jpeg_io, 10, 20)
+    o = Oil::JPEGReader.new(jpeg_io)
     o.each do |d|
       assert_raises(RuntimeError) do
         o.each { |e| }
@@ -132,15 +149,78 @@ class TestJPEG < MiniTest::Test
   end
 
   def test_each_shrinks_buffer
-    io = StringIO.new(JPEG_DATA)
-    io_out = binary_stringio
-    Oil.new(io, 200, 200).each{ |d| io_out << d; d.slice!(0, 4) }
+    Oil::JPEGReader.new(jpeg_io).each{ |d| d.slice!(0, 4) }
   end
   
   def test_each_enlarges_buffer
-    io = StringIO.new(JPEG_DATA)
-    io_out = binary_stringio
-    o = Oil.new(io, 200, 200).each{ |d| io_out << d; d << "foobar" }
+    Oil::JPEGReader.new(jpeg_io).each{ |d| d << "foobar" }
+  end
+
+  def test_marker_roundtrip
+    str = ""
+    opts = { markers: { COM: ["hello world", "foobar123"]}}
+    Oil::JPEGReader.new(jpeg_io).each(opts){ |s| str << s }
+
+    r = Oil::JPEGReader.new(StringIO.new(str), [:COM])
+
+    assert_equal(r.markers, opts[:markers])
+  end
+
+  def test_marker_code_unrecognized
+    assert_raises(RuntimeError) do
+      Oil::JPEGReader.new(jpeg_io, [:FOOBAR])
+    end
+  end
+
+  def test_marker_codes_not_array
+    assert_raises(TypeError) do
+      Oil::JPEGReader.new(jpeg_io, 1234)
+    end
+  end
+
+  def test_marker_code_not_symbol
+    assert_raises(TypeError) do
+      Oil::JPEGReader.new(jpeg_io, [1234])
+    end
+  end
+
+  def test_marker_too_big
+    opts = { markers: { COM: ["hello world"*10000]}}
+
+    assert_raises(RuntimeError) do
+      Oil::JPEGReader.new(jpeg_io).each(opts){ |s| str << s }
+    end
+  end
+
+  def test_markers_not_hash
+    opts = { markers: 1234 }
+
+    assert_raises(TypeError) do
+      Oil::JPEGReader.new(jpeg_io).each(opts){}
+    end
+  end
+
+  def test_marker_value_not_array
+    opts = { markers: { COM: 1234}}
+
+    assert_raises(TypeError) do
+      Oil::JPEGReader.new(jpeg_io).each(opts){}
+    end
+  end
+
+  def test_marker_value_entry_not_string
+    opts = { markers: { COM: [1234]}}
+
+    assert_raises(TypeError) do
+      Oil::JPEGReader.new(jpeg_io).each(opts){}
+    end
+  end
+
+  def test_quality_not_a_number
+    opts = { quality: "foobar" }
+    assert_raises(TypeError) do
+      Oil::JPEGReader.new(jpeg_io).each(opts){}
+    end
   end
 
   private
@@ -148,4 +228,8 @@ class TestJPEG < MiniTest::Test
   def jpeg_io
     StringIO.new(JPEG_DATA)
   end
+
+  def drain_string(str)
+    Oil::JPEGReader.new(StringIO.new(str)).each{ |s| }
+  end
 end

data/test/test_png.rb

@@ -13,11 +13,16 @@ class TestPNG < MiniTest::Test
 \x57\xBF\xAB\xD4\x00\x00\x00\x00\x49\x45\x4E\x44\xAE\x42\x60\x82".b
 
   BIG_PNG = begin
-    resize_string(PNG_DATA, 500, 1000)
+    s = ""
+    r = Oil::PNGReader.new(StringIO.new(PNG_DATA))
+    r.scale_width = 500
+    r.scale_height = 1000
+    r.each{ |a| s << a }
+    s
   end
 
   def test_valid
-    o = Oil.new(png_io, 10 ,20)
+    o = Oil::PNGReader.new(png_io)
     assert_equal 1, o.width
     assert_equal 1, o.height
   end
@@ -25,20 +30,20 @@ class TestPNG < MiniTest::Test
   def test_bogus_header_chunk
     str = PNG_DATA.dup
     str[15] = "\x10"
-    assert_raises(RuntimeError) { resize_string(str) }
+    assert_raises(RuntimeError) { drain_string(str) }
   end
 
   def test_bogus_body_chunk
     str = PNG_DATA.dup
     str[37] = "\x10"
-    assert_raises(RuntimeError) { resize_string(str) }
+    assert_raises(RuntimeError) { drain_string(str) }
   end
 
   def test_bogus_end_chunk
     str = PNG_DATA.dup
     str[-6] = "\x10"
     io = StringIO.new(str)
-    o = Oil.new(png_io, 10 ,20)
+    o = Oil::PNGReader.new(png_io)
     assert_equal 1, o.width
     assert_equal 1, o.height
   end
@@ -66,7 +71,7 @@ class TestPNG < MiniTest::Test
   end
 
   def resize(io)
-    Oil.new(io, 20, 10).each{ |d| }
+    Oil::PNGReader.new(io).each{ |d| }
   end
 
   def test_io_too_much_data
@@ -109,33 +114,29 @@ class TestPNG < MiniTest::Test
 
   def test_raise_in_each
     assert_raises(CustomError) do
-      Oil.new(png_io, 10, 20).each { raise CustomError }
+      Oil::PNGReader.new(png_io).each { raise CustomError }
     end
   end
 
   def test_throw_in_each
     catch(:foo) do
-      Oil.new(png_io, 10, 20).each { throw :foo }
+      Oil::PNGReader.new(png_io).each { throw :foo }
     end
   end
 
   def test_each_in_each
-    o = Oil.new(png_io, 10, 20)
+    o = Oil::PNGReader.new(png_io)
     o.each do |d|
       assert_raises(RuntimeError){ o.each { |e| } }
     end
   end
 
   def test_each_shrinks_buffer
-    io = StringIO.new(PNG_DATA)
-    io_out = binary_stringio
-    Oil.new(io, 200, 200).each { |d| io_out << d; d.slice!(0, 4) }
+    Oil::PNGReader.new(png_io).each { |d| d.slice!(0, 4) }
   end
   
   def test_each_enlarges_buffer
-    io = StringIO.new(PNG_DATA)
-    io_out = binary_stringio
-    Oil.new(io, 200, 200).each { |d| io_out << d; d << "foobar" }
+    Oil::PNGReader.new(png_io).each { |d| d << "foobar" }
   end
 
   private
@@ -143,4 +144,8 @@ class TestPNG < MiniTest::Test
   def png_io
     StringIO.new(PNG_DATA)
   end
+
+  def drain_string(str)
+    Oil::PNGReader.new(StringIO.new(str)).each{|s|}
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: oil
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Timothy Elliott
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-15 00:00:00.000000000 Z
+date: 2014-11-25 00:00:00.000000000 Z
 dependencies: []
 description: Resize JPEG and PNG images, aiming for fast performance and low memory
   use.
@@ -54,7 +54,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.3
+rubygems_version: 2.4.4
 signing_key: 
 specification_version: 4
 summary: Resize JPEG and PNG images.