axon 0.0.2 → 0.1.0

data/CHANGELOG.rdoc

@@ -1,7 +1,13 @@
-=== 0.0.1 / 2011-08-01
+=== 0.1.0 / 2012-1-5
 
-* Initial Release
+* Make images and operations behave more like Ruby IO instead of enumerables.
+* Full rdoc documentation.
+* Rubinius and 1.8.7 support.
 
 === 0.0.2 / 2011-08-16
 
-* Fix a makefile bug that prevented axon from loading in 1.8.7
+* Fix a makefile bug that prevented axon from loading in 1.8.7
+
+=== 0.0.1 / 2011-08-01
+
+* Initial Release

data/README.rdoc

@@ -1,72 +1,65 @@
-= Axon
+= axon
 
 http://github.com/ender672/axon
 
 == DESCRIPTION:
 
-Axon is a library for streaming and manipulating JPEG and PNG images. It scales
-and crops images along the way.
+axon reads, manipulates, and writes images.
 
-By limiting its functionality, Axon is able to depend on two ubiquitous
-libraries: libjpeg and libpng. Axon can be installed anywhere those libraries
-are available.
+axon depends only on libjpeg and libpng.
 
-Axon never stores an entire image in memory. All images and operations are
-streamed from an input to an output. As a result, memory requirements and
-latency are low.
+axon never stores an entire image in memory. All images and operations are
+streamed. This keeps memory requirements and latency low.
 
 == FEATURES:
 
 * Read and Write JPEG and PNG images.
-* Scale images using bilinear (fast!) or nearest-neighbor (even faster!)
-  interpolation.
-* Crop images.
+* Scale images using bilinear or nearest-neighbor interpolation.
+* Crop images and image regions.
+* Scale images to fit into a box while preserving aspect ratio.
 
 == SYNOPSIS:
 
   # Short, chained example. Reads a JPEG from io_in and writes scaled png to
   # io_out.
-  Axon.JPEG(io_in).fit(100, 100).write_png(io_out)
+  Axon.jpeg(io_in).fit(100, 100).png(io_out)
 
   # Longer example, reads the JPEG header, looks at properties and header
   # values, sets decompression options, scales the image, sets compression
   # options, and writes a JPEG.
-  image = Axon.JPEG(io, [:APP2])
+  reader = Axon::JPEG::Reader(io, [:APP2])
 
-  puts image.width
-  puts image.height
-  puts image[:APP2]
-  image.scale_denom = 4
+  puts reader.width  #=> Integer
+  puts reader.height #=> Integer
+  puts reader[:APP2] #=> Array of Strings
+  reader.scale_denom = 4 # Image will be scaled by 1/4 on read
 
-  jpeg = image.fit(100, 100).to_jpeg
-  jpeg.quality = 88
-  jpeg.write(io)
+  fitted = Axon::Fit.new(reader, 100, 100) # Fits image in a 100x100 box
+  JPEG.write(fitted, io, :quality => 88)
 
 == BASIC API:
 
-There are three basic object types: Image, Reader and Writer.
+All image objects are expected to respond to the following methods:
 
-Every Image object has the following methods:
-
-  * Image#height, Image#width
-    These are the output dimensions of the image.
+  * Image#height
+    Output height of the image.
+  * Image#width
+    Output width of the image.
   * Image#color_model
     Can be :GRAYSCALE or :RGB
   * Image#components
-    An RGB image will have 3 components. A grayscale image with an alpha channel
-    (transparency) will have 2 components: grayscale and transparency, etc.
-  * Image#each(&block)
-    Yields every line in the image as a binary ruby string. Image properties
-    are not allowed to change between the first and last yield.
+    RGB image with alpha has 4 components.
+    RGB image has 3 components.
+    Grayscale image with alpha has 2 components.
+    Grayscale image has 1 component.
+  * Image#gets
+    Returns the next line in the image as a binary ruby string.
+  * Image#lineno
+    The line number of the next line that will be returned, starting at 0.  
 
 A Reader object has the same methods as an Image object, with added methods that
 are specific to the decoding of the image format.
 
-A Writer has two methods:
-
-  * Writer#write(io[, options])
-  * Writer#data([options]) # returns image data as a string
-
 == REQUIREMENTS:
 
 IJG JPEG Library Version 6b or later.

data/Rakefile

@@ -1,30 +1,35 @@
-require 'rubygems'
-require 'hoe'
+require 'rake/clean'
+require 'rake/testtask'
 
-HOE = Hoe.spec 'axon' do
-  developer('Timothy Elliott', 'tle@holymonkey.com')
-  self.readme_file   = 'README.rdoc'
-  self.history_file  = 'CHANGELOG.rdoc'
-  self.extra_dev_deps << ['rake-compiler', '>= 0']
-  self.spec_extras = { :extensions => ["ext/axon/extconf.rb"] }
+file 'ext/axon/Makefile' do
+  cd 'ext/axon' do
+    ruby "extconf.rb #{ENV['EXTOPTS']}"
+  end
 end
 
-require "rake/extensiontask"
-
-Rake::ExtensionTask.new('axon', HOE.spec) do |ext|
-  ext.lib_dir = File.join('lib', 'axon')
+file 'ext/axon/axon.so' => FileList.new('ext/axon/Makefile', 'ext/axon/*{.c,.h}') do
+  cd 'ext/axon' do
+    sh 'make'
+  end
 end
 
-Rake::Task[:test].prerequisites << :compile
+CLEAN.add('ext/axon/*{.o,.so,.log}', 'ext/axon/Makefile')
+CLOBBER.add('*.gem')
 
-desc 'Run a test in looped mode so that you can look for memory leaks.'
-task 'test_loop' do
-  code = %Q[require '#{$*[1]}'; loop{ MiniTest::Unit.new.run }]
-  cmd = %Q[ruby -Ilib -Itest -e "#{ code }"]
-  system cmd
+desc 'Clean up Rubinius .rbc files.'
+namespace :clean do
+  task :rbc do
+    system "find . -name *.rbc -delete"
+  end
 end
 
