async-ruby-vips 1.2.1

data/ext/callback.h

@@ -0,0 +1,9 @@
+#ifndef ASYNC_VIPS_CALLBACK_H
+#define ASYNC_VIPS_CALLBACK_H
+
+#include "transform_data.h"
+
+void av_add_to_event_queue(transform_data_t* tdata);
+void init_async_vips_event_thread(void);
+
+#endif

data/ext/details.c

@@ -0,0 +1,54 @@
+#include "details.h"
+
+int image_scale_none = 0x00;
+int image_scale_stretch = 0x01;
+int image_scale_fit = 0x02;
+int image_scale_no_scale_up = 0x04;
+int image_scale_detect_proportions = 0x08; // detect if the picture width & height are need to be swapped
+int image_scale_fit_no_scale_up = 0x06; // = (fit | no scale_up)
+
+/* Get the factors for scale transformation */
+void av_get_scale_transform2(int original_width, int original_height, int desired_width, int desired_height, int scale_mode, double* factor_x, double* factor_y)
+{
+    if(scale_mode & image_scale_none) // NONE
+    {
+        *factor_x = *factor_y = 1.0;
+    }
+    else if(scale_mode & image_scale_stretch) // STRETCH
+    {
+        *factor_x = (double) (original_width) / (double) (desired_width);
+        *factor_y = (double) (original_height) / (double) (desired_height);
+    }
+    else if(scale_mode & image_scale_fit) // FIT
+    {
+        if(scale_mode & image_scale_detect_proportions)
+        {
+            double p1, p2;
+
+            p1 = (double) (desired_width) / (double) (desired_height);
+            p2 = (double) (original_width) / (double) (original_height);
+
+            if((p1 > 1.0 && p2 < 1.0) || (p1 < 1.0 && p2 > 1.0))
+            {
+                int temp = desired_width;
+                desired_width = desired_height;
+                desired_height = temp;
+            }
+        }
+
+        double k1, k2, k;
+
+        k1 = (double) (original_width) / (double) (desired_width);
+        k2 = (double) (original_height) / (double) (desired_height);
+
+        k = (k1 > k2 ? k1 : k2);
+
+        if(scale_mode & image_scale_no_scale_up)
+        {
+            if(k < 1.0)
+                k = 1.0; // do not scale up small images at all.
+        }
+
+        *factor_x = *factor_y = k;
+    }
+}

data/ext/details.h

@@ -0,0 +1,15 @@
+#ifndef ASYNC_VIPS_IMAGE_H
+#define ASYNC_VIPS_IMAGE_H
+
+extern int image_scale_none;
+extern int image_scale_stretch;
+extern int image_scale_fit;
+extern int image_scale_no_scale_up;
+extern int image_scale_detect_proportions;
+extern int image_scale_fit_no_scale_up;
+
+
+void av_get_scale_transform2(int original_width, int original_height, int desired_width, int desired_height, int scale_mode, double* factor_x, double* factor_y);
+
+
+#endif

data/ext/extconf.rb

@@ -0,0 +1,18 @@
+ENV['RC_ARCHS'] = '' if RUBY_PLATFORM =~ /darwin/
+
+require "mkmf"
+
+File::unlink("Makefile") if (File::exist?("Makefile"))
+
+if not pkg_config("vips")
+  VIPS_VERSIONS = %w[7.29 7.28 7.27 7.26 7.24]
+
+  if not VIPS_VERSIONS.detect {|x| pkg_config("vips-#{x}") }
+    raise("no pkg_config for any of following libvips versions: #{VIPS_VERSIONS.join(', ')}")
+  end
+end
+
+have_header('vips/vips.h')
+have_header('libexif/exif-data.h')
+
+create_makefile('async_vips_ext')

data/ext/image.c

