libpng-ruby 0.5.4 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c2bce27799394aabf7194c7ec674b2db1886d7491ce048e72f59b161860c4fc4
-  data.tar.gz: 9561de3dfb0453f87cbea9409576b3a657c34f8c29211c6209de72d376168064
+  metadata.gz: 7065dd93f08e6f53cce0a60e91bda0fdbfe9fd305d4bea5e35dc5a82f5e87f75
+  data.tar.gz: 9bda38b5eb8d4c70a269ec574fd1a9db7dabb1ffd8004da6adc6e9e0fe16197e
 SHA512:
-  metadata.gz: c85f80903cdb0af93630d84d886c09339f559ed0e2d544b8e59b89cc4e211c76918501d43f8f94d08831604fa1f550d7b5abbb46ad9b4d8497514c909defb4a7
-  data.tar.gz: 6d8423b4a8c4e2ade0efd34be94a5a110fa7befb8c188c30219da9afa70b68e82f51dd42c38d8c53bfe4c8107b12a73a8d4a17ffb839b8ee8abd0c226315c6e6
+  metadata.gz: 174bcdf1fb51539d63ce18b6a32abeb7b484052ada9086106259fba1c6a7e99e740a97fb2a4f3c52fdbeac577114760ee86acbbf5f0722da199a526e236f0334
+  data.tar.gz: 33d169bc03a3e7cf778f2588529d1f450ff9b4af794b54780562916d5e29be0870f704d351e46d9499c70e558ae1ec9548c9dd014caefd195df3dc4ae3046942

data/README.md

@@ -59,7 +59,7 @@ IO.binwrite("test.png", enc << IO.binread("test.raw"))
 #### encode options
 | option | value type | description |
 |---|---|---|
-| :pixel_fromat | String or Symbol | input pixel format |
+| :pixel_format | String or Symbol | input pixel format |
 | :interlace    | Boolean          | use interlace mode |
 | :compression  | Integer or String or Symbol | compression level |
 | :text         | Hash             | text information |

data/ext/png/png.c

@@ -4,10 +4,6 @@
  *  Copyright (C) 2016 Hiroshi Kuwagata <kgt9221@gmail.com>
  */
 
-/*
- * $Id: png.c 67 2016-06-07 06:10:47Z pi $
- */
-
 #include <stdio.h>
 #include <stdint.h>
 #include <string.h>
@@ -19,11 +15,13 @@
 #include <zlib.h>
 
 #include "ruby.h"
+#include "ruby/version.h"
 
 #define N(x)                        (sizeof(x)/sizeof(*x))
 
 #define RUNTIME_ERROR(msg)          rb_raise(rb_eRuntimeError, (msg))
 #define ARGUMENT_ERROR(msg)         rb_raise(rb_eArgError, (msg))
+#define RANGE_ERROR(msg)            rb_raise(rb_eRangeError, (msg))
 #define TYPE_ERROR(msg)             rb_raise(rb_eTypeError, (msg))
 #define NOMEMORY_ERROR(msg)         rb_raise(rb_eNoMemError, (msg))
 
@@ -33,6 +31,22 @@
 #define EQ_STR(val,str)             (rb_to_id(val) == rb_intern(str))
 #define EQ_INT(val,n)               (FIX2INT(val) == n)
 
+#define SET_DATA(ptr, idat, odat) \
+   do { \
+     (ptr)->ibuf     = (idat);\
+     (ptr)->obuf     = (odat);\
+     (ptr)->error    = Qnil;\
+     (ptr)->warn_msg = Qnil;\
+   } while (0)
+
+#define CLR_DATA(ptr) \
+   do { \
+     (ptr)->ibuf     = Qnil;\
+     (ptr)->obuf     = Qnil;\
+     (ptr)->error    = Qnil;\
+     (ptr)->warn_msg = Qnil;\
+   } while (0)
+
 static VALUE module;
 static VALUE encoder_klass;
 static VALUE decoder_klass;