-desc 'Watch Memory use of a looping test'
-task 'test_loop_mem' do
-  system 'watch "ps aux | grep Itest"'
+Rake::TestTask.new do |t|
+  t.libs += ['test', 'ext']
+  t.test_files = FileList['test/test*.rb']
+  t.verbose = true
 end
+
+desc 'Compile axon'
+task :compile => 'ext/axon/axon.so'
+task :test => :compile
+task :default => :test

data/TODO.rdoc

@@ -1,12 +1,7 @@
 = TODO
+  * get everything running on osx and windows
   * have a setting where decode / encode warnings will result in exceptions
-
-  * Test scalers with images that lie about width & height. Never trust
-    Image#width or Image#height -- instead always go by scanline size and how
-    many times #each_scanline calls yield
-
   * add #initialize_copy
-
   * Check frozen status on setters, etc.
   * Check frozen status (and freeze) on all VALUEs that we stash for later use
   * Check trusted status (1.9.x only)

data/ext/axon/axon.c

@@ -1,20 +1,11 @@
-#include <ruby.h>
-
-#include "jpeg_common.h"
-#include "png_common.h"
-#include "interpolation.h"
+void Init_JPEG();
+void Init_PNG();
+void Init_Interpolation();
 
 void
 Init_axon()
 {
-    Init_jpeg();
-    Init_jpeg_reader();
-    Init_jpeg_native_writer();
-
-    Init_png();
-    Init_png_reader();
-    Init_png_native_writer();
-
-    Init_bilinear_interpolation();
-    Init_nearest_neighbor_interpolation();
+    Init_JPEG();
+    Init_PNG();
+    Init_Interpolation();
 }

data/ext/axon/extconf.rb

@@ -1,21 +1,31 @@
 require 'mkmf'
 
-$CFLAGS += " -g -O0" if ENV['GCC_DEBUG']
+# 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 find_header('jpeglib.h')
-  abort "libjpeg headers are missing. Please install libjpeg headers."
+unless have_header('jpeglib.h')
+  abort "libjpeg headers were not found."
 end
 
-unless have_library('jpeg', nil)
-  abort "libjpeg is missing. Please install libjpeg."
+unless have_library('jpeg')
+  abort "libjpeg was not found."
 end
 
-unless find_header('png.h')
-  abort "libpng headers are missing. Please install libpng headers."
+unless have_header('png.h')
+  abort "libpng headers were not found."
 end
 
-unless have_library('png', nil)
-  abort "libpng is missing. Please install libpng."
+unless have_library('png')
+  abort "libpng was not found."
 end
 
 create_makefile('axon/axon')

data/ext/axon/interpolation.c

@@ -0,0 +1,147 @@
+#include <ruby.h>
+
+/*     c00                 a    c10
+ *      --------------------------
+ *      |                  |     |
+ *      |                  |     |
+ *      |                ty|     |
+ *      |       tx         |     |
+ *      |------------------+-----|
+ *      |                 /|     |
+ *      |            sample|     |
+ *      |                  |     |
+ *      |                  |     |
+ *      |                  |     |
+ *      |                  |     |
+ *      --------------------------
+ *     c01                 b    c11
+ *
+ * a      = (1 - tx) * c00 + tx * c10
+ * b      = (1 - tx) * c01 + tx * c11
+ * sample = (1 - ty) *   a + ty * b
+ *
+ * sample = (1 - ty) * (1 - tx) * c00 +
+ *          (1 - ty) * tx       * c10 +
+ *          ty       * (1 - tx) * c01 +
+ *          ty       * tx       * c11
+ */
+static VALUE
+bilinear2(size_t width, size_t src_width, size_t components, double ty,
+	  char *scanline1, char *scanline2)
+{
+    VALUE rb_dest_sl;
+    double width_ratio_inv, sample_x, tx, _tx, p00, p10, p01, p11;
+    unsigned char *c00, *c10, *c01, *c11, *dest_sl;
+    size_t sample_x_i, i, j;
+
+    rb_dest_sl = rb_str_new(0, width * components);
+    dest_sl = RSTRING_PTR(rb_dest_sl);
+    
+    width_ratio_inv = (double)src_width / width;
+
+    for (i = 0; i < width; i++) {
+	sample_x = i * width_ratio_inv;
+	sample_x_i = (int)sample_x;
+
+	tx = sample_x - sample_x_i;
+	_tx = 1 - tx;
+
+	p11 =  tx * ty;
+	p01 = _tx * ty;
+	p10 =  tx - p11;
+	p00 = _tx - p01;
+
+	c00 = scanline1 + sample_x_i * components;
+	c10 = c00 + components;
+	c01 = scanline2 + sample_x_i * components;
+	c11 = c01 + components;
+
+	for (j = 0; j < components; j++)
+	    *dest_sl++ = p00 * c00[j] + p10 * c10[j] + p01 * c01[j] +
+			 p11 * c11[j];
+    }
+    
+    return rb_dest_sl;    
+}
+
+/* :nodoc: */
+
+static VALUE
+bilinear(VALUE self, VALUE rb_scanline1, VALUE rb_scanline2, VALUE rb_width,
+	 VALUE rb_ty, VALUE rb_components)
+{
+    double ty;
+    unsigned char *scanline1, *scanline2;
+    int src_line_size;
+    size_t width, components, src_width;
+
+    width = NUM2INT(rb_width);
+    components = NUM2INT(rb_components);
+    ty = NUM2DBL(rb_ty);
+
+    Check_Type(rb_scanline1, T_STRING);
+    Check_Type(rb_scanline2, T_STRING);
+
+    src_line_size = RSTRING_LEN(rb_scanline1);
+
+    if (RSTRING_LEN(rb_scanline2) != src_line_size)
+	rb_raise(rb_eArgError, "Scanlines don't have the same width.");
+
+    src_width = src_line_size / components - 1;
+    scanline1 = RSTRING_PTR(rb_scanline1);
+    scanline2 = RSTRING_PTR(rb_scanline2);
+
+    return bilinear2(width, src_width, components, ty, scanline1, scanline2);
+}
+
+static VALUE
+nearest2(size_t width, size_t src_width, size_t components, char *scanline)
+{
+    double inv_scale_x;
+    VALUE rb_dest_sl;
+    char *dest_sl, *xpos;
+    size_t i, j;
+    
+    inv_scale_x = (double)src_width / width;
+
+    rb_dest_sl = rb_str_new(0, width * components);
+    dest_sl = RSTRING_PTR(rb_dest_sl);
+
+    for (i = 0; i < width; i++) {
+	xpos = scanline + (int)(i * inv_scale_x) * components;
+	for (j = 0; j < components; j++)
+            *dest_sl++ = *xpos++;
+    }
+
+    return rb_dest_sl;    
+}
+
+/* :nodoc: */
+
+static VALUE
+nearest(VALUE self, VALUE rb_scanline, VALUE rb_width, VALUE rb_components)
+{
+    unsigned char *scanline;
+    size_t width, src_width, src_line_size, components;
+
+    width = NUM2INT(rb_width);
+    components = NUM2INT(rb_components);
+
+    Check_Type(rb_scanline, T_STRING);
+    src_line_size = RSTRING_LEN(rb_scanline);
+    scanline = RSTRING_PTR(rb_scanline);
+
+    src_width = src_line_size / components;
+    return nearest2(width, src_width, components, scanline);
+}
+
+
+void
+Init_Interpolation()
+{
+    VALUE mAxon = rb_define_module("Axon");
+    /* :nodoc: */
+    VALUE mInterpolation = rb_define_module_under(mAxon, "Interpolation");
+    rb_define_singleton_method(mInterpolation, "bilinear", bilinear, 5);
+    rb_define_singleton_method(mInterpolation, "nearest", nearest, 3);
+}

