lilimg 0.2.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 900d7bd9c19efc86e18ee14f04c0085672a9f79e
-  data.tar.gz: ac8f159eb6161af5dc5032633462168d8a11a665
+SHA256:
+  metadata.gz: 7344a27d23f240ea551b8db61d3f8eba90e514e506c023420bd92beed2a814d9
+  data.tar.gz: 46f1fa4a072cd1a25fd309f9f414b3200c94fa5cc3d065fc7ab8a19ee575ec1a
 SHA512:
-  metadata.gz: 63decb5a032f645892ff836208f5a0d8f51b18e93bf64cb994e5392832c17d2ada038efc950581a999f740f4215836911679fab31fb046e4ec7793dc6eea6ea9
-  data.tar.gz: 3d64f2099dc8a9b8f99d9c815992f030d352118c553eabf865e1680bd47b79fa769feb438ac7c0f765f6d12c03e2573f2397dc5b9e7a90866a340b2a6b0bfc88
+  metadata.gz: 965fa9322f61aeafb20ba16c25585603b1cd1c387a7b9aa244fbfe458d73491ad15198a9ef8252964ca9eb6e7ffe2fc13a3540b47bf38b946f3001cc69387ffc
+  data.tar.gz: 89c780e97b318a3e005ef6fbb86f1e0e5d6ddb12e4dafcbdca67cf02e4580ec2445380264e5456bcb5d854e9b185448bb6328b04927dd97ec9cfa8af590ca937

data/example/test.rb

@@ -1,7 +1,12 @@
-require('./lilimg')
+# require('./lilimg')
+require_relative('../ext/lilimg/lilimg')
 
-jpeg = IO.read('../label.jpg')
-gif = Lili.jpeg_to_gif(jpeg)
-# puts gif.length
+jpeg = IO.read(__dir__ + '/label.jpg')
+gif = Lilimg.jpeg_to_gif(jpeg, 4)
+puts gif.length
+File.open('out.gif', 'wb') { |f| f.write(gif) }
 
-File.open('out.gif', 'wb') { |f| f.write(gif) })
+png = IO.read(__dir__ + '/label.png')
+gif = Lilimg.png_to_gif(png, 4)
+puts gif.length
+File.open('out2.gif', 'wb') { |f| f.write(gif) }

data/ext/lilimg/extconf.rb

@@ -1,3 +1,4 @@
 require 'mkmf'
 CONFIG['warnflags'].slice!(/ -Wdeclaration-after-statement/)
+$objs = ["lilimg.o", "lodepng.o"]
 create_makefile('lilimg/lilimg')

data/ext/lilimg/lilimg.c

@@ -4,71 +4,123 @@
 #include <stdlib.h>
 #include <string.h>
 #include "nanojpeg.h"
+#include "lodepng.h"
 #include "jo_gif.h"
 
