axon 0.0.1

data/ext/axon/jpeg_common.c

@@ -0,0 +1,118 @@
+#include "jpeg_common.h"
+
+static ID id_GRAYSCALE, id_RGB, id_YCbCr, id_CMYK, id_YCCK, id_UNKNOWN;
+static ID id_APP0, id_APP1, id_APP2, id_APP3, id_APP4, id_APP5, id_APP6,
+	  id_APP7, id_APP8, id_APP9, id_APP10, id_APP11, id_APP12, id_APP13,
+	  id_APP14, id_APP15, id_COM;
+
+struct jpeg_error_mgr jerr;
+
+ID
+j_color_space_to_id(J_COLOR_SPACE cs)
+{
+    switch (cs) {
+	case JCS_GRAYSCALE: return id_GRAYSCALE;
+	case JCS_RGB:       return id_RGB;
+	case JCS_YCbCr:     return id_YCbCr;
+	case JCS_CMYK:      return id_CMYK;
+	case JCS_YCCK:      return id_YCCK;
+    }
+
+    return id_UNKNOWN;
+}
+
+J_COLOR_SPACE
+id_to_j_color_space(ID rb)
+{
+    if      (rb == id_GRAYSCALE) return JCS_GRAYSCALE;
+    else if (rb == id_RGB)       return JCS_RGB;
+    else if (rb == id_YCbCr)     return JCS_YCbCr;
+    else if (rb == id_CMYK)      return JCS_CMYK;
+    else if (rb == id_YCCK)      return JCS_YCCK;
+    else if (rb == id_UNKNOWN)   return JCS_UNKNOWN;
+
+    rb_raise(rb_eRuntimeError, "Color Space not recognized.");
+}
+
+int sym_to_marker_code(VALUE sym)
+{
+    ID rb = SYM2ID(sym);
+
+    if      (rb == id_APP0)  return JPEG_APP0;
+    else if (rb == id_APP1)  return JPEG_APP0 + 1;
+    else if (rb == id_APP2)  return JPEG_APP0 + 2;
+    else if (rb == id_APP3)  return JPEG_APP0 + 3;
+    else if (rb == id_APP4)  return JPEG_APP0 + 4;
+    else if (rb == id_APP5)  return JPEG_APP0 + 5;
+    else if (rb == id_APP6)  return JPEG_APP0 + 6;
+    else if (rb == id_APP7)  return JPEG_APP0 + 7;
+    else if (rb == id_APP8)  return JPEG_APP0 + 8;
+    else if (rb == id_APP9)  return JPEG_APP0 + 9;
+    else if (rb == id_APP10) return JPEG_APP0 + 10;
+    else if (rb == id_APP11) return JPEG_APP0 + 11;
+    else if (rb == id_APP12) return JPEG_APP0 + 12;
+    else if (rb == id_APP13) return JPEG_APP0 + 13;
+    else if (rb == id_APP14) return JPEG_APP0 + 14;
+    else if (rb == id_APP15) return JPEG_APP0 + 15;
+    else if (rb == id_COM)   return JPEG_COM;
+
+    rb_raise(rb_eRuntimeError, "Marker code not recognized.");
+}
+
+void
+error_exit(j_common_ptr cinfo)
+{
+    char buffer[JMSG_LENGTH_MAX];
+
+    (*cinfo->err->format_message) (cinfo, buffer);
+    rb_raise(rb_eRuntimeError, "jpeglib: %s", buffer);
+}
+
+void
+output_message(j_common_ptr cinfo)
+{
+    /* do nothing */
+}
+
+void
+init_jerror(struct jpeg_error_mgr * err)
+{
+    jpeg_std_error(err);
+    err->error_exit = error_exit;
+    err->output_message = output_message;
+}
+
+void
+Init_jpeg()
+{
+    VALUE mAxon = rb_define_module("Axon");
+    rb_const_set(mAxon, rb_intern("JPEG_LIB_VERSION"),
+		 INT2FIX(JPEG_LIB_VERSION));
+
+    init_jerror(&jerr);
+
+    id_GRAYSCALE = rb_intern("GRAYSCALE");
+    id_RGB = rb_intern("RGB");
+    id_YCbCr = rb_intern("YCbCr");
+    id_CMYK = rb_intern("CMYK");
+    id_YCCK = rb_intern("YCCK");
+    id_UNKNOWN = rb_intern("UNKNOWN");
+
+    id_APP0 = rb_intern("APP0");
+    id_APP1 = rb_intern("APP1");
+    id_APP2 = rb_intern("APP2");
+    id_APP3 = rb_intern("APP3");
+    id_APP4 = rb_intern("APP4");
+    id_APP5 = rb_intern("APP5");
+    id_APP6 = rb_intern("APP6");
+    id_APP7 = rb_intern("APP7");
+    id_APP8 = rb_intern("APP8");
+    id_APP9 = rb_intern("APP9");
+    id_APP10 = rb_intern("APP10");
+    id_APP11 = rb_intern("APP11");
+    id_APP12 = rb_intern("APP12");
+    id_APP13 = rb_intern("APP13");
+    id_APP14 = rb_intern("APP14");
+    id_APP15 = rb_intern("APP15");
+    id_COM = rb_intern("COM");
+}

