psd_native 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 43ce99138b4b79f02a2f05ac620b2cb74572fea3
-  data.tar.gz: 2b003b13301a2009dc8ed4668435bd60a77a60ec
+  metadata.gz: c081770f983b87fa68b32f0a04576c8384bce760
+  data.tar.gz: aa04b516926a30d512c22fec87f43524a2eca4b5
 SHA512:
-  metadata.gz: 2be538272093186445f346678e4e589715182d37a870f3dc13b075d55d226e835d55fd56e9f21bd17e424e484ee7007ced0f7d0f70fefd09cede853d40f18861
-  data.tar.gz: dedc579ccb2b5c9fdbd867c0badab4aebff2bb3e55d2d64c3484d0915b9f2ddee8c281e595d92fe943b3954d90cf6e452ada0f7203b647af9965464d99f4ef50
+  metadata.gz: 2d8876e7d2981bdecd7701c3d25adca20b8c5e4cebfc00f7f382ae227477972f3e6174ab60daef81f5713da7cbec490e057ae62e120e327221d13bba7968bd6a
+  data.tar.gz: 03a9c93c7c2ab9d7176909497edf96bcbbb500befeaac3cedc9005ba584bcb072940c9c4dd21b2176d856378c640117811dda1070f4bb789664bd3023d5a9eb9

data/README.md

@@ -11,6 +11,8 @@ Currently, PSDNative replaces these sections of PSD.rb with native code:
 * Greyscale processing
 * RLE decoding
 * Some color conversions
+* Color composition
+* Clipping masks
 
 ## Installation
 

data/ext/psd_native/clipping_mask.c

@@ -0,0 +1,60 @@
+#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");
+  }
+
+  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) {
+        alpha = 0;
+      } else {
+        mask_x = x - mask_left;
+        mask_y = y - mask_top;
+
+        pixel = rb_ary_entry(pixel_data, mask_y * mask_width + mask_x);
+        if (pixel == Qnil) {
+          alpha = 0;
+        } else {
+          alpha = A(FIX2UINT(pixel));
+        }
+      }
+
+      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));
+    }
+  }
+
+  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)
+  );
+}

data/ext/psd_native/clipping_mask.h

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

data/ext/psd_native/color.c

