oil 0.0.3 → 0.1.0

data/ext/oil/resample.h

@@ -0,0 +1,46 @@
+#ifndef RESAMPLE_H
+#define RESAMPLE_H
+
+#define OIL_FILLER 1
+
+/**
+ * Scale scanline in to the scanline out.
+ */
+void xscale(unsigned char *in, long in_width, unsigned char *out,
+	long out_width, int cmp, int opts);
+
+/**
+ * Indicate how many taps will be required to scale an image. The number of taps
+ * required indicates how tall a strip needs to be.
+ */
+long calc_taps(long dim_in, long dim_out);
+
+/**
+ * Given input & output dimensions and an output position, return the
+ * corresponding input position and put the sub-pixel remainder in rest.
+ */
+long split_map(unsigned long dim_in, unsigned long dim_out, unsigned long pos,
+	float *rest);
+
+/**
+ * Scale a strip. The height parameter indicates the height of the strip, not
+ * the height of the image.
+ *
+ * The strip_height parameter indicates how many scanlines we are passing in. It
+ * must be a multiple of 4.
+ *
+ * The in parameter points to an array of scanlines, each with width samples in
+ * sample_fmt format. There must be at least strip_height scanlines in the
+ * array.
+ *
+ * The ty parameter indicates how far our mapped sampling position is from the
+ * center of the strip.
+ *
+ * Note that all scanlines in the strip must be populated, even when this
+ * requires scanlines that are less than 0 or larger than the height of the
+ * source image.
+ */
+void strip_scale(void **in, long strip_height, long width, void *out, float ty,
+	int cmp, int opts);
+
+#endif

data/ext/oil/yscaler.c

@@ -0,0 +1,138 @@
+#include "yscaler.h"
+#include <stdlib.h>
+#include <stdint.h>
+
+/**
+ * Initializes a strip of height scanlines.
+ *
+ * Scanlines are allocated with a size of len bytes.
+ */
+static void strip_init(struct strip *st, uint32_t height, size_t buflen)
+{
+	uint32_t i;
+
+	st->height = height;
+	st->rr = 0;
+	st->sl = malloc(height * sizeof(uint8_t *));
+	st->virt = malloc(height * sizeof(uint8_t *));
+	for (i=0; i<height; i++) {
+		st->sl[i] = malloc(buflen);
+		st->virt[i] = st->sl[0];
+	}
+}
+
+/**
+ * Frees memory allocated at initialization.
+ */
+static void strip_free(struct strip *st)
+{
+	uint32_t i;
+
+	for (i=0; i<st->height; i++) {
+		free(st->sl[i]);
+	}
+	free(st->sl);
+	free(st->virt);
+}
+
+/**
+ * Shifts the virtual scanline pointers downwards by one.
+ *
+ * The bottmomost virtual scanline pointer is left untouched since we may have
+ * reached the end of the source image and we may want to leave it pointing at
+ * the bottom.
+ *
+ * If we have not reached the bottom of the source image this call should be
+ * followed up by strip_bottom_shift() to complete the strip shift.
+ */
+static void strip_top_shift(struct strip *st)
+{
+	uint32_t i;
+	for (i=1; i<st->height; i++) {
+		st->virt[i - 1] = st->virt[i];
+	}
+}
+
+/**
+ * Points the bottommost virtual scanline to the next allocated scanline,
+ * discarding the topmost scanline.
+ *
+ * The caller is expected to fill the bottom virtual scanline with image data
+ * after this call.
+ */
+static void strip_bottom_shift(struct strip *st)
+{
+	st->rr = (st->rr + 1) % st->height;
+	st->virt[st->height - 1] = st->sl[st->rr];
+}
+
+/**
+ * Returns a pointer to the bottommost virtual scanline.
+ */
+static void *strip_bottom(struct strip *st)
+{
+	return st->virt[st->height - 1];
+}
+
+static void yscaler_map_pos(struct yscaler *ys)
+{
+	uint32_t target;
+	target = split_map(ys->in_height, ys->out_height, ys->out_pos, &ys->ty);
+	ys->in_target = target + ys->strip.height / 2 + 1;
+}
+
+void yscaler_init(struct yscaler *ys, uint32_t in_height, uint32_t out_height,
+	uint32_t buflen)
+{
+	uint32_t taps;
+
+	ys->in_height = in_height;
+	ys->out_height = out_height;
+	ys->in_pos = 0;
+	ys->out_pos = 0;
+
+	taps = calc_taps(in_height, out_height);
+	strip_init(&ys->strip, taps, buflen);
+	yscaler_map_pos(ys);
+}
+
+void yscaler_free(struct yscaler *ys)
+{
+	strip_free(&ys->strip);
+}
+
+unsigned char *yscaler_next(struct yscaler *ys)
+{
+	struct strip *st;
+
+	st = &ys->strip;
+
+	/* We need the first scanline for top padding. */
+	if (ys->in_pos == 0) {
+		ys->in_pos++;
+		return strip_bottom(st);
+	}
+
+	while (ys->in_pos < ys->in_target) {
+		ys->in_pos++;
+		strip_top_shift(&ys->strip);
+		if (ys->in_pos <= ys->in_height) {
+			strip_bottom_shift(st);
+			return strip_bottom(st);
+		}
+	}
+
+	return 0;
+}
+
+void yscaler_scale(struct yscaler *ys, uint8_t *out, uint32_t width,
+	uint8_t cmp, uint8_t opts)
+{
+	struct strip *st;
+
+	st = &ys->strip;
+	strip_scale((void **)st->virt, st->height, width, (void *)out, ys->ty,
+		cmp, opts);
+	ys->out_pos++;
+	yscaler_map_pos(ys);
+}

