oil 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8667c59ce2f99a70651d4f217513aa0de0ee294b444bba1dcfa5e6123d841c18
-  data.tar.gz: b32ae44e0fc03708e7ea10a4f0e9b10378377fcc1ce78c6e74a15f56a543526c
+  metadata.gz: 43f7b2521cd984aa636d4d3f55d72b25b3e58f99ddfbaf1fa52dff9dc3e9369d
+  data.tar.gz: 753964c879c07214b84cba0ea49e629e4bff83e490999bfe19fef0fc82c2ce91
 SHA512:
-  metadata.gz: 33d09f09e4f4f897e98e50496415485d5ed5861b0ee260fd6eee7cb491c93d1844ec4567957d3dfeb4491be23f9fdd10e3ec9ba544e0d7b0c88d23d785146aca
-  data.tar.gz: ec308eb4710bc46faffbe24d802539d6fabf33d0a37e2edf2fd6c2706508fac486efb12e8bbc41960e7b4f018f1bda286054fc1526564210441875fcb83a1eaf
+  metadata.gz: cb401d8f26646728db46c67c887e040fe04faf06dacb49f19738102be2defc0b872745dd7166d55a9bf64fb174e7bf9976032e690ed713b5c66fde3ea47f5bb2
+  data.tar.gz: a0620f7f9e1e6c8e1688c2e4c5cbb1c8934613f48c83b5a41b463eacfa24afafb721ae62d5dc1fb8b273c2b6c77de4b293d197bc40da92ffe8f8e73d6875829a

data/MIT-LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2018 Timothy Elliott
+Copyright (c) 2019 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

data/Rakefile

@@ -6,7 +6,7 @@ Rake::ExtensionTask.new('oil') do |ext|
   ext.lib_dir = 'lib/oil'
 end
 
-s = Gem::Specification.new('oil', '0.2.0') do |s|
+s = Gem::Specification.new('oil', '0.2.1') do |s|
   s.license = 'MIT'
   s.summary = 'Resize JPEG and PNG images.'
   s.description = 'Resize JPEG and PNG images, aiming for fast performance and low memory use.'
@@ -17,8 +17,12 @@ s = Gem::Specification.new('oil', '0.2.0') do |s|
     README.rdoc
     MIT-LICENSE
     lib/oil.rb
-    ext/oil/resample.c
-    ext/oil/resample.h
+    ext/oil/oil_resample.c
+    ext/oil/oil_resample.h
+    ext/oil/oil_libjpeg.c
+    ext/oil/oil_libjpeg.h
+    ext/oil/oil_libpng.c
+    ext/oil/oil_libpng.h
     ext/oil/jpeg.c
     ext/oil/png.c
     ext/oil/oil.c

data/ext/oil/jpeg.c

@@ -1,7 +1,7 @@
 #include <ruby.h>
 #include <ruby/st.h>
 #include <jpeglib.h>
-#include "resample.h"
+#include "oil_libjpeg.h"
 
 #define READ_SIZE 1024
 #define WRITE_SIZE 1024
@@ -170,8 +170,8 @@ struct readerdata {
 	int locked;
 	VALUE source_io;
 	VALUE buffer;
-	uint32_t scale_width;
-	uint32_t scale_height;
+	int scale_width;
+	int scale_height;
 };
 
 static void null_jdecompress(j_decompress_ptr dinfo) {}
@@ -754,8 +754,7 @@ struct write_jpeg_args {
 	struct writerdata *writer;
 	unsigned char *inwidthbuf;
 	unsigned char *outwidthbuf;
-	struct yscaler ys;
-	struct preprocess_xscaler xs;
+	struct oil_libjpeg ol;
 };
 
 static VALUE each2(struct write_jpeg_args *args)
@@ -763,12 +762,13 @@ static VALUE each2(struct write_jpeg_args *args)
 	struct writerdata *writer;
 	struct jpeg_decompress_struct *dinfo;
 	struct jpeg_compress_struct *cinfo;
-	unsigned char *outwidthbuf, *xinbuf;
-	uint16_t *yinbuf;
-	uint32_t i, scalex, scaley;
+	unsigned char *outwidthbuf;
+	int i, scalex, scaley;
 	VALUE quality, markers;
+	struct oil_libjpeg *ol;
 
 	writer = args->writer;
+	ol = &args->ol;
 	outwidthbuf = args->outwidthbuf;
 	dinfo = &args->reader->dinfo;
 	cinfo = &writer->cinfo;
@@ -784,8 +784,6 @@ static VALUE each2(struct write_jpeg_args *args)
 	writer->cinfo.in_color_space = dinfo->out_color_space;
 	writer->cinfo.input_components = dinfo->output_components;
 
