lilimg 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4bc3f91be83cff03e7680e73b94427087e6e44a88037f974b137aba75cc8a5b
-  data.tar.gz: ed63c2c8ec68ef51bb53dcf40d31eb9f03ade06bbfeecc334bfebd50bee59560
+  metadata.gz: 7344a27d23f240ea551b8db61d3f8eba90e514e506c023420bd92beed2a814d9
+  data.tar.gz: 46f1fa4a072cd1a25fd309f9f414b3200c94fa5cc3d065fc7ab8a19ee575ec1a
 SHA512:
-  metadata.gz: 8c60b48052865276f135a3ad039fbcc4d3f589be520a51851156650a9749fb985c899bceec75807fb5b81ca16a207be611b50a0cf6909dde21707b7343abd56d
-  data.tar.gz: 239ad652b2639c7d1f7a61176674e7babf495299716ed925972090fa671a90cf0fcb66a672788978fae2f1d7aa3c33fbf0a1d712234ae523a78b7811a217c33f
+  metadata.gz: 965fa9322f61aeafb20ba16c25585603b1cd1c387a7b9aa244fbfe458d73491ad15198a9ef8252964ca9eb6e7ffe2fc13a3540b47bf38b946f3001cc69387ffc
+  data.tar.gz: 89c780e97b318a3e005ef6fbb86f1e0e5d6ddb12e4dafcbdca67cf02e4580ec2445380264e5456bcb5d854e9b185448bb6328b04927dd97ec9cfa8af590ca937

data/ext/lilimg/lilimg.c

@@ -7,122 +7,120 @@
 #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");
-
-  if (!fp) {
-    free(jpeg);
-    rb_raise(rb_eRuntimeError, "Cannot initialize memstream");
-    return Qnil;
-  }
+  unsigned char * rgba = to_rgba(pixels, w, h, njIsColor() ? 3 : 1);
+  njDone(); // frees pixels
+  if (!rgba) rb_raise(rb_eNoMemError, "Cannot allocate pixel buffer");
 
-  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);
+  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(jpeg); <-- this will cause all sorts of errors (FIXME)
-  free(rgba);
   free(out);
-  njDone();
 
   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 = INT2NUM(max_colors);
-  int size = RSTRING_LEN(buf);
-  unsigned char * png = (unsigned char *)StringValuePtr(buf);
+  int maxColors = NUM2INT(max_colors);
+  int size = (int)RSTRING_LEN(buf);
+  unsigned char * png = (unsigned char *)RSTRING_PTR(buf);
 
   unsigned char png_header[] = {137, 80, 78, 71, 13, 10, 26, 10};
-  if (memcmp(png, png_header, 8) != 0) {
+  if (size < 8 || memcmp(png, png_header, 8) != 0) {
     rb_raise(rb_eRuntimeError, "Not a PNG image!");
-    return Qnil;
-  }
-
-  char * out;
-  size_t bufsize;
-  FILE * fp = open_memstream(&out, &bufsize);
-
-  if (!fp) {
-    free(png);
-    rb_raise(rb_eRuntimeError, "Cannot initialize memstream");
-    return Qnil;
   }
 
   unsigned err, w, h;
   LodePNGState state;
   lodepng_state_init(&state);
-  unsigned char * rgba;
+  unsigned char * rgba = NULL;
 
   err = lodepng_decode(&rgba, &w, &h, &state, png, size);
+  lodepng_state_cleanup(&state);
   if (err) {
-    lodepng_state_cleanup(&state);
-    free(png);
-    free(out); // memstream
+    free(rgba);
     rb_raise(rb_eRuntimeError, "Unable to decode PNG, error code %u\n", err);
-    return Qnil;
   }
 
-  // convert rgba data to memstream (fp)
-  jo_gif_t gif = jo_gif_start(fp, w, h, 0, maxColors);
-  jo_gif_frame(&gif, rgba, 0, 0);
-  jo_gif_end(&gif);
+  if (w == 0 || h == 0 || w > 32767 || h > 32767) {
+    free(rgba);
+    rb_raise(rb_eRuntimeError, "Invalid PNG dimensions (%ux%u)", w, h);
+  }
 
-  VALUE rstr = rb_str_new(out, bufsize);
+  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");
 
-  free(rgba); // rgba raw data
-  free(png); // png buffer, converted from buf VALUE
-  free(out); // memstream
-  lodepng_state_cleanup(&state);
+  VALUE rstr = rb_str_new(out, bufsize);
+  free(out);
 
   return rstr;
 }

data/lilimg.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name        = 'lilimg'
-  s.version     = '0.2.1'
+  s.version     = '0.2.2'
   s.platform    = Gem::Platform::RUBY
   s.authors     = ['Tomas Pollak']
   s.email       = ['tomas@forkhq.com']

data/spec/lilimg_spec.rb

