ruby-epeg 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+--- 
+SHA1: 
+  data.tar.gz: a74556fb134df892052b76328aea0e4f96d54c40
+  metadata.gz: 0c96cb9a81aa3fbb2f2ad4cfb9c00e0e80ce84ea
+SHA512: 
+  data.tar.gz: 33908fd54a508260a450943c79e033f268122ddd9e19155a7535594b08bec957c0b1f24771bb62ef81df12822f76789716697d57ffb21899872b8b67a843a531
+  metadata.gz: 43dd7ceaad8db8ae820edbcf6a1b2e0465e934f87906e2ce0b223afbe329fe4981b8c4befe2141ea7ec32ac0537aaec001137119b3de3759604a11a17db7b512

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+Makefile
+*.so
+*.o
+*.a
+mkmf.log

data/.travis.yml

@@ -0,0 +1,14 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.3
+  - 2.0
+  - 2.1
+script: "bundle exec rake"
+gemfile:
+  - Gemfile
+before_install:
+  - uname -a
+  - sudo apt-get install libexif-dev libjpeg8-dev
+  - gem -v
+  - gem install bundler -v '~> 1.7'

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in epeg.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Nelson Darkwah Oppong
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,56 @@
+# ruby-epeg ![Travis CI - build status](https://travis-ci.org/nelsond/ruby-epeg.svg?branch=master)
+
+Ruby extension for the epeg library which provides facilities for scaling JPEG images very quickly.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ruby-epeg'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ruby-epeg
+
+## Example
+
+```ruby
+require "epeg"
+
+# Set the global default jpeg quality
+Epeg::Image.quality = 90 # default is 85
+
+# Create an image object from the file some-image.jpg
+image = Epeg::Image.open("./some-image.jpg")
+
+# You can get the width and height without loading any pixels
+"some-image.jpeg is #{image.width}x#{image.height}px"
+# => some-image.jpeg is 1000x500
+
+# Resize the image to 50x50, set the quality to 50 and save it
+image.resize(50,50)
+image.quality = 50
+image.write("./some-other-image.jpg")
+
+# The image is now closed and you can't do any further operations
+image.closed? # => true
+
+# Load the same image from a buffer
+File.open("./some-image.jpg") do |file|
+  image = Epeg::Image.from_blob(file.read)
+end
+
+# Resize to fill 50x50px (i. e. width and height are at
+# least 50px with preserving the aspect ratio) and return the blob
+image.resize_to_fill(50,50).to_blob
+
+# Let's crop the resized image
+image = Epeg::Image.open("./some-other-image.jpg")
+image.crop(50, 50).write("./final-image.jpg")
+```

data/Rakefile

@@ -0,0 +1,11 @@
+ROOT = File.expand_path(File.dirname(__FILE__))
+
+require "bundler/gem_tasks"
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec => [:compile])
+task :default => :spec
+task :test    => :spec
+
+require "rake/extensiontask"
+Rake::ExtensionTask.new("epeg")

data/epeg.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'epeg/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ruby-epeg"
+  spec.version       = Epeg::VERSION
+  spec.authors       = ["Nelson Darkwah Oppong"]
+  spec.email         = ["ndo@felixnelson.de"]
+  spec.summary       = %q{Ruby extension for the epeg library which provides facilities for scaling JPEG images very quickly.}
+  spec.homepage      = "http://github.com/nelsond/ruby-epeg"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.extensions    = ["ext/epeg/extconf.rb"]
+
+  spec.add_dependency "rake-compiler", "~> 0.9"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/ext/epeg/EPEG_LICENSE

@@ -0,0 +1,7 @@
+Copyright (C) 2000 Carsten Haitzler and various contributors (Jerome Foucher, Michal Kowalczuk, Wirtualna Polska)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies of the Software and its Copyright notices. In addition publicly documented acknowledgment must be given that this software has been used if no source code of this software is made available publicly. This includes acknowledgments in either Copyright notices, Manuals, Publicity and Marketing documents or any documentation provided with any product containing this software. This License does not apply to any software that links to the libraries provided by this software (statically or dynamically), but only to the software provided.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/ext/epeg/Epeg.h