-	xinbuf = args->inwidthbuf;
-
 	jpeg_set_defaults(cinfo);
 
 	if (!NIL_P(args->opts)) {
@@ -806,12 +804,8 @@ static VALUE each2(struct write_jpeg_args *args)
 		}
 	}
 
-	for(i=0; i<scaley; i++) {
-		while ((yinbuf = yscaler_next(&args->ys))) {
-			jpeg_read_scanlines(dinfo, (JSAMPARRAY)&xinbuf, 1);
-			preprocess_xscaler_scale(&args->xs, xinbuf, yinbuf);
-		}
-		yscaler_scale(&args->ys, outwidthbuf, i);
+	for(i=scaley; i>0; i--) {
+		oil_libjpeg_read_scanline(ol, outwidthbuf);
 		jpeg_write_scanlines(cinfo, (JSAMPARRAY)&outwidthbuf, 1);
 	}
 
@@ -820,24 +814,6 @@ static VALUE each2(struct write_jpeg_args *args)
 	return Qnil;
 }
 
-static enum oil_colorspace jpeg_cs_to_oil(J_COLOR_SPACE cs)
-{
-	switch(cs) {
-	case JCS_GRAYSCALE:
-		return OIL_CS_G;
-	case JCS_RGB:
-		return OIL_CS_RGB;
-	case JCS_CMYK:
-		return OIL_CS_CMYK;
-#ifdef JCS_EXTENSIONS
-	case JCS_EXT_RGBX:
-		return OIL_CS_RGBX;
-#endif
-	default:
-		rb_raise(rb_eRuntimeError, "Color space not recognized.");
-	}
-}
-
 /*
  * call-seq:
  *    reader.each(opts, &block) -> self
@@ -856,12 +832,10 @@ static VALUE each(int argc, VALUE *argv, VALUE self)
 {
 	struct readerdata *reader;
 	struct writerdata writer;
-	int state;
+	int state, width_out, ret;
 	struct write_jpeg_args args;
-	unsigned char *inwidthbuf, *outwidthbuf;
-	uint32_t width_in, width_out;
+	unsigned char *outwidthbuf;
 	VALUE opts;
-	enum oil_colorspace cs;
 
 	rb_scan_args(argc, argv, "01", &opts);
 
@@ -877,27 +851,29 @@ static VALUE each(int argc, VALUE *argv, VALUE self)
 	writer.cinfo.err = &reader->jerr;
 	jpeg_create_compress(&writer.cinfo);
 
-	cs = jpeg_cs_to_oil(reader->dinfo.out_color_space);
-	width_in = reader->dinfo.output_width;
 	width_out = reader->scale_width;
-	inwidthbuf = malloc(width_in * CS_TO_CMP(cs));
-	outwidthbuf = malloc(width_out * CS_TO_CMP(cs));
-	preprocess_xscaler_init(&args.xs, width_in, width_out, cs);
-	yscaler_init(&args.ys, reader->dinfo.output_height, reader->scale_height,
-		width_out, cs);
+	ret = oil_libjpeg_init(&args.ol, &reader->dinfo, width_out,
+		reader->scale_height);
+	if (ret!=0) {
+		jpeg_destroy_compress(&writer.cinfo);
+		rb_raise(rb_eRuntimeError, "Unable to allocate memory.");
+	}
+	outwidthbuf = malloc(width_out * OIL_CMP(args.ol.os.cs));
+	if (!outwidthbuf) {
+		oil_libjpeg_free(&args.ol);
+		jpeg_destroy_compress(&writer.cinfo);
+		rb_raise(rb_eRuntimeError, "Unable to allocate memory.");
+	}
 
 	args.reader = reader;
 	args.opts = opts;
 	args.writer = &writer;
-	args.inwidthbuf = inwidthbuf;
 	args.outwidthbuf = outwidthbuf;
 	reader->locked = 1;
 	rb_protect((VALUE(*)(VALUE))each2, (VALUE)&args, &state);
 
-	yscaler_free(&args.ys);
-	preprocess_xscaler_free(&args.xs);
+	oil_libjpeg_free(&args.ol);
 	free(outwidthbuf);
-	free(inwidthbuf);
 	jpeg_destroy_compress(&writer.cinfo);
 
 	if (state) {

data/ext/oil/oil.c

@@ -1,13 +1,14 @@
 #include <ruby.h>
-#include "resample.h"
+#include "oil_resample.h"
 
 static VALUE rb_fix_ratio(VALUE self, VALUE src_w, VALUE src_h, VALUE out_w, VALUE out_h)
 {
-	uint32_t out_width, out_height;
+	int out_width, out_height;
 	VALUE ret;
+
 	out_width = NUM2INT(out_w);
 	out_height = NUM2INT(out_h);
-	fix_ratio(NUM2INT(src_w), NUM2INT(src_h), &out_width, &out_height);
+	oil_fix_ratio(NUM2INT(src_w), NUM2INT(src_h), &out_width, &out_height);
 	ret = rb_ary_new2(2);
 	rb_ary_push(ret, INT2FIX(out_width));
 	rb_ary_push(ret, INT2FIX(out_height));

data/ext/oil/oil_libjpeg.c

@@ -0,0 +1,104 @@
+/**
+ * Copyright (c) 2014-2019 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.
+ */
+
+#include "oil_libjpeg.h"
+#include <stdlib.h>
+
+int oil_libjpeg_init(struct oil_libjpeg *ol,
+	struct jpeg_decompress_struct *dinfo, int out_width, int out_height)
+{
+	int ret;
+	enum oil_colorspace cs;
+
+	ol->dinfo = dinfo;
+
+	cs = jpeg_cs_to_oil(dinfo->out_color_space);
+	if (cs == OIL_CS_UNKNOWN) {
+		return -1;
+	}
+
+	ol->inbuf = malloc(dinfo->output_width * dinfo->output_components);
+	if (!ol->inbuf) {
+		return -2;
+	}
+
+	ret = oil_scale_init(&ol->os, dinfo->output_height, out_height,
+		dinfo->output_width, out_width, cs);
+	if (ret!=0) {
+		free(ol->inbuf);
+		return ret;
+	}
+
+	return 0;
+}
+
+void oil_libjpeg_free(struct oil_libjpeg *ol)
+{
+	if (ol->inbuf) {
+		free(ol->inbuf);
+	}
+	oil_scale_free(&ol->os);
+}
+
+void oil_libjpeg_read_scanline(struct oil_libjpeg *ol, unsigned char *outbuf)
+{
+	int i;
+
+	for (i=oil_scale_slots(&ol->os); i>0; i--) {
+		jpeg_read_scanlines(ol->dinfo, &ol->inbuf, 1);
+		oil_scale_in(&ol->os, ol->inbuf);
+	}
+	oil_scale_out(&ol->os, outbuf);
+}
+
+enum oil_colorspace jpeg_cs_to_oil(J_COLOR_SPACE cs)
+{
+	switch(cs) {
+	case JCS_GRAYSCALE:
+		return OIL_CS_G;
+	case JCS_RGB:
+		return OIL_CS_RGB;
+	case JCS_CMYK:
+		return OIL_CS_CMYK;
+#ifdef JCS_EXTENSIONS
+	case JCS_EXT_RGBX:
+	case JCS_EXT_BGRX:
+		return OIL_CS_RGBX;
+#endif
+	default:
+		return OIL_CS_UNKNOWN;
+	}
+}
+
+J_COLOR_SPACE oil_cs_to_jpeg(enum oil_colorspace cs)
+{
+	switch(cs) {
+	case OIL_CS_G:
+		return JCS_GRAYSCALE;
+	case OIL_CS_RGB:
+		return JCS_RGB;
+	case OIL_CS_CMYK:
+		return JCS_CMYK;
+	default:
+		return JCS_UNKNOWN;
+	}
+}
+