data/ext/axon/jpeg.c

@@ -0,0 +1,1207 @@
+#include <ruby.h>
+#include <jpeglib.h>
+#include "iccjpeg.h"
+
+/*
+ * Marker size is defined by two bytes, so the maximum is 65,535 bytes.
+ * Two of those bytes are used by the size indicator bytes themselves, leaving
+ * 65,533 bytes.
+ */
+
+#define MAX_MARKER_LEN 65533
+
+/*
+ * The Exif marker eats 4 bytes for "Exif", and 2 bytes for NULL terminators.
+ */
+
+#define EXIF_OVERHEAD_LEN 6
+#define MAX_EXIF_DATA_LEN MAX_MARKER_LEN - EXIF_OVERHEAD_LEN
+#define EXIF_MARKER (JPEG_APP0 + 1)
+
+#define WRITE_BUFSIZE 1024
+#define READ_SIZE 2048
+
+static ID id_ISLOW, id_IFAST, id_FLOAT, id_DEFAULT, id_FASTEST;
+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_write, id_gets, id_width, id_height, id_color_model, id_read,
+	  id_components;
+static VALUE sym_icc_profile, sym_exif, sym_quality, sym_bufsize;
+
+static struct jpeg_error_mgr jerr;
+
+struct buf_dest_mgr {
+    struct jpeg_destination_mgr pub;
+    VALUE io;
+    JOCTET *buffer;
+    size_t alloc;
+    size_t total;
+};
+
+struct readerdata {
+    struct jpeg_decompress_struct cinfo;
+    struct jpeg_source_mgr mgr;
+
+    int header_read;
+    int locked;
+
+    VALUE source_io;
+    VALUE buffer;
+};
+
+static ID
+j_dct_method_to_id(J_DCT_METHOD dct_method)
+{
+    switch (dct_method) {
+	case JDCT_ISLOW: return id_ISLOW;
+	case JDCT_IFAST: return id_IFAST;
+	case JDCT_FLOAT: return id_FLOAT;
+    }
+
+    return Qnil;
+}
+
+static J_DCT_METHOD
+id_to_j_dct_method(ID rb)
+{
+    if      (rb == id_ISLOW) return JDCT_ISLOW;
+    else if (rb == id_IFAST) return JDCT_IFAST;
+    else if (rb == id_FLOAT) return JDCT_FLOAT;
+
+    return (J_DCT_METHOD)NULL;
+}
+
+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;
+    }
+
+    return id_UNKNOWN;
+}
+
+static J_COLOR_SPACE
+id_to_j_color_space(ID rb)
+{
+    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;
+    else if (rb == id_UNKNOWN)   return JCS_UNKNOWN;
+
+    rb_raise(rb_eRuntimeError, "Color Space not recognized.");
+}
+
+static int
+sym_to_marker_code(VALUE sym)
+{
+    ID rb = SYM2ID(sym);
+
+    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;
+    else if (rb == id_COM)   return JPEG_COM;
+
+    rb_raise(rb_eRuntimeError, "Marker code not recognized.");
+}
+
+static void
+reset_buffer(struct buf_dest_mgr *dest)
+{
+    dest->pub.next_output_byte = dest->buffer;
+    dest->pub.free_in_buffer = dest->alloc;
+}
+
+static void
+init_destination(j_compress_ptr cinfo)
+{
+    struct buf_dest_mgr *dest = (struct buf_dest_mgr *) cinfo->dest;
+    size_t size = dest->alloc * sizeof(JOCTET);
+
+    /* Allocate the output buffer --- it will be released when done */
+    dest->buffer = (JOCTET *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo,
+							  JPOOL_IMAGE, size);
+    dest->total = 0;
+    reset_buffer(dest);
+}
+
+static boolean
+empty_output_buffer(j_compress_ptr cinfo)
+{
+    VALUE str, write_len;
+    struct buf_dest_mgr *dest = (struct buf_dest_mgr *) cinfo->dest;
+    size_t write_len_i;
+
+    str = rb_str_new(dest->buffer, dest->alloc);
+
+    write_len = rb_funcall(dest->io, id_write, 1, str);
+    /* in 1.8.7, NUM2INT gives funny numbers for Symbols */
+    if (SYMBOL_P(write_len))
+	rb_raise(rb_eTypeError, "write returned a symbol.");
+
+    write_len_i = (size_t)NUM2INT(write_len);
+    dest->total += write_len_i;
+    if (write_len_i != dest->alloc)
+	rb_raise(rb_eRuntimeError, "Write Error. Wrote %d instead of %d bytes.",
+		 (int)write_len_i, (int)dest->alloc);
+
+    reset_buffer(dest);
+
+    return TRUE;
+}
+
+static void
+term_destination(j_compress_ptr cinfo)
+{
+    struct buf_dest_mgr *dest = (struct buf_dest_mgr *) cinfo->dest;
+    size_t write_len_i, len = dest->alloc - dest->pub.free_in_buffer;
+    VALUE str, write_len;
+
+    if (len > 0) {
+	str = rb_str_new(dest->buffer, len);
+	write_len = rb_funcall(dest->io, id_write, 1, str);
+	/* in 1.8.7, NUM2INT gives funny numbers for Symbols */
+	if (SYMBOL_P(write_len))
+	    rb_raise(rb_eTypeError, "write returned a symbol.");
+	write_len_i = (size_t)NUM2INT(write_len);
+	dest->total += write_len_i;
+	if (write_len_i != len)
+	    rb_raise(rb_eRuntimeError, "Write Error. Wrote %d instead of %d bytes.",
+		     (int)write_len_i, (int)len);
+    }
+}
+
+static VALUE
+write_scanline(VALUE scan_line, j_compress_ptr cinfo)
+{
+    JSAMPROW row_pointer[1];
+
+    if (TYPE(scan_line) != T_STRING)
+	scan_line = rb_obj_as_string(scan_line);
+
+    if (RSTRING_LEN(scan_line) != cinfo->image_width * cinfo->num_components)
+	rb_raise(rb_eRuntimeError, "Scanline has a bad size. Expected %d but got %d.",
+		 (int)(cinfo->image_width * cinfo->num_components),
+		 (int)RSTRING_LEN(scan_line));
+
+    row_pointer[0] = (JSAMPLE *)RSTRING_PTR(scan_line);
+    jpeg_write_scanlines(cinfo, row_pointer, 1);
+    return Qnil;
+}
+
+static int
+write_exif(j_compress_ptr cinfo, char *str, int len)
+{
+    if (len > MAX_EXIF_DATA_LEN) {
+	rb_raise(rb_eRuntimeError, "Exif data is too large. Max is %d.",
+		 MAX_EXIF_DATA_LEN);
+    }
+
+    jpeg_write_m_header(cinfo, EXIF_MARKER,
+			(unsigned int) (len + EXIF_OVERHEAD_LEN));
+
+    jpeg_write_m_byte(cinfo, 0x45);
+    jpeg_write_m_byte(cinfo, 0x78);
+    jpeg_write_m_byte(cinfo, 0x69);
+    jpeg_write_m_byte(cinfo, 0x66);
+    jpeg_write_m_byte(cinfo, 0x0);
+    jpeg_write_m_byte(cinfo, 0x0);
+
+    /* Add the profile data */
+    while (len--) {
+	jpeg_write_m_byte(cinfo, *str);
+	str++;
+    }
+}
+
+static void
+write_configure(j_compress_ptr cinfo, VALUE image_in, VALUE quality)
+{
+    VALUE color_model, width, components, rb_height;
+    int height;
+
+    width = rb_funcall(image_in, id_width, 0);
+    /* in 1.8.7, NUM2INT gives funny numbers for Symbols */
+    if (SYMBOL_P(width))
+	rb_raise(rb_eTypeError, "source image has a symbol for width.");
+    cinfo->image_width = NUM2INT(width);
+
+    rb_height = rb_funcall(image_in, id_height, 0);
+    /* in 1.8.7, NUM2INT gives funny numbers for Symbols */
+    if (SYMBOL_P(rb_height))
+	rb_raise(rb_eTypeError, "source image has a symbol for height.");
+
+    height = NUM2INT(rb_height);
+    if (height < 1)
+	rb_raise(rb_eRuntimeError, "Source image gave an invalid height.");
+    cinfo->image_height = height;
+
+    components = rb_funcall(image_in, id_components, 0);
+    /* in 1.8.7, NUM2INT gives funny numbers for Symbols */
+    if (SYMBOL_P(components))
+	rb_raise(rb_eTypeError, "source image has a symbol for components.");
+    cinfo->input_components = NUM2INT(components);
+
+    color_model = rb_funcall(image_in, id_color_model, 0);
+    if (SYMBOL_P(color_model))
+	cinfo->in_color_space = id_to_j_color_space(SYM2ID(color_model));
+    else
+	rb_raise(rb_eTypeError, "source image has a non symbol color space");
+
+    /* in 1.8.7, NUM2INT gives funny numbers for Symbols */
+    if (SYMBOL_P(quality))
+	rb_raise(rb_eTypeError, "symbol for quality.");
+
+
+    jpeg_set_defaults(cinfo);
+
+    if(!NIL_P(quality))
+	jpeg_set_quality(cinfo, NUM2INT(quality), TRUE);
+}
+
+static void
+write_header(j_compress_ptr cinfo, VALUE icc, VALUE exif)
+{
+    if(!NIL_P(icc)) {
+	StringValue(icc);
+	write_icc_profile(cinfo, RSTRING_PTR(icc), RSTRING_LEN(icc));
+    }
+
+    if (!NIL_P(exif)) {
+	StringValue(exif);
+	write_exif(cinfo, RSTRING_PTR(exif), RSTRING_LEN(exif));
+    }
+}
+
+static VALUE
+write_jpeg3(VALUE *args)
+{
+    VALUE image_in, scanline, quality, icc_profile, exif;
+    j_compress_ptr cinfo;
+    struct buf_dest_mgr *mgr;
+    size_t i;
+
+    cinfo = (j_compress_ptr) args[0];
+    image_in = args[1];
+    quality = args[2];
+    icc_profile = args[3];
+    exif = args[4];
+
+    write_configure(cinfo, image_in, quality);
+
+    jpeg_start_compress(cinfo, TRUE);
+
+    write_header(cinfo, icc_profile, exif);
+
+    for (i = 0; i < cinfo->image_height; i++) {
+	scanline = rb_funcall(image_in, id_gets, 0);
+	write_scanline(scanline, cinfo);
+    }
+
+    jpeg_finish_compress(cinfo);
+
+    mgr = (struct buf_dest_mgr *)(cinfo->dest);
+    return INT2FIX(mgr->total);
+}
+
+static VALUE
+write_jpeg3_ensure(VALUE *args)
+{
+    jpeg_destroy_compress((j_compress_ptr) args[0]);
+    return INT2FIX(0);
+}
+
+static VALUE
+write_jpeg2(VALUE image_in, VALUE io_out, size_t bufsize, VALUE icc_profile,
+	    VALUE exif, VALUE quality)
+{
+    struct jpeg_compress_struct cinfo;
+    struct buf_dest_mgr mgr;
+    VALUE ensure_args[5];
+
+    cinfo.err = &jerr;
+
+    jpeg_create_compress(&cinfo);
+
+    mgr.pub.init_destination = init_destination;
+    mgr.pub.empty_output_buffer = empty_output_buffer;
+    mgr.pub.term_destination = term_destination;
+    mgr.alloc = 1024;
+    mgr.io = io_out;
+    cinfo.dest = (struct jpeg_destination_mgr *)&mgr;
+
+    ensure_args[0] = (VALUE)&cinfo;
+    ensure_args[1] = image_in;
+    ensure_args[2] = quality;
+    ensure_args[3] = icc_profile;
+    ensure_args[4] = exif;
+
+    return rb_ensure(write_jpeg3, (VALUE)ensure_args, write_jpeg3_ensure,
+		     (VALUE)ensure_args);
+}
+
+/*
+ *  call-seq:
+ *     write(image_in, io_out [, options]) -> integer
+ *
+ *  Writes the given image +image_in+ to +io_out+ as compressed JPEG data.
+ *  Returns the number of bytes written.
+ *
+ *  +options+ may contain the following symbols:
+ *
+ *     * :bufsize - the size in bytes of the writes that will be made to
+ *        +io_out+.
+ *     * :quality - the JPEG quality on a 0..100 scale.
+ *     * :exif - raw exif data that will be saved in the header.
+ *     * :icc_profile - raw icc profile that will be saved in the header.
+ *
+ *  Example:
+ *     image = Axon::Solid.new(200, 300)
+ *     io = File.open("test.jpg", "w")
+ *     Axon::JPEG.write(image, io)     #=> 1234
+ */
+
+static VALUE
+write_jpeg(int argc, VALUE *argv, VALUE self)
+{
+    VALUE image_in, io_out, rb_bufsize, icc_profile, exif, quality, options;
+    int bufsize;
+
+    rb_scan_args(argc, argv, "21", &image_in, &io_out, &options);
+
+    bufsize = WRITE_BUFSIZE;
+
+    if (!NIL_P(options) && TYPE(options) == T_HASH) {
+	rb_bufsize = rb_hash_aref(options, sym_bufsize);
+	/* in 1.8.7, NUM2INT gives funny numbers for Symbols */
+	if (SYMBOL_P(rb_bufsize))
+	    rb_raise(rb_eTypeError, "symbol for bufsize.");
+
+	if (!NIL_P(rb_bufsize)) {
+	    bufsize = NUM2INT(rb_bufsize);
+	    if (bufsize < 1)
+		rb_raise(rb_eRuntimeError, "Buffer size must be greater than zero");
+	}
+
+	icc_profile = rb_hash_aref(options, sym_icc_profile);
+	exif = rb_hash_aref(options, sym_exif);
+	quality = rb_hash_aref(options, sym_quality);
+    } else {
+	icc_profile = Qnil;
+	exif = Qnil;
+	quality = Qnil;
+    }
+
+    return write_jpeg2(image_in, io_out, bufsize, icc_profile, exif, quality);
+}
+
+static void
+error_exit(j_common_ptr cinfo)
+{
+    char buffer[JMSG_LENGTH_MAX];
+    (*cinfo->err->format_message) (cinfo, buffer);
+    rb_raise(rb_eRuntimeError, "jpeglib: %s", buffer);
+}
+
+static void
+output_message(j_common_ptr cinfo)
+{
+    /* do nothing */
+}
+
+static void
+init_jerror(struct jpeg_error_mgr * err)
+{
+    jpeg_std_error(err);
+    err->error_exit = error_exit;
+    err->output_message = output_message;
+}
+
+static void
+raise_if_locked(struct readerdata *reader)
+{
+    if (reader->locked)
+	rb_raise(rb_eRuntimeError, "Can't modify a locked Reader");
+}
+
+static void
+deallocate(struct readerdata *reader)
+{
+    jpeg_abort_decompress(&reader->cinfo);
+    jpeg_destroy_decompress(&reader->cinfo);
+    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);
+}
+
+/* Data Source Callbacks */
+
+static void
+init_source(j_decompress_ptr cinfo)
+{
+    /* do nothing */
+}
+
+static void
+term_source(j_decompress_ptr cinfo)
+{
+    /* do nothing */
+}
+
+static void
+set_input_buffer(struct readerdata *reader, VALUE string)
+{
+    size_t nbytes = 0;
+    JOCTET *buffer;
+
+    if (!NIL_P(string)) {
+	StringValue(string);
+	OBJ_FREEZE(string);
+	nbytes = (size_t)RSTRING_LEN(string);
+	buffer = (JOCTET *)RSTRING_PTR(string);
+	reader->buffer = string;
+    }
+
+    if (!nbytes) {
+	nbytes = 2;
+	reader->buffer = rb_str_new(0, 2);
+
+	buffer = (JOCTET *)RSTRING_PTR(reader->buffer);
+	buffer[0] = (JOCTET) 0xFF;
+	buffer[1] = (JOCTET) JPEG_EOI;
+    }
+
+    reader->mgr.next_input_byte = buffer;
+    reader->mgr.bytes_in_buffer = nbytes;
+}
+
+static boolean
+fill_input_buffer(j_decompress_ptr cinfo)
+{
+    VALUE string;
+    struct readerdata *reader;
+
+    reader = (struct readerdata *)cinfo;
+    string = rb_funcall(reader->source_io, id_read, 1, INT2FIX(READ_SIZE));
+    set_input_buffer(reader, string);
+
+    return TRUE;
+}
+
+static void
+skip_input_data(j_decompress_ptr cinfo, long num_bytes)
+{
+    struct jpeg_source_mgr * src = cinfo->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) (cinfo);
+	}
+	src->next_input_byte += (size_t) num_bytes;
+	src->bytes_in_buffer -= (size_t) num_bytes;
+    }
+}
+
+static VALUE
+allocate(VALUE klass)
+{
+    struct readerdata *reader;
+    VALUE self;
+
+    self = Data_Make_Struct(klass, struct readerdata, mark, deallocate, reader);
+
+    reader->cinfo.err = &jerr;
+    jpeg_create_decompress(&reader->cinfo);
+
+    reader->cinfo.src = &reader->mgr;
+    reader->mgr.init_source = init_source;
+    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 = term_source;
+
+    return self;
+}
+
+static VALUE
+read_header2(VALUE arg)
+{
+    struct readerdata *reader;
+
+    reader = (struct readerdata *)arg;
+    jpeg_read_header(&reader->cinfo, TRUE);
+    reader->header_read = 1;
+
+    return Qnil;
+}
+
+static void
+read_header(struct readerdata *reader, VALUE markers)
+{
+    int i, marker_code, state;
+    j_decompress_ptr cinfo;
+
+    cinfo = &reader->cinfo;
+
+    if(NIL_P(markers)) {
+	jpeg_save_markers(cinfo, JPEG_COM, 0xFFFF);
+
+	for (i = 0; i < 16; i++)
+	    jpeg_save_markers(cinfo, JPEG_APP0 + i, 0xFFFF);
+    } else {
+	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(cinfo, marker_code, 0xFFFF);
+	}
+    }
+
+    rb_protect(read_header2, (VALUE)reader, &state);
+
+    if(state) {
+      jpeg_abort_decompress(&reader->cinfo);
+      rb_jump_tag(state);
+    }
+
+    jpeg_calc_output_dimensions(cinfo);
+}
+
+/*
+ *  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 = Axon::JPEG::Reader.new(io)
+ * 
+ *     io = File.open("image.jpg", "r")
+ *     reader = Axon::JPEG::Reader.new(io, [:APP4, :APP5])
+ */
+
+static VALUE
+initialize(int argc, VALUE *argv, VALUE self)
+{
+    struct readerdata *reader;
+    j_decompress_ptr cinfo;
+    VALUE io, markers;
+    int i;
+
+    Data_Get_Struct(self, struct readerdata, reader);
+    raise_if_locked(reader);
+    cinfo = &reader->cinfo;
+
+    rb_scan_args(argc, argv, "11", &io, &markers);
+
+    reader->source_io = io;
+    reader->mgr.bytes_in_buffer = 0;
+
+    read_header(reader, markers);
+
+    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 * cinfo;
+    Data_Get_Struct(self, struct jpeg_decompress_struct, cinfo);
+    return INT2FIX(cinfo->num_components);
+}
+
+/*
+ *  call-seq:
+ *     reader.in_color_model -> 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 nil if the color model is not recognized.
+ */
+
+static VALUE
+in_color_model(VALUE self)
+{
+    struct jpeg_decompress_struct * cinfo;
+    ID id;
+
+    Data_Get_Struct(self, struct jpeg_decompress_struct, cinfo);
+    id = j_color_space_to_id(cinfo->jpeg_color_space);
+
+    return ID2SYM(id);
+}
+
+/*
+ *  call-seq:
+ *     reader.in_color_model = symbol
+ *
+ *  Explicitly sets the color model the JPEG will be read in. This will override
+ *  the guessed color model.
+ */
+
+static VALUE
+set_in_color_model(VALUE self, VALUE cs)
+{
+    struct readerdata *reader;
+
+    Data_Get_Struct(self, struct readerdata, reader);
+    raise_if_locked(reader);
+    reader->cinfo.jpeg_color_space = id_to_j_color_space(SYM2ID(cs));
+
+    return cs;
+}
+
+/*
+ *  call-seq:
+ *     reader.color_model -> symbol
+ *
+ *  Returns a symbol representing the color model into which the JPEG will be
+ *  transformed as it is read.
+ *
+ *  Possible color models are: :GRAYSCALE, :RGB, :YCbCr, :CMYK, and :YCCK. This
+ *  method will return nil if the color model is not recognized.
+ */
+
+static VALUE
+color_model(VALUE self)
+{
+    ID id;
+    struct jpeg_decompress_struct * cinfo;
+
+    Data_Get_Struct(self, struct jpeg_decompress_struct, cinfo);
+
+    id = j_color_space_to_id(cinfo->out_color_space);
+    return ID2SYM(id);
+}
+
+/*
+ *  call-seq:
+ *     reader.color_model = symbol
+ *
+ *  Explicitly sets the color model to which the JPEG will be transformed as it
+ *  is read.
+ *
+ *  Legal transformations are:
+ *  :YCbCr to :GRAYSCALE, :YCbCr to :RGB, :GRAYSCALE to :RGB, and :YCCK to :CMYK
+ */
+
+static VALUE
+set_color_model(VALUE self, VALUE cs)
+{
+    struct readerdata *reader;
+
+    Data_Get_Struct(self, struct readerdata, reader);
+    raise_if_locked(reader);
+
+    reader->cinfo.out_color_space = id_to_j_color_space(SYM2ID(cs));
+    return cs;
+}
+
+/*
+ *  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 * cinfo;
+    Data_Get_Struct(self, struct jpeg_decompress_struct, cinfo);
+    return INT2FIX(cinfo->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.
+ *
+ *  Prior to version 1.2, libjpeg-turbo will not scale down images on
+ *  decompression, and this option will do nothing.
+ */
+
+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->cinfo.scale_num = NUM2INT(scale_num);
+    jpeg_calc_output_dimensions(&reader->cinfo);
+    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 * cinfo;
+    Data_Get_Struct(self, struct jpeg_decompress_struct, cinfo);
+    return INT2FIX(cinfo->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->cinfo.scale_denom = NUM2INT(scale_denom);
+    jpeg_calc_output_dimensions(&reader->cinfo);
+    return scale_denom;
+}
+
+/*
+ *  call-seq:
+ *     reader.dct_method -> symbol
+ *
+ *  Returns a symbol representing the algorithm used for the DCT (discrete
+ *  cosine transform) step in JPEG encoding.
+ *
+ *  Possible DCT algorithms are: :ISLOW, :IFAST, and :IFLOAT.
+ */
+
+static VALUE
+dct_method(VALUE self)
+{
+    struct jpeg_decompress_struct * cinfo;
+    ID id;
+
+    Data_Get_Struct(self, struct jpeg_decompress_struct, cinfo);
+
+    id = j_dct_method_to_id(cinfo->dct_method);
+
+    if (NIL_P(id))
+	return Qnil;
+    else
+	return ID2SYM(id);
+}
+
+/*
+ *  call-seq:
+ *     reader.dct_method = symbol
+ *
+ *  Sets the algorithm used for the DCT step in JPEG encoding.
+ *
+ *  Possible DCT algorithms are: :ISLOW, :IFAST, and :IFLOAT.
+ */
+
+static VALUE
+set_dct_method(VALUE self, VALUE dct_method)
+{
+    struct readerdata *reader;
+    J_DCT_METHOD val;
+
+    Data_Get_Struct(self, struct readerdata, reader);
+    raise_if_locked(reader);
+
+    val = id_to_j_dct_method(SYM2ID(dct_method));
+    if (val == (J_DCT_METHOD)NULL) {
+	return Qnil;
+    } else {
+	reader->cinfo.dct_method = val;
+	return dct_method;
+    }
+}
+
+static VALUE
+j_gets2(struct readerdata *reader)
+{
+    struct jpeg_decompress_struct * cinfo;
+    VALUE sl;
+    int width, components, sl_width, ret;
+    JSAMPROW ijg_buffer;
+
+    cinfo = &reader->cinfo;
+
+    width      = cinfo->output_width;
+    components = cinfo->output_components;
+
+    sl_width = width * components;
+
+    sl = rb_str_new(0, sl_width);
+    ijg_buffer = (JSAMPROW)RSTRING_PTR(sl);
+    ret = jpeg_read_scanlines(cinfo, &ijg_buffer, 1);
+
+    return ret == 0 ? Qnil : sl;
+}
+
+/*
+ *  call-seq:
+ *     gets -> string or nil
+ *
+ *  Reads the next scanline of data from the image. Once the first scanline has
+ *  been read you can no longer change read options for this reader.
+ *
+ *  If the end of the image has been reached, this will return nil.
+ */
+
+static VALUE
+j_gets(VALUE self)
+{
+    struct jpeg_decompress_struct * cinfo;
+    struct readerdata *reader;
+
+    Data_Get_Struct(self, struct readerdata, reader);
+
+    if (!reader->header_read)
+      read_header(reader, Qnil);
+
+    if (reader->locked == 0) {
+	reader->locked = 1;
+	jpeg_start_decompress(&reader->cinfo);
+    }
+
+    return j_gets2(reader);
+}
+
+/*
+ *  call-seq:
+ *     reader.width -> number
+ *
+ *  Retrieve the width of the image as it will be written out. This can be
+ *  affected by scale_num and scale_denom if they are set.
+ */
+
+static VALUE
+width(VALUE self)
+{
+    struct jpeg_decompress_struct * cinfo;
+    Data_Get_Struct(self, struct jpeg_decompress_struct, cinfo);
+    return INT2FIX(cinfo->output_width);
+}
+
+/*
+ *  call-seq:
+ *     reader.height -> number
+ *
+ *  Retrieve the height of the image as it will be written out. This can be
+ *  affected by scale_num and scale_denom if they are set.
+ */
+
+static VALUE
+height(VALUE self)
+{
+    struct jpeg_decompress_struct * cinfo;
+    Data_Get_Struct(self, struct jpeg_decompress_struct, cinfo);
+    return INT2FIX(cinfo->output_height);
+}
+
+/*
+ *  call-seq:
+ *     reader.icc_profile -> string
+ *
+ *  Read the raw icc_profile from the JPEG. This requires that the APP2 segment
+ *  has been selected by initialize (this is the default behaviour).
+ */
+
+static VALUE
+icc_profile(VALUE self)
+{
+    struct jpeg_decompress_struct * cinfo;
+    JOCTET *icc_embed_buffer;
+    unsigned int icc_embed_len;
+    VALUE str;
+
+    Data_Get_Struct(self, struct jpeg_decompress_struct, cinfo);
+    read_icc_profile(cinfo, &icc_embed_buffer, &icc_embed_len);
+
+    if (icc_embed_len <= 0) {
+	return Qnil;
+    } else {
+	str = rb_str_new(icc_embed_buffer, icc_embed_len);
+	free(icc_embed_buffer);
+	return str;
+    }
+}
+
+static boolean
+marker_is_exif(jpeg_saved_marker_ptr marker)
+{
+    return marker->marker == EXIF_MARKER &&
+	   marker->data_length >= EXIF_OVERHEAD_LEN &&
+	   /* verify the identifying string */
+	   GETJOCTET(marker->data[0]) == 0x45 &&
+	   GETJOCTET(marker->data[1]) == 0x78 &&
+	   GETJOCTET(marker->data[2]) == 0x69 &&
+	   GETJOCTET(marker->data[3]) == 0x66 &&
+	   GETJOCTET(marker->data[4]) == 0x0  &&
+	   GETJOCTET(marker->data[5]) == 0x0;
+}
+
+/*
+ *  call-seq:
+ *     reader.exif -> string
+ *
+ *  Get the raw Exif data from the JPEG. This requires that the APP1 segment
+ *  has been selected by initialize (this is the default behavior).
+ */
+
+static VALUE
+exif(VALUE self)
+{
+    struct jpeg_decompress_struct * cinfo;
+    jpeg_saved_marker_ptr marker;
+    int len;
+
+    Data_Get_Struct(self, struct jpeg_decompress_struct, cinfo);
+
+    for (marker = cinfo->marker_list; marker != NULL; marker = marker->next) {
+	if (marker_is_exif(marker)) {
+	    len = marker->data_length - EXIF_OVERHEAD_LEN;
+	    return rb_str_new(marker->data + EXIF_OVERHEAD_LEN, len);
+	}
+    }
+
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     reader[marker] -> array
+ *
+ *  Read raw data from the given JPEG header marker. Note that the marker must
+ *  have been specified by initialize.
+ *
+ *  The return from this method is an array, since there may be multiple
+ *  instances of a single marker in a JPEG header.
+ */
+
+static VALUE
+aref(VALUE self, VALUE marker_sym)
+{
+    struct jpeg_decompress_struct * cinfo;
+    jpeg_saved_marker_ptr marker;
+    VALUE ary = rb_ary_new();
+    int marker_i = sym_to_marker_code(marker_sym);
+
+    Data_Get_Struct(self, struct jpeg_decompress_struct, cinfo);
+
+    for (marker = cinfo->marker_list; marker != NULL; marker = marker->next)
+	if (marker->marker == marker_i)
+	    rb_ary_push(ary, rb_str_new(marker->data, marker->data_length));
+
+    return ary;
+}
+
+/*
+ *  call-seq:
+ *     reader.saw_jfif_marker -> boolean
+ *
+ *  Indicates whether a JFIF marker was found in the header.
+ */
+
+static VALUE
+saw_jfif_marker(VALUE self)
+{
+    struct jpeg_decompress_struct * cinfo;
+    Data_Get_Struct(self, struct jpeg_decompress_struct, cinfo);
+    return cinfo->saw_JFIF_marker ? Qtrue : Qfalse;
+}
+
+/*
+ *  call-seq:
+ *     reader.saw_adobe_marker -> boolean
+ *
+ *  Indicates whether an Adobe marker was found in the header.
+ */
+
+static VALUE
+saw_adobe_marker(VALUE self)
+{
+    struct jpeg_decompress_struct * cinfo;
+    Data_Get_Struct(self, struct jpeg_decompress_struct, cinfo);
+    return cinfo->saw_Adobe_marker ? Qtrue : Qfalse;
+}
+
+/*
+ *  call-seq:
+ *     reader.lineno -> number
+ *
+ *  Returns the number of the next line to be read from the image, starting at
+ *  0.
+ */
+
+static VALUE
+lineno(VALUE self)
+{
+    struct jpeg_decompress_struct * cinfo;
+    Data_Get_Struct(self, struct jpeg_decompress_struct, cinfo);
+    return INT2FIX(cinfo->output_scanline);
+}
+
+/*
+ * Document-class: Axon::JPEG::Reader
+ *
+ * Read compressed JPEG images from an IO.
+ */
+
+void
+Init_JPEG()
+{
+    VALUE mAxon, mJPEG, cJPEGReader;
+
+    init_jerror(&jerr);
+
+    mAxon = rb_define_module("Axon");
+    mJPEG = rb_define_module_under(mAxon, "JPEG");
+    rb_const_set(mJPEG, rb_intern("LIB_VERSION"), INT2FIX(JPEG_LIB_VERSION));
+#ifdef JCS_EXTENSIONS
+    rb_const_set(mJPEG, rb_intern("LIB_TURBO"), Qtrue);
+#else
+    rb_const_set(mJPEG, rb_intern("LIB_TURBO"), Qfalse);
+#endif
+    rb_define_singleton_method(mJPEG, "write", write_jpeg, -1);
+
+    cJPEGReader = rb_define_class_under(mJPEG, "Reader", rb_cObject);
+    rb_define_alloc_func(cJPEGReader, allocate);
+    rb_define_method(cJPEGReader, "initialize", initialize, -1);
+    rb_define_method(cJPEGReader, "icc_profile", icc_profile, 0);
+    rb_define_method(cJPEGReader, "exif", exif, 0);
+    rb_define_method(cJPEGReader, "saw_jfif_marker", saw_jfif_marker, 0);
+    rb_define_method(cJPEGReader, "saw_adobe_marker", saw_adobe_marker, 0);
+    rb_define_method(cJPEGReader, "[]", aref, 1);
+    rb_define_method(cJPEGReader, "in_color_model", in_color_model, 0);
+    rb_define_method(cJPEGReader, "in_color_model=", set_in_color_model, 1);
+    rb_define_method(cJPEGReader, "color_model", color_model, 0);
+    rb_define_method(cJPEGReader, "color_model=", set_color_model, 1);
+    rb_define_method(cJPEGReader, "components", components, 0);
+    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, "dct_method", dct_method, 0);
+    rb_define_method(cJPEGReader, "dct_method=", set_dct_method, 1);
+    rb_define_method(cJPEGReader, "width", width, 0);
+    rb_define_method(cJPEGReader, "height", height, 0);
+    rb_define_method(cJPEGReader, "lineno", lineno, 0);
+    rb_define_method(cJPEGReader, "gets", j_gets, 0);
+
+    id_IFAST = rb_intern("IFAST");
+    id_ISLOW = rb_intern("ISLOW");
+    id_FLOAT = rb_intern("FLOAT");
+    id_DEFAULT = rb_intern("DEFAULT");
+    id_FASTEST = rb_intern("FASTEST");
+
+    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");
+    id_write = rb_intern("write");
+    id_width = rb_intern("width");
+    id_height = rb_intern("height");
+    id_color_model = rb_intern("color_model");
+    id_components = rb_intern("components");
+    id_gets = rb_intern("gets");
+
+    sym_icc_profile = ID2SYM(rb_intern("icc_profile"));
+    sym_exif = ID2SYM(rb_intern("exif"));
+    sym_quality = ID2SYM(rb_intern("quality"));
+    sym_bufsize = ID2SYM(rb_intern("bufsize"));
+
+    rb_const_set(cJPEGReader, rb_intern("DEFAULT_DCT"),
+		 ID2SYM(j_dct_method_to_id(JDCT_DEFAULT)));
+    rb_const_set(cJPEGReader, rb_intern("FASTEST_DCT"),
+		 ID2SYM(j_dct_method_to_id(JDCT_FASTEST)));
+}