@@ -0,0 +1,76 @@
+#ifndef _EPEG_H
+#define _EPEG_H
+
+#ifdef EAPI
+#undef EAPI
+#endif
+#ifdef WIN32
+# ifdef BUILDING_DLL
+#  define EAPI __declspec(dllexport)
+# else
+#  define EAPI __declspec(dllimport)
+# endif
+#else
+# ifdef __GNUC__
+#  if __GNUC__ >= 4
+#   define EAPI __attribute__ ((visibility("default")))
+#  else
+#   define EAPI
+#  endif
+# else
+#  define EAPI
+# endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+   typedef enum _Epeg_Colorspace
+     {
+	EPEG_GRAY8,
+	  EPEG_YUV8,
+	  EPEG_RGB8,
+	  EPEG_BGR8,
+	  EPEG_RGBA8,
+	  EPEG_BGRA8,
+	  EPEG_ARGB32,
+	  EPEG_CMYK
+     }
+   Epeg_Colorspace;
+   
+   typedef struct _Epeg_Image          Epeg_Image;
+   typedef struct _Epeg_Thumbnail_Info Epeg_Thumbnail_Info;
+
+   struct _Epeg_Thumbnail_Info
+     {
+	char                   *uri;
+	unsigned long long int  mtime;
+	int                     w, h;
+	char                   *mimetype;
+     };
+   
+   EAPI Epeg_Image   *epeg_file_open                 (const char *file);
+   EAPI Epeg_Image   *epeg_memory_open               (unsigned char *data, int size);
+   EAPI void          epeg_size_get                  (Epeg_Image *im, int *w, int *h);
+   EAPI void          epeg_decode_size_set           (Epeg_Image *im, int w, int h);
+   EAPI void          epeg_colorspace_get            (Epeg_Image *im, int *space);
+   EAPI void          epeg_decode_colorspace_set     (Epeg_Image *im, Epeg_Colorspace colorspace);
+   EAPI const void   *epeg_pixels_get                (Epeg_Image *im, int x, int y, int w, int h);
+   EAPI void          epeg_pixels_free               (Epeg_Image *im, const void *data);
+   EAPI const char   *epeg_comment_get               (Epeg_Image *im);
+   EAPI void          epeg_thumbnail_comments_get    (Epeg_Image *im, Epeg_Thumbnail_Info *info);
+   EAPI void          epeg_comment_set               (Epeg_Image *im, const char *comment);
+   EAPI void          epeg_quality_set               (Epeg_Image *im, int quality);
+   EAPI void          epeg_thumbnail_comments_enable (Epeg_Image *im, int onoff);
+   EAPI void          epeg_file_output_set           (Epeg_Image *im, const char *file);
+   EAPI void          epeg_memory_output_set         (Epeg_Image *im, unsigned char **data, int *size);
+   EAPI int           epeg_encode                    (Epeg_Image *im);
+   EAPI int           epeg_trim                      (Epeg_Image *im);
+   EAPI void          epeg_close                     (Epeg_Image *im);
+   
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/epeg/epeg_image.c

