psd_native 0.6.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 960643fec9eb4c5832460760e567953247189174
-  data.tar.gz: b3000995230c06cad6c95112e30e9be26d70c6aa
+  metadata.gz: 0267ebc332f459a2246da73dbb83ba072c6689a4
+  data.tar.gz: de14d32f2fe1a2ea603487364783085c5821266a
 SHA512:
-  metadata.gz: 9da0d02c2b6eb361f3750d44d370ed165af072e03f0ee91a66721da8e516d23213d93e30586630dca03aeba5ffbf4581cf691caf3c480d21401bede582ed46de
-  data.tar.gz: 5d2fc658099b074118b6890bcf0608a2be393fef2a415e1f2aba389500f6d6386bdb53c70b8ac0fca87214bc276d250e1015961082507f94260c3aacb36bde1c
+  metadata.gz: d8934cedf3e9142a63974542b4fce9ab0b1c3c687626bfa735a289e6ecc2cf08b38232177fe59cf159ceea5578c7b51ceed6871be17869473145fcc79a7f0c3f
+  data.tar.gz: 558be83a9bde428df951a1377294badabf601a4c772bded8402eb75c5d3537619665781d263ad352a30cee5bb0c7ae9a361ed0809b61603547237b5e2e1d102e

data/Gemfile

@@ -1,6 +1,4 @@
 source 'https://rubygems.org'
 
-# gem 'psd', git: 'git@github.com:layervault/psd.rb'
-
 # Specify your gem's dependencies in psd_native.gemspec
 gemspec

data/ext/psd_native/blender.c

@@ -0,0 +1,57 @@
+#include "psd_native_ext.h"
+
+VALUE psd_native_blender_compose_bang(VALUE self) {
+  psd_logger("debug", "Composing with native code");
+
+  VALUE Compose = rb_const_get(
+    rb_const_get(rb_cObject, rb_intern("PSD")),
+    rb_intern("Compose")
+  );
+  
+  VALUE fg = rb_iv_get(self, "@fg");
+  VALUE bg = rb_iv_get(self, "@bg");
+
+  VALUE fg_canvas = rb_funcall(fg, rb_intern("canvas"), 0);
+  VALUE bg_canvas = rb_funcall(bg, rb_intern("canvas"), 0);
+
+  VALUE fg_pixels = rb_funcall(fg_canvas, rb_intern("pixels"), 0);
+  VALUE bg_pixels = rb_funcall(bg_canvas, rb_intern("pixels"), 0);
+  VALUE *bg_pixels_ptr = RARRAY_PTR(bg_pixels);
+
+  int fg_width = FIX2INT(rb_funcall(fg, rb_intern("width"), 0));
+  int bg_height = FIX2INT(rb_funcall(bg, rb_intern("height"), 0));
+  int bg_width = FIX2INT(rb_funcall(bg, rb_intern("width"), 0));
+
+  int offset_x = FIX2INT(rb_funcall(fg, rb_intern("left"), 0)) - FIX2INT(rb_funcall(bg, rb_intern("left"), 0));
+  int offset_y = FIX2INT(rb_funcall(fg, rb_intern("top"), 0)) - FIX2INT(rb_funcall(bg, rb_intern("top"), 0));
+
+  VALUE blending_mode = rb_intern_str(rb_funcall(rb_funcall(fg, rb_intern("node"), 0), rb_intern("blending_mode"), 0));
+  VALUE options = rb_funcall(self, rb_intern("compose_options"), 0);
+
+  int i, len, x, y, base_x, base_y;
+  VALUE color;
+  for (i = 0, len = RARRAY_LEN(fg_pixels); i < len; i++) {
+    x = (i % fg_width);
+    y = floor(i / fg_width);
+
+    base_x = x + offset_x;
+    base_y = y + offset_y;
+
+    if (base_x < 0 || base_y < 0 || base_x >= bg_width || base_y >= bg_height) {
+      continue;
+    }
+
+    color = rb_funcall(
+      Compose,
+      blending_mode,
+      3,
+      rb_funcall(fg_canvas, rb_intern("[]"), 2, INT2FIX(x), INT2FIX(y)),
+      bg_pixels_ptr[base_y * bg_width + base_x],
+      options
+    );
+
+    rb_ary_store(bg_pixels, base_y * bg_width + base_x, color);
+  }
+
+  return Qnil;
+}

data/ext/psd_native/blender.h

@@ -0,0 +1,6 @@
+#ifndef PSD_NATIVE_BLENDER
+#define PSD_NATIVE_BLENDER
+
+VALUE psd_native_blender_compose_bang(VALUE self);
+
+#endif

data/ext/psd_native/canvas.c

@@ -0,0 +1,9 @@
+#include "psd_native_ext.h"
+
+VALUE psd_canvas_to_pixel_array(VALUE canvas) {
+  return rb_funcall(
+    rb_funcall(canvas, rb_intern("canvas"), 0),
+    rb_intern("pixels"),
+    0
+  );
+}

data/ext/psd_native/canvas.h

@@ -0,0 +1,6 @@
+#ifndef PSD_NATIVE_CANVAS
+#define PSD_NATIVE_CANVAS
+
+VALUE psd_canvas_to_pixel_array(VALUE canvas);
+
+#endif

data/ext/psd_native/clipping_mask.c

@@ -1,60 +1,55 @@
 #include "psd_native_ext.h"
 
