async-ruby-vips 1.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2fd9bfe82936faf9228063b50fd6b2b77c6941c8
+  data.tar.gz: 73b4f797dd51f56737bdbc5eede0e8a21f730890
+SHA512:
+  metadata.gz: 69c7e4a80904bd8b2b74daedc1270c59d933fecca2a1ace15d49e6e53932ff5226b8e34ce6cfe648e156f460d0ce29bae04f79e252b66c2c32edcb672ecc30d3
+  data.tar.gz: 605dd6ae731af3ade945dcbb47983c9351bd89569d3b5d7e8aa529fe1da9083c54611b951d615f8e736782723547471a39963d06a3a1a166499cb57d9f5f068b

data/Gemfile.lock

@@ -0,0 +1,63 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    addressable (2.3.5)
+    builder (3.2.2)
+    diff-lcs (1.2.5)
+    faraday (0.8.8)
+      multipart-post (~> 1.2.0)
+    git (1.2.6)
+    github_api (0.10.1)
+      addressable
+      faraday (~> 0.8.1)
+      hashie (>= 1.2)
+      multi_json (~> 1.4)
+      nokogiri (~> 1.5.2)
+      oauth2
+    hashie (2.0.5)
+    highline (1.6.20)
+    httpauth (0.2.0)
+    jeweler (1.8.8)
+      builder
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      github_api (= 0.10.1)
+      highline (>= 1.6.15)
+      nokogiri (= 1.5.10)
+      rake
+      rdoc
+    json (1.8.1)
+    jwt (0.1.8)
+      multi_json (>= 1.5)
+    multi_json (1.8.2)
+    multi_xml (0.5.5)
+    multipart-post (1.2.0)
+    nokogiri (1.5.10)
+    oauth2 (0.9.2)
+      faraday (~> 0.8)
+      httpauth (~> 0.2)
+      jwt (~> 0.1.4)
+      multi_json (~> 1.0)
+      multi_xml (~> 0.5)
+      rack (~> 1.2)
+    rack (1.5.2)
+    rake (10.1.1)
+    rdoc (3.12.2)
+      json (~> 1.4)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.7)
+    rspec-expectations (2.14.4)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.5)
+  jeweler (~> 1.8)
+  rdoc (~> 3.12)
+  rspec (~> 2.14)

data/README.md

@@ -0,0 +1,101 @@
+async-ruby-vips
+===============
+
+Non-blocking transformation and image writing in Ruby, powered by VIPS
+
+## Requirements
+
+  * OS X or Linux
+  * MRI >= 1.9.2
+  * libvips 7.28.x
+  * libexif
+
+## Prerequisites
+  * On Ubuntu, `apt-get install libvips-dev`, or follow the guidelines at: https://github.com/jcupitt/libvips
+
+If you installed it from source, make sure:
+  * /usr/local/lib is on your LD_LIBRARY_PATH
+  * /usr/local/bin is on PATH
+  * /usr/local/lib/pkgconfig is on PKG_CONFIG_PATH
+
+
+## Building
+  * bundle install # to install dependencies
+  * rake gemspec # to generate gemspec file
+  * rake build # to build the gem
+  * rake install # to install the gem
+
+## Example
+
+```ruby
+require 'rubygems'
+require 'async_vips'
+include AsyncVips
+
+
+# Non-blocking scaling of an image:
+# Allowed symbols are:  :load, :scale_x, :scale_y, :save
+# Wneh called, a function is invoked on a separate native thread. 
+# The callback-proc is invoked on a separate Ruby thread on completion.
+AsyncVips.transform(:load => srcfile, :scale_x => 800, :save => dstfile) do |img|
+  if(img.error != nil)
+    puts img.error
+  end
+end
+
+# Set the number of operations cached by VIPS: 
+AsyncVips.set_cache(100)
+
+# Get image information:
+# Allowed symbols are:  :load
+AsyncVips.info(:load => srcfile) do |img|
+  puts img.src    # image filepath
+  puts img.width  # image width
+  puts img.height # image height
+  puts img.size   # image size in bytes
+end
+
+
+## Using event machine
+
+require 'rubygems'
+require 'async_vips'
+require 'eventmachine'
+include AsyncVips
+
+#puts AsyncVips::VERSION
+#puts AsyncVips::LIB_VERSION
+AsyncVips.set_cache(0) # sets the number of operations cached by VIPS
+
+EM.run do
+
+  EM.add_timer(3) do
+     source = './images/*.JPG'
+     files = Dir[source]
+     files.each do |srcfile|
+       dstfile = './output/'+File.basename(srcfile)
+       
+       AsyncVips.transform(:load => srcfile, :scale_x => 800, :save => dstfile) do |img|
+         puts img.src
+         if(img.error != nil)
+           puts img.error
+         end                 
+       end
+        
+     end
+  end
+
+  EM.add_periodic_timer(1) do
+    puts "#{Time.now}"
+  end
+end
+
+
+```ruby
+
+
+## Version history
+
+### 1.2.1 - added support for natural_orientation flag
+### 1.1.0 - shrink operation
+### 1.0.0 - initial release

