axon 0.0.1

data/CHANGELOG.rdoc

@@ -0,0 +1,3 @@
+=== 0.0.1 / 2011-08-01
+
+* Initial Release

data/README.rdoc

@@ -0,0 +1,104 @@
+= 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.
+
+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 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.
+
+== FEATURES:
+
+* Read and Write JPEG and PNG images.
+* Scale images using bilinear (fast!) or nearest-neighbor (even faster!)
+  interpolation.
+* Crop images.
+
+== 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)
+
+  # 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])
+
+  puts image.width
+  puts image.height
+  puts image[:APP2]
+  image.scale_denom = 4
+
+  jpeg = image.fit(100, 100).to_jpeg
+  jpeg.quality = 88
+  jpeg.write(io)
+
+== BASIC API:
+
+There are three basic object types: Image, Reader and Writer.
+
+Every Image object has the following methods:
+
+  * Image#height, Image#width
+    These are the output dimensions 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.
+
+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.
+pnglib version 1.2.x or later.
+
+== INSTALL:
+
+gem install axon
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2011
+
+* {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

@@ -0,0 +1,30 @@
+require 'rubygems'
+require 'hoe'
+
+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"] }
+end
+
+require "rake/extensiontask"
+
+Rake::ExtensionTask.new('axon', HOE.spec) do |ext|
+  ext.lib_dir = File.join('lib', 'axon')
+end
+
+Rake::Task[:test].prerequisites << :compile
+
+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
+end
+
+desc 'Watch Memory use of a looping test'
+task 'test_loop_mem' do
+  system 'watch "ps aux | grep Itest"'
+end

data/TODO.rdoc

@@ -0,0 +1,12 @@
+= TODO
+  * 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

@@ -0,0 +1,20 @@
+#include <ruby.h>
+
+#include "jpeg_common.h"
+#include "png_common.h"
+#include "interpolation.h"
+
+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();
+}

data/ext/axon/bilinear_interpolation.c

@@ -0,0 +1,115 @@
+#include <ruby.h>
+
+static ID id_image, id_components, id_width_ratio, id_width;
+
+
+/*     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
+interpolate_scanline2(size_t width, double width_ratio, size_t components,
+                      double ty, char *scanline1, char *scanline2)
+{
+    VALUE rb_dest_sl;
+    double 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);
+    
+    for (i = 0; i < width; i++) {
+        sample_x = i / width_ratio;
+        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;    
+}
+
+/*
+ *  call-seq:
+ *     image.interpolate_scanline(original_scanlines, q) -> interpolated_scanline
+ *     Expects the instance variable @image to respond to components, and
+ *     expects the intance variable @width_ratio to respond to the ratio that
+ *     we will resample our width to.
+ */
+static VALUE
+interpolate_scanline(VALUE self, VALUE orig_scanline1, VALUE orig_scanline2,
+                     VALUE rb_sample_y)
+{
+    VALUE rb_components, rb_width_ratio, rb_image, rb_width;
+    double width_ratio, ty, sample_y;
+    unsigned char *scanline1, *scanline2;
+    size_t width, components;
+
+    rb_width = rb_ivar_get(self, id_width);
+    width = FIX2INT(rb_width);
+
+    rb_image = rb_ivar_get(self, id_image);
+    rb_components = rb_funcall(rb_image, id_components, 0);
+    components = FIX2INT(rb_components);
+
+    rb_width_ratio = rb_ivar_get(self, id_width_ratio);
+    width_ratio = NUM2DBL(rb_width_ratio);
+
+    sample_y = NUM2DBL(rb_sample_y);
+    ty = sample_y - (int)sample_y;
+
+    scanline1 = RSTRING_PTR(orig_scanline1);
+    scanline2 = RSTRING_PTR(orig_scanline2);
+
+    return interpolate_scanline2(width, width_ratio, components, ty, scanline1,
+                                 scanline2);
+}
+
+void
+Init_bilinear_interpolation()
+{
+    VALUE mAxon = rb_define_module("Axon");
+    VALUE mBilinearScaling = rb_define_module_under(mAxon, "BilinearScaling");
+    rb_define_method(mBilinearScaling, "interpolate_scanline", interpolate_scanline, 3);
+    
+    id_width = rb_intern("@width");
+    id_width_ratio = rb_intern("@width_ratio");
+    id_image = rb_intern("@image");
+    id_components = rb_intern("components");
+}

data/ext/axon/extconf.rb

@@ -0,0 +1,21 @@
+require 'mkmf'
+
+$CFLAGS += " -g -O0" if ENV['GCC_DEBUG']
+
+unless find_header('jpeglib.h')
+  abort "libjpeg headers are missing. Please install libjpeg headers."
+end
+
+unless have_library('jpeg', nil)
+  abort "libjpeg is missing. Please install libjpeg."
+end
+
+unless find_header('png.h')
+  abort "libpng headers are missing. Please install libpng headers."
+end
+
+unless have_library('png', nil)
+  abort "libpng is missing. Please install libpng."
+end
+
+create_makefile('jpeg/axon')

