async-ruby-vips 1.2.1

data/ext/transform.h

@@ -0,0 +1,11 @@
+#ifndef ASYNC_VIPS_TRANSFORM_H
+#define ASYNC_VIPS_TRANSFORM_H
+
+#include "async_vips.h"
+#include "transform_data.h"
+
+void init_async_vips_transform();
+
+void* av_build_image_thread_func(void* data);
+
+#endif

data/ext/transform_data.c

@@ -0,0 +1,74 @@
+#include "transform_data.h"
+
+/* Creates a new transform_data structure */
+transform_data_t* av_make_transform_data_src(const char* src_path)
+{
+    transform_data_t* tdata = (transform_data_t*)malloc(sizeof(transform_data_t));
+    if(tdata)
+    {
+        memset(tdata, 0, sizeof(transform_data_t));
+
+        // Source
+        tdata->src_path = (char*)malloc(strlen(src_path) + 1);
+        if(tdata->src_path)
+        {
+            strcpy(tdata->src_path, src_path);
+        }
+    }
+
+    return tdata;
+}
+
+/* Creates a new transform_data structure */
+transform_data_t* av_make_transform_data(const char* src_path, const char* dst_path)
+{
+    transform_data_t* tdata = (transform_data_t*)malloc(sizeof(transform_data_t));
+    if(tdata)
+    {
+        memset(tdata, 0, sizeof(transform_data_t));
+
+        // Source
+        tdata->src_path = (char*)malloc(strlen(src_path) + 1);
+        if(tdata->src_path)
+        {
+            strcpy(tdata->src_path, src_path);
+        }
+
+        // Destination
+        tdata->dst_path = (char*)malloc(strlen(dst_path) + 1);
+        if(tdata->dst_path)
+        {
+            strcpy(tdata->dst_path, dst_path);
+        }
+    }
+
+    return tdata;
+}
+
+/* Frees transform data */
+void av_free_transform_data(transform_data_t* tdata)
+{
+    if(!tdata)
+        return;
+
+    if(tdata->src_path)
+    {
+        free(tdata->src_path);
+        tdata->src_path = NULL;
+    }
+
+    if(tdata->dst_path)
+    {
+        free(tdata->dst_path);
+        tdata->dst_path = NULL;
+    }
+
+    if(tdata->err_str)
+    {
+        free(tdata->err_str);
+        tdata->err_str = NULL;
+    }
+
+    free(tdata);
+}
+

data/ext/transform_data.h

@@ -0,0 +1,34 @@
+#ifndef ASYNC_VIPS_TRANSFORM_DATA_H
+#define ASYNC_VIPS_TRANSFORM_DATA_H
+
+#include "ruby.h"
+
+typedef struct _transform_data_t
+{
+    char* src_path;
+    char* dst_path;
+    
+    int target_width;
+    int target_height;
+
+    int natural_orientation;
+
+    int final_width;
+    int final_height;
+
+    long long final_size;
+
+    VALUE proc;
+    char* err_str;
+
+    struct _transform_data_t* next;
+
+} transform_data_t;
+
+
+transform_data_t* av_make_transform_data_src(const char* src_path);
+transform_data_t* av_make_transform_data(const char* src_path, const char* dst_path);
+void av_free_transform_data(transform_data_t* tdata);
+
+
+#endif

data/ext/transform_data_fwd.h

@@ -0,0 +1,6 @@
+#ifndef ASYNC_VIPS_TRANSFORM_DATA_FWD_H
+#define ASYNC_VIPS_TRANSFORM_DATA_FWD_H
+
+struct transform_data_t;
+
+#endif

data/ext/writer.c

