oil 0.0.3 → 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4036eeaab5f839b40269e35db9d1c5e74f905a2d
+  data.tar.gz: c369f27885d7edc5353b0012973075b7b1969aac
+SHA512:
+  metadata.gz: ff2f9e88da8fd2c1845e63ceffc1fd460d58a1ede777734c812eaad8a195bc7007575aa1221cd80c529a4f2ce0ddabaa23b900dd996c489c8dbe10fb07555025
+  data.tar.gz: ad0f4b2dfee53093fa6daf65a3d7deba426799e2921f0d4d6e76e6742efc423ad5f9a4429addf1f9b702eab2d6f0927d3f75c9d9014dd070b34414a2b55142d8

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Timothy Elliott
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.rdoc

@@ -4,8 +4,8 @@ http://github.com/ender672/oil
 
 == DESCRIPTION:
 
-Oil resizes JPEG and PNG images. It aims for fast performance and low memory
-use.
+Oil is a Ruby extension for resizing JPEG and PNG images. It aims for fast
+performance and low memory use.
 
 == INSTALLATION:
 
@@ -14,24 +14,23 @@ use.
 == SYNOPSIS:
 
   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)
+  # Oil uses IO objects for input & output.
+  io_in = File.open('image.jpg', 'rb')
+  io_out = File.open('image_resized.jpg', 'w')
 
-  # yield successive parts of the resized and compressed JPEG file
-  jpeg.each { |data| }
+  # Read the source image header and prepare to fit it into a 200x300 box.
+  img = Oil.new(io_in, 200, 300)
+
+  # Write the resized image to disk
+  img.each { |data| io_out << data }
 
 == REQUIREMENTS:
 
 These requirements do not apply to the JRuby gem.
 
-* IJG JPEG Library or libjpeg-turbo.
-* libpng
-
-Installing libjpeg headers (OSX):
-
-  $ brew install libjpeg # requires homebrew (http://mxcl.github.com/homebrew/)
+  * libjpeg-turbo
+  * libpng
 
 Installing libjpeg and libpng headers (Debian/Ubuntu):
 
@@ -47,43 +46,12 @@ Compile & run unit tests. Should show no warnings and no failing tests:
 Valgrind should not complain (ruby-1.9.3p125, compiled with -O3):
 
   $ valgrind /path/to/ruby -Iext:test test/test_jpeg.rb
-  $ valgrind --suppressions=test/valgrind_suppressions.txt /path/to/ruby -Iext:test test/test_png.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::Unit.new.run }"
+  $ 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
-
-== TODO:
-
-* Windows
-
-== LICENSE:
-
-(The MIT License)
-
-Copyright (c) 2012
-
-* {Timothy Elliott}[http://holymonkey.com]
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-'Software'), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -1,41 +1,45 @@
-require 'rake/clean'
+require 'rake/extensiontask'
+require 'rubygems/package_task'
 require 'rake/testtask'
 
-file 'ext/oil.jar' => FileList['ext/*.java'] do
-  cd 'ext' do
-    sh "javac -g -cp #{Config::CONFIG['prefix']}/lib/jruby.jar #{FileList['*.java']}"
-    quoted_files = (FileList.new('*.class').to_a.map { |f| "'#{f}'" }).join(' ')
-    sh "jar cf oil.jar #{quoted_files}"
-  end
+Rake::ExtensionTask.new('oil') do |ext|
+  ext.lib_dir = 'lib/oil'
 end
 
-file 'ext/Makefile' do
-  cd 'ext' do
-    ruby "extconf.rb #{ENV['EXTOPTS']}"
-  end
+s = Gem::Specification.new('oil', '0.1.0') 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.'
+  s.authors = ['Timothy Elliott']
+  s.email = 'tle@holymonkey.com'
+  s.files = %w{
+    Rakefile
+    README.rdoc
+    MIT-LICENSE
+    lib/oil.rb
+    ext/oil/resample.c
+    ext/oil/resample.h
+    ext/oil/yscaler.c
+    ext/oil/yscaler.h
+    ext/oil/jpeg.c
+    ext/oil/png.c
+    ext/oil/oil.c
+    ext/oil/extconf.rb
+    test/helper.rb
+    test/test_jpeg.rb
+    test/test_png.rb
+  }
+  s.homepage = 'http://github.com/ender672/oil'
+  s.extensions << 'ext/oil/extconf.rb'
+  s.extra_rdoc_files = ['README.rdoc']
 end
 