data/ext/oil/yscaler.h

@@ -0,0 +1,31 @@
+#ifndef YSCALER_H
+#define YSCALER_H
+
+#include "resample.h"
+#include <stdint.h>
+
+struct strip {
+	uint32_t height;
+	uint8_t **sl;
+	uint8_t **virt;
+	uint32_t rr;
+};
+
+struct yscaler {
+	uint32_t in_height;
+	uint32_t out_height;
+	struct strip strip;
+	uint32_t in_pos;
+	uint32_t out_pos;
+	uint32_t in_target;
+	float ty;
+};
+
+void yscaler_init(struct yscaler *ys, uint32_t in_height, uint32_t out_height,
+	uint32_t buflen);
+void yscaler_free(struct yscaler *ys);
+unsigned char *yscaler_next(struct yscaler *ys);
+void yscaler_scale(struct yscaler *ys, uint8_t *out,  uint32_t width,
+	uint8_t cmp, uint8_t opts);
+
+#endif

data/lib/oil.rb

@@ -0,0 +1,77 @@
+module Oil
+  VERSION = "0.1.0"
+
+  def self.fix_ratio(sw, sh, boxw, boxh)
+    x = boxw / sw.to_f
+    y = boxh / sh.to_f
+
+    destw = boxw
+    desth = boxh
+
+    if x < y
+      desth = (sh * x).round
+    else
+      destw = (sw * y).round
+    end
+
+    if desth < 1
+      desth = 1
+    end
+
+    if destw < 1
+      destw = 1
+    end
+
+    return destw, desth
+  end
+
+  # JPEG Pre-scaling is equivalent to a box filter at an integer scale factor.
+  # We don't use this to scale down past 4x the target image size in order to
+  # get proper bicubic scaling in the final image.
+  def self.pre_scale(sw, sh, dw, dh)
+    inv_scale = sw / dw
+    inv_scale /= 4
+
+    if inv_scale >= 8
+      return 8
+    elsif inv_scale >= 4
+      return 4
+    elsif inv_scale >= 2
+      return 2
+    else
+      return 0
+    end
+  end
+
+  def self.new(io, box_width, box_height)
+    a = io.getc
+    b = io.getc
+    io.ungetc(b)
+    io.ungetc(a)
+
+    if (a == "\xFF".b && b == "\xD8".b)
+      o = JPEGReader.new(io, [:COM, :APP1, :APP2])
+      if (o.color_space == :RGB)
+        o.out_color_space = :RGBX
+      end
+    elsif (a == "\x89".b && b == "P".b)
+      o = PNGReader.new(io)
+    else
+      raise "Unknown image file format."
+    end
+
+    destw, desth = self.fix_ratio(o.width, o.height, box_width, box_height)
+    pre = self.pre_scale(o.width, o.height, box_width, box_height)
+
+    o.scale_width = destw
+    o.scale_height = desth
+
+    if o.respond_to?(:scale_denom) and pre > 0
+      o.scale_denom = pre
+    end
+
+    return o
+  end
+end
+
+require 'oil/oil.so'

data/test/helper.rb

@@ -1,12 +1,90 @@
+require 'stringio'
+
 class CustomError < RuntimeError; end
 
-class CustomIO
-  def initialize(proc, *args)
-    @parent = StringIO.new(*args)
-    @proc = proc
+class CustomIO < StringIO
+  def initialize(str, options={})
+    @read_count = options[:read_count]
+    @byte_count = options[:byte_count]
+    @read_count = 0 unless @read_count || @byte_count
+    super(str)
   end
 
