oil 0.1.3 → 0.2.0

data/ext/oil/resample.h

@@ -1,46 +1,119 @@
+/**
+ * Copyright (c) 2014-2016 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.
+ */
+
 #ifndef RESAMPLE_H
 #define RESAMPLE_H
 
-#define OIL_FILLER 1
+#include <stdint.h>
+#include <stddef.h>
+
+enum oil_colorspace {
+	OIL_CS_G       = 0x0001,
+	OIL_CS_GA      = 0x0002,
+	OIL_CS_RGB     = 0x0003,
+	OIL_CS_RGBX    = 0x0004,
+	OIL_CS_RGBA    = 0x0104,
+	OIL_CS_CMYK    = 0x0204,
+};
+#define CS_TO_CMP(x) (x&0xFF)
+
+struct sl_rbuf {
+	uint32_t height; // number of scanlines that the ring buffer can hold
+	size_t length; // width in bytes of each scanline in the buffer
+	uint32_t count; // total no. of scanlines that have been fed in
+	uint16_t *buf; // buffer for the ring buffer
+	uint16_t **virt; // space to provide scanline pointers for scaling
+};
 
 /**
- * Scale scanline in to the scanline out.
+ * Struct to hold state for y-scaling.
  */
-void xscale(unsigned char *in, long in_width, unsigned char *out,
-	long out_width, int cmp, int opts);
+struct yscaler {
+	struct sl_rbuf rb; // ring buffer holding scanlines.
+	uint32_t in_height; // input image height.
+	uint32_t out_height; // output image height.
+	uint32_t width;
+	enum oil_colorspace cs;
+	uint32_t target; // where the ring buffer should be on next scaling.
+	float ty; // sub-pixel offset for next scaling.
+};
 
 /**
- * Indicate how many taps will be required to scale an image. The number of taps
- * required indicates how tall a strip needs to be.
+ * Initialize a yscaler struct. Calculates how large the scanline ring buffer
+ * will need to be and allocates it.
  */
-long calc_taps(long dim_in, long dim_out);
+int yscaler_init(struct yscaler *ys, uint32_t in_height, uint32_t out_height,
+	uint32_t width, enum oil_colorspace cs);
 
 /**
- * Given input & output dimensions and an output position, return the
- * corresponding input position and put the sub-pixel remainder in rest.
+ * Free a yscaler struct, including the ring buffer.
  */
-long split_map(unsigned long dim_in, unsigned long dim_out, unsigned long pos,
-	float *rest);
+void yscaler_free(struct yscaler *ys);
 
 /**
- * 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.
+ * Get a pointer to the next scanline to be filled in the ring buffer. Returns
+ * null if no more scanlines are needed to perform scaling.
+ */
+uint16_t *yscaler_next(struct yscaler *ys);
+
+/**
+ * Scale the buffered contents of the yscaler to produce the next scaled output
+ * scanline.
  *
- * 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.
+ * Scaled scanline will be written to the out parameter.
+ * The width parameter is the nuber of samples in each scanline.
+ * The cmp parameter is the number of components per sample (3 for RGB).
+ * The pos parameter is the position of the output scanline.
+ */
+int yscaler_scale(struct yscaler *ys, uint8_t *out, uint32_t pos);
+
+/**
+ * Struct to hold state for x-scaling.
+ */
+struct xscaler {
+	uint16_t *psl_buf;
+	uint16_t *psl_pos0;
+	size_t psl_offset;
+	uint32_t width_in;
+	uint32_t width_out;
+	enum oil_colorspace cs;
+};
+
+struct preprocess_xscaler {
+	struct xscaler xs;
+	uint32_t width_in;
+	enum oil_colorspace cs_in;
+	uint32_t scale_factor;
+};
+
+int preprocess_xscaler_init(struct preprocess_xscaler *pxs, uint32_t width_in,
+	uint32_t width_out, enum oil_colorspace cs_in);
+void preprocess_xscaler_scale(struct preprocess_xscaler *pxs, uint8_t *in,
+	uint16_t *out);
+void preprocess_xscaler_free(struct preprocess_xscaler *pxs);
+
+/**
+ * Utility helpers.
  */