@@ -17,32 +17,4 @@ VALUE psd_native_cmyk_to_rgb(VALUE self, VALUE c, VALUE m, VALUE y, VALUE k) {
 
 int psd_clamp_int(int n, int low, int high) {
   return n < low ? low : (n > high ? high : n);
-}
-
-int opaque(uint32_t color) {
-  return a(color) == 0x000000ff;
-}
-
-int transparent(uint32_t color) {
-  return a(color) == 0x00000000;
-}
-
-uint32_t r(uint32_t color) {
-  return (color & 0xff000000) >> 24;
-}
-
-uint32_t g(uint32_t color) {
-  return (color & 0x00ff0000) >> 16;
-}
-
-uint32_t b(uint32_t color) {
-  return (color & 0x0000ff00) >> 8;
-}
-
-uint32_t a(uint32_t color) {
-  return color & 0x000000ff;
-}
-
-uint32_t rgba(uint32_t r, uint32_t g, uint32_t b, uint32_t a) {
-  return r << 24 | g << 16 | b << 8 | a;
 }

data/ext/psd_native/color.h

@@ -1,14 +1,18 @@
 #ifndef PSD_NATIVE_COLOR
 #define PSD_NATIVE_COLOR
 
+#define BUILD_PIXEL(r, g, b, a) (((PIXEL) (r) << 24) + ((PIXEL) (g) << 16) + ((PIXEL) (b) << 8) + (PIXEL) (a))
+#define CLAMP_PIXEL(p) ((p < 0) ? 0 : ((p > 255) ? 255 : p))
+#define R(color) (PIXEL) (((PIXEL) (color) & (PIXEL) 0xff000000) >> 24)
+#define G(color) (PIXEL) (((PIXEL) (color) & (PIXEL) 0x00ff0000) >> 16)
+#define B(color) (PIXEL) (((PIXEL) (color) & (PIXEL) 0x0000ff00) >> 8)
+#define A(color) (PIXEL) ((PIXEL) (color) & (PIXEL) 0x000000ff)
+#define OPAQUE(color) ((PIXEL) A(color) == (PIXEL) 0x000000ff)
+#define TRANSPARENT(color) ((PIXEL) A(color) == (PIXEL) 0x00000000)
+#define PSD_MAX(a, b) (((a) > (b)) ? (a) : (b))
+#define PSD_MIN(a, b) (((a) < (b)) ? (a) : (b))
+
 VALUE psd_native_cmyk_to_rgb(VALUE self, VALUE c, VALUE m, VALUE y, VALUE k);
 int psd_clamp_int(int n, int low, int high);
-int opaque(uint32_t color);
-int transparent(uint32_t color);
-uint32_t r(uint32_t color);
-uint32_t g(uint32_t color);
-uint32_t b(uint32_t color);
-uint32_t a(uint32_t color);
-uint32_t rgba(uint32_t r, uint32_t g, uint32_t b, uint32_t a);
 
 #endif

data/ext/psd_native/compose.c

@@ -1,29 +1,382 @@
+#include <math.h>
 #include "psd_native_ext.h"
 
 AlphaValues alpha;
 
 VALUE psd_native_compose_normal(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts) {
-  uint32_t fg = FIX2UINT(r_fg);
-  uint32_t bg = FIX2UINT(r_bg);
-  uint32_t new_r, new_g, new_b;
+  PIXEL fg = FIX2UINT(r_fg);
+  PIXEL bg = FIX2UINT(r_bg);
+  PIXEL new_r, new_g, new_b;
 
-  if (opaque(fg) || transparent(bg)) return INT2FIX(fg);
-  if (transparent(fg)) return INT2FIX(bg);
+  if (OPAQUE(fg) || TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(fg)) return r_bg;
 
   calculate_alphas(fg, bg, &opts);
 
-  new_r = blend_channel(r(bg), r(fg), alpha.mix);
-  new_g = blend_channel(g(bg), g(fg), alpha.mix);
-  new_b = blend_channel(b(bg), b(fg), alpha.mix);
+  new_r = BLEND_CHANNEL(R(bg), R(fg), alpha.mix);
+  new_g = BLEND_CHANNEL(G(bg), G(fg), alpha.mix);
+  new_b = BLEND_CHANNEL(B(bg), B(fg), alpha.mix);
 
-  return INT2FIX(rgba(new_r, new_g, new_b, alpha.dst));
+  return INT2FIX(BUILD_PIXEL(new_r, new_g, new_b, alpha.dst));
 }
 
-void calculate_alphas(uint32_t fg, uint32_t bg, VALUE *opts) {
+VALUE psd_native_compose_darken(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts) {
+  PIXEL fg = FIX2UINT(r_fg);
+  PIXEL bg = FIX2UINT(r_bg);
+  PIXEL new_r, new_g, new_b;
+
+  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(fg)) return r_bg;
+
+  calculate_alphas(fg, bg, &opts);
+
+  new_r = R(fg) <= R(bg) ? BLEND_CHANNEL(R(bg), R(fg), alpha.mix) : R(bg);
+  new_g = G(fg) <= G(bg) ? BLEND_CHANNEL(G(bg), G(fg), alpha.mix) : G(bg);
+  new_b = B(fg) <= B(bg) ? BLEND_CHANNEL(B(bg), B(fg), alpha.mix) : B(bg);
+
+  return INT2FIX(BUILD_PIXEL(new_r, new_g, new_b, alpha.dst));
+}
+
+VALUE psd_native_compose_multiply(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts) {
+  PIXEL fg = FIX2UINT(r_fg);
+  PIXEL bg = FIX2UINT(r_bg);
+  PIXEL new_r, new_g, new_b;
+
+  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(fg)) return r_bg;
+
+  calculate_alphas(fg, bg, &opts);
+
+  new_r = BLEND_CHANNEL(R(bg), R(fg) * R(bg) >> 8, alpha.mix);
+  new_g = BLEND_CHANNEL(G(bg), G(fg) * G(bg) >> 8, alpha.mix);
+  new_b = BLEND_CHANNEL(B(bg), B(fg) * B(bg) >> 8, alpha.mix);
+
+  return INT2FIX(BUILD_PIXEL(new_r, new_g, new_b, alpha.dst));
+}
+
+VALUE psd_native_compose_color_burn(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts) {
+  PIXEL fg = FIX2UINT(r_fg);
+  PIXEL bg = FIX2UINT(r_bg);
+  PIXEL new_r, new_g, new_b;
+
+  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(fg)) return r_bg;
+
+  calculate_alphas(fg, bg, &opts);
+
+  new_r = BLEND_CHANNEL(R(bg), color_burn_foreground(R(bg), R(fg)), alpha.mix);
+  new_g = BLEND_CHANNEL(G(bg), color_burn_foreground(G(bg), G(fg)), alpha.mix);
+  new_b = BLEND_CHANNEL(B(bg), color_burn_foreground(B(bg), B(fg)), alpha.mix);
+
+  return INT2FIX(BUILD_PIXEL(new_r, new_g, new_b, alpha.dst));
+}
+
+PIXEL color_burn_foreground(PIXEL b, PIXEL f) {
+  if (f > 0) {
+    f = ((255 - b) << 8) / f;
+    return f > 255 ? 0 : (255 - f);
+  } else {
+    return b;
+  }
+}
+
+VALUE psd_native_compose_linear_burn(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts) {
+  PIXEL fg = FIX2UINT(r_fg);
+  PIXEL bg = FIX2UINT(r_bg);
+  PIXEL new_r, new_g, new_b;
+
+  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(fg)) return r_bg;
+
+  calculate_alphas(fg, bg, &opts);
+
+  new_r = BLEND_CHANNEL(R(bg), (R(fg) < (255 - R(bg))) ? 0 : R(fg) - (255 - R(bg)), alpha.mix);
+  new_g = BLEND_CHANNEL(G(bg), (G(fg) < (255 - G(bg))) ? 0 : G(fg) - (255 - G(bg)), alpha.mix);
+  new_b = BLEND_CHANNEL(B(bg), (B(fg) < (255 - B(bg))) ? 0 : B(fg) - (255 - B(bg)), alpha.mix);
+
+  return INT2FIX(BUILD_PIXEL(new_r, new_g, new_b, alpha.dst));
+}
+
+VALUE psd_native_compose_lighten(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts) {
+  PIXEL fg = FIX2UINT(r_fg);
+  PIXEL bg = FIX2UINT(r_bg);
+  PIXEL new_r, new_g, new_b;
+
+  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(fg)) return r_bg;
+
+  calculate_alphas(fg, bg, &opts);
+
+  new_r = (R(fg) >= R(bg)) ? BLEND_CHANNEL(R(bg), R(fg), alpha.mix) : R(bg);
+  new_g = (G(fg) >= G(bg)) ? BLEND_CHANNEL(G(bg), G(fg), alpha.mix) : G(bg);
+  new_b = (B(fg) >= B(bg)) ? BLEND_CHANNEL(B(bg), B(fg), alpha.mix) : B(bg);
+
+  return INT2FIX(BUILD_PIXEL(new_r, new_g, new_b, alpha.dst));
+}
+
+VALUE psd_native_compose_screen(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts) {
+  PIXEL fg = FIX2UINT(r_fg);
+  PIXEL bg = FIX2UINT(r_bg);
+  PIXEL new_r, new_g, new_b;
+
+  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(fg)) return r_bg;
+
+  calculate_alphas(fg, bg, &opts);
+
+  new_r = BLEND_CHANNEL(R(bg), 255 - ((255 - R(bg)) * (255 - R(fg)) >> 8), alpha.mix);
+  new_g = BLEND_CHANNEL(G(bg), 255 - ((255 - G(bg)) * (255 - G(fg)) >> 8), alpha.mix);
+  new_b = BLEND_CHANNEL(B(bg), 255 - ((255 - B(bg)) * (255 - B(fg)) >> 8), alpha.mix);
+
+  return INT2FIX(BUILD_PIXEL(new_r, new_g, new_b, alpha.dst));
+}
+
+VALUE psd_native_compose_color_dodge(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts) {
+  PIXEL fg = FIX2UINT(r_fg);
+  PIXEL bg = FIX2UINT(r_bg);
+  PIXEL new_r, new_g, new_b;
+
+  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(fg)) return r_bg;
+
+  calculate_alphas(fg, bg, &opts);
+
+  new_r = BLEND_CHANNEL(R(bg), color_dodge_foreground(R(bg), R(fg)), alpha.mix);
+  new_g = BLEND_CHANNEL(G(bg), color_dodge_foreground(G(bg), G(fg)), alpha.mix);
+  new_b = BLEND_CHANNEL(B(bg), color_dodge_foreground(B(bg), B(fg)), alpha.mix);
+
+  return INT2FIX(BUILD_PIXEL(new_r, new_g, new_b, alpha.dst));
+}
+
+PIXEL color_dodge_foreground(PIXEL b, PIXEL f) {
+  if (f < 255) {
+    return CLAMP_PIXEL((b << 8) / (255 - f));
+  } else {
+    return b;
+  }
+}
+
+VALUE psd_native_compose_linear_dodge(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts) {
+  PIXEL fg = FIX2UINT(r_fg);
+  PIXEL bg = FIX2UINT(r_bg);
+  PIXEL new_r, new_g, new_b;
+
+  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(fg)) return r_bg;
+
+  calculate_alphas(fg, bg, &opts);
+
+  new_r = BLEND_CHANNEL(R(bg), (R(bg) + R(fg)) > 255 ? 255 : R(bg) + R(fg), alpha.mix);
+  new_g = BLEND_CHANNEL(G(bg), (G(bg) + G(fg)) > 255 ? 255 : G(bg) + G(fg), alpha.mix);
+  new_b = BLEND_CHANNEL(B(bg), (B(bg) + B(fg)) > 255 ? 255 : B(bg) + B(fg), alpha.mix);
+
+  return INT2FIX(BUILD_PIXEL(new_r, new_g, new_b, alpha.dst));
+}
+
+VALUE psd_native_compose_overlay(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts) {
+  PIXEL fg = FIX2UINT(r_fg);
+  PIXEL bg = FIX2UINT(r_bg);
+  PIXEL new_r, new_g, new_b;
+
+  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(fg)) return r_bg;
+
+  calculate_alphas(fg, bg, &opts);
+
+  new_r = BLEND_CHANNEL(R(bg), overlay_foreground(R(bg), R(fg)), alpha.mix);
+  new_g = BLEND_CHANNEL(G(bg), overlay_foreground(G(bg), G(fg)), alpha.mix);
+  new_b = BLEND_CHANNEL(B(bg), overlay_foreground(B(bg), B(fg)), alpha.mix);
+
+  return INT2FIX(BUILD_PIXEL(new_r, new_g, new_b, alpha.dst));
+}
+
+PIXEL overlay_foreground(PIXEL b, PIXEL f) {
+  if (b < 128) {
+    return b * f >> 7;
+  } else {
+    return 255 - ((255 - b) * (255 - f) >> 7);
+  }
+}
+
+VALUE psd_native_compose_soft_light(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts) {
+  PIXEL fg = FIX2UINT(r_fg);
+  PIXEL bg = FIX2UINT(r_bg);
+  PIXEL new_r, new_g, new_b;
+
+  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(fg)) return r_bg;
+
+  calculate_alphas(fg, bg, &opts);
+
+  new_r = BLEND_CHANNEL(R(bg), soft_light_foreground(R(bg), R(fg)), alpha.mix);
+  new_g = BLEND_CHANNEL(G(bg), soft_light_foreground(G(bg), G(fg)), alpha.mix);
+  new_b = BLEND_CHANNEL(B(bg), soft_light_foreground(B(bg), B(fg)), alpha.mix);
+
+  return INT2FIX(BUILD_PIXEL(new_r, new_g, new_b, alpha.dst));
+}
+
+PIXEL soft_light_foreground(PIXEL b, PIXEL f) {
+  uint32_t c1 = b * f >> 8;
+  uint32_t c2 = 255 - ((255 - b) * (255 - f) >> 8);
+  return ((255 - b) * c1 >> 8) + (b * c2 >> 8);
+}
+
+VALUE psd_native_compose_hard_light(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts) {
+  PIXEL fg = FIX2UINT(r_fg);
+  PIXEL bg = FIX2UINT(r_bg);
+  PIXEL new_r, new_g, new_b;
+
+  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(fg)) return r_bg;
+
+  calculate_alphas(fg, bg, &opts);
+
+  new_r = BLEND_CHANNEL(R(bg), hard_light_foreground(R(bg), R(fg)), alpha.mix);
+  new_g = BLEND_CHANNEL(G(bg), hard_light_foreground(G(bg), G(fg)), alpha.mix);
+  new_b = BLEND_CHANNEL(B(bg), hard_light_foreground(B(bg), B(fg)), alpha.mix);
+
+  return INT2FIX(BUILD_PIXEL(new_r, new_g, new_b, alpha.dst));
+}
+
+PIXEL hard_light_foreground(PIXEL b, PIXEL f) {
+  if (f < 128) {
+    return b * f >> 7;
+  } else {
+    return 255 - ((255 - f) * (255 - b) >> 7);
+  }
+}
+
+VALUE psd_native_compose_vivid_light(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts) {
+  PIXEL fg = FIX2UINT(r_fg);
+  PIXEL bg = FIX2UINT(r_bg);
+  PIXEL new_r, new_g, new_b;
+
+  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(fg)) return r_bg;
+
+  calculate_alphas(fg, bg, &opts);
+
+  new_r = BLEND_CHANNEL(R(bg), vivid_light_foreground(R(bg), R(fg)), alpha.mix);
+  new_g = BLEND_CHANNEL(G(bg), vivid_light_foreground(G(bg), G(fg)), alpha.mix);
+  new_b = BLEND_CHANNEL(B(bg), vivid_light_foreground(B(bg), B(fg)), alpha.mix);
+
+  return INT2FIX(BUILD_PIXEL(new_r, new_g, new_b, alpha.dst));
+}
+
+PIXEL vivid_light_foreground(PIXEL b, PIXEL f) {
+  if (f < 255) {
+    return CLAMP_PIXEL((b * b / (255 - f) + f * f / (255 - b)) >> 1);
+  } else {
+    return b;
+  }
+}
+
+VALUE psd_native_compose_linear_light(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts) {
+  PIXEL fg = FIX2UINT(r_fg);
+  PIXEL bg = FIX2UINT(r_bg);
+  PIXEL new_r, new_g, new_b;
+
+  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(fg)) return r_bg;
+
+  calculate_alphas(fg, bg, &opts);
+
+  new_r = BLEND_CHANNEL(R(bg), linear_light_foreground(R(bg), R(fg)), alpha.mix);
+  new_g = BLEND_CHANNEL(G(bg), linear_light_foreground(G(bg), G(fg)), alpha.mix);
+  new_b = BLEND_CHANNEL(B(bg), linear_light_foreground(B(bg), B(fg)), alpha.mix);
+
+  return INT2FIX(BUILD_PIXEL(new_r, new_g, new_b, alpha.dst));
+}
+
+PIXEL linear_light_foreground(PIXEL b, PIXEL f) {
+  if (b < 255) {
+    return CLAMP_PIXEL(f * f / (255 - b));
+  } else {
+    return 255;
+  }
+}
+
+VALUE psd_native_compose_pin_light(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts) {
+  PIXEL fg = FIX2UINT(r_fg);
+  PIXEL bg = FIX2UINT(r_bg);
+  PIXEL new_r, new_g, new_b;
+
+  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(fg)) return r_bg;
+
+  calculate_alphas(fg, bg, &opts);
+
+  new_r = BLEND_CHANNEL(R(bg), pin_light_foreground(R(bg), R(fg)), alpha.mix);
+  new_g = BLEND_CHANNEL(G(bg), pin_light_foreground(G(bg), G(fg)), alpha.mix);
+  new_b = BLEND_CHANNEL(B(bg), pin_light_foreground(B(bg), B(fg)), alpha.mix);
+
+  return INT2FIX(BUILD_PIXEL(new_r, new_g, new_b, alpha.dst));
+}
+
+PIXEL pin_light_foreground(PIXEL b, PIXEL f) {
+  if (f >= 128) {
+    return PSD_MAX(b, (f - 128) * 2);
+  } else {
+    return PSD_MIN(b, f * 2);
+  }
+}
+
+VALUE psd_native_compose_hard_mix(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts) {
+  PIXEL fg = FIX2UINT(r_fg);
+  PIXEL bg = FIX2UINT(r_bg);
+  PIXEL new_r, new_g, new_b;
+
+  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(fg)) return r_bg;
+
+  calculate_alphas(fg, bg, &opts);
+
+  new_r = BLEND_CHANNEL(R(bg), (R(bg) + R(fg) <= 255) ? 0 : 255, alpha.mix);
+  new_g = BLEND_CHANNEL(G(bg), (G(bg) + G(fg) <= 255) ? 0 : 255, alpha.mix);
+  new_b = BLEND_CHANNEL(B(bg), (B(bg) + B(fg) <= 255) ? 0 : 255, alpha.mix);
+
+  return INT2FIX(BUILD_PIXEL(new_r, new_g, new_b, alpha.dst));
+}
+
+VALUE psd_native_compose_difference(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts) {
+  PIXEL fg = FIX2UINT(r_fg);
+  PIXEL bg = FIX2UINT(r_bg);
+  PIXEL new_r, new_g, new_b;
+
+  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(fg)) return r_bg;
+
+  calculate_alphas(fg, bg, &opts);
+
+  new_r = BLEND_CHANNEL(R(bg), abs(R(bg) - R(fg)), alpha.mix);
+  new_g = BLEND_CHANNEL(G(bg), abs(G(bg) - G(fg)), alpha.mix);
+  new_b = BLEND_CHANNEL(B(bg), abs(B(bg) - B(fg)), alpha.mix);
+
+  return INT2FIX(BUILD_PIXEL(new_r, new_g, new_b, alpha.dst));
+}
+
+VALUE psd_native_compose_exclusion(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts) {
+  PIXEL fg = FIX2UINT(r_fg);
+  PIXEL bg = FIX2UINT(r_bg);
+  PIXEL new_r, new_g, new_b;
+
+  if (TRANSPARENT(bg)) return r_fg;
+  if (TRANSPARENT(fg)) return r_bg;
+
+  calculate_alphas(fg, bg, &opts);
+
+  new_r = BLEND_CHANNEL(R(bg), R(bg) + R(fg) - (R(bg) * R(fg) >> 7), alpha.mix);
+  new_g = BLEND_CHANNEL(G(bg), G(bg) + G(fg) - (G(bg) * G(fg) >> 7), alpha.mix);
+  new_b = BLEND_CHANNEL(B(bg), B(bg) + B(fg) - (B(bg) * B(fg) >> 7), alpha.mix);
+
+  return INT2FIX(BUILD_PIXEL(new_r, new_g, new_b, alpha.dst));
+}
+
+void calculate_alphas(PIXEL fg, PIXEL bg, VALUE *opts) {
   uint32_t opacity = calculate_opacity(opts);
-  uint32_t src_alpha = a(fg) * opacity >> 8;
+  uint32_t src_alpha = A(fg) * opacity >> 8;
 
-  alpha.dst = a(bg);
+  alpha.dst = A(bg);
   alpha.mix = (src_alpha << 8) / (src_alpha + ((256 - src_alpha) * alpha.dst >> 8));
   alpha.dst = alpha.dst + ((256 - alpha.dst) * src_alpha >> 8);
 }
