bench9000 0.1

data/vendor/psd_native/Rakefile

@@ -0,0 +1,13 @@
+require "bundler/gem_tasks"
+require "rake/extensiontask"
+require 'rspec/core/rake_task'
+
+Rake::ExtensionTask.new('psd_native') do |ext|
+  ext.lib_dir = File.join('lib', 'psd_native')
+  ext.config_options = '--with-cflags="-std=c99"'
+end
+
+Rake::Task['spec'].prerequisites << :compile
+
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec

data/vendor/psd_native/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/vendor/psd_native/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/vendor/psd_native/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/vendor/psd_native/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/vendor/psd_native/ext/psd_native/clipping_mask.c

@@ -0,0 +1,57 @@
+#include "psd_native_ext.h"
+
+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 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 = 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;
+  VALUE pixel;
+  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 {
+        loc = mask_y * mask_width + mask_x;
+
+        if (loc > mask_pixel_length) {
+          alpha = 0;
+        } else {
+          pixel = rb_ary_entry(mask_pixels, loc);
+          alpha = pixel == Qnil ? 0 : A(FIX2UINT(pixel));
+        }
+      }
+
+      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 Qnil;
+}

data/vendor/psd_native/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_bang(VALUE self);
+
+#endif

data/vendor/psd_native/ext/psd_native/color.c

@@ -0,0 +1,20 @@
+#include "psd_native_ext.h"
+
+VALUE psd_native_cmyk_to_rgb(VALUE self, VALUE c, VALUE m, VALUE y, VALUE k) {
+  int r, g, b;
+
+  r = psd_clamp_int((65535 - (FIX2INT(c) * (255 - FIX2INT(k)) + (FIX2INT(k) << 8))) >> 8, 0, 255);
+  g = psd_clamp_int((65535 - (FIX2INT(m) * (255 - FIX2INT(k)) + (FIX2INT(k) << 8))) >> 8, 0, 255);
+  b = psd_clamp_int((65535 - (FIX2INT(y) * (255 - FIX2INT(k)) + (FIX2INT(k) << 8))) >> 8, 0, 255);
+
+  VALUE result = rb_hash_new();
+  rb_hash_aset(result, ID2SYM(rb_intern("r")), INT2FIX(r));
+  rb_hash_aset(result, ID2SYM(rb_intern("g")), INT2FIX(g));
+  rb_hash_aset(result, ID2SYM(rb_intern("b")), INT2FIX(b));
+
+  return result;
+}
+
+int psd_clamp_int(int n, int low, int high) {
+  return n < low ? low : (n > high ? high : n);
+}

data/vendor/psd_native/ext/psd_native/color.h

@@ -0,0 +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);
+
+#endif

data/vendor/psd_native/ext/psd_native/compose.c

@@ -0,0 +1,394 @@
+#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) {
+  PIXEL fg = FIX2UINT(r_fg);
+  PIXEL bg = FIX2UINT(r_bg);
+  PIXEL new_r, new_g, new_b;
+
+  if (TRANSPARENT(bg)) return INT2FIX(apply_opacity(fg, &opts));
+  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);
+
+  return INT2FIX(BUILD_PIXEL(new_r, new_g, new_b, alpha.dst));
+}
+
+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 INT2FIX(apply_opacity(fg, &opts));
+  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 INT2FIX(apply_opacity(fg, &opts));
+  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 INT2FIX(apply_opacity(fg, &opts));
+  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 INT2FIX(apply_opacity(fg, &opts));
+  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 INT2FIX(apply_opacity(fg, &opts));
+  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 INT2FIX(apply_opacity(fg, &opts));
+  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 INT2FIX(apply_opacity(fg, &opts));
+  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 INT2FIX(apply_opacity(fg, &opts));
+  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 INT2FIX(apply_opacity(fg, &opts));
+  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 INT2FIX(apply_opacity(fg, &opts));
+  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 INT2FIX(apply_opacity(fg, &opts));
+  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 INT2FIX(apply_opacity(fg, &opts));
+  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 INT2FIX(apply_opacity(fg, &opts));
+  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 INT2FIX(apply_opacity(fg, &opts));
+  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 INT2FIX(apply_opacity(fg, &opts));
+  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 INT2FIX(apply_opacity(fg, &opts));
+  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 INT2FIX(apply_opacity(fg, &opts));
+  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;
+
+  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);
+}
+
+uint32_t calculate_opacity(VALUE *opts) {
+  uint32_t opacity = FIX2UINT(rb_hash_aref(*opts, ID2SYM(rb_intern("opacity"))));
+  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);
+}