-file 'ext/oil.so' => FileList.new('ext/Makefile', 'ext/oil.c') do
-  cd 'ext' do
-    sh 'make'
-  end
-end
+Gem::PackageTask.new(s){}
 
 Rake::TestTask.new do |t|
-  t.libs = ['ext', 'test']
-  t.test_files = FileList['test/test_*.rb']
+  t.libs = ['lib', 'test']
+  t.test_files = FileList['test/test_jpeg.rb', 'test/test_png.rb']
 end
 
-CLEAN.add('ext/*{.o,.so,.log,.class,.jar}', 'ext/Makefile')
-CLOBBER.add('*.gem')
-
-desc 'Build the gem and include the java library'
-task :gem => "ext/oil.jar" do
-  system "gem build oil.gemspec"
-end
-
-desc 'Compile the extension'
-task :compile => "ext/oil.#{RUBY_PLATFORM =~ /java/ ? 'jar' : 'so'}"
-
-task :test => :compile
-task :default => :test
+task test: :compile
+task default: :test

data/ext/{extconf.rb → oil/extconf.rb}

@@ -1,16 +1,6 @@
 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)
+$CFLAGS += " -O3 -ffast-math -march=native"
 
 unless have_header('jpeglib.h')
   abort "libjpeg headers were not found."
@@ -28,4 +18,4 @@ unless have_library('png')
   abort "libpng was not found."
 end
 
-create_makefile('oil')
+create_makefile('oil/oil')

data/ext/oil/jpeg.c