data/ext/oil/oil_libjpeg.h

@@ -0,0 +1,57 @@
+/**
+ * Copyright (c) 2014-2019 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 OIL_LIBJPEG_H
+#define OIL_LIBJPEG_H
+
+#include <stdio.h>
+#include <jpeglib.h>
+#include "oil_resample.h"
+
+struct oil_libjpeg {
+	struct oil_scale os;
+	struct jpeg_decompress_struct *dinfo;
+	unsigned char *inbuf;
+};
+
+/**
+ * Initialize an oil_libjpeg struct.
+ * @ol: Pointer to the struct to be initialized.
+ * @dinfo: Pointer to a libjpeg decompress struct, with header already read.
+ * @out_height: Desired height, in pixels, of the output image.
+ * @out_width: Desired width, in pixels, of the output image.
+ *
+ * Returns 0 on success.
+ * Returns -1 if an argument is bad.
+ * Returns -2 if unable to allocate memory.
+ */
+int oil_libjpeg_init(struct oil_libjpeg *ol,
+	struct jpeg_decompress_struct *dinfo, int out_width, int out_height);
+
+void oil_libjpeg_free(struct oil_libjpeg *ol);
+
+void oil_libjpeg_read_scanline(struct oil_libjpeg *ol, unsigned char *outbuf);
+
+enum oil_colorspace jpeg_cs_to_oil(J_COLOR_SPACE cs);
+
+J_COLOR_SPACE oil_cs_to_jpeg(enum oil_colorspace cs);
+
+#endif