data/ext/axon/iccjpeg.c

@@ -0,0 +1,248 @@
+/*
+ * iccprofile.c
+ *
+ * This file provides code to read and write International Color Consortium
+ * (ICC) device profiles embedded in JFIF JPEG image files.  The ICC has
+ * defined a standard format for including such data in JPEG "APP2" markers.
+ * The code given here does not know anything about the internal structure
+ * of the ICC profile data; it just knows how to put the profile data into
+ * a JPEG file being written, or get it back out when reading.
+ *
+ * This code depends on new features added to the IJG JPEG library as of
+ * IJG release 6b; it will not compile or work with older IJG versions.
+ *
+ * NOTE: this code would need surgery to work on 16-bit-int machines
+ * with ICC profiles exceeding 64K bytes in size.  If you need to do that,
+ * change all the "unsigned int" variables to "INT32".  You'll also need
+ * to find a malloc() replacement that can allocate more than 64K.
+ */
+
+#include "iccjpeg.h"
+#include <stdlib.h>			/* define malloc() */
+
+
+/*
+ * Since an ICC profile can be larger than the maximum size of a JPEG marker
+ * (64K), we need provisions to split it into multiple markers.  The format
+ * defined by the ICC specifies one or more APP2 markers containing the
+ * following data:
+ *	Identifying string	ASCII "ICC_PROFILE\0"  (12 bytes)
+ *	Marker sequence number	1 for first APP2, 2 for next, etc (1 byte)
+ *	Number of markers	Total number of APP2's used (1 byte)
+ *      Profile data		(remainder of APP2 data)
+ * Decoders should use the marker sequence numbers to reassemble the profile,
+ * rather than assuming that the APP2 markers appear in the correct sequence.
+ */
+
+#define ICC_MARKER  (JPEG_APP0 + 2)	/* JPEG marker code for ICC */
+#define ICC_OVERHEAD_LEN  14		/* size of non-profile data in APP2 */
+#define MAX_BYTES_IN_MARKER  65533	/* maximum data len of a JPEG marker */
+#define MAX_DATA_BYTES_IN_MARKER  (MAX_BYTES_IN_MARKER - ICC_OVERHEAD_LEN)
+
+
+/*
+ * This routine writes the given ICC profile data into a JPEG file.
+ * It *must* be called AFTER calling jpeg_start_compress() and BEFORE
+ * the first call to jpeg_write_scanlines().
+ * (This ordering ensures that the APP2 marker(s) will appear after the
+ * SOI and JFIF or Adobe markers, but before all else.)
+ */
+
+void
+write_icc_profile (j_compress_ptr cinfo,
+		   const JOCTET *icc_data_ptr,
+		   unsigned int icc_data_len)
+{
+  unsigned int num_markers;	/* total number of markers we'll write */
+  int cur_marker = 1;		/* per spec, counting starts at 1 */
+  unsigned int length;		/* number of bytes to write in this marker */
+
+  /* Calculate the number of markers we'll need, rounding up of course */
+  num_markers = icc_data_len / MAX_DATA_BYTES_IN_MARKER;
+  if (num_markers * MAX_DATA_BYTES_IN_MARKER != icc_data_len)
+    num_markers++;
+
+  while (icc_data_len > 0) {
+    /* length of profile to put in this marker */
+    length = icc_data_len;
+    if (length > MAX_DATA_BYTES_IN_MARKER)
+      length = MAX_DATA_BYTES_IN_MARKER;
+    icc_data_len -= length;
+
+    /* Write the JPEG marker header (APP2 code and marker length) */
+    jpeg_write_m_header(cinfo, ICC_MARKER,
+			(unsigned int) (length + ICC_OVERHEAD_LEN));
+
+    /* Write the marker identifying string "ICC_PROFILE" (null-terminated).
+     * We code it in this less-than-transparent way so that the code works
+     * even if the local character set is not ASCII.
+     */
+    jpeg_write_m_byte(cinfo, 0x49);
+    jpeg_write_m_byte(cinfo, 0x43);
+    jpeg_write_m_byte(cinfo, 0x43);
+    jpeg_write_m_byte(cinfo, 0x5F);
+    jpeg_write_m_byte(cinfo, 0x50);
+    jpeg_write_m_byte(cinfo, 0x52);
+    jpeg_write_m_byte(cinfo, 0x4F);
+    jpeg_write_m_byte(cinfo, 0x46);
+    jpeg_write_m_byte(cinfo, 0x49);
+    jpeg_write_m_byte(cinfo, 0x4C);
+    jpeg_write_m_byte(cinfo, 0x45);
+    jpeg_write_m_byte(cinfo, 0x0);
+
+    /* Add the sequencing info */
+    jpeg_write_m_byte(cinfo, cur_marker);
+    jpeg_write_m_byte(cinfo, (int) num_markers);
+
+    /* Add the profile data */
+    while (length--) {
+      jpeg_write_m_byte(cinfo, *icc_data_ptr);
+      icc_data_ptr++;
+    }
+    cur_marker++;
+  }
+}
+
+
+/*
+ * Prepare for reading an ICC profile
+ */
+
+void
+setup_read_icc_profile (j_decompress_ptr cinfo)
+{
+  /* Tell the library to keep any APP2 data it may find */
+  jpeg_save_markers(cinfo, ICC_MARKER, 0xFFFF);
+}
+
+
+/*
+ * Handy subroutine to test whether a saved marker is an ICC profile marker.
+ */
+
+static boolean
+marker_is_icc (jpeg_saved_marker_ptr marker)
+{
+  return
+    marker->marker == ICC_MARKER &&
+    marker->data_length >= ICC_OVERHEAD_LEN &&
+    /* verify the identifying string */
+    GETJOCTET(marker->data[0]) == 0x49 &&
+    GETJOCTET(marker->data[1]) == 0x43 &&
+    GETJOCTET(marker->data[2]) == 0x43 &&
+    GETJOCTET(marker->data[3]) == 0x5F &&
+    GETJOCTET(marker->data[4]) == 0x50 &&
+    GETJOCTET(marker->data[5]) == 0x52 &&
+    GETJOCTET(marker->data[6]) == 0x4F &&
+    GETJOCTET(marker->data[7]) == 0x46 &&
+    GETJOCTET(marker->data[8]) == 0x49 &&
+    GETJOCTET(marker->data[9]) == 0x4C &&
+    GETJOCTET(marker->data[10]) == 0x45 &&
+    GETJOCTET(marker->data[11]) == 0x0;
+}
+
+
+/*
+ * See if there was an ICC profile in the JPEG file being read;
+ * if so, reassemble and return the profile data.
+ *
+ * TRUE is returned if an ICC profile was found, FALSE if not.
+ * If TRUE is returned, *icc_data_ptr is set to point to the
+ * returned data, and *icc_data_len is set to its length.
+ *
+ * IMPORTANT: the data at **icc_data_ptr has been allocated with malloc()
+ * and must be freed by the caller with free() when the caller no longer
+ * needs it.  (Alternatively, we could write this routine to use the
+ * IJG library's memory allocator, so that the data would be freed implicitly
+ * at jpeg_finish_decompress() time.  But it seems likely that many apps
+ * will prefer to have the data stick around after decompression finishes.)
+ *
+ * NOTE: if the file contains invalid ICC APP2 markers, we just silently
+ * return FALSE.  You might want to issue an error message instead.
+ */
+
+boolean
+read_icc_profile (j_decompress_ptr cinfo,
+		  JOCTET **icc_data_ptr,
+		  unsigned int *icc_data_len)
+{
+  jpeg_saved_marker_ptr marker;
+  int num_markers = 0;
+  int seq_no;
+  JOCTET *icc_data;
+  unsigned int total_length;
+#define MAX_SEQ_NO  255		/* sufficient since marker numbers are bytes */
+  char marker_present[MAX_SEQ_NO+1];	  /* 1 if marker found */
+  unsigned int data_length[MAX_SEQ_NO+1]; /* size of profile data in marker */
+  unsigned int data_offset[MAX_SEQ_NO+1]; /* offset for data in marker */
+
+  *icc_data_ptr = NULL;		/* avoid confusion if FALSE return */
+  *icc_data_len = 0;
+
+  /* This first pass over the saved markers discovers whether there are
+   * any ICC markers and verifies the consistency of the marker numbering.
+   */
+
+  for (seq_no = 1; seq_no <= MAX_SEQ_NO; seq_no++)
+    marker_present[seq_no] = 0;
+
+  for (marker = cinfo->marker_list; marker != NULL; marker = marker->next) {
+    if (marker_is_icc(marker)) {
+      if (num_markers == 0)
+	num_markers = GETJOCTET(marker->data[13]);
+      else if (num_markers != GETJOCTET(marker->data[13]))
+	return FALSE;		/* inconsistent num_markers fields */
+      seq_no = GETJOCTET(marker->data[12]);
+      if (seq_no <= 0 || seq_no > num_markers)
+	return FALSE;		/* bogus sequence number */
+      if (marker_present[seq_no])
+	return FALSE;		/* duplicate sequence numbers */
+      marker_present[seq_no] = 1;
+      data_length[seq_no] = marker->data_length - ICC_OVERHEAD_LEN;
+    }
+  }
+
+  if (num_markers == 0)
+    return FALSE;
+
+  /* Check for missing markers, count total space needed,
+   * compute offset of each marker's part of the data.
+   */
+
+  total_length = 0;
+  for (seq_no = 1; seq_no <= num_markers; seq_no++) {
+    if (marker_present[seq_no] == 0)
+      return FALSE;		/* missing sequence number */
+    data_offset[seq_no] = total_length;
+    total_length += data_length[seq_no];
+  }
+
+  if (total_length <= 0)
+    return FALSE;		/* found only empty markers? */
+
+  /* Allocate space for assembled data */
+  icc_data = (JOCTET *) malloc(total_length * sizeof(JOCTET));
+  if (icc_data == NULL)
+    return FALSE;		/* oops, out of memory */
+
+  /* and fill it in */
+  for (marker = cinfo->marker_list; marker != NULL; marker = marker->next) {
+    if (marker_is_icc(marker)) {
+      JOCTET FAR *src_ptr;
+      JOCTET *dst_ptr;
+      unsigned int length;
+      seq_no = GETJOCTET(marker->data[12]);
+      dst_ptr = icc_data + data_offset[seq_no];
+      src_ptr = marker->data + ICC_OVERHEAD_LEN;
+      length = data_length[seq_no];
+      while (length--) {
+	*dst_ptr++ = *src_ptr++;
+      }
+    }
+  }
+
+  *icc_data_ptr = icc_data;
+  *icc_data_len = total_length;
+
+  return TRUE;
+}