@@ -0,0 +1,861 @@
+#include <ruby.h>
+#include <jpeglib.h>
+#include "resample.h"
+#include "yscaler.h"
+
+#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_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;
+static ID id_read;
+
+static VALUE sym_quality, sym_markers;
+
+/* Color Space Conversion Helpers. */
+
+static ID j_color_space_to_id(J_COLOR_SPACE cs)
+{
+	switch (cs) {
+	case JCS_GRAYSCALE:
+		return id_GRAYSCALE;
+	case JCS_RGB:
+		return id_RGB;
+	case JCS_YCbCr:
+		return id_YCbCr;
+	case JCS_CMYK:
+		return id_CMYK;
+	case JCS_YCCK:
+		return id_YCCK;
+	default:
+		return id_UNKNOWN;
+	}
+}
+
+static J_COLOR_SPACE sym_to_j_color_space(VALUE sym)
+{
+	ID rb = SYM2ID(sym);
+
+	if (rb == id_GRAYSCALE) {
+		return JCS_GRAYSCALE;
+	} else if (rb == id_RGB) {
+		return JCS_RGB;
+	} else if (rb == id_YCbCr) {
+		return JCS_YCbCr;
+	} else if (rb == id_CMYK) {
+		return JCS_CMYK;
+	} else if (rb == id_YCCK) {
+		return JCS_YCCK;
+	}
+	rb_raise(rb_eRuntimeError, "Color space not recognized.");
+}
+
+static int sym_to_marker_code(VALUE sym)
+{
+	ID rb = SYM2ID(sym);
+
+	if (rb == id_COM) {
+		return JPEG_COM;
+	} else if (rb == id_APP0) {
+		return JPEG_APP0;
+	} else if (rb == id_APP1) {
+		return JPEG_APP0 + 1;
+	} else if (rb == id_APP2) {
+		return JPEG_APP0 + 2;
+	} else if (rb == id_APP3) {
+		return JPEG_APP0 + 3;
+	} else if (rb == id_APP4) {
+		return JPEG_APP0 + 4;
+	} else if (rb == id_APP5) {
+		return JPEG_APP0 + 5;
+	} else if (rb == id_APP6) {
+		return JPEG_APP0 + 6;
+	} else if (rb == id_APP7) {
+		return JPEG_APP0 + 7;
+	} else if (rb == id_APP8) {
+		return JPEG_APP0 + 8;
+	} else if (rb == id_APP9) {
+		return JPEG_APP0 + 9;
+	} else if (rb == id_APP10) {
+		return JPEG_APP0 + 10;
+	} else if (rb == id_APP11) {
+		return JPEG_APP0 + 11;
+	} else if (rb == id_APP12) {
+		return JPEG_APP0 + 12;
+	} else if (rb == id_APP13) {
+		return JPEG_APP0 + 13;
+	} else if (rb == id_APP14) {
+		return JPEG_APP0 + 14;
+	} else if (rb == id_APP15) {
+		return JPEG_APP0 + 15;
+	}
+	rb_raise(rb_eRuntimeError, "Marker code not recognized.");
+}
+
+static VALUE marker_code_to_sym(int marker_code)
+{
+	switch(marker_code) {
+	case JPEG_COM:
+		return ID2SYM(id_COM);
+	case JPEG_APP0:
+		return ID2SYM(id_APP0);	
+	case JPEG_APP0 + 1:
+		return ID2SYM(id_APP1);	
+	case JPEG_APP0 + 2:
+		return ID2SYM(id_APP2);	
+	case JPEG_APP0 + 3:
+		return ID2SYM(id_APP3);	
+	case JPEG_APP0 + 4:
+		return ID2SYM(id_APP4);	
+	case JPEG_APP0 + 5:
+		return ID2SYM(id_APP5);	
+	case JPEG_APP0 + 6:
+		return ID2SYM(id_APP6);	
+	case JPEG_APP0 + 7:
+		return ID2SYM(id_APP7);	
+	case JPEG_APP0 + 8:
+		return ID2SYM(id_APP8);	
+	case JPEG_APP0 + 9:
+		return ID2SYM(id_APP9);	
+	case JPEG_APP0 + 10:
+		return ID2SYM(id_APP10);	
+	case JPEG_APP0 + 11:
+		return ID2SYM(id_APP11);	
+	case JPEG_APP0 + 12:
+		return ID2SYM(id_APP12);	
+	case JPEG_APP0 + 13:
+		return ID2SYM(id_APP13);	
+	case JPEG_APP0 + 14:
+		return ID2SYM(id_APP14);	
+	case JPEG_APP0 + 15:
+		return ID2SYM(id_APP15);	
+	}
+	rb_raise(rb_eRuntimeError, "Marker code not recognized.");
+}
+
+/* JPEG Error Handler -- raise a ruby exception. */
+
+void output_message(j_common_ptr cinfo)
+{
+	char buffer[JMSG_LENGTH_MAX];
+	cinfo->err->format_message(cinfo, buffer);
+	rb_warning("jpeglib: %s", buffer);
+}
+
+static void error_exit(j_common_ptr dinfo)
+{
+	char buffer[JMSG_LENGTH_MAX];
+	(*dinfo->err->format_message) (dinfo, buffer);
+	rb_raise(rb_eRuntimeError, "jpeglib: %s", buffer);
+}
+
+/* JPEG Data Source */
+
+struct readerdata {
+	struct jpeg_decompress_struct dinfo;
+	struct jpeg_source_mgr mgr;
+	struct jpeg_error_mgr jerr;
+	int locked;
+	VALUE source_io;
+	VALUE buffer;
+	uint32_t scale_width;
+	uint32_t scale_height;
+};
+
+static void null_jdecompress(j_decompress_ptr dinfo) {}
+
+static boolean fill_input_buffer(j_decompress_ptr dinfo)
+{
+	VALUE string;
+	long strl;
+	struct readerdata *reader;
+
+	reader = (struct readerdata *)dinfo;
+
+	string = rb_funcall(reader->source_io, id_read, 1, INT2FIX(READ_SIZE));
+	Check_Type(string, T_STRING);
+
+	strl = RSTRING_LEN(string);
+	if (strl > READ_SIZE) {
+		rb_raise(rb_eRuntimeError, "IO returned too much data.");
+	}
+
+	if (!strl) {
+		string = rb_str_new2("\xFF\xD9");
+		strl = 2;
+	}
+
+	reader->buffer = string;
+	reader->mgr.bytes_in_buffer = strl;
+	reader->mgr.next_input_byte = (unsigned char *)RSTRING_PTR(string);
+
+	return TRUE;
+}
+
+static void skip_input_data(j_decompress_ptr dinfo, long num_bytes)
+{
+	struct jpeg_source_mgr * src = dinfo->src;
+
+	if (num_bytes > 0) {
+		while (num_bytes > (long) src->bytes_in_buffer) {
+			num_bytes -= (long) src->bytes_in_buffer;
+			(void) (*src->fill_input_buffer) (dinfo);
+		}
+		src->next_input_byte += (size_t) num_bytes;
+		src->bytes_in_buffer -= (size_t) num_bytes;
+	}
+}
+
+/* Ruby GC */
+
+static void deallocate(struct readerdata *reader)
+{
+	jpeg_destroy_decompress(&reader->dinfo);
+	free(reader);
+}
+
+static void mark(struct readerdata *reader)
+{
+	if (!NIL_P(reader->source_io)) {
+		rb_gc_mark(reader->source_io);
+	}
+
+	if (!NIL_P(reader->buffer)) {
+		rb_gc_mark(reader->buffer);
+	}
+}
+
+static VALUE allocate(VALUE klass)
+{
+	struct readerdata *reader;
+	VALUE self;
+	self = Data_Make_Struct(klass, struct readerdata, mark, deallocate, reader);
+
+	jpeg_std_error(&reader->jerr);
+	reader->jerr.error_exit = error_exit;
+	reader->jerr.output_message = output_message;
+	reader->dinfo.err = &reader->jerr;
+	reader->mgr.init_source = null_jdecompress;
+	reader->mgr.fill_input_buffer = fill_input_buffer;
+	reader->mgr.skip_input_data = skip_input_data;
+	reader->mgr.resync_to_restart = jpeg_resync_to_restart;
+	reader->mgr.term_source = null_jdecompress;
+	return self;
+}
+
+/* Helper that raises an exception if the reader is locked. */
+
+static void raise_if_locked(struct readerdata *reader)
+{
+	if (reader->locked) {
+		rb_raise(rb_eRuntimeError, "Can't modify a Reader after decompress started.");
+	}
+}
+
+/*
+ *  call-seq:
+ *     Reader.new(io_in [, markers]) -> reader
+ *
+ *  Creates a new JPEG Reader. +io_in+ must be an IO-like object that responds
+ *  to read(size).
+ *
+ *  +markers+ should be an array of valid JPEG header marker symbols. Valid
+ *  symbols are :APP0 through :APP15 and :COM.
+ *
+ *  If performance is important, you can avoid reading any header markers by
+ *  supplying an empty array, [].
+ *
+ *  When markers are not specified, we read all known JPEG markers.
+ *
+ *     io = File.open("image.jpg", "r")
+ *     reader = Oil::JPEGReader.new(io)
+ * 
+ *     io = File.open("image.jpg", "r")
+ *     reader = Oil::JPEGReader.new(io, [:APP1, :APP2])
+ */
+
+static VALUE initialize(int argc, VALUE *argv, VALUE self)
+{
+	struct readerdata *reader;
+	VALUE io, markers;
+	struct jpeg_decompress_struct *dinfo;
+	int i, marker_code;
+
+	Data_Get_Struct(self, struct readerdata, reader);
+	dinfo = &reader->dinfo;
+
+	/* If source_io has already been set, then this is a re-used jpeg reader
+	 * object. This means we need to abort the previous decompress to
+	 * prevent memory leaks.
+	 */
+	if (reader->source_io) {
+		jpeg_abort_decompress(dinfo);
+	}
+
+	jpeg_create_decompress(&reader->dinfo);
+	reader->dinfo.src = &reader->mgr;
+
+	rb_scan_args(argc, argv, "11", &io, &markers);
+	reader->source_io = io;
+	reader->mgr.bytes_in_buffer = 0;
+
+	if(!NIL_P(markers)) {
+		Check_Type(markers, T_ARRAY);
+		for (i=0; i<RARRAY_LEN(markers); i++) {
+			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_calc_output_dimensions(dinfo);
+
+	return self;
+}
+
+/*
+ *  call-seq:
+ *     reader.components -> number
+ *
+ *  Retrieve the number of components as stored in the JPEG image.
+ */
+
+static VALUE components(VALUE self)
+{
+	struct jpeg_decompress_struct * dinfo;
+	Data_Get_Struct(self, struct jpeg_decompress_struct, dinfo);
+	return INT2FIX(dinfo->num_components);
+}
+
+/*
+ *  call-seq:
+ *     reader.color_space -> symbol
+ *
+ *  Returns a symbol representing the color model in which the JPEG is stored.
+ *
+ *  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.
+ *
+ *  Possible color models are: :GRAYSCALE, :RGB, :YCbCr, :CMYK, and :YCCK. This
+ *  method will return :UNKNOWN if the color model is not recognized.
+ */
+
+static VALUE color_space(VALUE self)
+{
+	struct jpeg_decompress_struct * dinfo;
+	ID id;
+
+	Data_Get_Struct(self, struct jpeg_decompress_struct, dinfo);
+	id = j_color_space_to_id(dinfo->jpeg_color_space);
+
+	return ID2SYM(id);
+}
+
+/*
+ *  call-seq:
+ *     reader.out_color_space -> symbol
+ *
+ *  Returns a symbol representing the color model to which the image will be
+ *  converted on decompress.
+ */
+
+static VALUE out_color_space(VALUE self)
+{
+	struct jpeg_decompress_struct * dinfo;
+	ID id;
+
+	Data_Get_Struct(self, struct jpeg_decompress_struct, dinfo);
+	id = j_color_space_to_id(dinfo->jpeg_color_space);
+
+	return ID2SYM(id);
+}
+
+/*
+ *  call-seq:
+ *     reader.out_color_space = symbol
+ *
+ *  Set the color model to which teh image will be converted on decompress.
+ */
+
+static VALUE set_out_color_space(VALUE self, VALUE cs)
+{
+	struct readerdata *reader;
+
+	Data_Get_Struct(self, struct readerdata, reader);
+	raise_if_locked(reader);
+
+	reader->dinfo.jpeg_color_space = sym_to_j_color_space(cs);
+	jpeg_calc_output_dimensions(&reader->dinfo);
+	return cs;
+}
+
+/*
+ *  call-seq:
+ *     reader.width -> number
+ *
+ *  Retrieve the width of the image.
+ */
+
+static VALUE width(VALUE self)
+{
+	struct jpeg_decompress_struct * dinfo;
+	Data_Get_Struct(self, struct jpeg_decompress_struct, dinfo);
+	return INT2FIX(dinfo->image_width);
+}
+
+/*
+ *  call-seq:
+ *     reader.height -> number
+ *
+ *  Retrieve the height of the image.
+ */
+
+static VALUE 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.markers -> hash
+ *
+ *  Get a hash of raw marker data from the JPEG.
+ *
+ *  The keys in the hash are the marker codes as symbols. The values are arrays.
+ *
+ *  Arrays since there may be multiple instances of a single marker in a JPEG
+ *  marker.
+ */
+
+static VALUE markers(VALUE self)
+{
+	struct jpeg_decompress_struct *dinfo;
+	jpeg_saved_marker_ptr marker;
+	VALUE hash, ary, key, val;
+
+	hash = rb_hash_new();
+
+	Data_Get_Struct(self, struct jpeg_decompress_struct, dinfo);
+
+	for (marker=dinfo->marker_list; marker; marker=marker->next) {
+		key = marker_code_to_sym(marker->marker);
+		ary = rb_hash_aref(hash, key);
+		if (NIL_P(ary)) {
+			ary = rb_ary_new();
+			rb_hash_aset(hash, key, ary);
+		}
+		val = rb_str_new((char *)marker->data, marker->data_length);
+		rb_ary_push(ary, val);
+	}
+
+	return hash;
+}
+
+/*
+ *  call-seq:
+ *     reader.scale_num -> number
+ *
+ *  Retrieve the numerator of the fraction by which the JPEG will be scaled as
+ *  it is read. This is always 1 for libjpeg version 6b. In version 8b this can
+ *  be 1 to 16.
+ */
+
+static VALUE scale_num(VALUE self)
+{
+	struct jpeg_decompress_struct *dinfo;
+	Data_Get_Struct(self, struct jpeg_decompress_struct, dinfo);
+	return INT2FIX(dinfo->scale_num);
+}
+
+/*
+ *  call-seq:
+ *     reader.scale_num = number
+ *
+ *  Set the numerator of the fraction by which the JPEG will be scaled as it is
+ *  read. This must always be 1 for libjpeg version 6b. In version 8b this can
+ *  be set to 1 through 16.
+ */
+
+static VALUE set_scale_num(VALUE self, VALUE scale_num)
+{
+	struct readerdata *reader;
+
+	Data_Get_Struct(self, struct readerdata, reader);
+	raise_if_locked(reader);
+
+	reader->dinfo.scale_num = NUM2INT(scale_num);
+	jpeg_calc_output_dimensions(&reader->dinfo);
+	return scale_num;
+}
+
+/*
+ *  call-seq:
+ *     reader.scale_denom -> number
+ *
+ *  Retrieve the denominator of the fraction by which the JPEG will be scaled as
+ *  it is read. This is 1, 2, 4, or 8 for libjpeg version 6b. In version 8b this
+ *  is always the source DCT size, which is 8 for baseline JPEG.
+ */
+
+static VALUE scale_denom(VALUE self)
+{
+	struct jpeg_decompress_struct *dinfo;
+	Data_Get_Struct(self, struct jpeg_decompress_struct, dinfo);
+	return INT2FIX(dinfo->scale_denom);
+}
+
+/*
+ *  call-seq:
+ *     reader.scale_denom = number
+ *
+ *  Set the denominator of the fraction by which the JPEG will be scaled as it
+ *  is read. This can be set to 1, 2, 4, or 8 for libjpeg version 6b. In version
+ *  8b this must always be the source DCT size, which is 8 for baseline JPEG.
+ *
+ *  Prior to version 1.2, libjpeg-turbo will not scale down images on
+ *  decompression, and this option will do nothing.
+ */
+
+static VALUE set_scale_denom(VALUE self, VALUE scale_denom)
+{
+	struct readerdata *reader;
+
+	Data_Get_Struct(self, struct readerdata, reader);
+	raise_if_locked(reader);
+
+	reader->dinfo.scale_denom = NUM2INT(scale_denom);
+	jpeg_calc_output_dimensions(&reader->dinfo);
+	return scale_denom;
+}
+
+/*
+ *  call-seq:
+ *     reader.scale_width -> number
+ *
+ *  Retrieve the width to which the image will be resized after decompression. A
+ *  width of 0 means the image will remain at original width.
+ */
+
+static VALUE scale_width(VALUE self)
+{
+	struct readerdata *reader;
+	Data_Get_Struct(self, struct readerdata, reader);
+	return INT2FIX(reader->scale_width);
+}
+
+/*
+ *  call-seq:
+ *     reader.scale_width = number
+ *
+ *  Set the width to which the image will be resized after decompression. A
+ *  width of 0 means the image will remain at original width.
+ */
+
+static VALUE set_scale_width(VALUE self, VALUE scale_width)
+{
+	struct readerdata *reader;
+	Data_Get_Struct(self, struct readerdata, reader);
+	raise_if_locked(reader);
+	reader->scale_width = NUM2INT(scale_width);
+	return scale_width;
+}
+
+/*
+ *  call-seq:
+ *     reader.scale_height -> number
+ *
+ *  Retrieve the height to which the image will be resized after decompression. A
+ *  height of 0 means the image will remain at original height.
+ */
+
+static VALUE scale_height(VALUE self)
+{
+	struct readerdata *reader;
+	Data_Get_Struct(self, struct readerdata, reader);
+	return INT2FIX(reader->scale_height);
+}
+
+/*
+ *  call-seq:
+ *     reader.scale_height = number
+ *
+ *  Set the height to which the image will be resized after decompression. A
+ *  height of 0 means the image will remain at original height.
+ */
+
+static VALUE set_scale_height(VALUE self, VALUE scale_height)
+{
+	struct readerdata *reader;
+	Data_Get_Struct(self, struct readerdata, reader);
+	raise_if_locked(reader);
+	reader->scale_height = NUM2INT(scale_height);
+	return scale_height;
+}
+
+/* JPEG Data Destination */
+
+struct writerdata {
+	struct jpeg_compress_struct cinfo;
+	struct jpeg_destination_mgr mgr;
+	VALUE buffer;
+};
+
+static void init_destination(j_compress_ptr cinfo)
+{
+	struct writerdata *writer;
+
+	writer = (struct writerdata *)cinfo;
+	writer->buffer = rb_str_new(NULL, WRITE_SIZE);
+	writer->mgr.next_output_byte = (JOCTET *)RSTRING_PTR(writer->buffer);
+	writer->mgr.free_in_buffer = WRITE_SIZE;
+}
+
+static boolean empty_output_buffer(j_compress_ptr cinfo)
+{
+	struct writerdata *writer;
+
+	writer = (struct writerdata *)cinfo;
+	rb_yield(writer->buffer);
+	init_destination(cinfo);
+	return TRUE;
+}
+
+static void term_destination(j_compress_ptr cinfo)
+{
+	struct writerdata *writer;
+	size_t datacount;
+
+	writer = (struct writerdata *)cinfo;
+	datacount = WRITE_SIZE - writer->mgr.free_in_buffer;
+
+	if (datacount > 0) {
+		rb_str_set_len(writer->buffer, datacount);
+		rb_yield(writer->buffer);
+	}
+}
+
+static int markerhash_each(VALUE marker_code_v, VALUE marker_ary, VALUE cinfo_v)
+{
+	struct jpeg_compress_struct *cinfo;
+	int i, marker_code;
+	size_t strl;
+	VALUE marker;
+
+	cinfo = (struct jpeg_compress_struct *)cinfo_v;
+	marker_code = sym_to_marker_code(marker_code_v);
+
+	Check_Type(marker_ary, T_ARRAY);
+	for (i=0; i<RARRAY_LEN(marker_ary); i++) {
+		marker = rb_ary_entry(marker_ary, i);
+		Check_Type(marker, T_STRING);
+		strl = RSTRING_LEN(marker);
+		jpeg_write_marker(cinfo, marker_code, (JOCTET *)RSTRING_PTR(marker), strl);
+	}
+
+	return ST_CONTINUE;
+}
+
+struct write_jpeg_args {
+	VALUE opts;
+	struct readerdata *reader;
+	struct writerdata *writer;
+	unsigned char *inwidthbuf;
+	unsigned char *outwidthbuf;
+	struct yscaler *ys;
+};
+
+static VALUE each2(struct write_jpeg_args *args)
+{
+	struct writerdata *writer;
+	struct jpeg_decompress_struct *dinfo;
+	struct jpeg_compress_struct *cinfo;
+	unsigned char *inwidthbuf, *outwidthbuf, *yinbuf;
+	struct yscaler *ys;
+	uint32_t i, scalex, scaley;
+	VALUE quality, markers;
+	int cmp, opts;
+
+	writer = args->writer;
+	inwidthbuf = args->inwidthbuf;
+	outwidthbuf = args->outwidthbuf;
+	ys = args->ys;
+	dinfo = &args->reader->dinfo;
+	cinfo = &writer->cinfo;
+	scalex = args->reader->scale_width;
+	scaley = args->reader->scale_height;
+
+	cmp = dinfo->output_components;
+	opts = dinfo->out_color_space == JCS_EXT_RGBX ? OIL_FILLER : 0;
+
+	writer->mgr.init_destination = init_destination;
+	writer->mgr.empty_output_buffer = empty_output_buffer;
+	writer->mgr.term_destination = term_destination;
+	writer->cinfo.dest = &writer->mgr;
+	writer->cinfo.image_width = scalex;
+	writer->cinfo.image_height = scaley;
+	writer->cinfo.in_color_space = dinfo->out_color_space;
+	writer->cinfo.input_components = cmp;
+
+	jpeg_set_defaults(cinfo);
+
+	if (!NIL_P(args->opts)) {
+		quality = rb_hash_aref(args->opts, sym_quality);
+		if (!NIL_P(quality)) {
+			jpeg_set_quality(cinfo, FIX2INT(quality), FALSE);
+		}
+
+		markers = rb_hash_aref(args->opts, sym_markers);
+		if (!NIL_P(markers)) {
+			Check_Type(markers, T_HASH);
+			rb_hash_foreach(markers, markerhash_each, (VALUE)cinfo);
+		}
+	}
+
+	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);
+			xscale(inwidthbuf, dinfo->output_width, yinbuf, scalex, cmp, opts);
+		}
+		yscaler_scale(ys, outwidthbuf, scalex, cmp, opts);
+		jpeg_write_scanlines(cinfo, (JSAMPARRAY)&outwidthbuf, 1);
+	}
+
+	jpeg_finish_compress(cinfo);
+
+	return Qnil;
+}
+
+/*
+ * call-seq:
+ *    reader.each(opts, &block) -> self
+ *
+ * Yields a series of binary strings that make up the output JPEG image.
+ *
+ * Options is a hash which may have the following symbols:
+ *
+ * :quality - JPEG quality setting. Betweein 0 and 100.
+ * :markers - Custom markers to include in the output JPEG. Must be a hash where
+ *   the keys are :APP[0-15] or :COM and the values are arrays of strings that
+ *   will be inserted into the markers.
+ */
+
+static VALUE each(int argc, VALUE *argv, VALUE self)
+{
+	struct readerdata *reader;
+	struct writerdata writer;
+	int cmp, state;
+	struct write_jpeg_args args;
+	unsigned char *inwidthbuf, *outwidthbuf;
+	struct yscaler ys;
+	VALUE opts;
+
+	rb_scan_args(argc, argv, "01", &opts);
+
+	Data_Get_Struct(self, struct readerdata, reader);
+
+	if (!reader->scale_width) {
+		reader->scale_width = reader->dinfo.output_width;
+	}
+	if (!reader->scale_height) {
+		reader->scale_height = reader->dinfo.output_height;
+	}
+
+	writer.cinfo.err = &reader->jerr;
+	jpeg_create_compress(&writer.cinfo);
+
+	cmp = reader->dinfo.output_components;
+	inwidthbuf = malloc(reader->dinfo.output_width * cmp);
+	outwidthbuf = malloc(reader->scale_width * cmp);
+	yscaler_init(&ys, reader->dinfo.output_height, reader->scale_height,
+		reader->scale_width * cmp);
+
+	args.reader = reader;
+	args.opts = opts;
+	args.writer = &writer;
+	args.inwidthbuf = inwidthbuf;
+	args.outwidthbuf = outwidthbuf;
+	args.ys = &ys;
+	reader->locked = 1;
+	rb_protect((VALUE(*)(VALUE))each2, (VALUE)&args, &state);
+
+	yscaler_free(&ys);
+	free(inwidthbuf);
+	free(outwidthbuf);
+	jpeg_destroy_compress(&writer.cinfo);
+
+	if (state) {
+		rb_jump_tag(state);
+	}
+
+	return self;
+}
+
+/*
+ * Document-class: Oil::JPEGReader
+ *
+ * Read a compressed JPEG image given an IO object.
+ */
+
+void Init_jpeg()
+{
+	VALUE mOil, cJPEGReader;
+
+	mOil = rb_const_get(rb_cObject, rb_intern("Oil"));
+
+	cJPEGReader = rb_define_class_under(mOil, "JPEGReader", rb_cObject);
+	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, "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, "each", each, -1);
+	rb_define_method(cJPEGReader, "scale_num", scale_num, 0);
+	rb_define_method(cJPEGReader, "scale_num=", set_scale_num, 1);
+	rb_define_method(cJPEGReader, "scale_denom", scale_denom, 0);
+	rb_define_method(cJPEGReader, "scale_denom=", set_scale_denom, 1);
+	rb_define_method(cJPEGReader, "scale_width", scale_width, 0);
+	rb_define_method(cJPEGReader, "scale_width=", set_scale_width, 1);
+	rb_define_method(cJPEGReader, "scale_height", scale_height, 0);
+	rb_define_method(cJPEGReader, "scale_height=", set_scale_height, 1);
+
+	id_GRAYSCALE = rb_intern("GRAYSCALE");
+	id_RGB = rb_intern("RGB");
+	id_YCbCr = rb_intern("YCbCr");
+	id_CMYK = rb_intern("CMYK");
+	id_YCCK = rb_intern("YCCK");
+	id_UNKNOWN = rb_intern("UNKNOWN");
+	id_APP0 = rb_intern("APP0");
+	id_APP1 = rb_intern("APP1");
+	id_APP2 = rb_intern("APP2");
+	id_APP3 = rb_intern("APP3");
+	id_APP4 = rb_intern("APP4");
+	id_APP5 = rb_intern("APP5");
+	id_APP6 = rb_intern("APP6");
+	id_APP7 = rb_intern("APP7");
+	id_APP8 = rb_intern("APP8");
+	id_APP9 = rb_intern("APP9");
+	id_APP10 = rb_intern("APP10");
+	id_APP11 = rb_intern("APP11");
+	id_APP12 = rb_intern("APP12");
+	id_APP13 = rb_intern("APP13");
+	id_APP14 = rb_intern("APP14");
+	id_APP15 = rb_intern("APP15");
+	id_COM = rb_intern("COM");
+	id_read = rb_intern("read");
+
+	sym_quality = ID2SYM(rb_intern("quality"));
+	sym_markers = ID2SYM(rb_intern("markers"));
+}