bench9000 0.1

data/vendor/psd_native/ext/psd_native/compose.h

@@ -0,0 +1,43 @@
+#ifndef PSD_NATIVE_COMPOSE
+#define PSD_NATIVE_COMPOSE
+
+typedef struct AlphaValues {
+  int mix;
+  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);
+uint32_t apply_opacity(uint32_t, VALUE *);
+
+#endif

data/vendor/psd_native/ext/psd_native/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+$CFLAGS << ' -Wall'
+create_makefile('psd_native/psd_native')

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

@@ -0,0 +1,64 @@
+#include "psd_native_ext.h"
+
+VALUE psd_native_combine_cmyk_channel(VALUE self) {
+  psd_logger("debug", "Beginning CMYK processing");
+  
+  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"));
+  int channel_count = RARRAY_LENINT(rb_iv_get(self, "@channels_info"));
+
+  int i, j;
+  uint32_t val, c, m, y, k;
+  uint32_t r, g, b;
+  uint32_t a = 255;
+  VALUE rgb;
+  
+  // TODO(mg): truffle c has problems with dynamic stack allocations
+  int * channel_ids = malloc(channel_count * sizeof(int));
+  // 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 = 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 - c), 
+      INT2FIX(255 - m), 
+      INT2FIX(255 - y),
+      INT2FIX(255 - k)
+    );
+
+
+    r = FIX2UINT(rb_hash_aref(rgb, ID2SYM(rb_intern("r"))));
+    g = FIX2UINT(rb_hash_aref(rgb, ID2SYM(rb_intern("g"))));
+    b = FIX2UINT(rb_hash_aref(rgb, ID2SYM(rb_intern("b"))));
+
+    rb_ary_push(rb_iv_get(self, "@pixel_data"), INT2FIX(BUILD_PIXEL(r, g, b, a)));
+  }
+
+  free(channel_ids); //TODO(mg)
+  return Qnil;
+}

data/vendor/psd_native/ext/psd_native/image_mode_cmyk.h

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

data/vendor/psd_native/ext/psd_native/image_mode_greyscale.c

@@ -0,0 +1,27 @@
+#include "psd_native_ext.h"
+
+VALUE psd_native_combine_greyscale_channel(VALUE self) {
+  psd_logger("debug", "Beginning greyscale processing");
+
+  uint32_t channel_count = FIX2UINT(rb_funcall(self, rb_intern("channels"), 0));
+  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* channel_data = RARRAY_PTR(rb_iv_get(self, "@channel_data"));
+  uint32_t channel_length = FIX2UINT(rb_iv_get(self, "@channel_length"));
+
+  uint32_t i, alpha, grey;
+  for (i = 0; i < num_pixels; i += pixel_step) {
+    if (channel_count == 2) {
+      grey = FIX2UINT(channel_data[i]);
+      alpha = FIX2UINT(channel_data[channel_length + i]);
+
+      rb_ary_push(rb_iv_get(self, "@pixel_data"), INT2FIX(BUILD_PIXEL(grey, grey, grey, alpha)));
+    } else {
+      grey = FIX2UINT(channel_data[i]);
+      rb_ary_push(rb_iv_get(self, "@pixel_data"), INT2FIX(BUILD_PIXEL(grey, grey, grey, 255)));
+    }
+  }
+
+  return Qnil;
+}

data/vendor/psd_native/ext/psd_native/image_mode_greyscale.h

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

data/vendor/psd_native/ext/psd_native/image_mode_rgb.c

@@ -0,0 +1,49 @@
+#include "psd_native_ext.h"
+
+VALUE psd_native_combine_rgb_channel(VALUE self) {
+  psd_logger("debug", "Beginning RGB processing");
+  
+  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"));
+  int channel_count = RARRAY_LENINT(rb_iv_get(self, "@channels_info"));
+
+  int i, j;
+  uint32_t val, color;
+
+  // int channel_ids[channel_count];
+  int * channel_ids = malloc(sizeof(int) * channel_count); // TODO(mg): trufflec cannot dynamically allocate stack space
+  for (i = 0; i < channel_count; i++) {
+    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;
+
+    // And every channel for every pixel
+    for (j = 0; j < channel_count; j++) {
+      if (channel_ids[j] == -2) continue;
+
+      val = FIX2UINT(channel_data[i + (channel_length * j)]);
+
+      // Get the hash containing channel info
+      switch (channel_ids[j]) {
+        case -1: color = (color & 0xffffff00) | val; break;         // A
+        case 0:  color = (color & 0x00ffffff) | (val << 24); break; // R
+        case 1:  color = (color & 0xff00ffff) | (val << 16); break; // G
+        case 2:  color = (color & 0xffff00ff) | (val << 8); break;  // B
+      }
+    }
+
+    rb_ary_push(pixel_data, INT2FIX(color));
+  }
+  
+  free(channel_ids); // TODO(mg)
+  return Qnil;
+}

data/vendor/psd_native/ext/psd_native/image_mode_rgb.h

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

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