@@ -1,22 +1,85 @@
 $VERBOSE = '1'
+require 'zlib'
 require_relative('../ext/lilimg/lilimg.so')
 
 describe 'Lilimg' do
+  def chunk(type, data)
+    [data.bytesize].pack('N') + type + data + [Zlib.crc32(type + data)].pack('N')
+  end
+
+  def build_png(w = 8, h = 8)
+    raw = (0...h).map { "\x00".b + ("\xFF\x00\x00\xFF".b * w) }.join
+    "\x89PNG\r\n\x1A\n".b +
+      chunk('IHDR', [w, h, 8, 6, 0, 0, 0].pack('NNCCCCC')) +
+      chunk('IDAT', Zlib::Deflate.deflate(raw)) +
+      chunk('IEND', '')
+  end
+
+  let(:jpeg) { IO.read('./example/label.jpg', mode: 'rb') }
+
+  describe '.jpeg_to_gif' do
+    it 'works in threads' do
+      threads = 10.times.map do
+        Thread.new do
+          expect(jpeg[0]).to eql("\xFF".b)
+          expect(jpeg[1]).to eql("\xD8".b)
+          gif = Lilimg.jpeg_to_gif(jpeg, 4)
+          expect(gif.to_s[0..3]).to eql("GIF8")
+        end
+      end
+      threads.each(&:join)
+    end
 
-  it 'works in threads' do
-    threads = 10.times.map do
-      jpeg = IO.read('./example/label.jpg')
-      Thread.new do
-        # check for JPEG header
-        expect(jpeg[0]).to eql("\xFF")
-        expect(jpeg[1]).to eql("\xD8")
-        # convert to GIF
-        gif = Lilimg.jpeg_to_gif(jpeg, 4)
-        expect(gif.to_s[0..3]).to eql("GIF8")
+    it 'does not corrupt the heap when called repeatedly' do
+      20.times do
+        expect(Lilimg.jpeg_to_gif(jpeg.dup, 4)[0..3]).to eql("GIF8")
+        GC.start
       end
     end
-    # puts "Waiting for processes to finish"
-    threads.each(&:join)
+
+    it 'converts grayscale JPEGs' do
+      gray = IO.read('./example/gray.jpg', mode: 'rb')
+      5.times { expect(Lilimg.jpeg_to_gif(gray.dup, 4)[0..3]).to eql("GIF8") }
+      GC.start
+    end
+
+    it 'raises on non-JPEG data' do
+      expect { Lilimg.jpeg_to_gif('hello world, not a jpeg at all', 4) }.to raise_error(RuntimeError, /Not a JPEG/)
+    end
+
+    it 'raises on truncated data and keeps working' do
+      expect { Lilimg.jpeg_to_gif(jpeg[0, 200], 4) }.to raise_error(RuntimeError)
+      GC.start
+      expect(Lilimg.jpeg_to_gif(jpeg, 4)[0..3]).to eql("GIF8")
+    end
+
+    it 'raises on a non-string' do
+      expect { Lilimg.jpeg_to_gif(nil, 4) }.to raise_error(TypeError)
+    end
   end
 
+  describe '.png_to_gif' do
+    it 'converts a PNG to a GIF' do
+      expect(Lilimg.png_to_gif(build_png, 4)[0..3]).to eql("GIF8")
+    end
+
+    it 'does not corrupt the heap when called repeatedly' do
+      png = build_png(64, 64)
+      20.times do
+        expect(Lilimg.png_to_gif(png.dup, 4)[0..3]).to eql("GIF8")
+        GC.start
+      end
+    end
+
+    it 'raises on non-PNG data' do
+      expect { Lilimg.png_to_gif('hello world, not a png at all', 4) }.to raise_error(RuntimeError, /Not a PNG/)
+    end
+
+    it 'raises on a corrupt PNG and keeps working' do
+      png = build_png
+      expect { Lilimg.png_to_gif(png[0, 40], 4) }.to raise_error(RuntimeError, /Unable to decode/)
+      GC.start
+      expect(Lilimg.png_to_gif(png, 4)[0..3]).to eql("GIF8")
+    end
+  end
 end

metadata

@@ -1,16 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lilimg
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Tomas Pollak
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-28 00:00:00.000000000 Z
+date: 2026-10-14 00:00:00.000000000 Z
 dependencies: []
-description: 
 email:
 - tomas@forkhq.com
 executables: []
@@ -21,6 +19,7 @@ files:
 - ".gitignore"
 - Rakefile
 - example/build.sh
+- example/gray.jpg
 - example/label.jpg
 - example/test.c
 - example/test.rb
@@ -37,7 +36,6 @@ files:
 homepage: https://github.com/tomas/lilimg
 licenses: []
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -52,9 +50,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.3
-signing_key: 
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Native image processing in Ruby without deps.
 test_files: []