data/ext/axon/jpeg_common.h

@@ -0,0 +1,37 @@
+#ifndef  AXON_JPEG_COMMON_H
+#define  AXON_JPEG_COMMON_H
+
+#include <ruby.h>
+#include <jpeglib.h>
+
+#ifndef HAVE_RB_BLOCK_CALL
+#define rb_block_call(arg1, arg2, arg3, arg4, arg5, arg6) rb_iterate(rb_each, arg1, arg5, arg6)
+#endif
+
+/*
+ * Marker size is defined by two bytes, so the maximum is 65,535 bytes.
+ * Two of those bytes are used by the size indicator bytes themselves, leaving
+ * 65,533 bytes.
+ */
+
+#define MAX_MARKER_LEN 65533
+
+/*
+ * The Exif marker eats 4 bytes for "Exif", and 2 bytes for NULL terminators.
+ */
+
+#define EXIF_OVERHEAD_LEN 6
+#define MAX_EXIF_DATA_LEN MAX_MARKER_LEN - EXIF_OVERHEAD_LEN
+#define EXIF_MARKER (JPEG_APP0 + 1)
+
+extern struct jpeg_error_mgr jerr;
+
+ID j_color_space_to_id(J_COLOR_SPACE cs);
+J_COLOR_SPACE id_to_j_color_space(ID rb);
+int sym_to_marker_code(ID rb);
+
+void Init_jpeg();
+void Init_jpeg_native_writer();
+void Init_jpeg_native_reader();
+
+#endif

data/ext/axon/jpeg_native_writer.c