@@ -0,0 +1,52 @@
+#include "psd_native_ext.h"
+
+VALUE psd_native_mask_apply_bang(VALUE self) {
+  psd_logger("debug", "Applying mask with native code");
+
+  int doc_width = FIX2INT(rb_iv_get(self, "@doc_width"));
+  int doc_height = FIX2INT(rb_iv_get(self, "@doc_height"));
+
+  VALUE layer = rb_iv_get(self, "@layer");
+  VALUE canvas = rb_iv_get(self, "@canvas");
+  VALUE mask = rb_funcall(layer, rb_intern("mask"), 0);
+  VALUE *mask_data = RARRAY_PTR(rb_funcall(rb_funcall(layer, rb_intern("image"), 0), rb_intern("mask_data"), 0));
+
+  int mask_height = FIX2INT(rb_funcall(mask, rb_intern("height"), 0));
+  int mask_width = FIX2INT(rb_funcall(mask, rb_intern("width"), 0));
+  int mask_left = FIX2INT(rb_funcall(mask, rb_intern("left"), 0));
+  int mask_top = FIX2INT(rb_funcall(mask, rb_intern("top"), 0));
+
+  int layer_height = FIX2INT(rb_funcall(layer, rb_intern("height"), 0));
+  int layer_width = FIX2INT(rb_funcall(layer, rb_intern("width"), 0));
+  int layer_left = FIX2INT(rb_funcall(layer, rb_intern("left"), 0));
+  int layer_top = FIX2INT(rb_funcall(layer, rb_intern("top"), 0));
+
+  PIXEL color;
+  int x, y, doc_x, doc_y, layer_x, layer_y, alpha;
+  int i = 0;
+  for (y = 0; y < mask_height; y++) {
+    for (x = 0; x < mask_width; x++) {
+      doc_x = mask_left + x;
+      doc_y = mask_top + y;
+      layer_x = doc_x - layer_left;
+      layer_y = doc_y - layer_top;
+
+      if (layer_x < 0 || layer_x >= layer_width || layer_y < 0 || layer_y >= layer_height) continue;
+
+      color = FIX2UINT(rb_funcall(canvas, rb_intern("[]"), 2, INT2FIX(layer_x), INT2FIX(layer_y)));
+
+      if (doc_x < 0 || doc_x >= doc_width || doc_y < 0 || doc_y > doc_height) {
+        alpha = 0;
+      } else {
+        alpha = FIX2INT(mask_data[i]);
+      }
+
+      color = (color & 0xffffff00) | (A(color) * alpha / 255);
+      rb_funcall(canvas, rb_intern("[]="), 3, INT2FIX(layer_x), INT2FIX(layer_y), INT2FIX(color));
+
+      i++;
+    }
+  }
+
+  return Qnil;
+}

data/vendor/psd_native/ext/psd_native/mask.h

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

data/vendor/psd_native/ext/psd_native/psd_native_ext.c

@@ -0,0 +1,87 @@
+#include "psd_native_ext.h"
+
+static VALUE psd_class;
+static VALUE logger;
+
+void Init_psd_native() {
+  // TODO(CS)
+  //psd_class = rb_const_get(rb_cObject, rb_intern("PSD"));
+  //logger = rb_funcall(psd_class, rb_intern("logger"), 0);
+
+  VALUE PSDNative = rb_define_module("PSDNative");
+  VALUE ImageMode = rb_define_module_under(PSDNative, "ImageMode");
+
+  // RGB Processing
+  VALUE ImageMode_RGB = rb_define_module_under(ImageMode, "RGB");
+  rb_define_private_method(ImageMode_RGB, "combine_rgb_channel", psd_native_combine_rgb_channel, 0);
+
+  // CMYK Processing
+  VALUE ImageMode_CMYK = rb_define_module_under(ImageMode, "CMYK");
+  rb_define_private_method(ImageMode_CMYK, "combine_cmyk_channel", psd_native_combine_cmyk_channel, 0);
+
+  // Greyscale Processing
+  VALUE ImageMode_Greyscale = rb_define_module_under(ImageMode, "Greyscale");
+  rb_define_private_method(ImageMode_Greyscale, "combine_greyscale_channel", psd_native_combine_greyscale_channel, 0);
+
+  // RLE decoding
+  VALUE ImageFormat = rb_define_module_under(PSDNative, "ImageFormat");
+  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);
+
+  // 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);
+
+  // 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);
+
+  // Mask
+  VALUE Mask = rb_define_module_under(Renderer, "Mask");
+  rb_define_method(Mask, "apply!", psd_native_mask_apply_bang, 0);
+
+  // 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");
+  rb_define_method(Util, "pad2", psd_native_util_pad2, 1);
+  rb_define_method(Util, "pad4", psd_native_util_pad4, 1);
+  rb_define_method(Util, "clamp", psd_native_util_clamp, 3);
+
+  psd_logger("info", "PSD native mixins enabled!");
+}
+
+void psd_logger(char* level, char* message) {
+  // TODO(CS)
+  //rb_funcall(logger, rb_intern(level), 1, rb_str_new2(message));
+}

data/vendor/psd_native/ext/psd_native/psd_native_ext.h

@@ -0,0 +1,31 @@
+#ifndef PSD_NATIVE_EXT
+#define PSD_NATIVE_EXT
+
+#include "ruby.h"
+
+#define RSTRING_NOT_MODIFIED
+
+// Pixels use 32 bits unsigned integers
+// We borrow this from OilyPNG
+typedef uint32_t PIXEL;
+
+// Our native mixins
+#include "util.h"
+#include "file.h"
+#include "color.h"
+#include "clipping_mask.h"
+#include "mask.h"
+#include "compose.h"
+#include "image_mode_cmyk.h"
+#include "image_mode_greyscale.h"
+#include "image_mode_rgb.h"
+#include "rle_decoding.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);
+
+#endif