@@ -58,13 +72,10 @@ typedef struct {
 	png_infop info; 
 
   png_uint_32 width;
+  png_uint_32 stride;
   png_uint_32 height;
-
-  png_byte** rows;
-
-  int stride;
+  png_uint_32 data_size;
   int num_comp;
-  int pixels;
   int with_time;
 
   int c_type;   // as 'color type'
@@ -72,10 +83,16 @@ typedef struct {
   int c_level;  // as 'compression level'
   int f_type;   // as 'filter type'
 
+  png_byte** rows;
   png_text* text;
   int num_text;
-
   double gamma;
+
+  VALUE ibuf;
+  VALUE obuf;
+
+  VALUE error;
+  VALUE warn_msg;
 } png_encoder_t;
 
 typedef union {
@@ -84,6 +101,9 @@ typedef union {
     int format;
     int need_meta;
     double display_gamma;
+
+    VALUE error;
+    VALUE warn_msg;
   } common;
 
   struct {
@@ -95,6 +115,9 @@ typedef union {
     int need_meta;
     double display_gamma;
 
+    VALUE error;
+    VALUE warn_msg;
+
     /*
      * classic api context
      */
@@ -130,6 +153,9 @@ typedef union {
     int need_meta;
     double display_gamma;
 
+    VALUE error;
+    VALUE warn_msg;
+
     /*
      * simplified api context
      */
@@ -153,16 +179,180 @@ static const char* encoder_opt_keys[] ={
   "text",            // hash<String,String>
   "time",            // bool (default: true)
   "gamma",           // float
+  "stride",          // int >0
 };
 
 static ID encoder_opt_ids[N(encoder_opt_keys)];
 
+static void
+mem_io_write_data(png_structp ctx, png_bytep src, png_size_t size)
+{
+  VALUE buf;
+
+  buf = (VALUE)png_get_io_ptr(ctx);
+  rb_str_buf_cat(buf, (const char *)src, size);
+}
+
+static void
+mem_io_read_data(png_structp ctx, png_bytep dst, png_size_t rq_size)
+{
+  mem_io_t* io;
+
+  io = (mem_io_t*)png_get_io_ptr(ctx);
+
+  if (io->pos + rq_size <= io->size) {
+    memcpy(dst, io->ptr + io->pos, rq_size);
+    io->pos += rq_size;
+
+  } else {
+    png_error(ctx, "data not enough.");
+  }
+}
+
+static void
+mem_io_flush(png_structp ctx)
+{
+  // ignore
+}
+
+static char*
+clone_cstr(VALUE s)
+{
+  char* ret;
+  size_t sz;
+
+  sz  = RSTRING_LEN(s);
+
+  ret = (char*)malloc(sz + 1);
+  if (ret == NULL) NOMEMORY_ERROR("no memory");
+
+  memcpy(ret, RSTRING_PTR(s), sz);
+  ret[sz] = '\0';
+
+  return ret;
+}
+
+static VALUE
+create_runtime_error(const char* fmt, ...)
+{
+  VALUE ret;
+  va_list ap;
+
+  va_start(ap, fmt);
+  ret = rb_exc_new_str(rb_eRuntimeError, rb_vsprintf(fmt, ap));
+  va_end(ap);
+
+  return ret;
+}
+
+static VALUE
+create_argument_error(const char* fmt, ...)
+{
+  VALUE ret;
+  va_list ap;
+
+  va_start(ap, fmt);
+  ret = rb_exc_new_str(rb_eArgError, rb_vsprintf(fmt, ap));
+  va_end(ap);
+
+  return ret;
+}
+
+static VALUE
+create_type_error(const char* fmt, ...)
+{
+  VALUE ret;
+  va_list ap;
+
+  va_start(ap, fmt);
+  ret = rb_exc_new_str(rb_eTypeError, rb_vsprintf(fmt, ap));
+  va_end(ap);
+
+  return ret;
+}
+
+static VALUE
+create_range_error(const char* fmt, ...)
+{
+  VALUE ret;
+  va_list ap;
+
+  va_start(ap, fmt);
+  ret = rb_exc_new_str(rb_eRangeError, rb_vsprintf(fmt, ap));
+  va_end(ap);
+
+  return ret;
+}
+
+#if 0
+static VALUE
+create_not_implement_error(const char* fmt, ...)
+{
+  VALUE ret;
+  va_list ap;
+
+  va_start(ap, fmt);
+  ret = rb_exc_new_str(rb_eNotImpError, rb_vsprintf(fmt, ap));
+  va_end(ap);
+
+  return ret;
+}
+#endif
+
+static VALUE
+create_memory_error()
+{
+  return rb_exc_new_str(rb_eRangeError, rb_str_new_cstr("no memory"));
+}
+
+void
+text_info_free(png_text* text, int n)
+{
+  int i;
+
+  if (text != NULL) {
+    for (i = 0; i < n; i++) {
+      if (text[i].key != NULL) {
+        free(text[i].key);
+      }
+
+      if (text[i].text != NULL) {
+        free(text[i].text);
+      }
+    }
+
+    free(text);
+  }
+}
+
+static void
+rb_encoder_mark(void* _ptr)
+{
+  png_encoder_t* ptr;
+
+  ptr = (png_encoder_t*)_ptr;
+
+  if (ptr->ibuf != Qnil) {
+    rb_gc_mark(ptr->ibuf);
+  }
+
+  if (ptr->obuf != Qnil) {
+    rb_gc_mark(ptr->obuf);
+  }
+
+  if (ptr->error != Qnil) {
+    rb_gc_mark(ptr->error);
+  }
+
+  if (ptr->warn_msg != Qnil) {
+    rb_gc_mark(ptr->warn_msg);
+  }
+}
 
 static void
 rb_encoder_free(void* _ptr)
 {
   png_encoder_t* ptr;
-  int i;
 
   ptr = (png_encoder_t*)_ptr;
 
@@ -175,35 +365,70 @@ rb_encoder_free(void* _ptr)
   }
 
   if (ptr->text != NULL) {
-    for (i = 0; i < ptr->num_text; i++) {
-      if (ptr->text[i].key != NULL) {
-        xfree(ptr->text[i].key);
-      }
-
-      if (ptr->text[i].text != NULL) {
-        xfree(ptr->text[i].text);
-      }
-    }
+    text_info_free(ptr->text, ptr->num_text);
   }
 
+  ptr->ibuf     = Qnil;
+  ptr->obuf     = Qnil;
+  ptr->error    = Qnil;
+  ptr->warn_msg = Qnil;
+
   free(ptr);
 }
 
-static void
-mem_io_write_data(png_structp ctx, png_bytep src, png_size_t size)
+static size_t
+rb_encoder_size(const void* _ptr)
 {
-  VALUE buf;
+  size_t ret;
+  png_encoder_t* ptr;
+  int i;
 
-  buf = (VALUE)png_get_io_ptr(ctx);
-  rb_str_buf_cat(buf, (const char *)src, size);
-}
+  ptr = (png_encoder_t*)_ptr;
 
-static void
-mem_io_flush(png_structp ctx)
-{
-  // ignore
+  ret  = sizeof(png_encoder_t);
+  // ret += sizeof(png_struct);
+  // ret += sizeof(png_info);
+  ret += (sizeof(png_byte*) * ptr->width);
+
+  ret += sizeof(png_text) * ptr->num_text;
+
+  for (i = 0; i < ptr->num_text; i++) {
+    ret += (strlen(ptr->text[i].key) + ptr->text[i].text_length);
+  }
+
+  return ret;
 }
 
+#if RUBY_API_VERSION_CODE > 20600
+static const rb_data_type_t png_encoder_data_type = {
+  "libpng-ruby encoder object",     // wrap_struct_name
+  {
+    rb_encoder_mark,                 // function.dmark
+    rb_encoder_free,                 // function.dfree
+    rb_encoder_size,                 // function.dsize
+    NULL,                            // function.dcompact
+    {NULL},                          // function.reserved
+  },
+  NULL,                              // parent
+  NULL,                              // data
+  (VALUE)RUBY_TYPED_FREE_IMMEDIATELY // flags
+};
+#else /* RUBY_API_VERSION_CODE > 20600 */
+static const rb_data_type_t png_encoder_data_type = {
+  "libpng-ruby encoder object",     // wrap_struct_name
+  {
+    rb_encoder_mark,                 // function.dmark
+    rb_encoder_free,                 // function.dfree
+    rb_encoder_size,                 // function.dsize
+    {NULL, NULL},                    // function.reserved
+  },
+  NULL,                              // parent
+  NULL,                              // data
+  (VALUE)RUBY_TYPED_FREE_IMMEDIATELY // flags
+};
+#endif /* RUBY_API_VERSION_CODE > 20600 */
+
+
 static VALUE
 rb_encoder_alloc(VALUE self)
 {
@@ -220,82 +445,125 @@ rb_encoder_alloc(VALUE self)
   ptr->with_time = !0;
   ptr->gamma     = NAN;
 
-  return Data_Wrap_Struct(encoder_klass, 0, rb_encoder_free, ptr);
+  return TypedData_Wrap_Struct(encoder_klass, &png_encoder_data_type, ptr);
 }
 
-static void
-eval_encoder_opt_color_type(png_encoder_t* ptr, VALUE opt)
+static VALUE
+eval_encoder_opt_pixel_format(png_encoder_t* ptr, VALUE opt)
 {
-  if (opt != Qundef) {
+  VALUE ret;
+  int type;
+  int comp;
+
+  ret = Qnil;
+
+  switch (TYPE(opt)) {
+  case T_UNDEF:
+    type = PNG_COLOR_TYPE_RGB;
+    comp = 3;
+    break;
+
+  case T_STRING:
+  case T_SYMBOL:
     if (EQ_STR(opt, "GRAY") || EQ_STR(opt, "GRAYSCALE")) {
-      ptr->c_type   = PNG_COLOR_TYPE_GRAY;
-      ptr->num_comp = 1;
+      type = PNG_COLOR_TYPE_GRAY;
+      comp = 1;
 
     } else if (EQ_STR(opt, "GA")) {
-      ptr->c_type   = PNG_COLOR_TYPE_GA;
-      ptr->num_comp = 2;
+      type = PNG_COLOR_TYPE_GA;
+      comp = 2;
 
     } else if (EQ_STR(opt, "RGB")) {
-      ptr->c_type   = PNG_COLOR_TYPE_RGB;
-      ptr->num_comp = 3;
+      type = PNG_COLOR_TYPE_RGB;
+      comp = 3;
 
     } else if (EQ_STR(opt, "RGBA")) {
-      ptr->c_type   = PNG_COLOR_TYPE_RGBA;
-      ptr->num_comp = 4;
+      type = PNG_COLOR_TYPE_RGBA;
+      comp = 4;
 
     } else {
-      ARGUMENT_ERROR(":color_type is invalid value");
+      ret = create_argument_error(":pixel_format invalid value");
     } 
+    break;
+
+  default:
+    ret = create_type_error(":pixel_format invalid type");
+    break;
   }
+
+  if (!RTEST(ret)) {
+    ptr->c_type   = type;
+    ptr->num_comp = comp;
+  }
+
+  return ret;
 }
 
-static void
+static VALUE
 eval_encoder_opt_interlace(png_encoder_t* ptr, VALUE opt)
 {
-  if (opt != Qundef) {
+  switch (TYPE(opt)) {
+  case T_UNDEF:
+    ptr->i_meth = PNG_INTERLACE_NONE;
+    break;
+
+  default:
     ptr->i_meth = (RTEST(opt))? PNG_INTERLACE_ADAM7: PNG_INTERLACE_NONE;
+    break;
   }
+
+  return Qnil;
 }
 
-static void
+static VALUE
 eval_encoder_opt_compression(png_encoder_t* ptr, VALUE opt)
 {
-  int val;
-
-  if (opt != Qundef) {
-    switch (TYPE(opt)) {
-    case T_FIXNUM:
-      val = FIX2INT(opt);
-      if (val < 0 || val > 9) {
-        ARGUMENT_ERROR(":compress is out of range");
-      }
-      break;
+  VALUE ret;
+  int lv;
 
-    case T_STRING:
-    case T_SYMBOL:
-      if (EQ_STR(opt, "NO_COMPRESSION")) {
-        val = Z_NO_COMPRESSION;
+  ret = Qnil;
 
-      } else if (EQ_STR(opt, "BEST_SPEED")) {
-        val = Z_BEST_SPEED;
+  switch (TYPE(opt)) {
+  case T_UNDEF:
+    lv = Z_DEFAULT_COMPRESSION;
+    break;
 
-      } else if (EQ_STR(opt, "BEST_COMPRESSION")) {
-        val = Z_BEST_COMPRESSION;
+  case T_STRING:
+  case T_SYMBOL:
+    if (EQ_STR(opt, "NO_COMPRESSION")) {
+      lv = Z_NO_COMPRESSION;
 
-      } else if (EQ_STR(opt, "DEFAULT")) {
-        val = Z_DEFAULT_COMPRESSION;
+    } else if (EQ_STR(opt, "BEST_SPEED")) {
+      lv = Z_BEST_SPEED;
 
-      } else {
-        ARGUMENT_ERROR(":interlace is invalid value");
-      }
-      break;
+    } else if (EQ_STR(opt, "BEST_COMPRESSION")) {
+      lv = Z_BEST_COMPRESSION;
+
+    } else if (EQ_STR(opt, "DEFAULT")) {
+      lv = Z_DEFAULT_COMPRESSION;
 
-    default:
-      TYPE_ERROR(":interlace is not Symbol and String");
+    } else {
+      ret = create_argument_error(":compress is invalid value");
     }
+    break;
+
+  case T_FIXNUM:
+    lv = FIX2INT(opt);
+    if (lv < 0 || lv > 9) {
+      ret = create_range_error(":compress out of range");
+    }
+    break;
+
+  default:
+    ret = create_type_error(":compress invalid type");
+    break;
+  }
 
-    ptr->c_level = val;
+  if (!RTEST(ret)) {
+    ptr->c_level = lv;
   }
+
+  return ret;
 }
 
 static VALUE
@@ -313,302 +581,522 @@ capitalize(VALUE str)
   return rb_ary_join(tmp, rb_str_new_cstr(" "));
 }
 
-static char*
-clone_cstr(VALUE s)
+struct convert_text_rb2c_arg {
+  VALUE src;
+  png_text* dst;
+};
+
+static VALUE
+convert_text_rb2c(VALUE _arg)
 {
-  char* ret;
-  size_t sz;
+  struct convert_text_rb2c_arg* arg;
+  VALUE src;
+  png_text* dst;
+  VALUE keys;
+  int i;
+  VALUE key;
+  VALUE val;
 
-  sz  = RSTRING_LEN(s);
-  ret = (char*)malloc(sz + 1);
+  arg  = (struct convert_text_rb2c_arg*)_arg;
+  src  = arg->src;
+  dst  = arg->dst;
 
-  memcpy(ret, RSTRING_PTR(s), sz);
-  ret[sz] = '\0';
+  /*
+   * 途中で例外が発生する可能性があるので資源回収できる様に
+   * 0クリアを最初に済ませておく。
+   */
+  keys = rb_funcall(src, rb_intern("keys"), 0);
 
-  return ret;
-}
+  for (i = 0; i < RARRAY_LEN(keys); i++) {
+    key  = rb_ary_entry(keys, i);
+    val  = rb_hash_aref(src, key);
 
+    if (TYPE(key) != T_STRING && TYPE(key) != T_SYMBOL) {
+      ARGUMENT_ERROR(":type is invalid structure");
+    }
 
-static void
+    if (TYPE(val) != T_STRING && TYPE(val) != T_SYMBOL) {
+      ARGUMENT_ERROR(":type is invalid structure");
+    }
+
+    key = capitalize(key);
+    if (RSTRING_LEN(key) >= 0 && RSTRING_LEN(key) <= 79) {
+      dst[i].compression = PNG_TEXT_COMPRESSION_NONE;
+      dst[i].key         = clone_cstr(key);
+      dst[i].text        = clone_cstr(val);
+      dst[i].text_length = RSTRING_LEN(val);
+
+    } else {
+      ARGUMENT_ERROR("keyword in :text is too long");
+    }
+  }
+
+  return Qnil;
+}
+
+static VALUE
 eval_encoder_opt_text(png_encoder_t* ptr, VALUE opt)
 {
-  VALUE keys;
-  VALUE key;
-  VALUE val;
-  int i;
+  VALUE ret;
   png_text* text;
+  size_t size;
+  struct convert_text_rb2c_arg arg;
+  int state;
 
-  text = NULL;
-
-  if (opt != Qundef) {
-    if (TYPE(opt) == T_HASH && RHASH_SIZE(opt) > 0) {
-      keys = rb_funcall(opt, rb_intern("keys"), 0);
-      text = (png_text*)xmalloc(sizeof(png_text) * RHASH_SIZE(opt));
-
-      /*
-       * 途中で例外が発生する可能性があるので rb_encoder_free()で
-       * 資源回収できる様に 0クリアとコンテキスト登録を最初に済ま
-       * せておく。
-       *
-       * なお、この処理はinitialize()の過程で呼び出される。このた
-       * め例外が発生しコンテキストの状態が中途半端な状態でユーザ
-       * から参照されることはない。
-       */
-      memset(text, 0, sizeof(*text));
-      ptr->text     = text;
-      ptr->num_text = RARRAY_LEN(keys);
-
-      for (i = 0; i < RARRAY_LEN(keys); i++) {
-        key  = RARRAY_AREF(keys, i);
-        val  = rb_hash_aref(opt, key);
-
-        if (TYPE(key) != T_STRING && TYPE(key) != T_SYMBOL) {
-          ARGUMENT_ERROR(":type is invalid structure");
-        }
-
-        if (TYPE(val) != T_STRING && TYPE(val) != T_SYMBOL) {
-          ARGUMENT_ERROR(":type is invalid structure");
-        }
-
-        key = capitalize(key);
-        if (RSTRING_LEN(key) >= 0 && RSTRING_LEN(key) <= 79) {
-          text[i].compression = PNG_TEXT_COMPRESSION_NONE;
-          text[i].key         = clone_cstr(key);
-          text[i].text        = clone_cstr(val);
-          text[i].text_length = RSTRING_LEN(val);
-
-        } else {
-          ARGUMENT_ERROR("keyword in :text is too long");
-        }
-      }
-    } else {
-      ARGUMENT_ERROR(":text is invalid value");
+  ret   = Qnil;
+  text  = NULL;
+  size  = 0;
+  state = 0;
+
+  switch (TYPE(opt)) {
+  case T_UNDEF:
+    // ignore
+    break;
+
+  case T_HASH:
+    size = RHASH_SIZE(opt);
+    if (size == 0) break;
+
+    text = (png_text*)malloc(sizeof(png_text) * size);
+    if (text == NULL) {
+      ret = create_memory_error();
+      break;
+    }
+
+    arg.src = opt;
+    arg.dst = text;
+
+    rb_protect(convert_text_rb2c, (VALUE)&arg, &state);
+
+    if (state != 0) {
+      ret = rb_errinfo();
+      rb_set_errinfo(Qnil);
+      text_info_free(text, size);
     }
+    break;
+
+  default:
+    ret = create_type_error(":text invalid type");
+    break;
   }
+
+  if (!RTEST(ret)) {
+    ptr->text     = text;
+    ptr->num_text = size;
+  }
+
+  return ret;
 }
 
-static void
+static VALUE
 eval_encoder_opt_time(png_encoder_t* ptr, VALUE opt)
 {
-  if (opt != Qundef) {
+  switch (TYPE(opt)) {
+  case T_UNDEF:
+    ptr->with_time = !0;
+    break;
+
+  default:
     ptr->with_time = RTEST(opt);
+    break;
   }
+
+  return Qnil;
 }
 
-static void
+static VALUE
 eval_encoder_opt_gamma(png_encoder_t* ptr, VALUE opt)
 {
-  if (opt != Qundef) {
-    ptr->gamma = NUM2DBL(opt);
+  VALUE ret;
+  double gamma;
+
+  ret = Qnil;
+
+  switch (TYPE(opt)) {
+  case T_UNDEF:
+    gamma = NAN;
+    break;
+
+  case T_FIXNUM:
+  case T_FLOAT:
+  case T_RATIONAL:
+    gamma = NUM2DBL(opt);
+    break;
+
+  default:
+    ret = create_type_error(":gamma invalid type");
+    break;
+  }
+
+  if (!RTEST(ret)) ptr->gamma = gamma;
+
+  return ret;
+}
+
+static VALUE
+eval_encoder_opt_stride(png_encoder_t* ptr, VALUE opt)
+{
+  VALUE ret;
+  png_uint_32 stride;
+
+  ret = Qnil;
+
+  switch (TYPE(opt)) {
+  case T_UNDEF:
+    stride = ptr->width * ptr->num_comp;
+    break;
+
+  case T_FIXNUM:
+    if (FIX2LONG(opt) >= (ptr->width * ptr->num_comp)) {
+      stride = FIX2LONG(opt);
+
+    } else {
+      ret = create_argument_error(":stride too little");
+    }
+    break;
+
+  default:
+    ret = create_type_error(":stride invalid type");
+    break;
+  }
+
+  if (!RTEST(ret)) ptr->stride = stride;
+
+  return ret;
+}
+
+static void
+encode_error(png_structp ctx, png_const_charp msg)
+{
+  png_encoder_t* ptr;
+
+  ptr = (png_encoder_t*)png_get_error_ptr(ctx);
+
+  ptr->error = create_runtime_error("encode error:%s", msg);
+
+  longjmp(png_jmpbuf(ptr->ctx), 1);
+}
+
+static void
+encode_warn(png_structp ctx, png_const_charp msg)
+{
+  png_encoder_t* ptr;
+
+  ptr = (png_encoder_t*)png_get_error_ptr(ctx);
+
+  if (ptr->warn_msg != Qnil) {
+    ptr->warn_msg = rb_ary_new();
   }
+
+  rb_ary_push(ptr->warn_msg, rb_str_new_cstr(msg));
 }
 
-static void
+static VALUE
 set_encoder_context(png_encoder_t* ptr, int wd, int ht, VALUE opt)
 {
+  VALUE ret;
+
   png_structp ctx;
   png_infop info;
+  png_byte** rows;
+
   VALUE opts[N(encoder_opt_ids)];
 
-  const char* err;
-  png_byte** rows;
+  /*
+   * initialize
+   */
+  ret = Qnil;
+  ctx  = NULL;
+  info = NULL;
+  rows = NULL;
 
   /*
-   * parse options
+   * argument check
    */
-  rb_get_kwargs(opt, encoder_opt_ids, 0, N(encoder_opt_ids), opts);
+  do {
+    if (wd <= 0) {
+      ret = create_range_error("image width less equal zero");
+      break;
+    }
+
+    if (ht <= 0) {
+      ret = create_range_error("image height less equal zero");
+      break;
+    }
+  } while (0);
 
   /*
-   * set context
+   * parse options
    */
-  eval_encoder_opt_color_type(ptr, opts[0]);
-  eval_encoder_opt_interlace(ptr, opts[1]);
-  eval_encoder_opt_compression(ptr, opts[2]);
-  eval_encoder_opt_text(ptr, opts[3]);
-  eval_encoder_opt_time(ptr, opts[4]);
-  eval_encoder_opt_gamma(ptr, opts[5]);
+  if (!RTEST(ret)) do {
+    rb_get_kwargs(opt, encoder_opt_ids, 0, N(encoder_opt_ids), opts);
+
+    // オプション評価で使用するので前もって設定しておく
+    ptr->width  = wd;
+    ptr->height = ht;
+
+    ret = eval_encoder_opt_pixel_format(ptr, opts[0]);
+    if (RTEST(ret)) break;
+
+    ret = eval_encoder_opt_interlace(ptr, opts[1]);
+    if (RTEST(ret)) break;
+
+    ret = eval_encoder_opt_compression(ptr, opts[2]);
+    if (RTEST(ret)) break;
+
+    ret = eval_encoder_opt_text(ptr, opts[3]);
+    if (RTEST(ret)) break;
+
+    ret = eval_encoder_opt_time(ptr, opts[4]);
+    if (RTEST(ret)) break;
+
+    ret = eval_encoder_opt_gamma(ptr, opts[5]);
+    if (RTEST(ret)) break;
+
+    ret = eval_encoder_opt_stride(ptr, opts[6]);
+    if (RTEST(ret)) break;
+  } while (0);
 
   /*
    * create PNG context
    */
-  do {
-    err  = NULL;
-    rows = NULL;
-    info = NULL;
-
-    ctx = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+  if (!RTEST(ret)) do {
+    ctx = png_create_write_struct(PNG_LIBPNG_VER_STRING,
+                                  ptr,
+                                  encode_error,
+                                  encode_warn);
     if (ctx == NULL) {
-      err = "png_create_read_struct() failed.";
+      ret = create_runtime_error("png_create_read_struct() failed");
       break;
     }
 
     info = png_create_info_struct(ctx);
     if (info == NULL) {
-      err = "png_create_info_structt() failed.";
+      ret = create_runtime_error("png_create_info_structt() failed");
       break;
     }
 
     rows = png_malloc(ctx, ht * sizeof(png_byte*));
     if (rows == NULL) {
-      err = "png_malloc() failed.";
+      ret = create_memory_error("png_malloc() failed");
       break;
     }
 
     memset(rows, 0, ht * sizeof(png_byte*));
 
-    ptr->ctx    = ctx;
-    ptr->info   = info;
-    ptr->width  = wd;
-    ptr->height = ht;
-    ptr->stride = ptr->width * ptr->num_comp;
-    ptr->pixels = ptr->stride * ptr->height;
-    ptr->rows   = rows;
-
+    ptr->data_size = ptr->stride * ptr->height;
+    ptr->ctx       = ctx;
+    ptr->info      = info;
+    ptr->rows      = rows;
+    ptr->ibuf      = Qnil;
+    ptr->obuf      = Qnil;
+    ptr->error     = Qnil;
+    ptr->warn_msg  = Qnil;
   } while(0);
 
   /*
    * post process
    */
-  if (err != NULL) {
-    if (ctx != NULL) {
-      png_destroy_write_struct(&ctx, &info);
-    }
-
-    if (rows != NULL) {
-      png_free(ctx, rows);
-    }
+  if (RTEST(ret)) {
+    if (ctx != NULL) png_destroy_write_struct(&ctx, &info);
+    if (rows != NULL) png_free(ctx, rows);
   }
+
+  return ret;
 }
 
 static VALUE
 rb_encoder_initialize(int argc, VALUE* argv, VALUE self)
 {
   png_encoder_t* ptr;
+  VALUE exc;
   VALUE wd;
   VALUE ht;
   VALUE opts;
 
+  /*
+   * initialize
+   */
+  exc = Qnil;
+
   /*
    * strip object
    */
-  Data_Get_Struct(self, png_encoder_t, ptr);
+  TypedData_Get_Struct(self, png_encoder_t, &png_encoder_data_type, ptr);
 
   /*
    * parse argument
    */
-  rb_scan_args(argc, argv, "21", &wd, &ht, &opts);
+  rb_scan_args(argc, argv, "2:", &wd, &ht, &opts);
 
-  Check_Type(wd, T_FIXNUM);
-  Check_Type(ht, T_FIXNUM);
-  if (opts != Qnil) Check_Type(opts, T_HASH);
+  /*
+   * check argument
+   */
+  do {
+    if (TYPE(wd) != T_FIXNUM) {
+      exc = create_argument_error("invalid width");
+      break;
+    }
 
+    if (TYPE(ht) != T_FIXNUM) {
+      exc = create_argument_error("invalid height");
+      break;
+    }
+  } while (0);
 
   /*
    * set context
    */
-  set_encoder_context(ptr, FIX2INT(wd), FIX2INT(ht), opts);
+  if (!RTEST(exc)) {
+    exc = set_encoder_context(ptr, FIX2INT(wd), FIX2INT(ht), opts);
+  }
+
+  /*
+   * post process
+   */
+  if (RTEST(exc)) rb_exc_raise(exc);
 
   return self;
 }
 
+static VALUE
+do_encode(VALUE arg)
+{
+  png_encoder_t* ptr;
+  png_uint_32 i;
+  png_byte* bytes;
+
+  /*
+   * initialize
+   */
+  ptr = (png_encoder_t*)arg;
+
+  if (setjmp(png_jmpbuf(ptr->ctx))) {
+    rb_exc_raise(ptr->error);
+
+  } else {
+    png_set_IHDR(ptr->ctx,
+                 ptr->info,
+                 ptr->width,
+                 ptr->height,
+                 8,
+                 ptr->c_type,
+                 ptr->i_meth,
+                 PNG_COMPRESSION_TYPE_BASE,
+                 PNG_FILTER_TYPE_BASE);
+
+    if (ptr->text) {
+      png_set_text(ptr->ctx, ptr->info, ptr->text, ptr->num_text);
+    }
+
+    if (ptr->with_time) {
+      time_t tm;
+      png_time png_time;
+
+      time(&tm);
+      png_convert_from_time_t(&png_time, tm);
+      png_set_tIME(ptr->ctx, ptr->info, &png_time);
+    }
+
+    if (!isnan(ptr->gamma)) {
+      png_set_gAMA(ptr->ctx, ptr->info, ptr->gamma);
+    }
+
+    png_set_compression_level(ptr->ctx, ptr->c_level);
+
+    png_set_write_fn(ptr->ctx,
+                     (png_voidp)ptr->obuf,
+                     (png_rw_ptr)mem_io_write_data,
+                     (png_flush_ptr)mem_io_flush);
+
+    bytes = (png_byte*)RSTRING_PTR(ptr->ibuf);
+    for (i = 0; i < ptr->height; i++) {
+      ptr->rows[i] = bytes;
+      bytes += ptr->stride;
+    }
+
+    png_set_rows(ptr->ctx, ptr->info, ptr->rows);
+    png_write_png(ptr->ctx, ptr->info, PNG_TRANSFORM_IDENTITY, NULL);
+  }
+
+  return Qnil;
+}
+
 static VALUE
 rb_encoder_encode(VALUE self, VALUE data)
 {
   VALUE ret;
+  VALUE exc;
   png_encoder_t* ptr;
-  png_uint_32 i;
-  uint8_t* p;
+  int state;
 
   /*
    * initialize
    */
-  ret = rb_str_buf_new(0);
+  ret   = rb_str_buf_new(0);
+  exc   = Qnil;
+  state = 0;
 
   /*
    * strip object
    */
-  Data_Get_Struct(self, png_encoder_t, ptr);
+  TypedData_Get_Struct(self, png_encoder_t, &png_encoder_data_type, ptr);
 
   /*
    * argument check
    */
   Check_Type(data, T_STRING);
-  if (RSTRING_LEN(data) != ptr->pixels) {
-    ARGUMENT_ERROR("invalid data size");
-  }
-
-  /*
-   * call libpng
-   */
-  png_set_IHDR(ptr->ctx,
-               ptr->info,
-               ptr->width,
-               ptr->height,
-               8,
-               ptr->c_type,
-               ptr->i_meth,
-               PNG_COMPRESSION_TYPE_BASE,
-               PNG_FILTER_TYPE_BASE);
-
-  if (ptr->text) {
-    png_set_text(ptr->ctx, ptr->info, ptr->text, ptr->num_text);
-  }
-
-  if (ptr->with_time) {
-    time_t tm;
-    png_time png_time;
 
-    time(&tm);
-    png_convert_from_time_t(&png_time, tm);
-    png_set_tIME(ptr->ctx, ptr->info, &png_time);
+  if (RSTRING_LEN(data) < ptr->data_size) {
+    ARGUMENT_ERROR("image data too short");
   }
 
-  if (!isnan(ptr->gamma)) {
-    png_set_gAMA(ptr->ctx, ptr->info, ptr->gamma);
+  if (RSTRING_LEN(data) > ptr->data_size) {
+    ARGUMENT_ERROR("image data too large");
   }
 
-  png_set_compression_level(ptr->ctx, ptr->c_level);
-
-  png_set_write_fn(ptr->ctx,
-                   (png_voidp)ret,
-                   (png_rw_ptr)mem_io_write_data,
-                   (png_flush_ptr)mem_io_flush);
+  /*
+   * prepare
+   */
+  SET_DATA(ptr, data, ret);
 
-  p = (png_byte*)RSTRING_PTR(data);
-  for (i = 0; i < ptr->height; i++) {
-    ptr->rows[i] = p;
-    p += ptr->stride;
+  /*
+   * do encode
+   */
+  if (!RTEST(exc)) {
+    rb_protect(do_encode, (VALUE)ptr, &state);
   }
 
-  png_set_rows(ptr->ctx, ptr->info, ptr->rows);
-
-  if (setjmp(png_jmpbuf(ptr->ctx))) {
-    RUNTIME_ERROR("encode error");
-
-  } else {
-    png_write_png(ptr->ctx, ptr->info, PNG_TRANSFORM_IDENTITY, NULL);
+  /*
+   * post process
+   */
+  if(state == 0) {
+    rb_ivar_set(ret, rb_intern("warn"), ptr->warn_msg);
+  }  
+ 
+  CLR_DATA(ptr);
+ 
+  if (state != 0) {
+    rb_jump_tag(state);
   }
 
+  /*
+   * post process
+   */
+  ptr->ibuf = Qnil;
+  ptr->obuf = Qnil;
+  
+  if (RTEST(exc)) rb_exc_raise(exc);
+
   return ret;
 }
 
 static void
-mem_io_read_data(png_structp ctx, png_bytep dst, png_size_t rq_size)
+rb_decoder_mark(void* _ptr)
 {
-  mem_io_t* io;
-
-  io = (mem_io_t*)png_get_io_ptr(ctx);
-
-  if (io->pos + rq_size <= io->size) {
-    memcpy(dst, io->ptr + io->pos, rq_size);
-    io->pos += rq_size;
-
-  } else {
-    png_error(ctx, "data not enough.");
-  }
+  // nothing
 }
 
-
 static void
 rb_decoder_free(void* _ptr)
 {
@@ -637,6 +1125,45 @@ rb_decoder_free(void* _ptr)
   free(ptr);
 }
 
+static size_t
+rb_decoder_size(const void* _ptr)
+{
+  size_t ret;
+
+  ret = sizeof(png_decoder_t);
+
+  return ret;
+}
+
+#if RUBY_API_VERSION_CODE > 20600
+static const rb_data_type_t png_decoder_data_type = {
+  "libpng-ruby decoder object",      // wrap_struct_name
+  {
+    rb_decoder_mark,                 // function.dmark
+    rb_decoder_free,                 // function.dfree
+    rb_decoder_size,                 // function.dsize
+    NULL,                            // function.dcompact
+    {NULL},                          // function.reserved
+  },
+  NULL,                              // parent
+  NULL,                              // data
+  (VALUE)RUBY_TYPED_FREE_IMMEDIATELY // flags
+};
+#else /* RUBY_API_VERSION_CODE > 20600 */
+static const rb_data_type_t png_decoder_data_type = {
+  "libpng-ruby decoder object",      // wrap_struct_name
+  {
+    rb_decoder_mark,                 // function.dmark
+    rb_decoder_free,                 // function.dfree
+    rb_decoder_size,                 // function.dsize
+    {NULL, NULL},                    // function.reserved
+  },
+  NULL,                              // parent
+  NULL,                              // data
+  (VALUE)RUBY_TYPED_FREE_IMMEDIATELY // flags
+};
+#endif /* RUBY_API_VERSION_CODE > 20600 */
+
 static VALUE
 rb_decoder_alloc(VALUE self)
 {
@@ -650,35 +1177,60 @@ rb_decoder_alloc(VALUE self)
   ptr->common.need_meta     = !0;
   ptr->common.display_gamma = NAN;
 
-  return Data_Wrap_Struct(decoder_klass, 0, rb_decoder_free, ptr);
+  return TypedData_Wrap_Struct(decoder_klass, &png_decoder_data_type, ptr);
 }
 
-static void
+static VALUE
 eval_decoder_opt_api_type(png_decoder_t* ptr, VALUE opt)
 {
-  int api_type;
+  VALUE ret;
+  int type;
 
-  if (opt != Qundef) {
+  ret = Qnil;
+
+  switch (TYPE(opt)) {
+  case T_UNDEF:
+    type = API_SIMPLIFIED;
+    break;
+
+  case T_STRING:
+  case T_SYMBOL:
     if (EQ_STR(opt, "simplified")) {
-      api_type = API_SIMPLIFIED;
+      type = API_SIMPLIFIED;
 
     } else if (EQ_STR(opt, "classic")) {
-      api_type = API_CLASSIC;
+      type = API_CLASSIC;
 
     } else {
-      ARGUMENT_ERROR(":api_type is invalid value");
+      ret = create_argument_error(":api_type invalid value");
     }
+    break;
 
-    ptr->common.api_type = api_type;
+  default:
+    ret = create_type_error(":api_type invalid type");
+    break;
   }
+
+  if (!RTEST(ret)) ptr->common.api_type = type;
+
+  return ret;
 }
 
-static void
+static VALUE
 eval_decoder_opt_pixel_format(png_decoder_t* ptr, VALUE opt)
 {
+  VALUE ret;
   int format;
 
-  if (opt != Qundef) {
+  ret = Qnil;
+
+  switch (TYPE(opt)) {
+  case T_UNDEF:
+    format = PNG_FORMAT_RGB;
+    break;
+
+  case T_STRING:
+  case T_SYMBOL:
     if (EQ_STR(opt, "GRAY") || EQ_STR(opt, "GRAYSCALE")) {
       format = PNG_FORMAT_GRAY;
 
@@ -707,97 +1259,179 @@ eval_decoder_opt_pixel_format(png_decoder_t* ptr, VALUE opt)
       format = PNG_FORMAT_ABGR;
 
     } else {
-      ARGUMENT_ERROR(":color_type is invalid value");
+      ret = create_argument_error(":pixel_format invalid value");
     }
+    break;
 
-    ptr->common.format = format;
+  default:
+    ret = create_type_error(":pixel_format invalid type");
+    break;
   }
+
+  if (!RTEST(ret)) ptr->common.format = format;
+
+  return ret;
 }
 
-static void
+static VALUE
 eval_decoder_opt_without_meta(png_decoder_t* ptr, VALUE opt)
 {
-  if (opt != Qundef) {
+  switch (TYPE(opt)) {
+  case T_UNDEF:
+    ptr->common.need_meta = !0;
+    break;
+
+  default:
     ptr->common.need_meta = !RTEST(opt);
+    break;
   }
+
+  return Qnil;
 }
 
-static void
+static VALUE
 eval_decoder_opt_display_gamma(png_decoder_t* ptr, VALUE opt)
 {
-  if (opt != Qundef) {
+  switch (TYPE(opt)) {
+  case T_UNDEF:
+    ptr->common.display_gamma = NAN;
+    break;
+
+  default:
     ptr->common.display_gamma = NUM2DBL(opt);
+    break;
   }
+
+  return Qnil;
 }
 
-static void
+static VALUE
 set_decoder_context(png_decoder_t* ptr, VALUE opt)
 {
+  VALUE ret;
   VALUE opts[N(decoder_opt_ids)];
 
   /*
-   * parse options
+   * initialize
    */
-  rb_get_kwargs(opt, decoder_opt_ids, 0, N(decoder_opt_ids), opts);
+  ret = Qnil;
 
   /*
-   * set context
+   * parse options
    */
-  eval_decoder_opt_api_type(ptr, opts[2]);
-  eval_decoder_opt_pixel_format(ptr, opts[0]);
-  eval_decoder_opt_without_meta(ptr, opts[1]);
-  eval_decoder_opt_display_gamma(ptr, opts[3]);
+  do {
+    rb_get_kwargs(opt, decoder_opt_ids, 0, N(decoder_opt_ids), opts);
+
+    ret = eval_decoder_opt_api_type(ptr, opts[2]);
+    if (RTEST(ret)) break;
+
+    ret = eval_decoder_opt_pixel_format(ptr, opts[0]);
+    if (RTEST(ret)) break;
+
+    ret = eval_decoder_opt_without_meta(ptr, opts[1]);
+    if (RTEST(ret)) break;
+
+    ret = eval_decoder_opt_display_gamma(ptr, opts[3]);
+    if (RTEST(ret)) break;
+  } while (0);
+
+  return ret;
 }
 
 static VALUE
 rb_decoder_initialize(int argc, VALUE* argv, VALUE self)
 {
   png_decoder_t* ptr;
-  VALUE opt;
+  VALUE exc;
+  VALUE opts;
+
+  /*
+   * initialize
+   */
+  exc = Qnil;
 
   /*
    * strip object
    */
-  Data_Get_Struct(self, png_decoder_t, ptr);
+  TypedData_Get_Struct(self, png_decoder_t, &png_decoder_data_type, ptr);
 
   /*
    * parse argument
    */
-  rb_scan_args(argc, argv, "01", &opt);
-  if (opt != Qnil) Check_Type(opt, T_HASH);
+  rb_scan_args(argc, argv, "0:", &opts);
 
   /*
    * set context
    */
-  set_decoder_context(ptr, opt);
+  exc = set_decoder_context(ptr, opts);
+
+  /*
+   * post process
+   */
+  if (RTEST(exc)) rb_exc_raise(exc);
 
   return Qtrue;
 }
 
+static void
+decode_error(png_structp ctx, png_const_charp msg)
+{
+  png_decoder_t* ptr;
+
+  ptr = (png_decoder_t*)png_get_error_ptr(ctx);
+
+  ptr->common.error = create_runtime_error("decode error:%s", msg);
+
+  longjmp(png_jmpbuf(ptr->classic.ctx), 1);
+}
+
+static void
+decode_warn(png_structp ctx, png_const_charp msg)
+{
+  png_decoder_t* ptr;
+
+  ptr = (png_decoder_t*)png_get_error_ptr(ctx);
+
+  if (ptr->common.warn_msg != Qnil) {
+    ptr->common.warn_msg = rb_ary_new();
+  }
+
+  rb_ary_push(ptr->common.warn_msg, rb_str_new_cstr(msg));
+}
+
+
 static void
 set_read_context(png_decoder_t* ptr, VALUE data)
 {
+  VALUE exc;
   png_structp ctx;
   png_infop fsi;
   png_infop bsi;
 
-  const char* err;
-
   do {
-    err = NULL;
+    exc = Qnil;
+    ctx = NULL;
     fsi = NULL;
     bsi = NULL;
 
-    ctx = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+    ctx = png_create_read_struct(PNG_LIBPNG_VER_STRING,
+                                 ptr,
+                                 decode_error,
+                                 decode_warn);
     if (ctx == NULL) {
-      err = "png_create_read_struct() failed.";
+      exc = create_runtime_error("png_create_read_struct() failed");
       break;
     }
 
     fsi = png_create_info_struct(ctx);
+    if (fsi == NULL) {
+      exc = create_runtime_error("png_create_info_struct() failed");
+      break;
+    }
+
     bsi = png_create_info_struct(ctx);
-    if (fsi == NULL || bsi == NULL) {
-      err = "png_create_info_struct() failed.";
+    if (bsi == NULL) {
+      exc = create_runtime_error("png_create_info_struct() failed");
       break;
     }
 
@@ -809,22 +1443,17 @@ set_read_context(png_decoder_t* ptr, VALUE data)
     ptr->classic.io.size = RSTRING_LEN(data);
     ptr->classic.io.pos  = 0;
 
-    if (setjmp(png_jmpbuf(ptr->classic.ctx))) {
-      RUNTIME_ERROR("decode error");
-
-    } else {
-      png_set_read_fn(ptr->classic.ctx,
-                      (png_voidp)&ptr->classic.io,
-                      (png_rw_ptr)mem_io_read_data);
-    }
+    png_set_read_fn(ptr->classic.ctx,
+                    (png_voidp)&ptr->classic.io,
+                    (png_rw_ptr)mem_io_read_data);
   } while(0);
 
-  if (err != NULL) {
+  if (RTEST(exc)) {
     if (ctx != NULL) {
       png_destroy_read_struct(&ctx, &fsi, &bsi);
     }
 
-    RUNTIME_ERROR(err);
+    rb_exc_raise(exc);
   }
 }
 
@@ -1164,8 +1793,13 @@ read_header_body(VALUE _arg)
   /*
    * read header
    */
-  png_read_info(ptr->classic.ctx, ptr->classic.fsi);
-  get_header_info(ptr);
+  if (setjmp(png_jmpbuf(ptr->classic.ctx))) {
+    rb_exc_raise(ptr->common.error);
+
+  } else {
+    png_read_info(ptr->classic.ctx, ptr->classic.fsi);
+    get_header_info(ptr);
+  }
 
   return create_meta(ptr);
 }
@@ -1201,7 +1835,7 @@ rb_decoder_read_header(VALUE self, VALUE data)
   /*
    * strip object
    */
-  Data_Get_Struct(self, png_decoder_t, ptr);
+  TypedData_Get_Struct(self, png_decoder_t, &png_decoder_data_type, ptr);
 
   /*
    * call read header funciton
@@ -1330,61 +1964,66 @@ decode_classic_api_body(VALUE _arg)
   /*
    * read basic info
    */
-  png_read_info(ptr->classic.ctx, ptr->classic.fsi);
+  if (setjmp(png_jmpbuf(ptr->classic.ctx))) {
+    rb_exc_raise(ptr->common.error);
 
-  /*
-   * gamma correction
-   */
-  if (!isnan(ptr->common.display_gamma)) {
-    if (!png_get_gAMA(ptr->classic.ctx, ptr->classic.fsi, &file_gamma)) {
-      file_gamma = 0.45;
-    }
+  } else {
+    png_read_info(ptr->classic.ctx, ptr->classic.fsi);
 
-    png_set_gamma(ptr->classic.ctx, ptr->common.display_gamma, file_gamma);
-  }
+    /*
+     * gamma correction
+     */
+    if (!isnan(ptr->common.display_gamma)) {
+      if (!png_get_gAMA(ptr->classic.ctx, ptr->classic.fsi, &file_gamma)) {
+        file_gamma = 0.45;
+      }
 
-  png_read_update_info(ptr->classic.ctx, ptr->classic.fsi);
+      png_set_gamma(ptr->classic.ctx, ptr->common.display_gamma, file_gamma);
+    }
 
-  /*
-   * get image size
-   */
+    png_read_update_info(ptr->classic.ctx, ptr->classic.fsi);
 
-  ptr->classic.width  = \
-      png_get_image_width(ptr->classic.ctx, ptr->classic.fsi);
+    /*
+     * get image size
+     */
 
-  ptr->classic.height = \
-      png_get_image_height(ptr->classic.ctx, ptr->classic.fsi);
+    ptr->classic.width  = \
+        png_get_image_width(ptr->classic.ctx, ptr->classic.fsi);
 
-  stride = png_get_rowbytes(ptr->classic.ctx, ptr->classic.fsi);
+    ptr->classic.height = \
+        png_get_image_height(ptr->classic.ctx, ptr->classic.fsi);
 
-  /*
-   * alloc return memory
-   */
-  ret  = rb_str_buf_new(stride * ptr->classic.height);
-  rb_str_set_len(ret, stride * ptr->classic.height);
+    stride = png_get_rowbytes(ptr->classic.ctx, ptr->classic.fsi);
 
-  /*
-   * alloc rows
-   */
-  ptr->classic.rows = png_malloc(ptr->classic.ctx,
-                                 ptr->classic.height * sizeof(png_byte*));
-  if (ptr->classic.rows == NULL) {
-    NOMEMORY_ERROR("no memory");
-  }
+    /*
+     * alloc return memory
+     */
+    ret  = rb_str_buf_new(stride * ptr->classic.height);
+    rb_str_set_len(ret, stride * ptr->classic.height);
 
-  p = (png_byte*)RSTRING_PTR(ret);
-  for (i = 0; i < ptr->classic.height; i++) {
-    ptr->classic.rows[i] = p;
-    p += stride;
-  }
+    /*
+     * alloc rows
+     */
+    ptr->classic.rows = png_malloc(ptr->classic.ctx,
+                                   ptr->classic.height * sizeof(png_byte*));
+    if (ptr->classic.rows == NULL) {
+      NOMEMORY_ERROR("no memory");
+    }
+
+    p = (png_byte*)RSTRING_PTR(ret);
+    for (i = 0; i < ptr->classic.height; i++) {
+      ptr->classic.rows[i] = p;
+      p += stride;
+    }
 
-  png_read_image(ptr->classic.ctx, ptr->classic.rows);
-  png_read_end(ptr->classic.ctx, ptr->classic.fsi);
+    png_read_image(ptr->classic.ctx, ptr->classic.rows);
+    png_read_end(ptr->classic.ctx, ptr->classic.fsi);
 
-  if (ptr->classic.need_meta) {
-    get_header_info(ptr);
-    rb_ivar_set(ret, id_meta, create_meta(ptr));
-    rb_define_singleton_method(ret, "meta", rb_decode_result_meta, 0);
+    if (ptr->classic.need_meta) {
+      get_header_info(ptr);
+      rb_ivar_set(ret, id_meta, create_meta(ptr));
+      rb_define_singleton_method(ret, "meta", rb_decode_result_meta, 0);
+    }
   }
 
   return ret;
@@ -1419,10 +2058,14 @@ rb_decoder_decode(VALUE self, VALUE data)
    */
   Check_Type(data, T_STRING);
 
+  if (png_sig_cmp((png_const_bytep)RSTRING_PTR(data), 0, 8)) {
+    RUNTIME_ERROR("Invalid PNG signature.");
+  }
+
   /*
    * strip object
    */
-  Data_Get_Struct(self, png_decoder_t, ptr);
+  TypedData_Get_Struct(self, png_decoder_t, &png_decoder_data_type, ptr);
 
   /*
    * call decode funcs