@@ -33,8 +386,4 @@ 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;
-}
-
-uint32_t blend_channel(uint32_t bg, uint32_t fg, uint32_t a) {
-  return ((bg << 8) + (fg - bg) * a) >> 8;
 }

data/ext/psd_native/compose.h

@@ -6,7 +6,35 @@ typedef struct AlphaValues {
   int dst;
 } AlphaValues;
 
+#define BLEND_CHANNEL(b, f, a) ((((b) << 8) + ((f) - (b)) * (a)) >> 8)
+
 VALUE psd_native_compose_normal(VALUE self, VALUE fg, VALUE bg, VALUE opts);
+VALUE psd_native_compose_darken(VALUE self, VALUE fg, VALUE bg, VALUE opts);
+VALUE psd_native_compose_multiply(VALUE self, VALUE fg, VALUE bg, VALUE opts);
+VALUE psd_native_compose_color_burn(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts);
+PIXEL color_burn_foreground(PIXEL b, PIXEL f);
+VALUE psd_native_compose_linear_burn(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts);
+VALUE psd_native_compose_lighten(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts);
+VALUE psd_native_compose_screen(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts);
+VALUE psd_native_compose_color_dodge(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts);
+PIXEL color_dodge_foreground(PIXEL b, PIXEL f);
+VALUE psd_native_compose_linear_dodge(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts);
+VALUE psd_native_compose_overlay(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts);
+PIXEL overlay_foreground(PIXEL b, PIXEL f);
+VALUE psd_native_compose_soft_light(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts);
+PIXEL soft_light_foreground(PIXEL b, PIXEL f);
+VALUE psd_native_compose_hard_light(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts);
+PIXEL hard_light_foreground(PIXEL b, PIXEL f);
+VALUE psd_native_compose_vivid_light(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts);
+PIXEL vivid_light_foreground(PIXEL b, PIXEL f);
+VALUE psd_native_compose_linear_light(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts);
+PIXEL linear_light_foreground(PIXEL b, PIXEL f);
+VALUE psd_native_compose_pin_light(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts);
+PIXEL pin_light_foreground(PIXEL b, PIXEL f);
+VALUE psd_native_compose_hard_mix(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts);
+VALUE psd_native_compose_difference(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts);
+VALUE psd_native_compose_exclusion(VALUE self, VALUE r_fg, VALUE r_bg, VALUE opts);
+
 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);