-void strip_scale(void **in, long strip_height, long width, void *out, float ty,
-	int cmp, int opts);
+void fix_ratio(uint32_t src_width, uint32_t src_height, uint32_t *out_width,
+	uint32_t *out_height);
 
 #endif

data/lib/oil.rb

@@ -1,5 +1,5 @@
 module Oil
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 
   def self.sniff_signature(io)
     a = io.getc
@@ -27,30 +27,6 @@ module Oil
 
   private
 
-  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
-
   def self.new_jpeg_reader(io, box_width, box_height)
     o = JPEGReader.new(io, [:COM, :APP1, :APP2])
 
@@ -60,20 +36,7 @@ module Oil
     end
 
     # JPEG Pre-scaling is equivalent to a box filter at an integer scale factor.
-    # We don't use this to scale down past 4x the target image size in order to
-    # get proper bicubic scaling in the final image.
-    inv_scale = o.image_width / box_width
-    inv_scale /= 4
-
-    if inv_scale >= 8
-      o.scale_denom = 8
-    elsif inv_scale >= 4
-      o.scale_denom = 4
-    elsif inv_scale >= 2
-      o.scale_denom = 2
-    end
-
-    destw, desth = self.fix_ratio(o.output_width, o.output_height, box_width, box_height)
+    destw, desth = Oil.fix_ratio(o.output_width, o.output_height, box_width, box_height)
     o.scale_width = destw
     o.scale_height = desth
 

data/test/test_png.rb

@@ -42,7 +42,6 @@ class TestPNG < MiniTest::Test
   def test_bogus_end_chunk
     str = PNG_DATA.dup
     str[-6] = "\x10"
-    io = StringIO.new(str)
     o = Oil::PNGReader.new(png_io)
     assert_equal 1, o.width
     assert_equal 1, o.height
@@ -134,7 +133,7 @@ class TestPNG < MiniTest::Test
   def test_each_shrinks_buffer
     Oil::PNGReader.new(png_io).each { |d| d.slice!(0, 4) }
   end
-  
+
   def test_each_enlarges_buffer
     Oil::PNGReader.new(png_io).each { |d| d << "foobar" }
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: oil
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Timothy Elliott
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-10 00:00:00.000000000 Z
+date: 2018-03-11 00:00:00.000000000 Z
 dependencies: []
 description: Resize JPEG and PNG images, aiming for fast performance and low memory
   use.
@@ -28,8 +28,6 @@ files:
 - ext/oil/png.c
 - ext/oil/resample.c
 - ext/oil/resample.h
-- ext/oil/yscaler.c
-- ext/oil/yscaler.h
 - lib/oil.rb
 - test/helper.rb
 - test/test_jpeg.rb
@@ -54,7 +52,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Resize JPEG and PNG images.

data/ext/oil/yscaler.c

@@ -1,167 +0,0 @@
-#include "yscaler.h"
-#include "resample.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);
-}
-
-void yscaler_prealloc_scale(uint32_t in_height, uint32_t out_height,
-	uint8_t **in, uint8_t *out, uint32_t pos, uint32_t width, uint8_t cmp,
-	uint8_t opts)
-{
-	uint32_t i, taps;
-	int32_t smp_i, strip_pos;
-	uint8_t **virt;
-	float ty;
-
-	taps = calc_taps(in_height, out_height);
-	virt = malloc(taps * sizeof(uint8_t *));
-	smp_i = split_map(in_height, out_height, pos, &ty);
-	strip_pos = smp_i + 1 - taps / 2;
-
-	for (i=0; i<taps; i++) {
-		if (strip_pos < 0) {
-			virt[i] = in[0];
-		} else if ((uint32_t)strip_pos > in_height - 1) {
-			virt[i] = in[in_height - 1];
-		} else {
-			virt[i] = in[strip_pos];
-		}
-		strip_pos++;
-	}
-
-	strip_scale((void **)virt, taps, width, (void *)out, ty, cmp, opts);
-}

data/ext/oil/yscaler.h

@@ -1,33 +0,0 @@
-#ifndef YSCALER_H
-#define YSCALER_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);
-void yscaler_prealloc_scale(uint32_t in_height, uint32_t out_height,
-	uint8_t **in, uint8_t *out, uint32_t pos, uint32_t width, uint8_t cmp,
-	uint8_t opts);
-
-#endif