-  def read(size, buf=nil)
-    @proc.call(@parent, size, buf) if @proc
+  def countdown(size)
+    ret = (@read_count && @read_count <= 0) || (@byte_count && @byte_count <= 0)
+    @read_count -= 1 if @read_count
+    @byte_count -= size if @byte_count
+    ret
   end
 end
+
+class GrowIO < CustomIO
+  def read(*args)
+    size = args[0]
+    buf = args[1]
+    return super unless countdown(size)
+    str = super(size)
+    str = str[0..-2] * 3 if str
+
+    if buf
+      buf.slice!(0,0) # this empties the buffer
+      buf << str
+    else
+      str
+    end
+  end
+end
+
+class ShrinkIO < CustomIO
+  def read(*args)
+    size = args[0]
+    return super unless countdown(size)
+    res = super(size)
+    raise RuntimeError unless res
+    new_size = res.size / 2
+    res[-1 * new_size, new_size]
+  end
+end
+
+class RaiseIO < CustomIO
+  def read(*args)
+    return super unless countdown(size)
+    raise CustomError
+  end
+end
+
+class ThrowIO < CustomIO
+  def read(*args)
+    return super unless countdown(size)
+    throw(:foo)
+  end
+end
+
+class NilIO < CustomIO
+  def read(*args)
+    super unless countdown(size)
+  end
+end
+
+class NotStringIO < CustomIO
+  def read(*args)
+    return super unless countdown(size)
+    return 78887
+  end
+end
+
+def resize_string(str, width=nil, height=nil)
+  io = StringIO.new(str)
+  width ||= 100
+  height ||= 200
+  out = binary_stringio
+  o = Oil.new(io, width, height).each{ |d| out << d }
+  out.string
+end
+
+def binary_stringio
+  io = StringIO.new
+  io.set_encoding 'ASCII-8BIT' if RUBY_VERSION >= '1.9'
+  io
+end
+

data/test/test_jpeg.rb

@@ -1,220 +1,150 @@
-require 'rubygems'
 require 'minitest/autorun'
 require 'oil'
 require 'stringio'
 require 'helper'
 
-module Oil
-  class TestJPEG < MiniTest::Unit::TestCase
-    # http://www.techsupportteam.org/forum/digital-imaging-photography/1892-worlds-smallest-valid-jpeg.html
-    JPEG_DATA = "\
-\xFF\xD8\xFF\xE0\x00\x10\x4A\x46\x49\x46\x00\x01\x01\x01\x00\x48\x00\x48\x00\
-\x00\xFF\xDB\x00\x43\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\
-\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\
-\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\
-\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xC2\x00\x0B\x08\x00\
-\x01\x00\x01\x01\x01\x11\x00\xFF\xC4\x00\x14\x10\x01\x00\x00\x00\x00\x00\x00\
-\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xFF\xDA\x00\x08\x01\x01\x00\x01\x3F\
-\x10\xFF\xD9"
-
-    def test_valid
-      validate_jpeg resize_string(JPEG_DATA)
-    end
+class TestJPEG < MiniTest::Test
+  # http://stackoverflow.com/a/2349470
+  JPEG_DATA = "\
+\xff\xd8\xff\xe0\x00\x10\x4a\x46\x49\x46\x00\x01\x01\x01\x00\x48\x00\x48\x00\
+\x00\xff\xdb\x00\x43\x00\x03\x02\x02\x02\x02\x02\x03\x02\x02\x02\x03\x03\x03\
+\x03\x04\x06\x04\x04\x04\x04\x04\x08\x06\x06\x05\x06\x09\x08\x0a\x0a\x09\x08\
+\x09\x09\x0a\x0c\x0f\x0c\x0a\x0b\x0e\x0b\x09\x09\x0d\x11\x0d\x0e\x0f\x10\x10\
+\x11\x10\x0a\x0c\x12\x13\x12\x10\x13\x0f\x10\x10\x10\xff\xc9\x00\x0b\x08\x00\
+\x01\x00\x01\x01\x01\x11\x00\xff\xcc\x00\x06\x00\x10\x10\x05\xff\xda\x00\x08\
+\x01\x01\x00\x00\x3f\x00\xd2\xcf\x20\xff\xd9".b
+
+  BIG_JPEG = begin
+    resize_string(JPEG_DATA, 2000, 2000)
+  end
 