-unsigned char * rgb_to_rgba(unsigned char * buf, int w, int h) {
-  int newsize = 4 * w * h;
-  unsigned char * dest = (unsigned char *)malloc(newsize);
-  int s = 0, d = 0;
-  while (d < newsize) {
-    dest[d++] = buf[s++];
-    dest[d++] = buf[s++];
-    dest[d++] = buf[s++];
+// channels: 3 for RGB, 1 for grayscale
+unsigned char * to_rgba(unsigned char * buf, int w, int h, int channels) {
+  size_t pixels = (size_t)w * h;
+  unsigned char * dest = (unsigned char *)malloc(pixels * 4);
+  if (!dest) return NULL;
+
+  size_t s = 0, d = 0;
+  for (size_t i = 0; i < pixels; i++) {
+    if (channels == 1) {
+      dest[d++] = buf[s];
+      dest[d++] = buf[s];
+      dest[d++] = buf[s++];
+    } else {
+      dest[d++] = buf[s++];
+      dest[d++] = buf[s++];
+      dest[d++] = buf[s++];
+    }
     dest[d++] = 255; // fully opaque
   }
 
   return dest;
 }
 
+// Encodes rgba pixels as a GIF. Returns a malloc'ed buffer (caller frees) or NULL.
+// jo_gif_end() closes the memstream, so out/bufsize are valid afterwards.
+static char * rgba_to_gif(unsigned char * rgba, int w, int h, int max_colors, size_t * bufsize) {
+  char * out = NULL;
+  FILE * fp = open_memstream(&out, bufsize);
+  if (!fp) return NULL;
+
+  jo_gif_t gif = jo_gif_start(fp, w, h, 0, max_colors);
+  jo_gif_frame(&gif, rgba, 0, 0);
+  jo_gif_end(&gif);
+  return out;
+}
+
+// NOTE: buf points into the Ruby string, so it must never be freed here.
 static VALUE jpeg_to_gif(VALUE self, VALUE buf, VALUE max_colors) {
   rb_check_type(buf, T_STRING);
 
-  int maxColors = INT2NUM(max_colors);
-  int size = RSTRING_LEN(buf);
-  unsigned char * jpeg = (unsigned char *)StringValuePtr(buf);
+  int maxColors = NUM2INT(max_colors);
+  int size = (int)RSTRING_LEN(buf);
+  unsigned char * jpeg = (unsigned char *)RSTRING_PTR(buf);
 
-  if (jpeg[0] != 0xFF || jpeg[1] != 0xD8) {
-    rb_raise(rb_eRuntimeError, "Not a JPEG image (%x %x should be FF D8)!", jpeg[0], jpeg[1]);
-    return Qnil;
+  if (size < 2 || jpeg[0] != 0xFF || jpeg[1] != 0xD8) {
+    rb_raise(rb_eRuntimeError, "Not a JPEG image (should start with FF D8)!");
   }
 
   njInit();
 
   if (njDecode(jpeg, size)) {
-    free(jpeg);
+    njDone();
     rb_raise(rb_eRuntimeError, "Error decoding input file (size %d)", size);
-    return Qnil;
   }
 
   unsigned char * pixels = njGetImage();
-  if (!pixels) {
-    free(jpeg);
+  int w = njGetWidth(), h = njGetHeight();
+  if (!pixels || w <= 0 || h <= 0 || w > 32767 || h > 32767) {
+    njDone();
     rb_raise(rb_eRuntimeError, "Couldn't decode image.");
-    return Qnil;
   }
 
-  char * out;
-  size_t bufsize;
-  FILE * fp = open_memstream(&out, &bufsize);
-  // FILE * fp = fopen("output.gif", "wb");
+  unsigned char * rgba = to_rgba(pixels, w, h, njIsColor() ? 3 : 1);
+  njDone(); // frees pixels
+  if (!rgba) rb_raise(rb_eNoMemError, "Cannot allocate pixel buffer");
+
+  size_t bufsize = 0;
+  char * out = rgba_to_gif(rgba, w, h, maxColors, &bufsize);
+  free(rgba);
+  if (!out) rb_raise(rb_eRuntimeError, "Cannot initialize memstream");
+
+  VALUE rstr = rb_str_new(out, bufsize);
+  free(out);
+
+  return rstr;
+}
+
+// NOTE: buf points into the Ruby string, so it must never be freed here.
+static VALUE png_to_gif(VALUE self, VALUE buf, VALUE max_colors) {
+  rb_check_type(buf, T_STRING);
+
+  int maxColors = NUM2INT(max_colors);
+  int size = (int)RSTRING_LEN(buf);
+  unsigned char * png = (unsigned char *)RSTRING_PTR(buf);
 
-  if (!fp) {
-    free(jpeg);
-    rb_raise(rb_eRuntimeError, "Cannot initialize memstream");
-    return Qnil;
+  unsigned char png_header[] = {137, 80, 78, 71, 13, 10, 26, 10};
+  if (size < 8 || memcmp(png, png_header, 8) != 0) {
+    rb_raise(rb_eRuntimeError, "Not a PNG image!");
   }
 
-  unsigned char * rgba = rgb_to_rgba(pixels, njGetWidth(), njGetHeight());
-  jo_gif_t gif = jo_gif_start(fp, njGetWidth(), njGetHeight(), 0, maxColors);
-  jo_gif_frame(&gif, rgba, 0, 0);
-  jo_gif_end(&gif);
+  unsigned err, w, h;
+  LodePNGState state;
+  lodepng_state_init(&state);
+  unsigned char * rgba = NULL;
 
-  VALUE rstr = rb_str_new(out, bufsize);
+  err = lodepng_decode(&rgba, &w, &h, &state, png, size);
+  lodepng_state_cleanup(&state);
+  if (err) {
+    free(rgba);
+    rb_raise(rb_eRuntimeError, "Unable to decode PNG, error code %u\n", err);
+  }
+
+  if (w == 0 || h == 0 || w > 32767 || h > 32767) {
+    free(rgba);
+    rb_raise(rb_eRuntimeError, "Invalid PNG dimensions (%ux%u)", w, h);
+  }
 
-  // free(jpeg); <-- this will cause all sorts of errors (FIXME)
+  size_t bufsize = 0;
+  char * out = rgba_to_gif(rgba, w, h, maxColors, &bufsize);
   free(rgba);
+  if (!out) rb_raise(rb_eRuntimeError, "Cannot initialize memstream");
+
+  VALUE rstr = rb_str_new(out, bufsize);
   free(out);
-  njDone();
 
   return rstr;
 }
@@ -78,4 +130,5 @@ VALUE Lilimg = Qnil;
 void Init_lilimg() {
   Lilimg = rb_define_module("Lilimg");
   rb_define_module_function(Lilimg, "jpeg_to_gif", jpeg_to_gif, 2);
+  rb_define_module_function(Lilimg, "png_to_gif", png_to_gif, 2);
 }