@@ -0,0 +1,248 @@
+#include "jpeg_common.h"
+#include "iccjpeg.h"
+
+static ID id_write, id_io, id_each, id_width, id_height, id_color_model,
+	  id_components, id_icc_profile, id_exif, id_quality, id_bufsize,
+	  id_image;
+
+struct buf_dest_mgr {
+  struct jpeg_destination_mgr pub;
+
+  VALUE io;
+
+  JOCTET *buffer;
+  size_t alloc;
+};
+
+static void
+reset_buffer(struct buf_dest_mgr *dest)
+{
+    dest->pub.next_output_byte = dest->buffer;
+    dest->pub.free_in_buffer = dest->alloc;
+}
+
+static void
+init_destination(j_compress_ptr cinfo)
+{
+    struct buf_dest_mgr *dest = (struct buf_dest_mgr *) cinfo->dest;
+    size_t size = dest->alloc * sizeof(JOCTET);
+
+    /* Allocate the output buffer --- it will be released when done */
+    dest->buffer = (JOCTET *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo,
+							  JPOOL_IMAGE, size);
+    reset_buffer(dest);
+}
+
+static boolean
+empty_output_buffer(j_compress_ptr cinfo)
+{
+    VALUE str, write_len;
+    struct buf_dest_mgr *dest = (struct buf_dest_mgr *) cinfo->dest;
+    size_t write_len_i;
+
+    str = rb_str_new(dest->buffer, dest->alloc);
+
+    write_len = rb_funcall(dest->io, id_write, 1, str);
+    write_len_i = (size_t)FIX2INT(write_len);
+    if (write_len_i != dest->alloc)
+	rb_raise(rb_eRuntimeError, "Write Error. Wrote %d instead of %d bytes.",
+		 (int)write_len_i, (int)dest->alloc);
+
+    reset_buffer(dest);
+
+    return TRUE;
+}
+
+static void
+term_destination(j_compress_ptr cinfo)
+{
+    struct buf_dest_mgr *dest = (struct buf_dest_mgr *) cinfo->dest;
+    size_t len = dest->alloc - dest->pub.free_in_buffer;
+    VALUE str;
+
+    if (len > 0) {
+	str = rb_str_new(dest->buffer, len);
+	rb_funcall(dest->io, id_write, 1, str);
+    }
+}
+
+static VALUE
+write_scanline(VALUE scan_line, VALUE data2)
+{
+    JSAMPROW row_pointer[1];
+    j_compress_ptr cinfo = (j_compress_ptr)data2;
+
+    if (TYPE(scan_line) != T_STRING)
+	scan_line = rb_obj_as_string(scan_line);
+
+    if (RSTRING_LEN(scan_line) != cinfo->image_width * cinfo->num_components)
+	rb_raise(rb_eRuntimeError, "Scanline has a bad size. Expected %d but got %d.",
+		 (int)(cinfo->image_width * cinfo->num_components),
+		 (int)RSTRING_LEN(scan_line));
+
+    row_pointer[0] = (JSAMPLE *)RSTRING_PTR(scan_line);
+    jpeg_write_scanlines(cinfo, row_pointer, 1);
+    return Qnil;
+}
+
+static int
+write_exif(j_compress_ptr cinfo, char *str, int len)
+{
+    if (len > MAX_EXIF_DATA_LEN) {
+	rb_raise(rb_eRuntimeError, "Exif data is too large. Max is %d.",
+		 MAX_EXIF_DATA_LEN);
+    }
+
+    jpeg_write_m_header(cinfo, EXIF_MARKER,
+			(unsigned int) (len + EXIF_OVERHEAD_LEN));
+
+    jpeg_write_m_byte(cinfo, 0x45);
+    jpeg_write_m_byte(cinfo, 0x78);
+    jpeg_write_m_byte(cinfo, 0x69);
+    jpeg_write_m_byte(cinfo, 0x66);
+    jpeg_write_m_byte(cinfo, 0x0);
+    jpeg_write_m_byte(cinfo, 0x0);
+
+    /* Add the profile data */
+    while (len--) {
+	jpeg_write_m_byte(cinfo, *str);
+	str++;
+    }
+}
+
+static void
+configure(VALUE self, j_compress_ptr cinfo)
+{
+    VALUE image, width, height, color_model, components, quality;
+
+    quality     = rb_funcall(self, id_quality, 0);
+
+    image       = rb_funcall(self, id_image, 0);
+    width       = rb_funcall(image, id_width, 0);
+    height      = rb_funcall(image, id_height, 0);
+    components  = rb_funcall(image, id_components, 0);
+    color_model = rb_funcall(image, id_color_model, 0);
+
+    cinfo->image_width      = FIX2INT(width);
+    cinfo->image_height     = FIX2INT(height);
+    cinfo->input_components = FIX2INT(components);
+    cinfo->in_color_space   = id_to_j_color_space(SYM2ID(color_model));
+
+    jpeg_set_defaults(cinfo);
+
+    if(!NIL_P(quality))
+	jpeg_set_quality(cinfo, FIX2INT(quality), TRUE);
+}
+
+static void
+write_header(VALUE self, j_compress_ptr cinfo)
+{
+    VALUE icc, exif;
+
+    icc = rb_funcall(self, id_icc_profile, 0);
+    if(!NIL_P(icc)) {
+	StringValue(icc);
+	write_icc_profile(cinfo, RSTRING_PTR(icc), RSTRING_LEN(icc));
+    }
+
+    exif = rb_funcall(self, id_exif, 0);
+    if (!NIL_P(exif)) {
+	StringValue(exif);
+	write_exif(cinfo, RSTRING_PTR(exif), RSTRING_LEN(exif));
+    }
+}
+
+static VALUE
+write2(VALUE *args)
+{
+    VALUE image, self;
+    
+    self = args[0];
+    image = rb_funcall(self, id_image, 0);
+    j_compress_ptr cinfo = (j_compress_ptr) args[1];
+
+    configure(self, cinfo);
+
+    jpeg_start_compress(cinfo, TRUE);
+
+    write_header(self, cinfo);
+    rb_block_call(image, id_each, 0, 0, write_scanline, (VALUE)cinfo);
+
+    jpeg_finish_compress(cinfo);
+
+    return Qnil;
+}
+
+static VALUE
+write2_ensure(VALUE *args)
+{
+    jpeg_destroy_compress((j_compress_ptr) args[1]);
+    return Qnil;
+}
+
+/*
+*  call-seq:
+*     writer.write -> nil
+*
+*  Compress image and write the jpeg.
+*/
+
+static VALUE
+jpeg_native_write(VALUE self)
+{
+    struct jpeg_compress_struct cinfo;
+    struct buf_dest_mgr mgr;
+    VALUE io, rb_bufsize, ensure_args[2];
+    int bufsize;
+
+    io         = rb_funcall(self, id_io, 0);
+    rb_bufsize = rb_funcall(self, id_bufsize, 0);
+    bufsize = FIX2INT(rb_bufsize);
+
+    if (bufsize < 1)
+	rb_raise(rb_eRuntimeError, "Buffer size must be greater than zero");
+
+    cinfo.err = &jerr;
+
+    jpeg_create_compress(&cinfo);
+
+    mgr.pub.init_destination = init_destination;
+    mgr.pub.empty_output_buffer = empty_output_buffer;
+    mgr.pub.term_destination = term_destination;
+    mgr.alloc = bufsize;
+    mgr.io = io;
+    cinfo.dest = (struct jpeg_destination_mgr *)&mgr;
+
+    ensure_args[0] = self;
+    ensure_args[1] = (VALUE)&cinfo;
+
+    return rb_ensure(write2, (VALUE)ensure_args, write2_ensure,
+		     (VALUE)ensure_args);
+}
+
+/* This module provides a single method #jpeg_native_write. It requires that
+ * the including class respond to #io, #image, #quality, #exif, #icc_profile,
+ * and #bufsize.
+ */
+
+void
+Init_jpeg_native_writer()
+{
+    VALUE mAxon = rb_define_module("Axon");
+    VALUE mNativeWriter = rb_define_module_under(mAxon, "JPEGNativeWriter");
+
+    rb_define_method(mNativeWriter, "jpeg_native_write", jpeg_native_write, 0);
+
+    id_write = rb_intern("write");
+    id_each = rb_intern("each");
+    id_io = rb_intern("io");
+    id_width = rb_intern("width");
+    id_height = rb_intern("height");
+    id_color_model = rb_intern("color_model");
+    id_components = rb_intern("components");
+    id_icc_profile = rb_intern("icc_profile");
+    id_exif = rb_intern("exif");
+    id_quality = rb_intern("quality");
+    id_bufsize = rb_intern("bufsize");
+    id_image = rb_intern("image");
+}