-VALUE psd_native_clipping_mask_apply(VALUE self) {
-  VALUE layer = rb_iv_get(self, "@layer");
-  if (rb_funcall(layer, rb_intern("clipped?"), 0) == Qfalse) {
-    return rb_iv_get(self, "@png");
+VALUE psd_native_clipping_mask_apply_bang(VALUE self) {
+  VALUE node = rb_iv_get(self, "@node");
+  if (rb_funcall(node, rb_intern("clipped?"), 0) == Qfalse) {
+    return Qnil;
   }
 
   psd_logger("debug", "Applying clipping mask with native code");
 
-  VALUE *dim = RARRAY_PTR(rb_funcall(layer, rb_intern("document_dimensions"), 0));
-  VALUE full_png = rb_funcall(self, rb_intern("compose_to_full"), 0);
-
-  uint32_t width = FIX2UINT(dim[0]);
-  uint32_t height = FIX2UINT(dim[1]);
-  VALUE mask = rb_funcall(self, rb_intern("mask"), 0);
-  VALUE pixel_data = rb_funcall(rb_funcall(mask, rb_intern("image"), 0), rb_intern("pixel_data"), 0);
-  VALUE pixel;
-  uint32_t color;
-  int mask_top = FIX2INT(rb_funcall(mask, rb_intern("top"), 0)),
-      mask_bottom = FIX2INT(rb_funcall(mask, rb_intern("bottom"), 0)),
-      mask_left = FIX2INT(rb_funcall(mask, rb_intern("left"), 0)),
-      mask_right = FIX2INT(rb_funcall(mask, rb_intern("right"), 0)),
-      mask_width = FIX2INT(rb_funcall(mask, rb_intern("width"), 0)),
-      alpha = 0,
-      mask_x, mask_y;
-
-  int x, y;
-  for (y = 0; y < height; y++) {
-    for (x = 0; x < width; x++) {
-      if (y < mask_top || y > mask_bottom || x < mask_left || x > mask_right) {
+  VALUE canvas = rb_iv_get(self, "@canvas");
+  VALUE canvas_pixels = psd_canvas_to_pixel_array(canvas);
+  VALUE mask = rb_iv_get(self, "@mask");
+  VALUE *mask_pixels = RARRAY_PTR(psd_canvas_to_pixel_array(mask));
+
+  uint32_t canvas_width = FIX2UINT(rb_funcall(canvas, rb_intern("width"), 0));
+  uint32_t canvas_height = FIX2UINT(rb_funcall(canvas, rb_intern("height"), 0));
+  int canvas_left = FIX2INT(rb_funcall(canvas, rb_intern("left"), 0));
+  int canvas_top = FIX2INT(rb_funcall(canvas, rb_intern("top"), 0));
+
+  uint32_t mask_width = FIX2UINT(rb_funcall(mask, rb_intern("width"), 0));
+  uint32_t mask_height = FIX2UINT(rb_funcall(mask, rb_intern("height"), 0));
+  int mask_left = FIX2INT(rb_funcall(mask, rb_intern("left"), 0));
+  int mask_top = FIX2INT(rb_funcall(mask, rb_intern("top"), 0));
+  int mask_pixel_length = mask_width * mask_height;
+
+  int x, y, doc_x, doc_y, mask_x, mask_y;
+  uint32_t alpha, color, loc;
+  for (y = 0; y < canvas_height; y++) {
+    for (x = 0; x < canvas_width; x++) {
+      doc_x = canvas_left + x;
+      doc_y = canvas_top + y;
+
+      mask_x = doc_x - mask_left;
+      mask_y = doc_y - mask_top;
+
+      if (mask_x < 0 || mask_x > mask_width || mask_y < 0 || mask_y > mask_height) {
         alpha = 0;
       } else {
-        mask_x = x - mask_left;
-        mask_y = y - mask_top;
+        loc = mask_y * mask_width + mask_x;
 
-        pixel = rb_ary_entry(pixel_data, mask_y * mask_width + mask_x);
-        if (pixel == Qnil) {
+        if (loc > mask_pixel_length) {
           alpha = 0;
         } else {
-          alpha = A(FIX2UINT(pixel));
+          alpha = A(FIX2UINT(mask_pixels[loc]));
         }
       }
 
-      color = FIX2UINT(rb_funcall(full_png, rb_intern("[]"), 2, INT2FIX(x), INT2FIX(y)));
-      color = (color & 0xffffff00) | (A(color) * alpha / 255);
-      rb_funcall(full_png, rb_intern("set_pixel"), 3, INT2FIX(x), INT2FIX(y), INT2FIX(color));
+      color = FIX2UINT(rb_ary_entry(canvas_pixels, y * canvas_width + x));
+      rb_ary_store(canvas_pixels, y * canvas_width + x, INT2FIX((color & 0xffffff00) | (A(color) * alpha / 255)));
     }
   }
 
-  return rb_funcall(
-    full_png,
-    rb_intern("crop!"),
-    4,
-    rb_funcall(layer, rb_intern("left"), 0),
-    rb_funcall(layer, rb_intern("top"), 0),
-    rb_funcall(layer, rb_intern("width"), 0),
-    rb_funcall(layer, rb_intern("height"), 0)
-  );
+  return Qnil;
 }

data/ext/psd_native/clipping_mask.h

@@ -1,6 +1,6 @@
 #ifndef PSD_NATIVE_CLIPPING_MASK
 #define PSD_NATIVE_CLIPPING_MASK
 
-VALUE psd_native_clipping_mask_apply(VALUE self);
+VALUE psd_native_clipping_mask_apply_bang(VALUE self);
 
 #endif

data/ext/psd_native/compose.c

@@ -8,7 +8,7 @@ VALUE psd_native_compose_normal(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts)
   PIXEL bg = FIX2UINT(r_bg);
   PIXEL new_r, new_g, new_b;
 
-  if (OPAQUE(fg) || TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(bg)) return INT2FIX(apply_opacity(fg, &opts));
   if (TRANSPARENT(fg)) return r_bg;
 
   calculate_alphas(fg, bg, &opts);
@@ -25,7 +25,7 @@ VALUE psd_native_compose_darken(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts)
   PIXEL bg = FIX2UINT(r_bg);
   PIXEL new_r, new_g, new_b;
 
-  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(bg)) return INT2FIX(apply_opacity(fg, &opts));
   if (TRANSPARENT(fg)) return r_bg;
 
   calculate_alphas(fg, bg, &opts);
@@ -42,7 +42,7 @@ VALUE psd_native_compose_multiply(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts
   PIXEL bg = FIX2UINT(r_bg);
   PIXEL new_r, new_g, new_b;
 
-  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(bg)) return INT2FIX(apply_opacity(fg, &opts));
   if (TRANSPARENT(fg)) return r_bg;
 
   calculate_alphas(fg, bg, &opts);
@@ -59,7 +59,7 @@ VALUE psd_native_compose_color_burn(VALUE self, VALUE r_fg, VALUE r_bg, VALUE op
   PIXEL bg = FIX2UINT(r_bg);
   PIXEL new_r, new_g, new_b;
 
-  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(bg)) return INT2FIX(apply_opacity(fg, &opts));
   if (TRANSPARENT(fg)) return r_bg;
 
   calculate_alphas(fg, bg, &opts);
@@ -85,7 +85,7 @@ VALUE psd_native_compose_linear_burn(VALUE self, VALUE r_fg, VALUE r_bg, VALUE o
   PIXEL bg = FIX2UINT(r_bg);
   PIXEL new_r, new_g, new_b;
 
-  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(bg)) return INT2FIX(apply_opacity(fg, &opts));
   if (TRANSPARENT(fg)) return r_bg;
 
   calculate_alphas(fg, bg, &opts);
@@ -102,7 +102,7 @@ VALUE psd_native_compose_lighten(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts)
   PIXEL bg = FIX2UINT(r_bg);
   PIXEL new_r, new_g, new_b;
 
-  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(bg)) return INT2FIX(apply_opacity(fg, &opts));
   if (TRANSPARENT(fg)) return r_bg;
 
   calculate_alphas(fg, bg, &opts);
@@ -119,7 +119,7 @@ VALUE psd_native_compose_screen(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts)
   PIXEL bg = FIX2UINT(r_bg);
   PIXEL new_r, new_g, new_b;
 
-  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(bg)) return INT2FIX(apply_opacity(fg, &opts));
   if (TRANSPARENT(fg)) return r_bg;
 
   calculate_alphas(fg, bg, &opts);
@@ -136,7 +136,7 @@ VALUE psd_native_compose_color_dodge(VALUE self, VALUE r_fg, VALUE r_bg, VALUE o
   PIXEL bg = FIX2UINT(r_bg);
   PIXEL new_r, new_g, new_b;
 
-  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(bg)) return INT2FIX(apply_opacity(fg, &opts));
   if (TRANSPARENT(fg)) return r_bg;
 
   calculate_alphas(fg, bg, &opts);
@@ -161,7 +161,7 @@ VALUE psd_native_compose_linear_dodge(VALUE self, VALUE r_fg, VALUE r_bg, VALUE
   PIXEL bg = FIX2UINT(r_bg);
   PIXEL new_r, new_g, new_b;
 
-  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(bg)) return INT2FIX(apply_opacity(fg, &opts));
   if (TRANSPARENT(fg)) return r_bg;
 
   calculate_alphas(fg, bg, &opts);
@@ -178,7 +178,7 @@ VALUE psd_native_compose_overlay(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts)
   PIXEL bg = FIX2UINT(r_bg);
   PIXEL new_r, new_g, new_b;
 
-  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(bg)) return INT2FIX(apply_opacity(fg, &opts));
   if (TRANSPARENT(fg)) return r_bg;
 
   calculate_alphas(fg, bg, &opts);
@@ -203,7 +203,7 @@ VALUE psd_native_compose_soft_light(VALUE self, VALUE r_fg, VALUE r_bg, VALUE op
   PIXEL bg = FIX2UINT(r_bg);
   PIXEL new_r, new_g, new_b;
 
-  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(bg)) return INT2FIX(apply_opacity(fg, &opts));
   if (TRANSPARENT(fg)) return r_bg;
 
   calculate_alphas(fg, bg, &opts);
@@ -226,7 +226,7 @@ VALUE psd_native_compose_hard_light(VALUE self, VALUE r_fg, VALUE r_bg, VALUE op
   PIXEL bg = FIX2UINT(r_bg);
   PIXEL new_r, new_g, new_b;
 
-  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(bg)) return INT2FIX(apply_opacity(fg, &opts));
   if (TRANSPARENT(fg)) return r_bg;
 
   calculate_alphas(fg, bg, &opts);
@@ -251,7 +251,7 @@ VALUE psd_native_compose_vivid_light(VALUE self, VALUE r_fg, VALUE r_bg, VALUE o
   PIXEL bg = FIX2UINT(r_bg);
   PIXEL new_r, new_g, new_b;
 
-  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(bg)) return INT2FIX(apply_opacity(fg, &opts));
   if (TRANSPARENT(fg)) return r_bg;
 
   calculate_alphas(fg, bg, &opts);
@@ -276,7 +276,7 @@ VALUE psd_native_compose_linear_light(VALUE self, VALUE r_fg, VALUE r_bg, VALUE
   PIXEL bg = FIX2UINT(r_bg);
   PIXEL new_r, new_g, new_b;
 
-  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(bg)) return INT2FIX(apply_opacity(fg, &opts));
   if (TRANSPARENT(fg)) return r_bg;
 
   calculate_alphas(fg, bg, &opts);
@@ -301,7 +301,7 @@ VALUE psd_native_compose_pin_light(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opt
   PIXEL bg = FIX2UINT(r_bg);
   PIXEL new_r, new_g, new_b;
 
-  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(bg)) return INT2FIX(apply_opacity(fg, &opts));
   if (TRANSPARENT(fg)) return r_bg;
 
   calculate_alphas(fg, bg, &opts);
@@ -326,7 +326,7 @@ VALUE psd_native_compose_hard_mix(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts
   PIXEL bg = FIX2UINT(r_bg);
   PIXEL new_r, new_g, new_b;
 
-  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(bg)) return INT2FIX(apply_opacity(fg, &opts));
   if (TRANSPARENT(fg)) return r_bg;
 
   calculate_alphas(fg, bg, &opts);
@@ -343,7 +343,7 @@ VALUE psd_native_compose_difference(VALUE self, VALUE r_fg, VALUE r_bg, VALUE op
   PIXEL bg = FIX2UINT(r_bg);
   PIXEL new_r, new_g, new_b;
 
-  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(bg)) return INT2FIX(apply_opacity(fg, &opts));
   if (TRANSPARENT(fg)) return r_bg;
 
   calculate_alphas(fg, bg, &opts);
@@ -360,7 +360,7 @@ VALUE psd_native_compose_exclusion(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opt
   PIXEL bg = FIX2UINT(r_bg);
   PIXEL new_r, new_g, new_b;
 
-  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(bg)) return INT2FIX(apply_opacity(fg, &opts));
   if (TRANSPARENT(fg)) return r_bg;
 
   calculate_alphas(fg, bg, &opts);
@@ -386,4 +386,9 @@ uint32_t calculate_opacity(VALUE *opts) {
   uint32_t fill_opacity = FIX2UINT(rb_hash_aref(*opts, ID2SYM(rb_intern("fill_opacity"))));
 
   return opacity * fill_opacity / 255;
+}
+
+PIXEL apply_opacity(PIXEL color, VALUE *opts) {
+  uint32_t opacity = calculate_opacity(opts);
+  return (color & 0xffffff00) | ((color & 0x000000ff) * opacity / 255);
 }

data/ext/psd_native/compose.h

@@ -38,5 +38,6 @@ VALUE psd_native_compose_exclusion(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opt
 void calculate_alphas(uint32_t fg, uint32_t bg, VALUE *opts);
 uint32_t calculate_opacity(VALUE *opts);
 uint32_t blend_channel(uint32_t bg, uint32_t fg, uint32_t a);
+uint32_t apply_opacity(uint32_t, VALUE *);
 
 #endif

data/ext/psd_native/file.c

@@ -0,0 +1,20 @@
+#include "psd_native_ext.h"
+
+VALUE psd_file_read_byte(VALUE self) {
+  // @file.read(1).bytes[0]
+  VALUE data = rb_funcall(psd_file(self), rb_intern("read"), 1, INT2FIX(1));
+  return RARRAY_PTR(rb_funcall(data, rb_intern("bytes"), 0))[0];
+}
+
+VALUE psd_file_read_bytes(VALUE self, int bytes) {
+  VALUE data = rb_funcall(psd_file(self), rb_intern("read"), 1, INT2FIX(bytes));
+  return rb_funcall(rb_funcall(data, rb_intern("bytes"), 0), rb_intern("to_a"), 0);
+}
+
+VALUE psd_file(VALUE self) {
+  return rb_iv_get(self, "@file");
+}
+
+int psd_file_tell(VALUE self) {
+  return FIX2INT(rb_funcall(psd_file(self), rb_intern("tell"), 0));
+}

data/ext/psd_native/file.h

@@ -0,0 +1,9 @@
+#ifndef PSD_NATIVE_FILE
+#define PSD_NATIVE_FILE
+
+VALUE psd_file_read_byte(VALUE self);
+VALUE psd_file_read_bytes(VALUE self, int bytes);
+VALUE psd_file(VALUE self);
+int psd_file_tell(VALUE self);
+
+#endif

data/ext/psd_native/image_mode_cmyk.c

@@ -6,28 +6,47 @@ VALUE psd_native_combine_cmyk_channel(VALUE self) {
   uint32_t num_pixels = FIX2UINT(rb_iv_get(self, "@num_pixels"));
   uint32_t pixel_step = FIX2UINT(rb_funcall(self, rb_intern("pixel_step"), 0));
 
+  VALUE* channels_info = RARRAY_PTR(rb_iv_get(self, "@channels_info"));
   VALUE* channel_data = RARRAY_PTR(rb_iv_get(self, "@channel_data"));
   uint32_t channel_length = FIX2UINT(rb_iv_get(self, "@channel_length"));
-  uint32_t channel_count = FIX2UINT(rb_funcall(self, rb_intern("channels"), 0));
+  int channel_count = RARRAY_LENINT(rb_iv_get(self, "@channels_info"));
 
-  int i;
+  int i, j;
+  uint32_t val, c, m, y, k;
   uint32_t r, g, b;
-  VALUE a, c, m, y, k, rgb;
+  uint32_t a = 255;
+  VALUE rgb;
+  
+  int channel_ids[channel_count];
+  for (i = 0; i < channel_count; i++) {
+    channel_ids[i] = FIX2INT(rb_hash_aref(channels_info[i], ID2SYM(rb_intern("id"))));
+  }
 
   // Loop through every pixel in the image
   for (i = 0; i < num_pixels; i += pixel_step) {
-    c = channel_data[i];
-    m = channel_data[i + channel_length];
-    y = channel_data[i + channel_length * 2];
-    k = channel_data[i + channel_length * 3];
-    a = (channel_count == 5 ? channel_data[i + channel_length * 4] : 255);
+    c = m = y = k = 0;
+    a = 255;
+
+    for (j = 0; j < channel_count; j++) {
+      if (channel_ids[j] == -2) continue;
+
+      val = FIX2UINT(channel_data[i + (channel_length * j)]);
+
+      switch (channel_ids[j]) {
+        case -1: a = val; break;
+        case 0: c = val; break;
+        case 1: m = val; break;
+        case 2: y = val; break;
+        case 3: k = val; break;
+      }
+    }
 
     rgb = psd_native_cmyk_to_rgb(
       self, 
-      INT2FIX(255 - FIX2INT(c)), 
-      INT2FIX(255 - FIX2INT(m)), 
-      INT2FIX(255 - FIX2INT(y)),
-      INT2FIX(255 - FIX2INT(k))
+      INT2FIX(255 - c), 
+      INT2FIX(255 - m), 
+      INT2FIX(255 - y),
+      INT2FIX(255 - k)
     );
 
 

data/ext/psd_native/image_mode_rgb.c

@@ -19,6 +19,8 @@ VALUE psd_native_combine_rgb_channel(VALUE self) {
     channel_ids[i] = FIX2INT(rb_hash_aref(channels_info[i], ID2SYM(rb_intern("id"))));
   }
 
+  VALUE pixel_data = rb_iv_get(self, "@pixel_data");
+
   // Loop through every pixel in the image
   for (i = 0; i < num_pixels; i += pixel_step) {
     color = 0x000000ff;
@@ -38,8 +40,8 @@ VALUE psd_native_combine_rgb_channel(VALUE self) {
       }
     }
 
-    rb_ary_push(rb_iv_get(self, "@pixel_data"), INT2FIX(color));
+    rb_ary_push(pixel_data, INT2FIX(color));
   }
-
+  
   return Qnil;
 }

data/ext/psd_native/layer_raw.c

@@ -0,0 +1,20 @@
+#include "psd_native_ext.h"
+
+VALUE psd_native_layer_raw_parse_raw_bang(VALUE self) {
+  psd_logger("debug", "Attempting to parse RAW encoded channel with native code...");
+
+  int chan_pos = FIX2INT(rb_iv_get(self, "@chan_pos"));
+  int chan_length = FIX2INT(rb_hash_aref(rb_iv_get(self, "@ch_info"), ID2SYM(rb_intern("length"))));
+  VALUE channel_data = rb_iv_get(self, "@channel_data");
+
+  VALUE data = psd_file_read_bytes(self, chan_length - 2);
+
+  int i, j = 0;
+  for (i = chan_pos; i < (chan_pos + chan_length - 2); i++) {
+    rb_ary_store(channel_data, i, rb_ary_entry(data, j++));
+  }
+
+  rb_iv_set(self, "@chan_pos", INT2FIX(chan_pos + chan_length - 2));
+
+  return Qnil;
+}

data/ext/psd_native/layer_raw.h

@@ -0,0 +1,6 @@
+#ifndef PSD_NATIVE_LAYER_RAW
+#define PSD_NATIVE_LAYER_RAW
+
+VALUE psd_native_layer_raw_parse_raw_bang(VALUE self);
+
+#endif

data/ext/psd_native/psd_native_ext.c

@@ -27,6 +27,10 @@ void Init_psd_native() {
   VALUE RLE = rb_define_module_under(ImageFormat, "RLE");
   rb_define_private_method(RLE, "decode_rle_channel", psd_native_decode_rle_channel, 0);
 
+  // RAW decoding
+  VALUE LayerRAW = rb_define_module_under(ImageFormat, "LayerRAW");
+  rb_define_private_method(LayerRAW, "parse_raw!", psd_native_layer_raw_parse_raw_bang, 0);
+
   // Color functions
   VALUE Color = rb_define_module_under(PSDNative, "Color");
   rb_define_module_function(Color, "cmyk_to_rgb", psd_native_cmyk_to_rgb, 4);
@@ -52,13 +56,16 @@ void Init_psd_native() {
   rb_define_module_function(Compose, "difference", psd_native_compose_difference, 3);
   rb_define_module_function(Compose, "exclusion", psd_native_compose_exclusion, 3);
 
-  VALUE ClippingMask = rb_define_module_under(PSDNative, "ClippingMask");
-  rb_define_method(ClippingMask, "apply", psd_native_clipping_mask_apply, 0);
+  // Renderer
+  VALUE Renderer = rb_define_module_under(PSDNative, "Renderer");
+
+  // Clipping Mask
+  VALUE ClippingMask = rb_define_module_under(Renderer, "ClippingMask");
+  rb_define_method(ClippingMask, "apply!", psd_native_clipping_mask_apply_bang, 0);
 
-  // Build preview
-  VALUE Node = rb_define_module_under(PSDNative, "Node");
-  VALUE BuildPreview = rb_define_module_under(Node, "BuildPreview");
-  rb_define_private_method(BuildPreview, "blend_pixels!", psd_native_build_preview_blend_pixels, 6);
+  // Blender
+  VALUE Blender = rb_define_module_under(Renderer, "Blender");
+  rb_define_method(Blender, "compose!", psd_native_blender_compose_bang, 0);
 
   // Util
   VALUE Util = rb_define_module_under(PSDNative, "Util");
@@ -71,12 +78,4 @@ void Init_psd_native() {
 
 void psd_logger(char* level, char* message) {
   rb_funcall(logger, rb_intern(level), 1, rb_str_new2(message));
-}
-
-VALUE psd_file(VALUE self) {
-  return rb_iv_get(self, "@file");
-}
-
-int psd_file_tell(VALUE self) {
-  return FIX2INT(rb_funcall(psd_file(self), rb_intern("tell"), 0));
 }

data/ext/psd_native/psd_native_ext.h

@@ -4,7 +4,6 @@
 #include "ruby.h"
 
 #define RSTRING_NOT_MODIFIED
-#define PSD_CONCURRENCY 4
 
 // Pixels use 32 bits unsigned integers
 // We borrow this from OilyPNG
@@ -12,6 +11,7 @@ typedef uint32_t PIXEL;
 
 // Our native mixins
 #include "util.h"
+#include "file.h"
 #include "color.h"
 #include "clipping_mask.h"
 #include "compose.h"
@@ -19,12 +19,12 @@ typedef uint32_t PIXEL;
 #include "image_mode_greyscale.h"
 #include "image_mode_rgb.h"
 #include "rle_decoding.h"
-#include "build_preview.h"
+#include "canvas.h"
+#include "blender.h"
+#include "layer_raw.h"
 
 void Init_psd_native();
 // VALUE psd_class();
 void psd_logger(char* level, char* message);
-VALUE psd_file(VALUE self);
-int psd_file_tell(VALUE self);
 
 #endif

data/ext/psd_native/rle_decoding.c

@@ -2,7 +2,7 @@
 
 VALUE psd_native_decode_rle_channel(VALUE self) {
   int bytes, len, val;
-  int i, j, k;
+  int i, j, k, l;
 
   int height = FIX2INT(rb_funcall(self, rb_intern("height"), 0));
   VALUE channel_data = rb_iv_get(self, "@channel_data");
@@ -10,6 +10,8 @@ VALUE psd_native_decode_rle_channel(VALUE self) {
   int line_index = FIX2INT(rb_iv_get(self, "@line_index"));
   int chan_pos = FIX2INT(rb_iv_get(self, "@chan_pos"));
 
+  VALUE byte_data;
+
   for (i = 0; i < height; i++) {
     bytes = FIX2INT(byte_counts[line_index + i]);
 
@@ -19,8 +21,11 @@ VALUE psd_native_decode_rle_channel(VALUE self) {
 
       if (len < 128) {
         len++;
+
+        l = 0;
+        byte_data = psd_file_read_bytes(self, len);
         for (k = chan_pos; k < chan_pos + len; k++) {
-          rb_ary_store(channel_data, k, psd_file_read_byte(self));
+          rb_ary_store(channel_data, k, rb_ary_entry(byte_data, l++));
         }
 
         chan_pos += len;
@@ -42,10 +47,4 @@ VALUE psd_native_decode_rle_channel(VALUE self) {
 
   rb_iv_set(self, "@chan_pos", INT2FIX(chan_pos));
   return Qnil;
-}
-
-VALUE psd_file_read_byte(VALUE self) {
-  // @file.read(1).bytes[0]
-  VALUE data = rb_funcall(psd_file(self), rb_intern("read"), 1, INT2FIX(1));
-  return RARRAY_PTR(rb_funcall(data, rb_intern("bytes"), 0))[0];
 }

data/ext/psd_native/rle_decoding.h

@@ -2,6 +2,5 @@
 #define PSD_NATIVE_RLE_DECODING
 
 VALUE psd_native_decode_rle_channel(VALUE self);
-VALUE psd_file_read_byte(VALUE self);
 
 #endif

data/lib/psd_native/version.rb

@@ -1,3 +1,3 @@
 module PSDNative
-  VERSION = "0.6.0"
+  VERSION = "1.0.0"
 end

data/lib/psd_native.rb

@@ -1,4 +1,5 @@
 require "psd"
+require "oily_png"
 
 module PSDNative
   def self.included(base)
@@ -6,14 +7,19 @@ module PSDNative
     base::Image.send(:include, PSDNative::ImageMode::CMYK)
     base::Image.send(:include, PSDNative::ImageMode::Greyscale)
     base::Image.send(:include, PSDNative::ImageFormat::RLE)
+    base::ChannelImage.send(:include, PSDNative::ImageFormat::LayerRAW)
     base::Color.send(:include, PSDNative::Color)
-    base::Node.send(:include, PSDNative::Node::BuildPreview)
     base::Util.extend PSDNative::Util
 
-    base::ClippingMask.class_eval do
-      remove_method :apply
+    base::Renderer::ClippingMask.class_eval do
+      remove_method :apply!
     end
-    base::ClippingMask.send(:include, PSDNative::ClippingMask)
+    base::Renderer::ClippingMask.send(:include, PSDNative::Renderer::ClippingMask)
+
+    base::Renderer::Blender.class_eval do
+      remove_method :compose!
+    end
+    base::Renderer::Blender.send(:include, PSDNative::Renderer::Blender)
   end
 end
 

data/psd_native.gemspec

@@ -17,21 +17,19 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
 
+  spec.platform      = Gem::Platform::RUBY
   spec.extensions    = ["ext/psd_native/extconf.rb"]
   spec.require_paths = ["lib", "ext"]
 
-  spec.add_runtime_dependency "psd", ">= 1.4.1"
+  spec.add_runtime_dependency "psd", ">= 2.0.0"
+  spec.add_runtime_dependency "oily_png", "~> 1.1"
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rake-compiler"
+  spec.add_development_dependency "rake-compiler", "~> 0.9"
 
   spec.test_files = Dir.glob("spec/**/*")
-  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rspec', "~> 2.14"
   spec.add_development_dependency 'guard'
   spec.add_development_dependency 'guard-rspec'
-
-  if RUBY_PLATFORM =~ /darwin/
-    spec.add_development_dependency 'rb-fsevent', '~> 0.9'
-  end
 end

data/spec/image_spec.rb

@@ -1,70 +1,86 @@
 require 'spec_helper'
 
 describe 'Image Exporting' do
-  before(:each) do
-    class PSD::Image 
-      attr_accessor :pixel_data
-    end
-
-    @psd = PSD.new('spec/files/pixel.psd')
-  end
+  let!(:psd) { PSD.new('spec/files/pixel.psd') }
 
   describe "the full preview image" do
     it "should successfully parse the image data" do
-      @psd.parse!
-      expect(@psd).to be_parsed
-      expect(@psd.image).to_not be_nil
-      expect(@psd.image.width).to eq(1)
-      expect(@psd.image.height).to eq(1)
-      expect(@psd.image.pixel_data).to eq([ChunkyPNG::Color.rgba(0, 100, 200, 255)])
+      psd.parse!
+      expect(psd).to be_parsed
+      expect(psd.image).to_not be_nil
+      expect(psd.image.width).to eq(1)
+      expect(psd.image.height).to eq(1)
+      expect(psd.image.pixel_data).to eq([ChunkyPNG::Color.rgba(0, 100, 200, 255)])
     end
 
     it "should be able to skip to the image" do
-      expect(@psd).to_not be_parsed
-      expect(@psd.image.width).to eq(1)
-      expect(@psd.image.height).to eq(1)
-      expect(@psd.image.pixel_data).to eq([ChunkyPNG::Color.rgba(0, 100, 200, 255)])
+      expect(psd).to_not be_parsed
+      expect(psd.image.width).to eq(1)
+      expect(psd.image.height).to eq(1)
+      expect(psd.image.pixel_data).to eq([ChunkyPNG::Color.rgba(0, 100, 200, 255)])
     end
 
     describe "as PNG" do
       it "should produce a valid PNG object" do
-        expect(@psd.image.to_png).to be_an_instance_of(ChunkyPNG::Canvas)
+        expect(psd.image.to_png).to be_an_instance_of(ChunkyPNG::Canvas)
 
-        expect(@psd.image.to_png.width).to eq(1)
-        expect(@psd.image.to_png.height).to eq(1)
+        expect(psd.image.to_png.width).to eq(1)
+        expect(psd.image.to_png.height).to eq(1)
         expect(
-          ChunkyPNG::Color.to_truecolor_alpha_bytes(@psd.image.to_png[0,0])
+          ChunkyPNG::Color.to_truecolor_alpha_bytes(psd.image.to_png[0,0])
         ).to eq([0, 100, 200, 255])
       end
     end
   end
 
-  describe "layer images" do
-    it "should successfully parse the image data" do
-      @psd.options[:parse_layer_images] = true
-      @psd.parse!
+  describe "Renderer" do
+    before(:each) do
+      psd.parse!
+    end
 
-      image = @psd.tree.children.first.image
-      expect(image).to be_an_instance_of(PSD::ChannelImage)
-      expect(image.width).to eq(1)
-      expect(image.height).to eq(1)
+    it "should be available via any tree node" do
+      [psd.tree, psd.tree.children.first].each do |node|
+        expect(node).to respond_to(:renderer)
+        expect(node).to respond_to(:to_png)
+        expect(node).to respond_to(:save_as_png)
+      end
+    end
 
-      expect(image.pixel_data).to eq([ChunkyPNG::Color.rgba(0, 100, 200, 255)])
+    it "returns a Renderer object" do
+      [psd.tree, psd.tree.children.first].each do |node|
+        expect(node.renderer).to be_an_instance_of(PSD::Renderer)
+      end
     end
 
-    describe "as PNG" do
-      it "should produce a valid PNG object" do
-        @psd.options[:parse_layer_images] = true
-        @psd.parse!
+    it "produces a correct PNG" do
+      expect(psd.tree.to_png).to be_an_instance_of(ChunkyPNG::Canvas)
+      expect(psd.tree.to_png.pixels).to eq([ChunkyPNG::Color.rgba(0, 100, 200, 255)])
+      expect(psd.tree.to_png[0, 0]).to eq(ChunkyPNG::Color.rgba(0, 100, 200, 255))
+    end
 
-        png = @psd.tree.children.first.image.to_png
-        expect(png).to be_an_instance_of(ChunkyPNG::Canvas)
-        expect(png.width).to eq(1)
-        expect(png.height).to eq(1)
-        expect(
-          ChunkyPNG::Color.to_truecolor_alpha_bytes(png[0,0])
-        ).to eq([0, 100, 200, 255])
+    describe "Canvas" do
+      before do
+        @node = psd.tree.children.first
+        @canvas = PSD::Renderer::Canvas.new(@node)
+      end
+
+      it 'is initialized properly' do
+        expect(@canvas.node).to be @node
+        expect(@canvas.width).to eq @node.width
+        expect(@canvas.height).to eq @node.height
+
+        expect(@canvas.opacity).to eq @node.opacity
+        expect(@canvas.fill_opacity).to eq @node.fill_opacity
+
+        expect(@canvas.canvas).to be_an_instance_of(ChunkyPNG::Canvas)
+        expect(@canvas.instance_variable_get(:@pixel_data)).to be_nil
+        expect(@canvas.canvas.pixels.length).to be 1
+      end
+
+      it 'delegates array methods to internal canvas' do
+        expect(@canvas[0, 0]).to eq ChunkyPNG::Color.rgba(0, 100, 200, 255)
+        expect(@canvas).to respond_to(:[]=)
       end
     end
   end
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: psd_native
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Ryan LeFevre
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-25 00:00:00.000000000 Z
+date: 2014-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: psd
@@ -16,14 +16,28 @@ dependencies:
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 1.4.1
+        version: 2.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 1.4.1
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: oily_png
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -56,30 +70,30 @@ dependencies:
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.9'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.14'
 - !ruby/object:Gem::Dependency
   name: guard
   requirement: !ruby/object:Gem::Requirement
@@ -108,20 +122,6 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: rb-fsevent
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '0.9'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '0.9'
 description: Native mixins to speed up PSD.rb
 email:
 - ryan@layervault.com
@@ -137,8 +137,10 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- ext/psd_native/build_preview.c
-- ext/psd_native/build_preview.h
+- ext/psd_native/blender.c
+- ext/psd_native/blender.h
+- ext/psd_native/canvas.c
+- ext/psd_native/canvas.h
 - ext/psd_native/clipping_mask.c
 - ext/psd_native/clipping_mask.h
 - ext/psd_native/color.c
@@ -146,12 +148,16 @@ files:
 - ext/psd_native/compose.c
 - ext/psd_native/compose.h
 - ext/psd_native/extconf.rb
+- ext/psd_native/file.c
+- ext/psd_native/file.h
 - ext/psd_native/image_mode_cmyk.c
 - ext/psd_native/image_mode_cmyk.h
 - ext/psd_native/image_mode_greyscale.c
 - ext/psd_native/image_mode_greyscale.h
 - ext/psd_native/image_mode_rgb.c
 - ext/psd_native/image_mode_rgb.h
+- ext/psd_native/layer_raw.c
+- ext/psd_native/layer_raw.h
 - ext/psd_native/psd_native_ext.c
 - ext/psd_native/psd_native_ext.h
 - ext/psd_native/rle_decoding.c
@@ -193,7 +199,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.11
+rubygems_version: 2.2.1
 signing_key: 
 specification_version: 4
 summary: Native C mixins to speed up the slowest parts of PSD.rb

data/ext/psd_native/build_preview.c

@@ -1,58 +0,0 @@
-#include "psd_native_ext.h"
-
-VALUE psd_native_build_preview_blend_pixels(
-  VALUE self, 
-  VALUE blending_mode, 
-  VALUE layer, 
-  VALUE base, 
-  VALUE other, 
-  VALUE r_offset_x, 
-  VALUE r_offset_y) {
-
-  int x, y, base_x, base_y, offset_x, offset_y;
-  uint32_t width, height, base_width, base_height;
-  VALUE color;
-  VALUE Compose = rb_const_get(rb_const_get(rb_cObject, rb_intern("PSD")), rb_intern("Compose"));
-
-  width = FIX2UINT(rb_funcall(other, rb_intern("width"), 0));
-  height = FIX2UINT(rb_funcall(other, rb_intern("height"), 0));
-  base_width = FIX2UINT(rb_funcall(base, rb_intern("width"), 0));
-  base_height = FIX2UINT(rb_funcall(base, rb_intern("height"), 0));
-  offset_x = FIX2INT(r_offset_x);
-  offset_y = FIX2INT(r_offset_y);
-  
-  VALUE opacity = rb_hash_new();
-  rb_hash_aset(
-    opacity, 
-    ID2SYM(rb_intern("opacity")),
-    rb_funcall(layer, rb_intern("opacity"), 0)
-  );
-
-  rb_hash_aset(
-    opacity,
-    ID2SYM(rb_intern("fill_opacity")),
-    rb_funcall(layer, rb_intern("fill_opacity"), 0)
-  );
-
-  for (y = 0; y < height; y++) {
-    for (x = 0; x < width; x++) {
-      base_x = x + offset_x;
-      base_y = y + offset_y;
-
-      if (base_x < 0 || base_y < 0 || base_x >= base_width || base_y >= base_height) continue;
-
-      color = rb_funcall(
-        Compose,
-        rb_intern_str(blending_mode),
-        3,
-        rb_funcall(other, rb_intern("[]"), 2, INT2FIX(x), INT2FIX(y)),
-        rb_funcall(base, rb_intern("[]"), 2, INT2FIX(base_x), INT2FIX(base_y)),
-        opacity
-      );
-
-      rb_funcall(base, rb_intern("[]="), 3, INT2FIX(base_x), INT2FIX(base_y), color);
-    }
-  }
-
-  return Qnil;
-}

data/ext/psd_native/build_preview.h

@@ -1,6 +0,0 @@
-#ifndef PSD_NATIVE_BUILD_PREVIEW
-#define PSD_NATIVE_BUILD_PREVIEW
-
-VALUE psd_native_build_preview_blend_pixels(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE);
-
-#endif