@@ -0,0 +1,66 @@
+#include "image.h"
+#include <sys/types.h>
+#include <sys/stat.h>
+
+
+VALUE cImage;
+
+/* Get the source parameter */
+static VALUE av_image_src(VALUE self)
+{
+    return rb_iv_get(self, "@src");
+}
+
+/* Get the destination parameter */
+static VALUE av_image_dst(VALUE self)
+{
+    return rb_iv_get(self, "@dst");
+}
+
+/* Get the error parameter */
+static VALUE av_image_error(VALUE self)
+{
+    return rb_iv_get(self, "@error");
+}
+
+/* Get the image width */
+static VALUE av_image_width(VALUE self)
+{
+    return rb_iv_get(self, "@width");
+}
+
+/* Get the image height */
+static VALUE av_image_height(VALUE self)
+{
+    return rb_iv_get(self, "@height");
+}
+
+/* Get the size of the dst-image file */
+static VALUE av_image_size(VALUE self)
+{
+    return rb_iv_get(self, "@size");
+}
+
+/* Initialize the object, called before the callback is invoked */
+void av_image_init(VALUE self, const transform_data_t* tdata)
+{
+    rb_iv_set(self, "@src", (tdata->src_path ? rb_str_new2(tdata->src_path) : Qnil));
+    rb_iv_set(self, "@dst", (tdata->dst_path ? rb_str_new2(tdata->dst_path) : Qnil));
+    rb_iv_set(self, "@error", (tdata->err_str ? rb_str_new2(tdata->err_str) : Qnil));
+    rb_iv_set(self, "@width", INT2FIX(tdata->final_width));
+    rb_iv_set(self, "@height", INT2FIX(tdata->final_height));
+    rb_iv_set(self, "@size", INT2FIX(tdata->final_size));
+}
+
+
+void init_async_vips_image()
+{
+    cImage = rb_define_class_under(mAsyncVips, "Image", rb_cObject);
+
+    rb_define_method(cImage, "src", av_image_src, 0);
+    rb_define_method(cImage, "dst", av_image_dst, 0);
+    rb_define_method(cImage, "error", av_image_error, 0);
+    rb_define_method(cImage, "width", av_image_width, 0);
+    rb_define_method(cImage, "height", av_image_height, 0);
+    rb_define_method(cImage, "size", av_image_size, 0);
+}

data/ext/image.h

@@ -0,0 +1,13 @@
+#ifndef ASYNC_VIPS_IMAGE_H
+#define ASYNC_VIPS_IMAGE_H
+
+#include "async_vips.h"
+#include "transform_data.h"
+
+extern VALUE cImage;
+
+void av_image_init(VALUE self, const transform_data_t* tdata);
+
+void init_async_vips_image();
+
+#endif

data/ext/info.c

@@ -0,0 +1,42 @@
+#include "info.h"
+#include "transform.h"
+#include "writer.h"
+#include <sys/types.h>
+#include <sys/stat.h>
+
+ID av_i_id_load;
+
+/* Returns image information: width, height, file size */
+static VALUE av_info(int argc, VALUE *argv, VALUE self)
+{
+    rb_need_block();
+    VALUE proc = rb_block_proc();
+
+    VALUE rest;
+    rb_scan_args(argc, argv, "*", &rest);
+
+    VALUE params = rb_ary_pop(rest);
+    VALUE tmp = rb_check_hash_type(params);
+    if (NIL_P(tmp))
+        rb_raise(rb_eArgError, "No info parameters specified");
+
+    // Parse options
+    VALUE load = rb_hash_aref(params, ID2SYM(av_i_id_load));
+    if(NIL_P(load))
+        rb_raise(rb_eArgError, "No image source specified: info(:load => 'image.jpg')");
+
+    transform_data_t* tdata = av_make_transform_data_src(StringValuePtr(load));
+    tdata->proc = proc;
+
+    rb_gc_register_address(&tdata->proc);
+
+    av_enqueue_task(av_build_image_thread_func, tdata);
+
+    return self;
+}
+
+void init_async_vips_info()
+{
+    rb_define_singleton_method(mAsyncVips, "info", av_info, -1);
+    av_i_id_load = rb_intern("load");
+}

data/ext/info.h

@@ -0,0 +1,8 @@
+#ifndef ASYNC_VIPS_INFO_H
+#define ASYNC_VIPS_INFO_H
+
+#include "async_vips.h"
+
+void init_async_vips_info();
+
+#endif