data/ext/axon/iccjpeg.h

@@ -0,0 +1,73 @@
+/*
+ * iccprofile.h
+ *
+ * This file provides code to read and write International Color Consortium
+ * (ICC) device profiles embedded in JFIF JPEG image files.  The ICC has
+ * defined a standard format for including such data in JPEG "APP2" markers.
+ * The code given here does not know anything about the internal structure
+ * of the ICC profile data; it just knows how to put the profile data into
+ * a JPEG file being written, or get it back out when reading.
+ *
+ * This code depends on new features added to the IJG JPEG library as of
+ * IJG release 6b; it will not compile or work with older IJG versions.
+ *
+ * NOTE: this code would need surgery to work on 16-bit-int machines
+ * with ICC profiles exceeding 64K bytes in size.  See iccprofile.c
+ * for details.
+ */
+
+#include <stdio.h>		/* needed to define "FILE", "NULL" */
+#include "jpeglib.h"
+
+
+/*
+ * This routine writes the given ICC profile data into a JPEG file.
+ * It *must* be called AFTER calling jpeg_start_compress() and BEFORE
+ * the first call to jpeg_write_scanlines().
+ * (This ordering ensures that the APP2 marker(s) will appear after the
+ * SOI and JFIF or Adobe markers, but before all else.)
+ */
+
+extern void write_icc_profile JPP((j_compress_ptr cinfo,
+				   const JOCTET *icc_data_ptr,
+				   unsigned int icc_data_len));
+
+
+/*
+ * Reading a JPEG file that may contain an ICC profile requires two steps:
+ *
+ * 1. After jpeg_create_decompress() but before jpeg_read_header(),
+ *    call setup_read_icc_profile().  This routine tells the IJG library
+ *    to save in memory any APP2 markers it may find in the file.
+ *
+ * 2. After jpeg_read_header(), call read_icc_profile() to find out
+ *    whether there was a profile and obtain it if so.
+ */
+
+
+/*
+ * Prepare for reading an ICC profile
+ */
+
+extern void setup_read_icc_profile JPP((j_decompress_ptr cinfo));
+
+
+/*
+ * See if there was an ICC profile in the JPEG file being read;
+ * if so, reassemble and return the profile data.
+ *
+ * TRUE is returned if an ICC profile was found, FALSE if not.
+ * If TRUE is returned, *icc_data_ptr is set to point to the
+ * returned data, and *icc_data_len is set to its length.
+ *
+ * IMPORTANT: the data at **icc_data_ptr has been allocated with malloc()
+ * and must be freed by the caller with free() when the caller no longer
+ * needs it.  (Alternatively, we could write this routine to use the
+ * IJG library's memory allocator, so that the data would be freed implicitly
+ * at jpeg_finish_decompress() time.  But it seems likely that many apps
+ * will prefer to have the data stick around after decompression finishes.)
+ */
+
+extern boolean read_icc_profile JPP((j_decompress_ptr cinfo,
+				     JOCTET **icc_data_ptr,
+				     unsigned int *icc_data_len));

data/ext/axon/interpolation.h

@@ -0,0 +1,7 @@
+#ifndef  AXON_INTERPOLATION_H
+#define  AXON_INTERPOLATION_H
+
+void Init_bilinear_interpolation();
+void Init_nearest_neighbor_interpolation();
+
+#endif