-    def test_missing_eof
-      validate_jpeg resize_string(JPEG_DATA[0..-2])
-    end
+  def test_valid
+    o = Oil::JPEGReader.new(jpeg_io)
+    assert_equal 1, o.width
+    assert_equal 1, o.height
+  end
 
-    def test_bogus_header_marker
-      str = JPEG_DATA.dup
-      str[3] = "\x10"
-      assert_raises(RuntimeError) { resize_string(str) }
-    end
+  def test_missing_eof
+    io = StringIO.new(JPEG_DATA[0..-2])
+    o = Oil::JPEGReader.new(io)
+    assert_equal 1, o.width
+    assert_equal 1, o.height
+  end
 
-    def test_bogus_body_marker
-      str = JPEG_DATA.dup
-      str[-1] = "\x10"
-      assert_raises(RuntimeError) { resize_string(str) }
-    end
+  def test_bogus_header_marker
+    str = JPEG_DATA.dup
+    str[3] = "\x10"
+    assert_raises(RuntimeError) { resize_string(str) }
+  end
 
-    def test_calls_each_during_yield
-      io = StringIO.new(JPEG_DATA)
-      j = JPEG.new(io, 600, 600)
-      assert_raises(RuntimeError) do
-        j.each{ |d| j.each { |e| j.each { |f| } } }
-      end
-    end
-    
-    def test_alloc_each
-      io = JPEG.allocate
-      assert_raises(NoMethodError){ io.each{ |f| } }
-    end
-    
-    # Test dimensions
-    
-    def test_zero_dim
-      assert_raises(ArgumentError){ resize_string(JPEG_DATA, 0, 0) }
-    end
-    
-    def test_neg_dim
-      assert_raises(ArgumentError){ resize_string(JPEG_DATA, -1231, -123) }
-    end
-    
-    # Test io source handler
-    
-    def test_io_returns_too_much_data
-      proc = Proc.new do |io, size, buf|
-        str = io.read(size)
-        str = str[0..-2] * 2 if str
-        if buf
-          buf.slice!(0,0) # this empties the buffer
-          buf << str
-        else
-          str
-        end
-      end
-      assert_raises(RuntimeError) { custom_io proc, JPEG_DATA }
-    end
-    
-    def test_io_does_nothing
-      assert_raises(RuntimeError) { custom_io(nil) }
-    end
+  def test_bogus_body_marker
+    str = JPEG_DATA.dup
+    str[-22] = "\x10"
+    assert_raises(RuntimeError) { resize_string(str) }
+  end
 
-    def test_io_raises_exception_immediately
-      proc = Proc.new{ raise CustomError }
-      assert_raises(CustomError) { custom_io proc }
-    end
+  # Allocation tests
 
-    def test_io_throws_immediately
-      proc = Proc.new{ throw(:foo) }
-      catch(:foo){ custom_io proc }
-    end
-    
-    def test_io_raises_exception_in_body
-      flag = false
-      proc = Proc.new do |parent, size, buf|
-        raise CustomError if flag
-        flag = true
-        if buf
-          parent.read(size, buf)
-        else
-          parent.read(size)
-        end
-      end
-      assert_raises(CustomError) { custom_io proc, big_jpeg }
-    end
+  def test_multiple_initialize_leak
+    o = Oil::JPEGReader.allocate
 
-    def test_io_throws_in_body
-      flag = false
-      proc = Proc.new do |parent, size, buf|
-        throw :foo if flag
-        flag = true
-        if buf
-          parent.read(size, buf)
-        else
-          parent.read(size)
-        end
-      end
-      catch(:foo){ custom_io proc, big_jpeg }
-    end
+    o.send(:initialize, jpeg_io)
+    o.each{ |d| }
 
-    def test_io_shrinks_buffer
-      proc = Proc.new do |parent, size, buf|
-        if buf
-          parent.read(size, buf)
-          buf.slice!(0, 10)
-        else
-          res = parent.read(size)
-          res[10, -1]
-        end
-      end
-      assert_raises(RuntimeError) { custom_io(proc, big_jpeg) }
-    end
+    o.send(:initialize, jpeg_io)
+    o.each{ |d| }
+  end
 
-    def test_io_enlarges_buffer_with_eof
-      proc = Proc.new do |parent, size, buf|
-        if buf
-          parent.read(size, buf)
-          buf << buf
-        else
-          str = parent.read(size)
-          str * 2
-        end
-      end
-      
-      if(RUBY_PLATFORM =~ /java/)
-        assert_raises(RuntimeError) { custom_io(proc, big_jpeg) }
-      else
-        validate_jpeg custom_io(proc, big_jpeg) # libjpeg stops when reaches eof
-      end
-    end
+  # Test io
+
+  IO_OFFSETS = [0, 10, 20, 1023, 1024, 1025, 8191, 8192, 8193, 12000]
 