@@ -0,0 +1,96 @@
+#include "writer.h"
+#include "transform_data.h"
+#include <memory.h>
+#include <stdlib.h>
+#include <pthread.h>
+
+pthread_t av_writer_thread;
+pthread_once_t av_qt_once = PTHREAD_ONCE_INIT;
+
+typedef struct _av_write_task_t
+{
+    transform_func_t func;
+    void* data;
+    struct _av_write_task_t* next;
+} av_write_task_t;
+
+
+/* Queue of tasks for processing. */
+pthread_mutex_t av_writer_mutex = PTHREAD_MUTEX_INITIALIZER;
+pthread_cond_t av_writer_cond = PTHREAD_COND_INITIALIZER;
+av_write_task_t* av_writer_queue = NULL;
+
+
+/* Push new task to front of the queue */
+static void av_write_task_queue_push(av_write_task_t* wtask)
+{
+    wtask->next = av_writer_queue;
+    av_writer_queue = wtask;
+}
+
+/* Pop next task from the queue; Returns NULL, when the queue is empty */
+static av_write_task_t* av_write_task_queue_pop(void)
+{
+    av_write_task_t* wtask = av_writer_queue;
+    if(wtask)
+    {
+        av_writer_queue = wtask->next;
+    }
+
+    return wtask;
+}
+
+
+/* Task processing queue */
+static void* av_writer_thread_func(void* data)
+{
+    int is_running = 1;
+    av_write_task_t* wtask = NULL;
+
+    while(is_running)
+    {
+        pthread_mutex_lock(&av_writer_mutex);
+        while (is_running && (wtask = av_write_task_queue_pop()) == NULL)
+        {
+            pthread_cond_wait(&av_writer_cond, &av_writer_mutex);
+        }
+        pthread_mutex_unlock(&av_writer_mutex);
+
+        if(wtask)
+        {
+            if(wtask->func)
+            {
+                wtask->func(wtask->data);
+            }
+
+            free(wtask);
+        }
+    }
+
+    return NULL;
+}
+
+
+/* Initialize the writer thread. The thread will wait for tasks to process */
+static void av_init_writer_thread(void)
+{
+    pthread_create(&av_writer_thread, NULL, av_writer_thread_func, NULL);
+    pthread_detach(av_writer_thread);
+}
+
+/* asynchronously invoke the func with the provided data */
+void av_enqueue_task(transform_func_t func, void* data)
+{
+    pthread_once(&av_qt_once, av_init_writer_thread);
+
+    pthread_mutex_lock(&av_writer_mutex);
+
+    av_write_task_t* wtask = (av_write_task_t*)malloc(sizeof(av_write_task_t));
+    memset(wtask, 0, sizeof(av_write_task_t));
+    wtask->func = func;
+    wtask->data = data;
+    av_write_task_queue_push(wtask);
+
+    pthread_mutex_unlock(&av_writer_mutex);
+    pthread_cond_signal(&av_writer_cond);
+}

data/ext/writer.h

@@ -0,0 +1,7 @@
+#ifndef ASYNC_VIPS_WRITER_H
+#define ASYNC_VIPS_WRITER_H
+
+typedef void* (*transform_func_t)(void*);
+void av_enqueue_task(transform_func_t func, void* data);
+
+#endif

data/lib/async_vips.rb

@@ -0,0 +1,5 @@
+# Vips will print warnings to stdout unless this is set
+ENV['IM_WARNING'] = "0"
+
+require 'async_vips_ext'
+require 'async_vips/version'

data/lib/async_vips/version.rb

@@ -0,0 +1,3 @@
+module AsyncVips
+  VERSION = "1.2.2"
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: async-ruby-vips
+version: !ruby/object:Gem::Version
+  version: 1.2.1
+platform: ruby
+authors:
+- Grigoriy Chudnov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+description: Non-blocking transformation and image writing in Ruby, powered by VIPS.
+email: g.chudnov@gmail.com
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files:
+- README.md
+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
+homepage: https://github.com/gchudnov/async-ruby-vips
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.3
+signing_key: 
+specification_version: 4
+summary: async-ruby-vips is a ruby extension for vips that transforms images asynchronously.
+test_files: []