@@ -0,0 +1,414 @@
+#include <epeg_image.h>
+
+void Init_epeg()
+{
+  VALUE mEpeg      = rb_define_module("Epeg"),
+        cEpegImage = rb_define_class_under(mEpeg, "Image", rb_cObject);
+
+  rb_cv_set(cEpegImage, "@@quality", INT2NUM(85));
+
+  rb_define_singleton_method(cEpegImage, "from_blob", rb_epeg_image_from_blob,           1);
+  rb_define_singleton_method(cEpegImage, "open",      rb_epeg_image_open,                1);
+  rb_define_singleton_method(cEpegImage, "quality=",  rb_epeg_image_set_default_quality, 1);
+  rb_define_singleton_method(cEpegImage, "quality",   rb_epeg_image_get_default_quality, 0);
+
+  rb_define_method(cEpegImage, "initialize", rb_epeg_image_initialize,  0);
+
+  rb_define_method(cEpegImage, "resize",         rb_epeg_image_resize,         2);
+  rb_define_method(cEpegImage, "resize_to_fit",  rb_epeg_image_resize_to_fit,  2);
+  rb_define_method(cEpegImage, "resize_to_fill", rb_epeg_image_resize_to_fill, 2);
+  rb_define_method(cEpegImage, "crop",           rb_epeg_image_crop,          -1);
+  rb_define_method(cEpegImage, "write",          rb_epeg_image_write,          1);
+  rb_define_method(cEpegImage, "to_blob",        rb_epeg_image_to_blob,        0);
+  rb_define_method(cEpegImage, "close",          rb_epeg_image_close,          0);
+  rb_define_method(cEpegImage, "closed?",        rb_epeg_image_is_closed,      0);
+  rb_define_method(cEpegImage, "quality=",       rb_epeg_image_set_quality,    1);
+
+  rb_define_attr(cEpegImage, "width",   1, 0);
+  rb_define_attr(cEpegImage, "height",  1, 0);
+  rb_define_attr(cEpegImage, "quality", 1, 0);
+  rb_define_attr(cEpegImage, "file_path",   1, 0);
+}
+
+/*
+ * call-seq:
+ *  open(file_path)
+ *
+ * Creates a new Image from +file_path+
+ *
+ *     img = Epeg::Image.open("./example.jpg")
+ */
+static VALUE rb_epeg_image_open(VALUE klass, VALUE file_path)
+{
+  Check_Type(file_path, T_STRING);
+
+  Epeg_Image *image = epeg_file_open(StringValueCStr(file_path));
+
+  if(!image) {
+    rb_raise(rb_eRuntimeError, "Error: unable to read file \"%s\"\n",
+                               StringValueCStr(file_path));
+  }
+
+  VALUE image_obj = Data_Wrap_Struct(klass, NULL, rb_epeg_image_destroy, image);
+  rb_obj_call_init(image_obj, 0, NULL);
+
+  return image_obj;
+}
+
+static VALUE rb_epeg_image_from_blob(VALUE klass, VALUE blob)
+{
+  Epeg_Image *image = epeg_memory_open(RSTRING_PTR(blob), RSTRING_LEN(blob));
+
+  if(!image) { rb_raise(rb_eRuntimeError, "Error: unable to read blob"); }
+
+  VALUE image_obj = Data_Wrap_Struct(klass, NULL, rb_epeg_image_destroy, image);
+
+  rb_obj_call_init(image_obj, 0, NULL);
+
+  return image_obj;
+}
+
+/*
+ * call-seq:
+ *  quality=(q)
+ *
+ * Sets the default quality (+q+ >= 0 and +q+ <= 100)
+ * See Epeg::Image#quality=
+ *
+ *     Epeg::Image.quality = 10
+ */
+static VALUE rb_epeg_image_set_default_quality(VALUE klass, VALUE q)
+{
+  Check_Type(q, T_FIXNUM);
+  int quality = NUM2INT(q);
+
+  rb_cv_set(klass, "@@quality", q);
+
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *  quality
+ *
+ * Returns the current default quality for all images.
+ * See Epeg::Image#quality
+ *
+ *     Epeg::Image.quality #=> 85
+ */
+static VALUE rb_epeg_image_get_default_quality(VALUE klass)
+{
+  return rb_cv_get(klass, "@@quality");
+}
+
+/*
+ * call-seq:
+ *  intialize(file_path)
+ *
+ * See Epeg::Image.open
+ */
+static VALUE rb_epeg_image_initialize(VALUE self)
+{
+  Epeg_Image *image;
+  Data_Get_Struct(self, Epeg_Image, image);
+
+  VALUE q = rb_cv_get(CLASS_OF(self), "@@quality");
+  epeg_quality_set(image, NUM2UINT(q));
+  rb_iv_set(self, "@quality", q);
+
+  unsigned int w, h;
+  epeg_size_get(image, &w, &h);
+
+  rb_iv_set(self, "@width",     UINT2NUM(w));
+  rb_iv_set(self, "@height",    UINT2NUM(h));
+
+  rb_iv_set(self, "epeg_file_closed", Qfalse);
+  rb_iv_set(self, "epeg_trimmed",     Qfalse);
+
+  return self;
+}
+
+/*
+ * call-seq:
+ *  resize(w, h)
+ *
+ * Resizes image to +w+ x +h+. Does not keep aspect ratio of the image
+ *
+ *     img = Epeg::Image.open("./example.jpg")
+ *     img.resize(width, height)
+ */
+static VALUE rb_epeg_image_resize(VALUE self, VALUE w, VALUE h)
+{
+  Check_Type(w, T_FIXNUM);
+  Check_Type(h, T_FIXNUM);
+
+  Epeg_Image *image;
+  Data_Get_Struct(self, Epeg_Image, image);
+
+  epeg_decode_bounds_set(image, 0, 0, NUM2UINT(w), NUM2UINT(h));
+  rb_iv_set(self, "epeg_trimmed", Qfalse);
+
+  return self;
+}
+
+/*
+ * call-seq:
+ *  resize_to_fit(w, h)
+ *
+ * Resizes image to fit +w+ x +h+. Please not that the actual width or
+ * height of the image can be smaller than +w+ respectively +h+.
+ * See Epeg::Image.resize_to_fill
+ */
+static VALUE rb_epeg_image_resize_to_fit(VALUE self, VALUE w, VALUE h)
+{
+  Check_Type(w, T_FIXNUM);
+  Check_Type(h, T_FIXNUM);
+
+  const double image_width   = (double)NUM2INT(rb_iv_get(self, "@width"));
+  const double image_height  = (double)NUM2INT(rb_iv_get(self, "@height"));
+
+  const double fit_width     = (double)NUM2INT(w);
+  const double fit_height    = (double)NUM2INT(w);
+
+  const double width_ratio   = image_width/fit_width;
+  const double height_ratio  = image_height/fit_height;
+
+  float width, height;
+
+  if(width_ratio == height_ratio) {
+    width  = fit_width;
+    height = fit_width;
+  } else {
+    if(width_ratio > height_ratio) {
+      width  = fit_width;
+      height = (fit_height/width_ratio);
+    } else {
+      width  = (fit_height/height_ratio);
+      height = fit_height;
+    }
+  }
+
+  return rb_epeg_image_resize(  self, INT2NUM( ceil(width) ), INT2NUM( ceil(height) )  );
+}
+
+/*
+ * call-seq:
+ *  resize_to_fill(w, h)
+ *
+ * Resizes image to fill +w+ x +h+. Please not that the actual width or
+ * height of the image can be larger than +w+ respectively +h+.
+ * See Epeg::Image.resize_to_fit
+ */
+static VALUE rb_epeg_image_resize_to_fill(VALUE self, VALUE w, VALUE h)
+{
+  Check_Type(w, T_FIXNUM);
+  Check_Type(h, T_FIXNUM);
+
+  const double image_width   = (double)NUM2INT(rb_iv_get(self, "@width"));
+  const double image_height  = (double)NUM2INT(rb_iv_get(self, "@height"));
+
+  const double fit_width     = (double)NUM2INT(w);
+  const double fit_height    = (double)NUM2INT(w);
+
+  const double width_ratio   = image_width/fit_width;
+  const double height_ratio  = image_height/fit_height;
+
+  float width, height;
+
+  if(width_ratio == height_ratio) {
+    width  = fit_width;
+    height = fit_width;
+  } else {
+    if(width_ratio > height_ratio) {
+      width  = fit_width*(width_ratio/height_ratio);
+      height = fit_height;
+    } else {
+      width  = fit_width;
+      height = fit_height*(height_ratio/width_ratio);
+    }
+  }
+
+  return rb_epeg_image_resize(  self, INT2NUM( ceil(width) ), INT2NUM( ceil(height) )  );
+}
+
+/*
+ * call-seq:
+ *  cropp(w, h, (x, y))
+ *
+ * Crops image to +w+ x +h+. If +x+ and +y+ are not specified the image is
+ * cropped with the center gravity.
+ */
+static VALUE rb_epeg_image_crop(int argc, VALUE *argv, VALUE self)
+{
+  if(argc < 2 || argc == 3 || argc > 4) {
+    rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 4)", argc);
+  }
+
+  unsigned int w, h, x, y, i;
+
+  if(argc == 2) {
+    for(i = 0; i < 2; i++) { Check_Type(argv[i], T_FIXNUM); }
+
+    w = NUM2UINT(argv[0]);
+    h = NUM2UINT(argv[1]);
+
+    x = (unsigned int)(   ceil(  (double)NUM2UINT( rb_iv_get(self, "@width")  )/2 ) - (double)w/2   );
+    y = (unsigned int)(   ceil(  (double)NUM2UINT( rb_iv_get(self, "@height") )/2 ) - (double)w/2   );
+  }
+
+  if (argc == 4) {
+    for(i = 0; i < 4; i++) { Check_Type(argv[i], T_FIXNUM); }
+
+    w = NUM2UINT(argv[0]);
+    h = NUM2UINT(argv[1]);
+
+    x = NUM2UINT(argv[2]);
+    y = NUM2UINT(argv[3]);
+  }
+
+  Epeg_Image *image;
+  Data_Get_Struct(self, Epeg_Image, image);
+
+  epeg_decode_bounds_set(image, x, y, w, h);
+  rb_iv_set(self, "epeg_trimmed", Qtrue);
+
+  return self;
+}
+
+/*
+ * internal use
+ */
+static void rb_epeg_image_encode_or_trim(VALUE obj, Epeg_Image *image) {
+  int status;
+
+  if(rb_iv_get(obj, "epeg_trimmed") == Qtrue) {
+    status = epeg_trim(image);
+  } else {
+    status = epeg_encode(image);
+  }
+
+  if(status != 0) { rb_raise(rb_eRuntimeError, "Error: can't encode"); }
+}
+
+/*
+ * call-seq:
+ *  write(file_path)
+ *
+ * Writes the image to +file_path+ and closes the image stream.
+ * Please note that you can't do any further operations on the image
+ * after using this method.
+ */
+static VALUE rb_epeg_image_write(VALUE self, VALUE file_path)
+{
+  Check_Type(file_path, T_STRING);
+
+  if(rb_iv_get(self, "epeg_file_closed") != Qfalse) {
+    rb_raise(rb_eRuntimeError, "Error: closed file");
+  }
+
+  Epeg_Image *image;
+  Data_Get_Struct(self, Epeg_Image, image);
+
+  epeg_file_output_set(image, StringValueCStr(file_path));
+  rb_epeg_image_encode_or_trim(self, image);
+
+  rb_iv_set(self, "epeg_file_closed", Qtrue);
+  rb_epeg_image_close(self);
+
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *  to_blob()
+ *
+ * Returns the image data as blob and closes the image stream.
+ * Please note that you can't do any further operations on the image
+ * after using this method.
+ */
+static VALUE rb_epeg_image_to_blob(VALUE self)
+{
+  if(rb_iv_get(self, "epeg_file_closed") != Qfalse) {
+    rb_raise(rb_eRuntimeError, "Error: closed file");
+  }
+
+  Epeg_Image *image;
+  Data_Get_Struct(self, Epeg_Image, image);
+
+  unsigned char *data;
+  int size;
+
+  epeg_memory_output_set(image, &data, &size);
+  rb_epeg_image_encode_or_trim(self, image);
+
+  VALUE blob = rb_str_new(data, size);
+  free(data);
+
+  rb_iv_set(self, "epeg_file_closed", Qtrue);
+  rb_epeg_image_close(self);
+
+  return blob;
+}
+
+/*
+ * call-seq:
+ *  quality=(q)
+ *
+ * Sets the quality of the image to +q+ (+q+ >= 0 and +q+ <= 100).
+ * See Epeg::Image.quality=
+ */
+static VALUE rb_epeg_image_set_quality(VALUE self, VALUE q)
+{
+  Check_Type(q, T_FIXNUM);
+
+  int quality = NUM2INT(q);
+
+  if (quality < 0)   { rb_raise(rb_eRuntimeError, "Error: quality must be >= 0"); }
+  if (quality > 100) { rb_raise(rb_eRuntimeError, "Error: quality must be <= 100"); }
+
+  Epeg_Image *image;
+  Data_Get_Struct(self, Epeg_Image, image);
+
+  epeg_quality_set(image, quality);
+  rb_iv_set(self, "@quality", INT2NUM(quality));
+
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *  close()
+ *
+ * Closes the image stream.
+ * Please note that you can't do any furhter operations on the image
+ * after using this method.    See Epeg::Image#closed?
+ */
+static VALUE rb_epeg_image_close(VALUE self)
+{
+  if(rb_iv_get(self, "epeg_file_closed") == Qfalse) {
+    Epeg_Image *image;
+    Data_Get_Struct(self, Epeg_Image, image);
+
+    epeg_close(image);
+    rb_iv_set(self, "epeg_file_closed", Qtrue);
+  }
+
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *  closed?()
+ *
+ * Returns true if the image stream is already closed.
+ * See Epeg::Image#close
+ */
+static VALUE rb_epeg_image_is_closed(VALUE self)
+{
+  return rb_iv_get(self, "epeg_file_closed");
+}
+
+static void rb_epeg_image_destroy(void *image)
+{
+  if(!image) { epeg_close((Epeg_Image *)image); }
+}