-    def test_io_seek
-      # Craft a JPEG with header content that will be skipped.
-      # Make sure an actual seek happens, and it doesn't just skip buffer.
+  def iotest(io_class)
+    IO_OFFSETS.each do |i|
+      yield io_class.new(BIG_JPEG, :byte_count => i)
     end
+  end
 
-    # Test yielding
+  def resize(io)
+    o = Oil.new(io, 20, 10).each{ |d| }
+  end
 
-    def test_raise_in_each
-      assert_raises(CustomError) do
-        io = StringIO.new(JPEG_DATA)
-        JPEG.new(io, 200, 200).each { raise CustomError }
-      end
+  def test_io_too_much_data
+    iotest(GrowIO) do |io|
+      assert_raises(RuntimeError) { resize(io) }
     end
+  end
 
-    def test_throw_in_each
-      catch(:foo) do
-        io = StringIO.new(JPEG_DATA)
-        JPEG.new(io, 200, 200).each { throw :foo }
-      end
+  def test_io_does_nothing
+    iotest(NilIO) do |io|
+      assert_raises(TypeError) { resize(io) }
     end
+  end
 
-    def test_each_shrinks_buffer
-      io = StringIO.new(JPEG_DATA)
-      io_out = binary_stringio
-      JPEG.new(io, 200, 200).each { |d| io_out << d; d.slice!(0, 4) }
-      validate_jpeg(io_out.string)
-    end
-    
-    def test_each_enlarges_buffer
-      io = StringIO.new(JPEG_DATA)
-      io_out = binary_stringio
-      JPEG.new(io, 200, 200).each { |d| io_out << d; d << "foobar" }
-      validate_jpeg(io_out.string)
+  def test_io_raises_exception
+    iotest(RaiseIO) do |io|
+      assert_raises(CustomError) { resize(io) }
     end
+  end
 
-    private
-    
-    def io(io, width=nil, height=nil)
-      width ||= 100
-      height ||= 200
-      out = binary_stringio
-      JPEG.new(io, width, height).each{ |d| out << d }
-      return out.string
+  def test_io_throws
+    iotest(ThrowIO) do |io|
+      assert_throws(:foo) { resize(io) }
     end
+  end
 
-    def custom_io(*args)
-      io CustomIO.new(*args)
+  # This causes valgrind errors, but I'm pretty sure that the libjpeg is
+  # returning uninitialized memory because the source jpeg is corrupt.
+  def test_io_shrinks_buffer
+    iotest(ShrinkIO) do |io|
+      resize(io) rescue nil
     end
+  end
 
-    def resize_string(str, width=nil, height=nil)
-      io(StringIO.new(str), width, height)
+  def test_not_string_io
+    iotest(NotStringIO) do |io|
+      assert_raises(TypeError) { resize(io) }
     end
-    
-    def validate_jpeg(data)
-      assert_equal "\xFF\xD8", data[0,2]
-      assert_equal "\xFF\xD9", data[-2, 2]
+  end
+
+  # Test yielding
+
+  def test_raise_in_each
+    assert_raises(CustomError) do
+      Oil.new(jpeg_io, 10, 20).each{ raise CustomError }
     end
+  end
 
-    def big_jpeg
-      resize_string(JPEG_DATA, 1000, 1000)
+  def test_throw_in_each
+    catch(:foo) do
+      Oil.new(jpeg_io, 10, 20).each{ throw :foo }
     end
+  end
 
-    def binary_stringio
-      io = StringIO.new
-      io.set_encoding 'ASCII-8BIT' if RUBY_VERSION >= '1.9'
-      io
+  def test_each_in_each
+    o = Oil.new(jpeg_io, 10, 20)
+    o.each do |d|
+      assert_raises(RuntimeError) do
+        o.each { |e| }
+      end
     end
   end
+
+  def test_each_shrinks_buffer
+    io = StringIO.new(JPEG_DATA)
+    io_out = binary_stringio
+    Oil.new(io, 200, 200).each{ |d| io_out << d; d.slice!(0, 4) }
+  end
+  
+  def test_each_enlarges_buffer
+    io = StringIO.new(JPEG_DATA)
+    io_out = binary_stringio
+    o = Oil.new(io, 200, 200).each{ |d| io_out << d; d << "foobar" }
+  end
+
+  private
+
+  def jpeg_io
+    StringIO.new(JPEG_DATA)
+  end
 end