data/ext/psd_native/psd_native_ext.c

@@ -28,6 +28,26 @@ void Init_psd_native() {
   // Compose functions
   VALUE Compose = rb_define_module_under(PSDNative, "Compose");
   rb_define_module_function(Compose, "normal", psd_native_compose_normal, 3);
+  rb_define_module_function(Compose, "darken", psd_native_compose_darken, 3);
+  rb_define_module_function(Compose, "multiply", psd_native_compose_multiply, 3);
+  rb_define_module_function(Compose, "color_burn", psd_native_compose_color_burn, 3);
+  rb_define_module_function(Compose, "linear_burn", psd_native_compose_linear_burn, 3);
+  rb_define_module_function(Compose, "lighten", psd_native_compose_lighten, 3);
+  rb_define_module_function(Compose, "screen", psd_native_compose_screen, 3);
+  rb_define_module_function(Compose, "color_dodge", psd_native_compose_color_dodge, 3);
+  rb_define_module_function(Compose, "linear_dodge", psd_native_compose_linear_dodge, 3);
+  rb_define_module_function(Compose, "overlay", psd_native_compose_overlay, 3);
+  rb_define_module_function(Compose, "soft_light", psd_native_compose_soft_light, 3);
+  rb_define_module_function(Compose, "hard_light", psd_native_compose_hard_light, 3);
+  rb_define_module_function(Compose, "vivid_light", psd_native_compose_vivid_light, 3);
+  rb_define_module_function(Compose, "linear_light", psd_native_compose_linear_light, 3);
+  rb_define_module_function(Compose, "pin_light", psd_native_compose_pin_light, 3);
+  rb_define_module_function(Compose, "hard_mix", psd_native_compose_hard_mix, 3);
+  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);
 
   psd_logger("info", "PSD native mixins enabled!");
 }