data/ext/oil/oil_libpng.c

@@ -0,0 +1,161 @@
+/**
+ * Copyright (c) 2014-2019 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.
+ */
+
+#include "oil_libpng.h"
+#include <stdlib.h>
+
+static unsigned char **alloc_full_image_buf(int height, int rowbytes)
+{
+	int i, j;
+	unsigned char **imgbuf;
+
+	imgbuf = malloc(height * sizeof(unsigned char *));
+	if (!imgbuf) {
+		return NULL;
+	}
+	for (i=0; i<height; i++) {
+		imgbuf[i] = malloc(rowbytes);
+		if (!imgbuf[i]) {
+			for (j=0; j<i-1; j++) {
+				free(imgbuf[j]);
+			}
+			free(imgbuf);
+			return NULL;
+		}
+	}
+	return imgbuf;
+}
+
+static void free_full_image_buf(unsigned char **imgbuf, int height)
+{
+	int i;
+	for (i=0; i<height; i++) {
+		free(imgbuf[i]);
+	}
+	free(imgbuf);
+}
+
+int oil_libpng_init(struct oil_libpng *ol, png_structp rpng, png_infop rinfo,
+	int out_width, int out_height)
+{
+	int ret, in_width, in_height, buf_len;
+	enum oil_colorspace cs;
+
+	ol->rpng = rpng;
+	ol->rinfo = rinfo;
+	ol->in_vpos = 0;
+	ol->inbuf = NULL;
+	ol->inimage = NULL;
+
+	cs = png_cs_to_oil(png_get_color_type(rpng, rinfo));
+	if (cs == OIL_CS_UNKNOWN) {
+		return -1;
+	}
+
+	in_width = png_get_image_width(rpng, rinfo);
+	in_height = png_get_image_height(rpng, rinfo);
+	ret = oil_scale_init(&ol->os, in_height, out_height, in_width,
+		out_width, cs);
+	if (ret!=0) {
+		free(ol->inbuf);
+		return ret;
+	}
+
+	buf_len = png_get_rowbytes(rpng, rinfo);
+	switch (png_get_interlace_type(rpng, rinfo)) {
+	case PNG_INTERLACE_NONE:
+		ol->inbuf = malloc(buf_len);
+		if (!ol->inbuf) {
+			oil_scale_free(&ol->os);
+			return -2;
+		}
+		break;
+	case PNG_INTERLACE_ADAM7:
+		ol->inimage = alloc_full_image_buf(in_height, buf_len);
+		if (!ol->inimage) {
+			oil_scale_free(&ol->os);
+			return -2;
+		}
+		png_read_image(rpng, ol->inimage);
+		break;
+	}
+
+	return 0;
+}
+
+void oil_libpng_free(struct oil_libpng *ol)
+{
+	if (ol->inbuf) {
+		free(ol->inbuf);
+	}
+	if (ol->inimage) {
+		free_full_image_buf(ol->inimage, ol->os.in_height);
+	}
+	oil_scale_free(&ol->os);
+}
+
+static void read_scanline_interlaced(struct oil_libpng *ol, unsigned char *outbuf)
+{
+	int i;
+
+	for (i=oil_scale_slots(&ol->os); i>0; i--) {
+		oil_scale_in(&ol->os, ol->inimage[ol->in_vpos++]);
+	}
+}
+
+static void read_scanline(struct oil_libpng *ol, unsigned char *outbuf)
+{
+	int i;
+
+	for (i=oil_scale_slots(&ol->os); i>0; i--) {
+		png_read_row(ol->rpng, ol->inbuf, NULL);
+		oil_scale_in(&ol->os, ol->inbuf);
+	}
+}
+
+void oil_libpng_read_scanline(struct oil_libpng *ol, unsigned char *outbuf)
+{
+	switch (png_get_interlace_type(ol->rpng, ol->rinfo)) {
+	case PNG_INTERLACE_NONE:
+		read_scanline(ol, outbuf);
+		break;
+	case PNG_INTERLACE_ADAM7:
+		read_scanline_interlaced(ol, outbuf);
+		break;
+	}
+	oil_scale_out(&ol->os, outbuf);
+}
+
+enum oil_colorspace png_cs_to_oil(png_byte cs)
+{
+	switch(cs) {
+	case PNG_COLOR_TYPE_GRAY:
+		return OIL_CS_G;
+	case PNG_COLOR_TYPE_GA:
+		return OIL_CS_GA;
+	case PNG_COLOR_TYPE_RGB:
+		return OIL_CS_RGB;
+	case PNG_COLOR_TYPE_RGBA:
+		return OIL_CS_RGBA;
+	default:
+		return OIL_CS_UNKNOWN;
+	}
+}