data/async-ruby-vips.gemspec

@@ -0,0 +1,74 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+# stub: async-ruby-vips 1.2.1 ruby lib
+# stub: ext/extconf.rb
+
+Gem::Specification.new do |s|
+  s.name = "async-ruby-vips"
+  s.version = "1.2.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
+  s.authors = ["Grigoriy Chudnov"]
+  s.date = "2014-01-27"
+  s.description = "Non-blocking transformation and image writing in Ruby, powered by VIPS."
+  s.email = "g.chudnov@gmail.com"
+  s.extensions = ["ext/extconf.rb"]
+  s.extra_rdoc_files = [
+    "README.md"
+  ]
+  s.files = [
+    "Gemfile.lock",
+    "README.md",
+    "async-ruby-vips.gemspec",
+    "ext/LICENSE",
+    "ext/async_vips.c",
+    "ext/async_vips.h",
+    "ext/callback.c",
+    "ext/callback.h",
+    "ext/details.c",
+    "ext/details.h",
+    "ext/extconf.rb",
+    "ext/image.c",
+    "ext/image.h",
+    "ext/info.c",
+    "ext/info.h",
+    "ext/transform.c",
+    "ext/transform.h",
+    "ext/transform_data.c",
+    "ext/transform_data.h",
+    "ext/transform_data_fwd.h",
+    "ext/writer.c",
+    "ext/writer.h",
+    "lib/async_vips.rb",
+    "lib/async_vips/version.rb"
+  ]
+  s.homepage = "https://github.com/gchudnov/async-ruby-vips"
+  s.licenses = ["MIT"]
+  s.rubygems_version = "2.2.1"
+  s.summary = "async-ruby-vips is a ruby extension for vips that transforms images asynchronously."
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.5"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.14"])
+    else
+      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<bundler>, ["~> 1.5"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8"])
+      s.add_dependency(%q<rspec>, ["~> 2.14"])
+    end
+  else
+    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<bundler>, ["~> 1.5"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8"])
+    s.add_dependency(%q<rspec>, ["~> 2.14"])
+  end
+end
+

data/ext/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Grigoriy Chudnov
+
+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/ext/async_vips.c

@@ -0,0 +1,73 @@
+#include "async_vips.h"
+#include "transform.h"
+#include "writer.h"
+#include "callback.h"
+#include "image.h"
+#include "info.h"
+
+VALUE mAsyncVips, eVipsError;
+
+/* Initialize VIPS library */
+void av_init()
+{
+    VALUE argv_0 = rb_gv_get("0");
+
+    if(NIL_P(argv_0))
+        vips_init("");
+    else
+        vips_init(RSTRING_PTR(argv_0));
+}
+
+/* Print internal debugging information from VIPS, including memory allocation information. */
+static VALUE av_debug_info(VALUE self)
+{
+    vips_object_print_all();
+    return Qnil;
+}
+
+/* Set the max number of operations to keep in cache. */
+static VALUE av_set_cache(VALUE self, VALUE val)
+{
+    vips_cache_set_max(NUM2INT(val));
+    return Qnil;
+}
+
+/* Get the version string */
+static VALUE av_version_string()
+{
+    return rb_str_new2(vips_version_string());
+}
+
+/* Copy error from vips */
+char* copy_vips_error(void)
+{
+    char* result = NULL;
+    const char* err_str = vips_error_buffer();
+    if(err_str && strlen(err_str) > 0)
+    {
+        result = malloc(strlen(err_str) + 1);
+        strcpy(result, err_str);
+        im_error_clear();
+    }
+
+    return result;
+}
+
+/* Initialize extension */
+void Init_async_vips_ext()
+{
+    av_init();
+
+    mAsyncVips = rb_define_module("AsyncVips");
+    eVipsError = rb_define_class_under(mAsyncVips, "Error", rb_eStandardError);
+
+    rb_define_singleton_method(mAsyncVips, "debug_info", av_debug_info, 0);
+    rb_define_singleton_method(mAsyncVips, "set_cache", av_set_cache, 1);
+    rb_define_const(mAsyncVips, "LIB_VERSION", av_version_string());
+
+    //
+    init_async_vips_transform();
+    init_async_vips_image();
+    init_async_vips_info();
+    init_async_vips_event_thread();
+}

data/ext/async_vips.h

@@ -0,0 +1,11 @@
+#ifndef ASYNC_VIPS_H
+#define ASYNC_VIPS_H
+
+#include "ruby.h"
+#include "vips/vips.h"
+
+extern VALUE mAsyncVips, eVipsError;
+
+char* copy_vips_error(void);
+
+#endif

data/ext/callback.c

@@ -0,0 +1,119 @@
+#include "callback.h"
+#include "async_vips.h"
+#include "image.h"
+#include "transform_data.h"
+#include <pthread.h>
+
+
+typedef struct _tdata_wait_t
+{
+    transform_data_t* tdata;
+    int abort;
+} tdata_wait_t;
+
+
+/* Queue of callbacks; each one invoked on a ruby thread */
+pthread_mutex_t av_proc_mutex = PTHREAD_MUTEX_INITIALIZER;
+pthread_cond_t av_proc_cond = PTHREAD_COND_INITIALIZER;
+transform_data_t* av_proc_queue = NULL;
+
+/* Push new callback to front of the queue */
+static void av_proc_queue_push(transform_data_t* tdata)
+{
+    tdata->next = av_proc_queue;
+    av_proc_queue = tdata;
+}
+
+/* Pop next callback from the queue; Returns NULL, when the queue is empty */
+static transform_data_t* av_proc_queue_pop(void)
+{
+    transform_data_t* tdata = av_proc_queue;
+    if(tdata)
+    {
+        av_proc_queue = tdata->next;
+    }
+
+    return tdata;
+}
+
+/* Callback executed by Ruby Thread */
+static VALUE av_handle_proc(void *d)
+{
+    transform_data_t* tdata = (transform_data_t*)d;
+
+    // Invoke callback with task argument
+    VALUE proc = (VALUE)tdata->proc;
+    VALUE img = rb_class_new_instance(0, NULL, cImage);
+
+    av_image_init(img, tdata);
+    rb_funcall2(proc, rb_intern("call"), 1, &img);
+    rb_gc_unregister_address(&tdata->proc);
+
+    av_free_transform_data(tdata);
+
+    return Qnil;
+}
+
+
+/* Wait until we have some callbacks to process  */
+static VALUE av_wait_for_tdata(void* w)
+{
+    tdata_wait_t* waiter = (tdata_wait_t*)w;
+
+    pthread_mutex_lock(&av_proc_mutex);
+    while (!waiter->abort && (waiter->tdata = av_proc_queue_pop()) == NULL)
+    {
+        pthread_cond_wait(&av_proc_cond, &av_proc_mutex);
+    }
+    pthread_mutex_unlock(&av_proc_mutex);
+
+    return Qnil;
+}
+
+/* Stop waiting for callbacks */
+static void av_stop_waiting_for_tdata(void* w)
+{
+    tdata_wait_t* waiter = (tdata_wait_t*)w;
+
+    pthread_mutex_lock(&av_proc_mutex);
+    waiter->abort = 1;
+    pthread_mutex_unlock(&av_proc_mutex);
+    pthread_cond_signal(&av_proc_cond);
+}
+
+
+/* ruby event thread, waiting for processed transformations (invokes callbacks) */
+static VALUE av_event_thread(void *unused)
+{
+    tdata_wait_t waiter = { .tdata = NULL, .abort = 0 };
+    while (!waiter.abort)
+    {
+        rb_thread_blocking_region(av_wait_for_tdata, &waiter, av_stop_waiting_for_tdata, &waiter);
+        if (waiter.tdata)
+        {
+            rb_thread_create(av_handle_proc, waiter.tdata);
+        }
+    }
+
+    return Qnil;
+}
+
+/* Initialize Ruby Event Thread for invokation of user-provider callbacks */
+static void av_create_event_thread(void)
+{
+    rb_thread_create(av_event_thread, NULL);
+}
+
+/* Add the transform data to the event queue */
+void av_add_to_event_queue(transform_data_t* tdata)
+{
+    pthread_mutex_lock(&av_proc_mutex);
+    av_proc_queue_push(tdata);
+    pthread_mutex_unlock(&av_proc_mutex);
+    pthread_cond_signal(&av_proc_cond);
+}
+
+void init_async_vips_event_thread(void)
+{
+    av_create_event_thread();
+}