data/ext/psd_native/psd_native_ext.h

@@ -8,10 +8,10 @@
 // Pixels use 32 bits unsigned integers
 // We borrow this from OilyPNG
 typedef uint32_t PIXEL;
-#define BUILD_PIXEL(r, g, b, a)  (((PIXEL) (r) << 24) + ((PIXEL) (g) << 16) + ((PIXEL) (b) << 8) + (PIXEL) (a))
 
 // Our native mixins
 #include "color.h"
+#include "clipping_mask.h"
 #include "compose.h"
 #include "image_mode_cmyk.h"
 #include "image_mode_greyscale.h"

data/lib/psd_native/compose.rb

@@ -3,9 +3,17 @@ require 'psd_native/psd_native'
 
 class PSD
   module Compose
-    def normal(fg, bg, opts={})
+    PSDNative::Compose.methods(false).each do |meth|
+      define_method(meth) do |*args|
+        do_blend meth, *args
+      end
+    end
+
+    private
+
+    def do_blend(blend, fg, bg, opts={})
       opts = DEFAULT_OPTS.merge(opts)
-      PSDNative::Compose.normal(fg, bg, opts)
+      PSDNative::Compose.send(blend, fg, bg, opts)
     end
   end
 end

data/lib/psd_native/version.rb

@@ -1,3 +1,3 @@
 module PSDNative
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/lib/psd_native.rb