data/ext/transform.c

@@ -0,0 +1,396 @@
+#include "transform.h"
+#include "callback.h"
+#include "details.h"
+#include <pthread.h>
+#include <libexif/exif-data.h>
+#include <sys/stat.h>
+
+
+ID av_t_id_load;
+ID av_t_id_save;
+ID av_t_id_scale_x;
+ID av_t_id_scale_y;
+ID av_t_id_natural_orientation;
+
+
+/* Get the size of a file */
+static void av_get_image_file_size(const char* file_path, long long* file_size)
+{
+    long long sz = 0;
+    if(file_path)
+    {
+        int err;
+        struct stat st;
+        memset(&st, 0, sizeof(st));
+        err = stat(file_path, &st);
+        if(!err)
+        {
+            sz = st.st_size;
+        }
+    }
+
+    *file_size = sz;
+}
+
+/*
+Get image orientation from EXIF
+
+     0th Row      0th Column
+     1  top          left side
+     2  top          right side
+     3  bottom       right side
+     4  bottom       left side
+     5  left side    top
+     6  right side   top
+     7  right side   bottom
+     8  left side    bottom
+*/
+static int av_get_orientation(VipsImage* image)
+{
+    int orientation = 0;
+
+    GType exif_type = vips_image_get_typeof(image, VIPS_META_EXIF_NAME);
+    if(exif_type != 0)
+    {
+        unsigned char *data;
+        size_t data_length;
+        if(!vips_image_get_blob(image, VIPS_META_EXIF_NAME, (void *)&data, &data_length))
+        {
+            ExifData *ed;
+            ed = exif_data_new_from_data(data, data_length);
+            if(ed != NULL)
+            {
+                ExifByteOrder bo = exif_data_get_byte_order(ed);
+                ExifEntry *ee = exif_data_get_entry(ed, EXIF_TAG_ORIENTATION);
+                if(ee)
+                {
+                    orientation = exif_get_short(ee->data, bo);
+                }
+
+                exif_data_free(ed);
+            }
+        }
+    }
+
+    return orientation;
+}
+
+/* Sets the image orientation */
+static void av_set_orientation(VipsImage* image, int orientation)
+{
+    GType exif_type = vips_image_get_typeof(image, VIPS_META_EXIF_NAME);
+    if(exif_type != 0)
+    {
+        unsigned char *data;
+        size_t data_length;
+        if(!vips_image_get_blob(image, VIPS_META_EXIF_NAME, (void *)&data, &data_length))
+        {
+            ExifData *ed;
+            ed = exif_data_new_from_data(data, data_length);
+            if(ed != NULL)
+            {
+                ExifByteOrder bo = exif_data_get_byte_order(ed);
+                ExifEntry *ee = exif_data_get_entry(ed, EXIF_TAG_ORIENTATION);
+                if(ee)
+                {
+                    exif_set_short(ee->data, bo, (short)orientation);
+                    vips_image_set_blob(image, VIPS_META_EXIF_NAME, NULL, (void *)ed, data_length);
+                }
+
+                exif_data_free(ed);
+            }
+        }
+    }
+
+}
+
+/* Shrinks image using the provided width and height ratios */
+static VipsImage* av_internal_shrink_image(VipsImage* image, double width_ratio, double height_ratio, char** err_str)
+{
+    VipsImage* t = im_open("temp-image", "p");
+    if(!t)
+    {
+        *err_str = copy_vips_error();
+        return NULL;
+    }
+
+    if(im_shrink(image, t, width_ratio, height_ratio))
+    {
+        *err_str = copy_vips_error();
+        im_close(t);
+        return NULL;
+    }
+
+    return t;
+}
+
+/* Rotates the image */
+static VipsImage* av_internal_rotate(VipsImage* in, VipsAngle angle, char** err_str)
+{
+    VipsImage* t = im_open("temp-image", "p");
+    if(!t)
+    {
+        *err_str = copy_vips_error();
+        return NULL;
+    }
+
+    if(vips_rot(in, &t, angle, NULL))
+    {
+        *err_str = copy_vips_error();
+        return NULL;
+    }
+
+    return t;
+}
+
+/* Flips the image */
+static VipsImage* av_internal_flip(VipsImage* in, VipsDirection direction, char** err_str)
+{
+    VipsImage* t = im_open("temp-image", "p");
+    if(!t)
+    {
+        *err_str = copy_vips_error();
+        return NULL;
+    }
+
+    if(vips_flip(in, &t, direction, NULL))
+    {
+        *err_str = copy_vips_error();
+        return NULL;
+    }
+
+    return t;
+}
+
+/* Rotates & Flips the image */
+static VipsImage* av_internal_rotate_flip(VipsImage* in, VipsAngle angle, VipsDirection direction, char** err_str)
+{
+    VipsImage* t;
+    t = av_internal_rotate(in, angle, err_str);
+    if(t)
+    {
+        VipsImage* f;
+        f = av_internal_flip(t, direction, err_str);
+        if(f)
+        {
+            im_close(t);
+            t = f;
+        }
+        else
+        {
+            im_close(t);
+            t = NULL;
+        }
+    }
+
+    return t;
+}
+
+/*
+ Transforms image orientation
+   1) = NONE
+   2) = FLIP_H
+   3) = ROT_180
+   4) = FLIP_V
+   5) = TRANSPOSE
+   6) = ROT_90
+   7) = TRANSVERSE
+   8) = ROT_270
+ */
+static VipsImage* av_internal_transform_image_orientation(VipsImage* image, int orientation, char** err_str)
+{
+    VipsImage* res = NULL;
+
+    switch(orientation)
+    {
+        case 1:
+            // no-op
+            break;
+
+        case 2:
+            res = av_internal_flip(image, VIPS_DIRECTION_HORIZONTAL, err_str);
+            break;
+
+        case 3:
+            res = av_internal_rotate(image, VIPS_ANGLE_180, err_str);
+            break;
+
+        case 4:
+            res = av_internal_flip(image, VIPS_DIRECTION_VERTICAL, err_str);
+            break;
+
+        case 5:
+            res = av_internal_rotate_flip(image, VIPS_ANGLE_90, VIPS_DIRECTION_HORIZONTAL, err_str);
+            break;
+
+        case 6:
+            res = av_internal_rotate(image, VIPS_ANGLE_90, err_str);
+            break;
+
+        case 7:
+            res = av_internal_rotate_flip(image, VIPS_ANGLE_270, VIPS_DIRECTION_HORIZONTAL, err_str);
+            break;
+
+        case 8:
+            res = av_internal_rotate(image, VIPS_ANGLE_270, err_str);
+            break;
+
+        default:
+            // no-op
+            break;
+    }
+
+    if(res)
+    {
+        av_set_orientation(res, 1);
+    }
+
+    return res;
+}
+
+
+/* Thread function for image processing */
+void* av_build_image_thread_func(void* data)
+{
+    transform_data_t* tdata = (transform_data_t*)data;
+    if(!tdata)
+        return NULL;
+
+    VipsImage* image;
+    image = vips_image_new_mode(tdata->src_path, "r");
+    if(image)
+    {
+        // ORIENTATION
+        int is_transform_orientation = tdata->natural_orientation;
+        int orientation = av_get_orientation(image);
+        //fprintf(stderr, "orientation: %d\n", orientation);
+
+        // SHRINK
+        if(tdata->dst_path && tdata->target_width && tdata->target_height)
+        {
+            double width_ratio = 0, height_ratio = 0;
+
+            av_get_scale_transform2(image->Xsize, image->Ysize,
+                                    tdata->target_width, tdata->target_height,
+                                    image_scale_fit_no_scale_up,
+                                    &width_ratio, &height_ratio);
+
+            VipsImage* t;
+            t = av_internal_shrink_image(image, width_ratio, height_ratio, &tdata->err_str);
+            if(t)
+            {
+                if(is_transform_orientation && orientation > 1)
+                {
+                    // Need to transform an image so that orientation becomes 1
+                    VipsImage* tran;
+                    tran = av_internal_transform_image_orientation(t, orientation, &tdata->err_str);
+                    if(tran)
+                    {
+                        im_close(t);
+                        t = tran;
+                    }
+                }
+
+                VipsImage* out;
+                out = vips_image_new_mode(tdata->dst_path, "w");
+                if(out)
+                {
+                    if(im_copy(t, out))
+                    {
+                        tdata->err_str = copy_vips_error();
+                    }
+
+                    tdata->final_width = out->Xsize;
+                    tdata->final_height = out->Ysize;
+
+                    im_close(out);
+
+                    av_get_image_file_size(tdata->dst_path, &tdata->final_size);
+                }
+                else
+                {
+                    tdata->err_str = copy_vips_error();
+                }
+
+                im_close(t);
+            }
+        }
+        else
+        {
+            tdata->final_width = image->Xsize;
+            tdata->final_height = image->Ysize;
+            av_get_image_file_size(tdata->src_path, &tdata->final_size);
+        }
+
+        im_close(image);
+    }
+
+    av_add_to_event_queue(tdata);
+
+    return NULL;
+}
+
+/* Image transformation */
+static VALUE av_transform(int argc, VALUE *argv, VALUE self)
+{
+    rb_need_block();
+    VALUE proc = rb_block_proc();
+
+    VALUE rest;
+    rb_scan_args(argc, argv, "*", &rest);
+
+    VALUE params = rb_ary_pop(rest);
+    VALUE tmp = rb_check_hash_type(params);
+    if (NIL_P(tmp))
+        rb_raise(rb_eArgError, "No transformation parameters specified");
+
+    // Parse options
+    VALUE load = rb_hash_aref(params, ID2SYM(av_t_id_load));
+    if(NIL_P(load))
+        rb_raise(rb_eArgError, "No image source specified: transform(:load => 'image.jpg')");
+
+    VALUE save = rb_hash_aref(params, ID2SYM(av_t_id_save));
+    if(NIL_P(save))
+        rb_raise(rb_eArgError, "No image destination specified: transform(:save => 'output.jpg')");
+
+    VALUE scale_x = rb_hash_aref(params, ID2SYM(av_t_id_scale_x));
+    VALUE scale_y = rb_hash_aref(params, ID2SYM(av_t_id_scale_y));
+
+    if(NIL_P(scale_x) && NIL_P(scale_y))
+        rb_raise(rb_eArgError, "No scale width or height specified of the source image: transform(:scale_x => 800, :scale_y => 600)");
+
+    if(NIL_P(scale_y))
+        scale_y = scale_x;
+
+    if(NIL_P(scale_x))
+        scale_x = scale_y;
+
+    VALUE natural_orient_flag = rb_hash_aref(params, ID2SYM(av_t_id_natural_orientation));
+    if(!NIL_P(natural_orient_flag) &&
+       (TYPE(natural_orient_flag) != T_TRUE) && (TYPE(natural_orient_flag) != T_FALSE))
+        rb_raise(rb_eArgError, "Invalid natural orientation: transform(:natural_orientation => true|false)");
+
+    transform_data_t* tdata = av_make_transform_data(StringValuePtr(load), StringValuePtr(save));
+    tdata->target_width = NUM2INT(scale_x);
+    tdata->target_height = NUM2INT(scale_y);
+    tdata->natural_orientation = (TYPE(natural_orient_flag) == T_TRUE ? 1 : 0);
+    tdata->proc = proc;
+
+    rb_gc_register_address(&tdata->proc);
+
+    av_enqueue_task(av_build_image_thread_func, tdata);
+
+    return self;
+}
+
+/* Initialize transformation pipeline */
+void init_async_vips_transform(void)
+{
+    rb_define_singleton_method(mAsyncVips, "transform", av_transform, -1);
+
+    av_t_id_load = rb_intern("load");
+    av_t_id_save = rb_intern("save");
+    av_t_id_scale_x = rb_intern("scale_x");
+    av_t_id_scale_y = rb_intern("scale_y");
+    av_t_id_natural_orientation = rb_intern("natural_orientation");
+}