@@ -7,6 +7,11 @@ module PSDNative
     base::Image.send(:include, PSDNative::ImageMode::Greyscale)
     base::Image.send(:include, PSDNative::ImageFormat::RLE)
     base::Color.send(:include, PSDNative::Color)
+
+    base::ClippingMask.class_eval do
+      remove_method :apply
+    end
+    base::ClippingMask.send(:include, PSDNative::ClippingMask)
   end
 end
 

data/psd_native.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
   spec.extensions    = ["ext/psd_native/extconf.rb"]
   spec.require_paths = ["lib", "ext"]
 
-  spec.add_runtime_dependency "psd", ">= 1.4"
+  spec.add_runtime_dependency "psd", ">= 1.4.1"
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"

data/spec/image_spec.rb

@@ -28,7 +28,7 @@ describe 'Image Exporting' do
 
     describe "as PNG" do
       it "should produce a valid PNG object" do
-        expect(@psd.image.to_png).to be_an_instance_of(ChunkyPNG::Image)
+        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)
@@ -58,7 +58,7 @@ describe 'Image Exporting' do
         @psd.parse!
 
         png = @psd.tree.children.first.image.to_png
-        expect(png).to be_an_instance_of(ChunkyPNG::Image)
+        expect(png).to be_an_instance_of(ChunkyPNG::Canvas)
         expect(png.width).to eq(1)
         expect(png.height).to eq(1)
         expect(

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: psd_native
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Ryan LeFevre
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-17 00:00:00.000000000 Z
+date: 2013-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: psd
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: 1.4.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: 1.4.1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -137,6 +137,8 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- ext/psd_native/clipping_mask.c
+- ext/psd_native/clipping_mask.h
 - ext/psd_native/color.c
 - ext/psd_native/color.h
 - ext/psd_native/compose.c