libjpeg-ruby 0.7.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7117f5dece9f78e847213078d1cba56591a30c01ea4b9de58cb4886647d5c530
-  data.tar.gz: 7bb5c400d519e4958fb9522c8a3af313931dc033a45c404a288d0d5020f02b7c
+  metadata.gz: 3523da7ee57f41d57b81fe97558564e0b0459c5977321ba88a298a450cd9273a
+  data.tar.gz: 103f379375f273f0f9a77109cc3dff8018779ce94837d2182e1e0ce50bb78213
 SHA512:
-  metadata.gz: 457f1b3f55ba6c164a40e66303a9c34df6e9ec590137d161c98cee69bbac1385aa4b309c60feb853637c0c392afabdb356996b6809adefd0ed5827051eb318f6
-  data.tar.gz: 9427246e376ff7a9464b0e4c8cf22b0dff47e9036649f13a49a213b769f7ceab7d3e76dbbd258d65c6c65e5c03bda362cf06acc1b921c83bde74bd49d0c8c85f
+  metadata.gz: fd38c818582812ce2ef404ade310846a5af944e2b05c2b16df4df66bf62dd3404c9c68c6508e65e8a603041ab6f0d21484d911680e967f7e11aa9ad94a7d2782
+  data.tar.gz: a05940b338d1660f90345c7eebdeea897629ac37c33949720cde9d4c4d5794eb73dcb0f1be568d078110185ffe223425e4f5cb61da10f3075dd63a6c1a1fe185

data/.gitignore

@@ -0,0 +1,8 @@
+*.gem
+.rbenv-gemsets
+.ruby-version
+/.config
+/pkg/
+/doc/
+/tmp/
+/.yardoc/

data/README.md

@@ -50,7 +50,8 @@ IO.binwrite("test.bgr", raw)
 | :expand_colormap | Booblean | T.B.D |
 | :scale | Rational or Float | T.B.D |
 | :dct_method | String or Symbol | T.B.D |
-| :with_exif | Boolean | Specify whether to read Exif tag. When set to true, the content of Exif tag will included in the meta information. |
+| :with_exif_tags | Boolean | Specify whether to read Exif tag. When set to true, the content of Exif tag will included in the meta information. |
+| :orientation | Boolean | Specify whether to parse Exif orientation. When set to true, apply orientation for decode result. |
 
 #### supported output format
 RGB RGB24 YUV422 YUYV RGB565 YUV444 YCbCr BGR BGR24 RGBX RGB32 BGRX BGR32 
@@ -75,4 +76,5 @@ IO.binwrite("test.jpg", enc << IO.binread("test.raw"))
 | :quality | Integer | encode quality (0-100) |
 | :scale | Rational or Float | |
 | :dct_method | String or Symbol | T.B.D |
+| :orientation | Integer | Specify Exif orientation value (1-8). |
 

data/ext/jpeg/extconf.rb

@@ -1,5 +1,6 @@
 require 'mkmf'
 require 'optparse'
+require 'rbconfig'
 
 OptionParser.new { |opt|
   opt.on('--with-jpeg-include=PATH', String) { |path|
@@ -16,4 +17,14 @@ OptionParser.new { |opt|
 have_library( "jpeg")
 have_header( "jpeglib.h")
 
+RbConfig::CONFIG.instance_eval {
+  flag = false
+
+  if /gcc/ =~ self['CC']
+    flag = ['CFLAGS', 'CPPFLAGS'].any? {|s| /-D_FORTIFY_SOURCE/ =~ self[s]}
+  end
+
+  have_library( "ssp") if flag
+}
+
 create_makefile( "jpeg/jpeg")

data/ext/jpeg/jpeg.c

@@ -4,16 +4,6 @@
  *  Copyright (C) 2015 Hiroshi Kuwagata <kgt9221@gmail.com>
  */
 
-/*
- * $Id: jpeg.c 159 2017-12-17 18:40:28Z pi $
- */
-
-/*
- * TODO
- *    libjpegのエラーハンドリングを全くやっていないので
- *    いずれ修正する事
- */
-
 #include <stdio.h>
 #include <stdint.h>
 #include <strings.h>
@@ -22,6 +12,7 @@
 #include <jpeglib.h>
 
 #include "ruby.h"
+#include "ruby/version.h"
 #include "ruby/encoding.h"
 
 #define UNIT_LINES                 10
@@ -33,6 +24,23 @@
 #define DEFAULT_QUALITY            75
 #define DEFAULT_INPUT_COLOR_SPACE  JCS_YCbCr
 #define DEFAULT_INPUT_COMPONENTS   2
+#define DEFAULT_ENCODE_FLAGS       (0)
+#define DEFAULT_DECODE_FLAGS       (F_NEED_META)
+
+#define F_NEED_META                0x00000001
+#define F_EXPAND_COLORMAP          0x00000002
+#define F_PARSE_EXIF               0x00000004
+#define F_APPLY_ORIENTATION        0x00000008
+#define F_DITHER                   0x00000010
+#define F_CREAT                    0x00010000
+
+#define SET_FLAG(ptr, msk)         ((ptr)->flags |= (msk))
+#define CLR_FLAG(ptr, msk)         ((ptr)->flags &= ~(msk))
+#define TEST_FLAG(ptr, msk)        ((ptr)->flags & (msk))
+#define TEST_FLAG_ALL(ptr, msk)    (((ptr)->flags & (msk)) == (msk))
+
+#define SET_DATA(ptr, dat)         ((ptr)->data = (dat))
+#define CLR_DATA(ptr)              ((ptr)->data = Qnil)
 
 #define FMT_YUV422                 1
 #define FMT_RGB565                 2
@@ -48,20 +56,25 @@
 #define JPEG_APP1                  0xe1   /* Exif marker */
 
 #define N(x)                       (sizeof(x)/sizeof(*x))
+#define SWAP(a,b,t) \
+        do {t c; c = (a); (a) = (b); (b) = c;} while (0)
 
 #define RUNTIME_ERROR(msg)         rb_raise(rb_eRuntimeError, (msg))
 #define ARGUMENT_ERROR(msg)        rb_raise(rb_eArgError, (msg))
+#define TYPE_ERROR(msg)            rb_raise(rb_eTypeError, (msg))
+#define RANGE_ERROR(msg)           rb_raise(rb_eRangeError, (msg))
+#define NOT_IMPLEMENTED_ERROR(msg) rb_raise(rb_eNotImpError, (msg))
 
 #define IS_COLORMAPPED(ci)         (((ci)->actual_number_of_colors > 0) &&\
                                     ((ci)->colormap != NULL) && \
                                     ((ci)->output_components == 1) && \
-                                       (((ci)->out_color_components == 1) || \
-                                        ((ci)->out_color_components == 3)))
+                                    (((ci)->out_color_components == 1) || \
+                                     ((ci)->out_color_components == 3)))
 
 #define ALLOC_ARRAY() \
-        ((JSAMPARRAY)xmalloc(sizeof(JSAMPROW) * UNIT_LINES))
+        ((JSAMPARRAY)malloc(sizeof(JSAMPROW) * UNIT_LINES))
 #define ALLOC_ROWS(w,c) \
-        ((JSAMPROW)xmalloc(sizeof(JSAMPLE) * (w) * (c) * UNIT_LINES))
+        ((JSAMPROW)malloc(sizeof(JSAMPLE) * (w) * (c) * UNIT_LINES))
 
 #define EQ_STR(val,str)            (rb_to_id(val) == rb_intern(str))
 #define EQ_INT(val,n)              (FIX2INT(val) == n)
@@ -76,11 +89,13 @@ static VALUE decerr_klass;
 
 static ID id_meta;
 static ID id_width;
+static ID id_stride;
 static ID id_height;
 static ID id_orig_cs;
 static ID id_out_cs;
 static ID id_ncompo;
-static ID id_exif;
+static ID id_exif_tags;
+static ID id_colormap;
 
 typedef struct {
   int tag;
@@ -246,25 +261,47 @@ tag_entry_t tag_i14y[] = {
 static const char* encoder_opts_keys[] = {
   "pixel_format",             // {str}
   "quality",                  // {integer}
-  "scale",                    // {rational} or {float}
-  "dct_method"                // {str}
+  "dct_method",               // {str}
+  "orientation",              // {integer}
+  "stride",                   // {integer}
 };
 
 static ID encoder_opts_ids[N(encoder_opts_keys)];
 
 typedef struct {
-  int format;
+  struct jpeg_error_mgr jerr;
+
+  char msg[JMSG_LENGTH_MAX+10];
+  jmp_buf jmpbuf;
+} ext_error_t;
+
+typedef struct {
+  int flags;
   int width;
+  int stride;
   int height;
-
   int data_size;
+
+  int format;
+  int color_space;
+  int components;
+  int quality;
   J_DCT_METHOD dct_method;
 
   struct jpeg_compress_struct cinfo;
-  struct jpeg_error_mgr jerr;
+  ext_error_t err_mgr;
 
   JSAMPARRAY array;
   JSAMPROW rows;
+
+  VALUE data;
+
+  struct {
+    unsigned char* mem;
+    unsigned long size;
+  } buf;
+
+  int orientation;
 } jpeg_encode_t;
 
 static const char* decoder_opts_keys[] = {
@@ -273,30 +310,24 @@ static const char* decoder_opts_keys[] = {
   "do_fancy_upsampling",      // {bool}
   "do_smoothing",             // {bool}
   "dither",                   // [{str}MODE, {bool}2PASS, {int}NUM_COLORS]
+#if 0
   "use_1pass_quantizer",      // {bool}
   "use_external_colormap",    // {bool}
   "use_2pass_quantizer",      // {bool}
+#endif
   "without_meta",             // {bool}
   "expand_colormap",          // {bool}
   "scale",                    // {rational} or {float}
   "dct_method",               // {str}
-  "with_exif"                 // {bool}
+  "with_exif_tags",           // {bool}
+  "orientation"               // {bool}
 };
 
 static ID decoder_opts_ids[N(decoder_opts_keys)];
 
 typedef struct {
-  struct jpeg_error_mgr jerr;
-
-  char msg[JMSG_LENGTH_MAX+10];
-  jmp_buf jmpbuf;
-} ext_error_t;
-
-typedef struct {
+  int flags;
   int format;
-  int need_meta;
-  int expand_colormap;
-  int parse_exif;
 
   J_COLOR_SPACE out_color_space;
   int scale_num;
@@ -317,8 +348,131 @@ typedef struct {
 
   struct jpeg_decompress_struct cinfo;
   ext_error_t err_mgr;
+
+  JSAMPARRAY array;
+
+  VALUE data;
+
+  struct {
+    int value;
+    VALUE buf;
+  } orientation;
 } jpeg_decode_t;
 
+#if 0
+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;
+}
+#endif
+
+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;
+}
+
+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;
+}
+
+static VALUE
+create_memory_error()
+{
+  return rb_exc_new_str(rb_eRangeError, rb_str_new_cstr("no memory"));
+}
+
+static void
+output_message(j_common_ptr cinfo)
+{
+  ext_error_t* err;
+
+  err = (ext_error_t*)cinfo->err;
+
+  (*err->jerr.format_message)(cinfo, err->msg);
+}
+
+static void
+emit_message(j_common_ptr cinfo, int msg_level)
+{
+  ext_error_t* err;
+
+  if (msg_level < 0) {
+    err = (ext_error_t*)cinfo->err;
+    (*err->jerr.format_message)(cinfo, err->msg);
+    /*
+     * 以前はemit_messageが呼ばれるとエラー扱いしていたが、
+     * Logicoolの一部のモデルなどで問題が出るので無視する
+     * ようにした。
+     * また本来であれば、警告表示を行うべきでもあるが一部
+     * のモデルで大量にemitされる場合があるので表示しない
+     * ようにしている。
+     * 問題が発生した際は、最後のメッセージをオブジェクト
+     * のインスタンスとして持たすべき。
+     */
+    // longjmp(err->jmpbuf, 1);
+  }
+}
+
+static void
+error_exit(j_common_ptr cinfo)
+{
+  ext_error_t* err;
+
+  err = (ext_error_t*)cinfo->err;
+  (*err->jerr.format_message)(cinfo, err->msg);
+  longjmp(err->jmpbuf, 1);
+}
 
 static VALUE
 lookup_tag_symbol(tag_entry_t* tbl, size_t n, int tag)
@@ -361,40 +515,87 @@ lookup_tag_symbol(tag_entry_t* tbl, size_t n, int tag)
 }
 
 static void
-encode_output_message(j_common_ptr cinfo)
+rb_encoder_mark(void* _ptr)
 {
-  char msg[JMSG_LENGTH_MAX];
+  jpeg_encode_t* ptr;
+
+  ptr = (jpeg_encode_t*)_ptr;
 
-  (*cinfo->err->format_message)(cinfo, msg);
+  if (ptr->data != Qnil) {
+    rb_gc_mark(ptr->data);
+  }
 }
 
 static void
-encode_error_exit(j_common_ptr cinfo)
+rb_encoder_free(void* _ptr)
 {
-  char msg[JMSG_LENGTH_MAX];
+  jpeg_encode_t* ptr;
 
-  (*cinfo->err->format_message)(cinfo, msg);
+  ptr = (jpeg_encode_t*)_ptr;
 
-  jpeg_destroy_compress((j_compress_ptr)cinfo);
-  rb_raise(encerr_klass, "%s", msg);
-}
+  if (ptr->array != NULL) {
+    free(ptr->array);
+  }
 
+  if (ptr->rows != NULL) {
+    free(ptr->rows);
+  }
 
-static void
-rb_encoder_free( void* _ptr)
+  if (ptr->buf.mem != NULL) {
+    free(ptr->buf.mem);
+  }
+
+  if (TEST_FLAG(ptr, F_CREAT)) {
+    jpeg_destroy_compress(&ptr->cinfo);
+  }
+
+  free(ptr);
+}
+
+static size_t
+rb_encoder_size(const void* _ptr)
 {
+  size_t ret;
   jpeg_encode_t* ptr;
 
-  ptr = (jpeg_encode_t*)_ptr;
-
-  if (ptr->array != NULL) xfree(ptr->array);
-  if (ptr->rows != NULL) xfree(ptr->rows);
+  ptr  = (jpeg_encode_t*)_ptr;
 
-  jpeg_destroy_compress(&ptr->cinfo);
+  ret  = sizeof(jpeg_encode_t);
+  ret += sizeof(JSAMPROW) * UNIT_LINES; 
+  ret += sizeof(JSAMPLE) * ptr->stride * UNIT_LINES;
 
-  free(_ptr);
+  return ret;
 }
 
+#if RUBY_API_VERSION_CODE > 20600
+static const rb_data_type_t jpeg_encoder_data_type = {
+  "libjpeg-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 jpeg_encoder_data_type = {
+  "libjpeg-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)
 {
@@ -403,192 +604,396 @@ rb_encoder_alloc(VALUE self)
   ptr = ALLOC(jpeg_encode_t);
   memset(ptr, 0, sizeof(*ptr));
 
-  ptr->dct_method = JDCT_FASTEST;
+  ptr->flags = DEFAULT_ENCODE_FLAGS;
 
-  return Data_Wrap_Struct(encoder_klass, 0, rb_encoder_free, ptr);
+  return TypedData_Wrap_Struct(encoder_klass, &jpeg_encoder_data_type, ptr);
 }
 
-static void
-set_encoder_context(jpeg_encode_t* ptr, int wd, int ht, VALUE opt)
+static VALUE
+eval_encoder_pixel_format_opt(jpeg_encode_t* ptr, VALUE opt)
 {
-  VALUE opts[N(encoder_opts_ids)];
+  VALUE ret;
   int format;
   int color_space;
   int components;
-  int data_size;
-  int quality;
-  int scale_num;
-  int scale_denom;
-  int i;
 
-  /*
-   * parse options
-   */
-  rb_get_kwargs(opt, encoder_opts_ids, 0, N(encoder_opts_ids), opts);
+  ret = Qnil;
 
-  /*
-   * eval :pixel_format option
-   */
-  if (opts[0] == Qundef||EQ_STR(opts[0], "YUV422")||EQ_STR(opts[0], "YUYV")) {
+  switch (TYPE(opt)) {
+  case T_UNDEF:
     format      = FMT_YUV422;
     color_space = JCS_YCbCr;
     components  = 3;
-    data_size   = (wd * ht * 2);
+    break;
 
-  } else if (EQ_STR(opts[0], "RGB565")) {
-    format      = FMT_RGB565;
-    color_space = JCS_RGB;
-    components  = 3;
-    data_size   = (wd * ht * 2);
+  case T_STRING:
+  case T_SYMBOL:
+    if (EQ_STR(opt, "YUV422") || EQ_STR(opt, "YUYV")) {
+      format      = FMT_YUV422;
+      color_space = JCS_YCbCr;
+      components  = 3;
 
-  } else if (EQ_STR(opts[0], "RGB") || EQ_STR(opts[0], "RGB24")) {
-    format      = FMT_RGB;
-    color_space = JCS_RGB;
-    components  = 3;
-    data_size   = (wd * ht * 3);
+    } else if (EQ_STR(opt, "RGB565")) {
+      format      = FMT_RGB565;
+      color_space = JCS_RGB;
+      components  = 3;
 
-  } else if (EQ_STR(opts[0], "BGR") || EQ_STR(opts[0], "BGR24")) {
-    format      = FMT_BGR;
-    color_space = JCS_EXT_BGR;
-    components  = 3;
-    data_size   = (wd * ht * 3);
+    } else if (EQ_STR(opt, "RGB") || EQ_STR(opt, "RGB24")) {
+      format      = FMT_RGB;
+      color_space = JCS_RGB;
+      components  = 3;
 
-  } else if (EQ_STR(opts[0], "YUV444") || EQ_STR(opts[0], "YCbCr")) {
-    format      = FMT_YUV;
-    color_space = JCS_YCbCr;
-    components  = 3;
-    data_size   = (wd * ht * 3);
+    } else if (EQ_STR(opt, "BGR") || EQ_STR(opt, "BGR24")) {
+      format      = FMT_BGR;
+      color_space = JCS_EXT_BGR;
+      components  = 3;
 
-  } else if (EQ_STR(opts[0], "RGBX") || EQ_STR(opts[0], "RGB32")) {
-    format      = FMT_RGB32;
-    color_space = JCS_EXT_RGBX;
-    components  = 4;
-    data_size   = (wd * ht * 4);
+    } else if (EQ_STR(opt, "YUV444") || EQ_STR(opt, "YCbCr")) {
+      format      = FMT_YUV;
+      color_space = JCS_YCbCr;
+      components  = 3;
 
+    } else if (EQ_STR(opt, "RGBX") || EQ_STR(opt, "RGB32")) {
+      format      = FMT_RGB32;
+      color_space = JCS_EXT_RGBX;
+      components  = 4;
 
-  } else if (EQ_STR(opts[0], "BGRX") || EQ_STR(opts[0], "BGR32")) {
-    format      = FMT_BGR32;
-    color_space = JCS_EXT_BGRX;
-    components  = 4;
-    data_size   = (wd * ht * 4);
+    } else if (EQ_STR(opt, "BGRX") || EQ_STR(opt, "BGR32")) {
+      format      = FMT_BGR32;
+      color_space = JCS_EXT_BGRX;
+      components  = 4;
 
+    } else if (EQ_STR(opt, "GRAYSCALE")) {
+      format      = FMT_GRAYSCALE;
+      color_space = JCS_GRAYSCALE;
+      components  = 1;
 
-  } else if (EQ_STR(opts[0], "GRAYSCALE")) {
-    format      = FMT_GRAYSCALE;
-    color_space = JCS_GRAYSCALE;
-    components  = 1;
-    data_size   = (wd * ht);
+    } else {
+      ret = create_argument_error("unsupportd :pixel_format option value");
+    }
+    break;
 
-  } else {
-    ARGUMENT_ERROR("Unsupportd :pixel_format option value.");
+  default:
+    ret = create_type_error("unsupportd :pixel_format option type");
+    break;
   }
 
-  /*
-   * eval :quality option
-   */
-  if (opts[1] == Qundef) {
-    quality = DEFAULT_QUALITY;
-
-  } else {
-    if (TYPE(opts[1]) != T_FIXNUM) {
-      ARGUMENT_ERROR("Unsupportd :quality option value.");
+  if (!RTEST(ret)) {
+    ptr->format      = format;
+    ptr->color_space = color_space;
+    ptr->components  = components;
+  }
 
-    } else {
-      quality = FIX2INT(opts[1]);
-    }
+  return ret;
+}
 
-    if (quality < 0) {
-      ARGUMENT_ERROR(":quality value is to little.");
+static VALUE
+eval_encoder_quality_opt(jpeg_encode_t* ptr, VALUE opt)
+{
+  VALUE ret;
+  long quality;
 
-    } else if (quality > 100) {
-      ARGUMENT_ERROR(":quality value is to big.");
-    }
-  }
-  
-  /*
-   * eval scale option
-   */
-  (void)scale_num;
-  (void)scale_denom;
+  ret = Qnil;
 
-  switch (TYPE(opts[2])) {
+  switch (TYPE(opt)) {
   case T_UNDEF:
-    // Nothing
+    quality = DEFAULT_QUALITY;
     break;
 
   case T_FLOAT:
-    scale_num   = 1000;
-    scale_denom = (int)(NUM2DBL(opts[2]) * 1000.0);
+    if (isnan(NUM2DBL(opt)) || isinf(NUM2DBL(opt))) {
+      ret = create_argument_error("unsupportd :quality option value");
+
+    } else if (NUM2DBL(opt) < 0.0) {
+      ret = create_range_error(":quality less than 0");
+
+    } else if (NUM2DBL(opt) > 100.0) {
+      ret = create_range_error(":quality greater than 100");
+
+    } else {
+      quality = NUM2INT(opt);
+    }
     break;
 
-  case T_RATIONAL:
-    scale_num   = FIX2INT(rb_rational_num(opts[2]));
-    scale_denom = FIX2INT(rb_rational_den(opts[2]));
+  case T_FIXNUM:
+    if (FIX2LONG(opt) < 0) {
+      ret = create_range_error(":quality less than 0");
+
+    } if (FIX2LONG(opt) > 100) {
+      ret = create_range_error(":quality greater than 100");
+
+    } else {
+      quality = FIX2INT(opt);
+    }
     break;
 
   default:
-    ARGUMENT_ERROR("Unsupportd :scale option value.");
+    ret = create_type_error("unsupportd :quality option type");
     break;
   }
 
-  /*
-   * eval dct_method option
-   */
-  if (opts[3] == Qundef || EQ_STR(opts[3], "FASTEST")) {
-    ptr->dct_method = JDCT_FASTEST;
+  if (!RTEST(ret)) ptr->quality = quality;
 
-  } else if (EQ_STR(opts[3], "ISLOW")) {
-    ptr->dct_method = JDCT_ISLOW;
+  return ret;
+}
 
-  } else if (EQ_STR(opts[3], "IFAST")) {
-    ptr->dct_method = JDCT_IFAST;
+static VALUE
+eval_encoder_dct_method_opt(jpeg_encode_t* ptr, VALUE opt)
+{
+  VALUE ret;
+  int dct_method;
 
-  } else if (EQ_STR(opts[3], "FLOAT")) {
-    ptr->dct_method = JDCT_FLOAT;
+  ret = Qnil;
 
-  } else {
-    ARGUMENT_ERROR("Unsupportd :dct_method option value.");
-  }
+  switch (TYPE(opt)) {
+  case T_UNDEF:
+    dct_method = JDCT_FASTEST;
+    break;
 
-  /*
-   * set context
-   */
-  ptr->format    = format;
-  ptr->width     = wd;
-  ptr->height    = ht;
-  ptr->data_size = data_size;
-  ptr->array     = ALLOC_ARRAY();
-  ptr->rows      = ALLOC_ROWS(wd, components);
+  case T_STRING:
+  case T_SYMBOL:
+    if (EQ_STR(opt, "FASTEST")) {
+      dct_method = JDCT_FASTEST;
 
-  for (i = 0; i < UNIT_LINES; i++) {
-    ptr->array[i] = ptr->rows + (i * components * wd);
-  }
+    } else if (EQ_STR(opt, "ISLOW")) {
+      dct_method = JDCT_ISLOW;
 
-  jpeg_create_compress(&ptr->cinfo);
+    } else if (EQ_STR(opt, "IFAST")) {
+      dct_method = JDCT_IFAST;
+
+    } else if (EQ_STR(opt, "FLOAT")) {
+      dct_method = JDCT_FLOAT;
+
+    } else {
+      ret = create_argument_error("unsupportd :dct_method option value");
+    }
+    break;
+
+  default:
+    ret = create_type_error("unsupportd :dct_method option type");
+    break;
+  }
+
+  if (!RTEST(ret)) ptr->dct_method = dct_method;
+
+  return ret;
+}
+ 
+static VALUE
+eval_encoder_orientation_opt(jpeg_encode_t* ptr, VALUE opt)
+{
+  VALUE ret;
+  int orientation;
+
+  ret = Qnil;
+
+  switch (TYPE(opt)) {
+  case T_UNDEF:
+    orientation = 0;
+    break;
+
+  case T_FIXNUM:
+    orientation = FIX2INT(opt);
+    if (orientation < 1 || orientation > 8) {
+      ret = create_range_error(":orientation option ouf range");
+    } 
+    break;
+
+  default:
+    ret = create_type_error("Unsupportd :orientation option type.");
+    break;
+  }
+
+  if (!RTEST(ret)) ptr->orientation = orientation;
+
+  return ret;
+}
+
+static VALUE
+eval_encoder_stride_opt(jpeg_encode_t* ptr, VALUE opt)
+{
+  VALUE ret;
+  int stride;
+
+  ret = Qnil;
+
+  switch (TYPE(opt)) {
+  case T_UNDEF:
+    stride = ptr->width * ptr->components;
+    break;
+
+  case T_FIXNUM:
+    stride = FIX2INT(opt);
+    if (stride < (ptr->width * ptr->components)) {
+      ret = create_range_error(":stride too little");
+    }
+    break;
+
+  default:
+    ret = create_type_error("unsupportd :stride option type");
+  }
+
+  if (!RTEST(ret)) ptr->stride = stride;
+
+  return ret;
+}
+
+static VALUE
+set_encoder_context(jpeg_encode_t* ptr, int wd, int ht, VALUE opt)
+{
+  VALUE ret;
+  VALUE opts[N(encoder_opts_ids)];
+  JSAMPARRAY ary;
+  JSAMPROW rows;
+
+  int i;
+
+  /*
+   * initialize
+   */
+  ret  = Qnil;
+  ary  = NULL;
+  rows = NULL;
+
+  /*
+   * argument check
+   */
+  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);
+
+  /*
+   * parse options
+   */
+  if (!RTEST(ret)) do {
+    rb_get_kwargs(opt, encoder_opts_ids, 0, N(encoder_opts_ids), opts);
+
+    // オプション評価で使用するので前もって設定しておく
+    ptr->width  = wd;
+    ptr->height = ht;
+
+    ret = eval_encoder_pixel_format_opt(ptr, opts[0]);
+    if (RTEST(ret)) break;
+
+    ret = eval_encoder_quality_opt(ptr, opts[1]);
+    if (RTEST(ret)) break;
+
+    ret = eval_encoder_dct_method_opt(ptr, opts[2]);
+    if (RTEST(ret)) break;
+
+    ret = eval_encoder_orientation_opt(ptr, opts[3]);
+    if (RTEST(ret)) break;
+
+    ret = eval_encoder_stride_opt(ptr, opts[4]);
+    if (RTEST(ret)) break;
+  } while (0);
+
+  /*
+   * alloc memory
+   */
+  if (!RTEST(ret)) do {
+    ary = ALLOC_ARRAY();
+    if (ary == NULL) {
+      ret = create_memory_error();
+      break;
+    }
+
+    rows = ALLOC_ROWS(ptr->width, ptr->components);
+    if (rows == NULL) {
+      ret = create_memory_error();
+      break;
+    }
+  } while (0);
 
-  ptr->cinfo.err              = jpeg_std_error(&ptr->jerr);
-  ptr->jerr.output_message    = encode_output_message;
-  ptr->jerr.error_exit        = encode_error_exit;
+  /*
+   * set the rest context parameter
+   */
+  if (!RTEST(ret)) {
+    ptr->err_mgr.jerr.output_message = output_message;
+    ptr->err_mgr.jerr.emit_message   = emit_message;
+    ptr->err_mgr.jerr.error_exit     = error_exit;
+
+    ptr->data_size = ptr->stride * ptr->height;
+    ptr->buf.mem   = NULL;
+    ptr->buf.size  = 0;
+    ptr->array     = ary;
+    ptr->rows      = rows;
+    ptr->data      = Qnil;
+
+    for (i = 0; i < UNIT_LINES; i++) {
+      ptr->array[i] = ptr->rows + (i * ptr->width * ptr->components);
+    }
+  }
 
-  ptr->cinfo.image_width      = wd;
-  ptr->cinfo.image_height     = ht;
-  ptr->cinfo.in_color_space   = color_space;
-  ptr->cinfo.input_components = components;
+  /*
+   * setup libjpeg
+   */
+  if (!RTEST(ret)) {
+    jpeg_create_compress(&ptr->cinfo);
+    SET_FLAG(ptr, F_CREAT);
+
+    ptr->cinfo.err              = jpeg_std_error(&ptr->err_mgr.jerr);
+    ptr->cinfo.image_width      = ptr->width;
+    ptr->cinfo.image_height     = ptr->height;
+    ptr->cinfo.in_color_space   = ptr->color_space;
+    ptr->cinfo.input_components = ptr->components;
+
+    ptr->cinfo.optimize_coding  = TRUE;
+    ptr->cinfo.arith_code       = TRUE;
+    ptr->cinfo.raw_data_in      = FALSE;
+    ptr->cinfo.dct_method       = ptr->dct_method;
+
+    jpeg_set_defaults(&ptr->cinfo);
+    jpeg_set_quality(&ptr->cinfo, ptr->quality, TRUE);
+    jpeg_suppress_tables(&ptr->cinfo, TRUE);
+  }
 
-  ptr->cinfo.optimize_coding  = TRUE;
-  ptr->cinfo.arith_code       = TRUE;
-  ptr->cinfo.raw_data_in      = FALSE;
-  ptr->cinfo.dct_method       = ptr->dct_method;
+  /*
+   * post process
+   */
+  if (RTEST(ret)) {
+    if (ary != NULL) free(ary);
+    if (rows != NULL) free(rows);
+  }
 
-  jpeg_set_defaults(&ptr->cinfo);
-  jpeg_set_quality(&ptr->cinfo, quality, TRUE);
-  jpeg_suppress_tables(&ptr->cinfo, TRUE);
+  return ret;
 }
 
+/**
+ * initialize encoder object
+ *
+ * @overload initialize(width, height, opts)
+ *
+ *   @param width [Integer] width of input image (px)
+ *   @param height [Integer] height of input image (px)
+ *   @param opts [Hash] options to initialize object
+ *
+ *   @option opts [Symbol] :pixel_format
+ *     specifies the format of the input image. possible values are:
+ *     YUV422 YUYV RGB565 RGB RGB24 BGR BGR24 YUV444 YCbCr
+ *     RGBX RGB32 BGRX BGR32 GRAYSCALE
+ *
+ *   @option opts [Integer] :quality
+ *     specifies the quality of the compressed image.
+ *     You can specify from 0 (lowest) to 100 (best).
+ *
+ *   @option opts [Symbol] :dct_method
+ *     specifies how encoding is handled. possible values are:
+ *     FASTEST ISLOW IFAST FLOAT
+ */
 static VALUE
 rb_encoder_initialize(int argc, VALUE *argv, VALUE self)
 {
   jpeg_encode_t* ptr;
+  VALUE exc;
   VALUE wd;
   VALUE ht;
   VALUE opt;
@@ -596,191 +1001,281 @@ rb_encoder_initialize(int argc, VALUE *argv, VALUE self)
   /*
    * initialize
    */
-  Data_Get_Struct(self, jpeg_encode_t, ptr);
+  exc = Qnil;
+
+  TypedData_Get_Struct(self, jpeg_encode_t, &jpeg_encoder_data_type, ptr);
 
   /*
    * parse arguments
    */
-  rb_scan_args(argc, argv, "21", &wd, &ht, &opt);
+  rb_scan_args(argc, argv, "2:", &wd, &ht, &opt);
+
+  /*
+   * argument check
+   */
+  do {
+    if (TYPE(wd) != T_FIXNUM) {
+      exc = create_argument_error("invalid width");
+      break;
+    }
 
-  Check_Type(wd, T_FIXNUM);
-  Check_Type(ht, T_FIXNUM);
-  if (opt != Qnil) Check_Type(opt, T_HASH);
+    if (TYPE(ht) != T_FIXNUM) {
+      exc = create_argument_error("invalid height");
+      break;
+    }
+  } while (0);
 
   /*
    * set context
    */ 
-  set_encoder_context(ptr, FIX2INT(wd), FIX2INT(ht), opt);
+  if (!RTEST(exc)) {
+    exc = set_encoder_context(ptr, FIX2INT(wd), FIX2INT(ht), opt);
+  }
+
+  /*
+   * post process
+   */
+  if (RTEST(exc)) rb_exc_raise(exc);
 
   return Qtrue;
 }
 
-static int
-push_rows_yuv422(JSAMPROW rows, int wd, uint8_t* data, int nrow)
+static void
+push_rows_yuv422(JSAMPROW dst, int wd, int st, uint8_t* data, int nrow)
 {
-  int size;
+  uint8_t* src;
   int i;
+  int j;
 
-  size = wd * nrow;
+  for (i = 0; i < nrow; i++) {
+    src = data;
 
-  for (i = 0; i < size; i += 2) {
-    rows[0] = data[0];
-    rows[1] = data[1];
-    rows[2] = data[3];
-    rows[3] = data[2];
-    rows[4] = data[1];
-    rows[5] = data[3];
+    for (j = 0; j < wd; j += 2) {
+      dst[0] = src[0];
+      dst[1] = src[1];
+      dst[2] = src[3];
+      dst[3] = src[2];
+      dst[4] = src[1];
+      dst[5] = src[3];
 
-    rows += 6;
-    data += 4;
-  }
+      dst += 6;
+      src += 4;
+    } 
 
-  return (size * 2);
+    data += st;
+  }
 }
 
-static int
-push_rows_rgb565(JSAMPROW rows, int wd, uint8_t* data, int nrow)
+static void
+push_rows_rgb565(JSAMPROW dst, int wd, int st, uint8_t* data, int nrow)
 {
-  int size;
+  uint8_t* src;
   int i;
+  int j;
 
-  size = wd * nrow;
+  for (i = 0; i < nrow; i++) {
+    src = data;
 
-  for (i = 0; i < size; i += 1) {
-    rows[0] = data[1] & 0xf8;
-    rows[1] = ((data[1] << 5) & 0xe0) | ((data[0] >> 3) & 0x1c);
-    rows[2] = (data[0] << 3) & 0xf8;
+    for (j = 0; j < wd; j++) {
+      dst[0] = src[1] & 0xf8;
+      dst[1] = ((src[1] << 5) & 0xe0) | ((src[0] >> 3) & 0x1c);
+      dst[2] = (src[0] << 3) & 0xf8;
 
-    rows += 3;
-    data += 2;
-  }
+      dst += 3;
+      src += 2;
+    }
 
-  return (size * 2);
+    data += st;
+  }
 }
 
-static int
-push_rows_comp3(JSAMPROW rows, int wd, uint8_t* data, int nrow)
+static void
+push_rows_comp3(JSAMPROW rows, int wd, int st, uint8_t* data, int nrow)
 {
   int size;
+  int i;
+
+  size = wd * 3;
 
-  size = wd * nrow * 3;
-  memcpy(rows, data, size);
+  for (i = 0; i < nrow; i++) {
+    memcpy(rows, data, size);
 
-  return size;
+    rows += size;
+    data += st;
+  }
 }
 
-static int
-push_rows_comp4(JSAMPROW rows, int wd, uint8_t* data, int nrow)
+static void
+push_rows_comp4(JSAMPROW rows, int wd, int st, uint8_t* data, int nrow)
 {
   int size;
+  int i;
 
-  size = wd * nrow * 4;
-  memcpy(rows, data, size);
-
-  return size;
-}
+  size = wd * 4;
 
+  for (i = 0; i < nrow; i++) {
+    memcpy(rows, data, size);
 
+    rows += size;
+    data += st;
+  }
+}
 
-static int
-push_rows_grayscale(JSAMPROW rows, int wd, uint8_t* data, int nrow)
+static void
+push_rows_grayscale(JSAMPROW rows, int wd, int st, uint8_t* data, int nrow)
 {
-  int size;
+  int i;
 
-  size = wd * nrow;
-  memcpy(rows, data, size);
+  for (i = 0; i < nrow; i++) {
+    memcpy(rows, data, wd);
 
-  return size;
+    rows += wd;
+    data += st;
+  }
 }
 
-static int
+static void
 push_rows(jpeg_encode_t* ptr, uint8_t* data, int nrow)
 {
-  int ret;
-
   switch (ptr->format) {
   case FMT_YUV422:
-    ret = push_rows_yuv422(ptr->rows, ptr->width, data, nrow);
+    push_rows_yuv422(ptr->rows, ptr->width, ptr->stride, data, nrow);
     break;
 
   case FMT_RGB565:
-    ret = push_rows_rgb565(ptr->rows, ptr->width, data, nrow);
+    push_rows_rgb565(ptr->rows, ptr->width, ptr->stride, data, nrow);
     break;
 
   case FMT_YUV:
   case FMT_RGB:
   case FMT_BGR:
-    ret = push_rows_comp3(ptr->rows, ptr->width, data, nrow);
+    push_rows_comp3(ptr->rows, ptr->width, ptr->stride, data, nrow);
     break;
 
   case FMT_RGB32:
   case FMT_BGR32:
-    ret = push_rows_comp4(ptr->rows, ptr->width, data, nrow);
+    push_rows_comp4(ptr->rows, ptr->width, ptr->stride, data, nrow);
     break;
 
   case FMT_GRAYSCALE:
-    ret = push_rows_grayscale(ptr->rows, ptr->width, data, nrow);
+    push_rows_grayscale(ptr->rows, ptr->width, ptr->stride, data, nrow);
     break;
 
   default:
     RUNTIME_ERROR("Really?");
   }
+}
 
-  return ret;
+static void
+put_exif_tags(jpeg_encode_t* ptr)
+{
+  uint8_t data[] = {
+    /* Exif header */
+    'E',  'x',  'i',  'f', 0x00, 0x00,
+    'M',  'M',
+    0x00, 0x2a,
+    0x00, 0x00, 0x00, 0x08,
+    0x00, 0x01,
+
+    /* orieatation */
+    0x01, 0x12,
+    0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00,
+    0x00, 0x00,
+
+    /* end mark */
+    0x00, 0x00, 0x00, 0x00,
+  };
+
+  data[24] = (ptr->orientation >> 8) & 0xff;
+  data[25] = (ptr->orientation >> 0) & 0xff;
+
+  jpeg_write_marker(&ptr->cinfo, JPEG_APP1, data, sizeof(data));
 }
 
 static VALUE
-do_encode(jpeg_encode_t* ptr, uint8_t* data)
+do_encode(VALUE _ptr)
 {
   VALUE ret;
-
-  unsigned char* buf;
-  unsigned long buf_size;
+  jpeg_encode_t* ptr;
+  uint8_t* data;
   int nrow;
 
-  buf = NULL;
+  /*
+   * initialize
+   */
+  ret  = Qnil;
+  ptr  = (jpeg_encode_t*)_ptr;
+  data = (uint8_t*)RSTRING_PTR(ptr->data);
 
+  /*
+   * do encode
+   */
+  if (setjmp(ptr->err_mgr.jmpbuf)) {
+    /*
+     * when error occurred
+     */
+    jpeg_abort_compress(&ptr->cinfo);
+    rb_raise(encerr_klass, "%s", ptr->err_mgr.msg);
 
-  jpeg_mem_dest(&ptr->cinfo, &buf, &buf_size); 
+  } else {
+    /*
+     * normal path
+     */
+    jpeg_start_compress(&ptr->cinfo, TRUE);
 
-  jpeg_start_compress(&ptr->cinfo, TRUE);
+    if (ptr->orientation != 0) {
+      put_exif_tags(ptr);
+    }
 
-  while (ptr->cinfo.next_scanline < ptr->cinfo.image_height) {
-    nrow = ptr->cinfo.image_height - ptr->cinfo.next_scanline;
-    if (nrow > UNIT_LINES) nrow = UNIT_LINES;
+    while (ptr->cinfo.next_scanline < ptr->cinfo.image_height) {
+      nrow = ptr->cinfo.image_height - ptr->cinfo.next_scanline;
+      if (nrow > UNIT_LINES) nrow = UNIT_LINES;
 
-    data += push_rows(ptr, data, nrow);
-    jpeg_write_scanlines(&ptr->cinfo, ptr->array, nrow);
-  }
+      push_rows(ptr, data, nrow);
 
-  jpeg_finish_compress(&ptr->cinfo);
+      jpeg_write_scanlines(&ptr->cinfo, ptr->array, nrow);
+      data += (ptr->stride * nrow);
+    }
 
-  /*
-   * create return data
-   */
-  ret = rb_str_buf_new(buf_size);
-  rb_str_set_len(ret, buf_size);
+    jpeg_finish_compress(&ptr->cinfo);
 
-  memcpy(RSTRING_PTR(ret), buf, buf_size);
+    /*
+     * build return data
+     */
+    ret = rb_str_buf_new(ptr->buf.size);
+    rb_str_set_len(ret, ptr->buf.size);
 
-  /*
-   * post process
-   */
-  free(buf);
+    memcpy(RSTRING_PTR(ret), ptr->buf.mem, ptr->buf.size);
+  }
 
   return ret;
 }
 
+/**
+ * encode data
+ *
+ * @overload encode(raw)
+ *
+ *   @param raw [String]  raw image data to encode.
+ *
+ *   @return [String] encoded JPEG data.
+ */
 static VALUE
 rb_encoder_encode(VALUE self, VALUE data)
 {
   VALUE ret;
+  int state;
   jpeg_encode_t* ptr;
 
   /*
    * initialize
    */
-  Data_Get_Struct(self, jpeg_encode_t, ptr);
+  ret   = Qnil;
+  state = 0;
+
+  TypedData_Get_Struct(self, jpeg_encode_t, &jpeg_encoder_data_type, ptr);
 
   /*
    * argument check
@@ -788,70 +1283,123 @@ rb_encoder_encode(VALUE self, VALUE data)
   Check_Type(data, T_STRING);
 
   if (RSTRING_LEN(data) < ptr->data_size) {
-    ARGUMENT_ERROR("raw image data is too short.");
+    ARGUMENT_ERROR("image data is too short");
   }
 
   if (RSTRING_LEN(data) > ptr->data_size) {
-    ARGUMENT_ERROR("raw image data is too large.");
+    ARGUMENT_ERROR("image data is too large");
+  }
+
+  /*
+   * alloc memory
+   */
+  jpeg_mem_dest(&ptr->cinfo, &ptr->buf.mem, &ptr->buf.size); 
+  if (ptr->buf.mem == NULL) {
+    RUNTIME_ERROR("jpeg_mem_dest() failed");
   }
 
+  /*
+   * prepare
+   */
+  SET_DATA(ptr, data);
+
   /*
    * do encode
    */
-  ret = do_encode(ptr, (uint8_t*)RSTRING_PTR(data));
+  ret = rb_protect(do_encode, (VALUE)ptr, &state);
+
+  /*
+   * post process
+   */
+  CLR_DATA(ptr);
+
+  if (ptr->buf.mem != NULL) {
+    free(ptr->buf.mem);
+
+    ptr->buf.mem  = NULL;
+    ptr->buf.size = 0;
+  }
+
+  if (state != 0) rb_jump_tag(state);
 
   return ret;
 }
 
 static void
-rb_decoder_free(void* ptr)
+rb_decoder_mark(void* _ptr)
 {
-  //jpeg_destroy_decompress(&(((jpeg_decode_t*)ptr)->cinfo));
+  jpeg_decode_t* ptr;
 
-  free(ptr);
+  ptr = (jpeg_decode_t*)_ptr; 
+
+  if (ptr->orientation.buf != Qnil) {
+    rb_gc_mark(ptr->orientation.buf);
+  }
+
+  if (ptr->data != Qnil) {
+    rb_gc_mark(ptr->data);
+  }
 }
 
 static void
-decode_output_message(j_common_ptr cinfo)
+rb_decoder_free(void* _ptr)
 {
-  ext_error_t* err;
+  jpeg_decode_t* ptr;
 
-  err = (ext_error_t*)cinfo->err;
+  ptr = (jpeg_decode_t*)_ptr;
 
-  (*err->jerr.format_message)(cinfo, err->msg);
-}
+  if (ptr->array != NULL) {
+    free(ptr->array);
+  }
 
-static void
-decode_emit_message(j_common_ptr cinfo, int msg_level)
-{
-  ext_error_t* err;
+  ptr->orientation.buf = Qnil;
+  ptr->data            = Qnil;
 
-  if (msg_level < 0) {
-    err = (ext_error_t*)cinfo->err;
-    (*err->jerr.format_message)(cinfo, err->msg);
-    /*
-     * 以前はemit_messageが呼ばれるとエラー扱いしていたが、
-     * Logicoolの一部のモデルなどで問題が出るので無視する
-     * ようにした。
-     * また本来であれば、警告表示を行うべきでもあるが一部
-     * のモデルで大量にemitされる場合があるので表示しない
-     * ようにしている。
-     * 問題が発生した際は、最後のメッセージをオブジェクト
-     * のインスタンスとして持たすべき。
-     */
-    // longjmp(err->jmpbuf, 1);
+  if (TEST_FLAG(ptr, F_CREAT)) {
+    jpeg_destroy_decompress(&ptr->cinfo);
   }
+
+  free(ptr);
 }
 
-static void
-decode_error_exit(j_common_ptr cinfo)
+static size_t
+rb_decoder_size(const void* ptr)
 {
-  ext_error_t* err;
+  size_t ret;
 
-  err = (ext_error_t*)cinfo->err;
-  (*err->jerr.format_message)(cinfo, err->msg);
-  longjmp(err->jmpbuf, 1);
-}
+  ret  = sizeof(jpeg_decode_t);
+
+  return ret;
+}
+
+#if RUBY_API_VERSION_CODE > 20600
+static const rb_data_type_t jpeg_decoder_data_type = {
+  "libjpeg-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 jpeg_decoder_data_type = {
+  "libjpeg-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)
@@ -861,54 +1409,40 @@ rb_decoder_alloc(VALUE self)
   ptr = ALLOC(jpeg_decode_t);
   memset(ptr, 0, sizeof(*ptr));
 
-  ptr->format                   = FMT_RGB;
-  ptr->need_meta                = !0;
-  ptr->expand_colormap          = 0;
-  ptr->parse_exif               = 0;
-
-  ptr->out_color_space          = JCS_RGB;
-
-  ptr->scale_num                = 1;
-  ptr->scale_denom              = 1;
+  ptr->flags = DEFAULT_DECODE_FLAGS;
 
-  ptr->out_color_components     = 3;
-  ptr->output_gamma             = 0.0;
-  ptr->buffered_image           = FALSE;
-  ptr->do_fancy_upsampling      = FALSE;
-  ptr->do_block_smoothing       = FALSE;
-  ptr->quantize_colors          = FALSE;
-  ptr->dither_mode              = JDITHER_NONE;
-  ptr->dct_method               = JDCT_FASTEST;
-  ptr->desired_number_of_colors = 0;
-  ptr->enable_1pass_quant       = FALSE;
-  ptr->enable_external_quant    = FALSE;
-  ptr->enable_2pass_quant       = FALSE;
-
-  return Data_Wrap_Struct(decoder_klass, 0, rb_decoder_free, ptr);
+  return TypedData_Wrap_Struct(decoder_klass, &jpeg_decoder_data_type, ptr);
 }
 
-static void
-eval_decoder_opt_pixel_format(jpeg_decode_t* ptr, VALUE opt)
+static VALUE
+eval_decoder_pixel_format_opt(jpeg_decode_t* ptr, VALUE opt)
 {
+  VALUE ret;
   int format;
   int color_space;
   int components;
 
-  if (opt != Qundef) {
+  ret = Qnil;
+
+  switch (TYPE(opt)) {
+  case T_UNDEF:
+    format      = FMT_RGB;
+    color_space = JCS_RGB;
+    components  = 3;
+    break;
+
+  case T_STRING:
+  case T_SYMBOL:
     if(EQ_STR(opt, "RGB") || EQ_STR(opt, "RGB24")) {
       format      = FMT_RGB;
       color_space = JCS_RGB;
       components  = 3;
 
     } else if (EQ_STR(opt, "YUV422") || EQ_STR(opt, "YUYV")) {
-      format      = FMT_YUV422;
-      color_space = JCS_YCbCr;
-      components  = 3;
+      ret = create_not_implement_error( "not implemented colorspace");
 
     } else if (EQ_STR(opt, "RGB565")) {
-      format      = FMT_RGB565;
-      color_space = JCS_RGB;
-      components  = 3;
+      ret = create_not_implement_error( "not implemented colorspace");
 
     } else if (EQ_STR(opt, "GRAYSCALE")) {
       format      = FMT_GRAYSCALE;
@@ -941,254 +1475,555 @@ eval_decoder_opt_pixel_format(jpeg_decode_t* ptr, VALUE opt)
       components  = 4;
 
     } else {
-      ARGUMENT_ERROR("Unsupportd :pixel_format option value.");
+      ret = create_argument_error("unsupportd :pixel_format option value");
     }
+    break;
+
+  default:
+    ret = create_type_error("unsupportd :pixel_format option type");
+    break;
+  }
 
-    ptr->format                = format;
-    ptr->out_color_space       = color_space;
-    ptr->out_color_components  = components;
+  if (!RTEST(ret)) {
+    ptr->format               = format;
+    ptr->out_color_space      = color_space;
+    ptr->out_color_components = components;
   }
+
+  return ret;
 }
 
-static void
-eval_decoder_opt_output_gamma(jpeg_decode_t* ptr, VALUE opt)
+static VALUE
+eval_decoder_output_gamma_opt(jpeg_decode_t* ptr, VALUE opt)
 {
+  VALUE ret;
+  double gamma;
+
+  ret = Qnil;
+
   switch (TYPE(opt)) {
   case T_UNDEF:
-    // Nothing
+    gamma = 0.0;
     break;
 
+  case T_FIXNUM:
   case T_FLOAT:
-    ptr->output_gamma = NUM2DBL(opt);
+    if (isnan(NUM2DBL(opt)) || isinf(NUM2DBL(opt))) {
+      ret = create_argument_error("unsupported :output_gamma value");
+    } else {
+      gamma = NUM2DBL(opt);
+    }
     break;
 
   default:
-    ARGUMENT_ERROR("Unsupportd :output_gamma option value.");
+    ret = create_type_error("unsupported :output_gamma type");
     break;
   }
+
+  if (!RTEST(ret)) ptr->output_gamma = gamma;
+
+  return ret;
 }
 
-static void
-eval_decoder_opt_do_fancy_upsampling(jpeg_decode_t* ptr, VALUE opt)
+static VALUE
+eval_decoder_do_fancy_upsampling_opt(jpeg_decode_t* ptr, VALUE opt)
 {
-  if (opt != Qundef) {
-    ptr->do_fancy_upsampling = (RTEST(opt))? TRUE: FALSE;
+  if (opt != Qundef && RTEST(opt)) {
+    ptr->do_fancy_upsampling = TRUE;
+  } else {
+    ptr->do_fancy_upsampling = FALSE;
   }
+
+  return Qnil;
 }
 
-static void
-eval_decoder_opt_do_smoothing(jpeg_decode_t* ptr, VALUE opt)
+static VALUE
+eval_decoder_do_smoothing_opt(jpeg_decode_t* ptr, VALUE opt)
 {
-  if (opt != Qundef) {
-    ptr->do_block_smoothing = (RTEST(opt))? TRUE: FALSE;
+  if (opt != Qundef && RTEST(opt)) {
+    ptr->do_block_smoothing = TRUE;
+  } else {
+    ptr->do_block_smoothing = FALSE;
   }
+
+  return Qnil;
 }
 
-static void
-eval_decoder_opt_dither( jpeg_decode_t* ptr, VALUE opt)
+static VALUE
+eval_decoder_dither_opt( jpeg_decode_t* ptr, VALUE opt)
 {
-  VALUE dmode;
-  VALUE pass2;
-  VALUE n_col;
+  VALUE ret;
+  VALUE tmp;
+  int mode;
+  int quant;
+  int pass2;
+  int ncol;
 
-  if (opt != Qundef) {
-    if (TYPE(opt) != T_ARRAY) {
-      ARGUMENT_ERROR("Unsupportd :dither option value.");
-    }
+  ret = Qnil;
+
+  switch (TYPE(opt)) {
+  case T_UNDEF:
+    mode  = JDITHER_NONE;
+    quant = FALSE;
+    ncol  = 0;
+    pass2 = FALSE;
+    break;
 
+  case T_ARRAY:
     if (RARRAY_LEN(opt) != 3) {
-      ARGUMENT_ERROR(":dither is illeagal length (shall be 3 entries).");
-    }
+      ret = create_argument_error(":dither invalid size");
+
+    } else do {
+      /*
+       * dither mode
+       */
+      tmp = rb_ary_entry(opt, 0);
+      if (TYPE(tmp) != T_STRING && TYPE(tmp) != T_SYMBOL) {
+        ret = create_type_error("unsupported dither mode type");
+        break;
 
-    dmode = RARRAY_AREF(opt, 0);
-    pass2 = RARRAY_AREF(opt, 1);
-    n_col = RARRAY_AREF(opt, 2);
-    
-    if (EQ_STR(dmode, "NONE")) {
-      ptr->dither_mode     = JDITHER_NONE;
-      ptr->quantize_colors = FALSE;
+      } else if (EQ_STR(tmp, "NONE")) {
+        mode  = JDITHER_NONE;
+        quant = FALSE;
 
-    } else if(EQ_STR(dmode, "ORDERED")) {
-      ptr->dither_mode     = JDITHER_ORDERED;
-      ptr->quantize_colors = TRUE;
+      } else if(EQ_STR(tmp, "ORDERED")) {
+        mode  = JDITHER_ORDERED;
+        quant = TRUE;
 
-    } else if(EQ_STR(dmode, "FS")) {
-      ptr->dither_mode     = JDITHER_FS;
-      ptr->quantize_colors = TRUE;
+      } else if(EQ_STR(tmp, "FS")) {
+        mode  = JDITHER_FS;
+        quant = TRUE;
 
-    } else {
-      ARGUMENT_ERROR("dither mode is illeagal value.");
-    }
+      } else {
+        ret = create_argument_error("dither mode is illeagal value.");
+        break;
+      }
 
-    ptr->two_pass_quantize = (RTEST(pass2))? TRUE: FALSE;
+      /*
+       * 2 pass flag
+       */
+      pass2 = (RTEST(rb_ary_entry(opt, 1)))? TRUE: FALSE;
+
+      /*
+       * number of color
+       */
+      tmp = rb_ary_entry(opt, 2);
+      if (TYPE(tmp) != T_FIXNUM) {
+        ret = create_type_error("unsupported number of colors type");
+        break;
 
-    if (TYPE(n_col) == T_FIXNUM) {
-      ptr->desired_number_of_colors = FIX2INT(n_col);
-    } else {
-      ARGUMENT_ERROR( "number of dithered colors is illeagal value.");
-    }
+      } else if (FIX2LONG(tmp) < 8) {
+        ret = create_range_error("number of colors less than 0");
+        break;
+
+      } else if (FIX2LONG(tmp) > 256) {
+        ret = create_range_error("number of colors greater than 256");
+        break;
+
+      } else {
+        ncol = FIX2INT(tmp); 
+      }
+    } while (0);
+    break;
+
+  default:
+    ret = create_type_error("unsupported :dither type");
+    break;
+  }
+
+  if (!RTEST(ret)) {
+    ptr->dither_mode              = mode;
+    ptr->quantize_colors          = quant;
+    ptr->two_pass_quantize        = pass2;
+    ptr->desired_number_of_colors = ncol;
+
+    if (mode != JDITHER_NONE) SET_FLAG(ptr, F_DITHER);
   }
+
+  return ret;
 }
 
+#if 0
 static void
-eval_decoder_opt_use_1pass_quantizer(jpeg_decode_t* ptr, VALUE opt)
+eval_decoder_use_1pass_quantizer_opt(jpeg_decode_t* ptr, VALUE opt)
 {
-  if (opt != Qundef) {
-    if (RTEST(opt)) {
-      ptr->enable_1pass_quant = TRUE;
-      ptr->buffered_image     = TRUE;
-    } else {
-      ptr->enable_1pass_quant = FALSE;
-    }
+  if (opt != Qundef && RTEST(opt)) {
+    ptr->enable_1pass_quant = TRUE;
+  } else {
+    ptr->enable_1pass_quant = FALSE;
   }
+
+  return Qnil;
 }
 
-static void
-eval_decoder_opt_use_external_colormap(jpeg_decode_t* ptr, VALUE opt)
+static VALUE
+eval_decoder_use_external_colormap_opt(jpeg_decode_t* ptr, VALUE opt)
 {
-  if (opt != Qundef) {
-    if (RTEST(opt)) {
+  if (opt != Qundef && RTEST(opt)) {
       ptr->enable_external_quant = TRUE;
-      ptr->buffered_image        = TRUE;
     } else {
       ptr->enable_external_quant = FALSE;
     }
   }
+
+  return Qnil;
 }
 
-static void
-eval_decoder_opt_use_2pass_quantizer(jpeg_decode_t* ptr, VALUE opt)
+static VALUE
+eval_decoder_use_2pass_quantizer_opt(jpeg_decode_t* ptr, VALUE opt)
 {
-  if (opt != Qundef) {
-    if (RTEST(opt)) {
+  if (opt != Qundef && RTEST(opt)) {
       ptr->enable_2pass_quant = TRUE;
-      ptr->buffered_image     = TRUE;
     } else {
       ptr->enable_2pass_quant = FALSE;
     }
   }
+
+  return Qnil;
 }
+#endif
 
-static void
-eval_decoder_opt_without_meta(jpeg_decode_t* ptr, VALUE opt)
+static VALUE
+eval_decoder_without_meta_opt(jpeg_decode_t* ptr, VALUE opt)
 {
-  if (opt != Qundef) {
-    ptr->need_meta = RTEST(opt);
+  if (opt != Qundef && RTEST(opt)) {
+    CLR_FLAG(ptr, F_NEED_META);
+  } else {
+    SET_FLAG(ptr, F_NEED_META);
   }
+
+  return Qnil;
 }
 
-static void
-eval_decoder_opt_expand_colormap(jpeg_decode_t* ptr, VALUE opt)
+static VALUE
+eval_decoder_expand_colormap_opt(jpeg_decode_t* ptr, VALUE opt)
 {
-  if (opt != Qundef) {
-    ptr->expand_colormap = RTEST(opt);
+  if (opt != Qundef && RTEST(opt)) {
+    SET_FLAG(ptr, F_EXPAND_COLORMAP);
+  } else {
+    CLR_FLAG(ptr, F_EXPAND_COLORMAP);
   }
+
+  return Qnil;
 }
 
-static void
-eval_decoder_opt_scale(jpeg_decode_t* ptr, VALUE opt)
+
+static VALUE
+eval_decoder_scale_opt(jpeg_decode_t* ptr, VALUE opt)
 {
+  VALUE ret;
+  int scale_num;
+  int scale_denom;
+
+  ret = Qnil;
+
   switch (TYPE(opt)) {
   case T_UNDEF:
-    // Nothing
+    scale_num   = 1;
+    scale_denom = 1;
+    break;
+
+  case T_FIXNUM:
+    if (FIX2LONG(opt) <= 0) {
+      ret = create_range_error(":scale less equal 0");
+
+    } else {
+      scale_num   = FIX2INT(opt) * 1000;
+      scale_denom = 1000;
+    }
     break;
 
   case T_FLOAT:
-    ptr->scale_num   = 1000;
-    ptr->scale_denom = (int)(NUM2DBL(opt) * 1000.0);
+    if (isnan(NUM2DBL(opt)) || isinf(NUM2DBL(opt))) {
+      ret = create_argument_error("unsupportd :quality option value");
+      
+    } else if (NUM2DBL(opt) <= 0.0) {
+      ret = create_range_error(":scale less equal 0");
+
+    } else {
+      scale_num   = (int)(NUM2DBL(opt) * 1000.0);
+      scale_denom = 1000;
+    }
     break;
 
   case T_RATIONAL:
-    ptr->scale_num   = FIX2INT(rb_rational_num(opt));
-    ptr->scale_denom = FIX2INT(rb_rational_den(opt));
+    scale_num   = (int)FIX2LONG(rb_rational_num(opt));
+    scale_denom = (int)FIX2LONG(rb_rational_den(opt));
     break;
 
   default:
-    ARGUMENT_ERROR("Unsupportd :exapnd_colormap option value.");
+    ret = create_type_error("unsupportd :scale option type");
     break;
   }
+
+  if (!RTEST(ret)) {
+    ptr->scale_num   = scale_num;
+    ptr->scale_denom = scale_denom;
+  }
+
+  return ret;
 }
 
-static void
-eval_decoder_opt_dct_method(jpeg_decode_t* ptr, VALUE opt)
+static VALUE
+eval_decoder_dct_method_opt(jpeg_decode_t* ptr, VALUE opt)
 {
-  if (opt != Qundef) {
-    if (EQ_STR(opt, "ISLOW")) {
-      ptr->dct_method = JDCT_ISLOW;
+  VALUE ret;
+  int dct_method;
+
+  ret = Qnil;
+
+  switch (TYPE(opt)) {
+  case T_UNDEF:
+    dct_method = JDCT_FASTEST;
+    break;
+
+  case T_STRING:
+  case T_SYMBOL:
+    if (EQ_STR(opt, "FASTEST")) {
+      dct_method = JDCT_FASTEST;
+
+    } else if (EQ_STR(opt, "ISLOW")) {
+      dct_method = JDCT_ISLOW;
 
     } else if (EQ_STR(opt, "IFAST")) {
-      ptr->dct_method = JDCT_IFAST;
+      dct_method = JDCT_IFAST;
 
     } else if (EQ_STR(opt, "FLOAT")) {
-      ptr->dct_method = JDCT_FLOAT;
-
-    } else if (EQ_STR(opt, "FASTEST")) {
-      ptr->dct_method = JDCT_FASTEST;
+      dct_method = JDCT_FLOAT;
 
     } else {
-      ARGUMENT_ERROR("Unsupportd :dct_method option value.");
+      ret = create_argument_error("unsupportd :dct_method option value");
     }
+    break;
+
+  default:
+    ret = create_type_error("unsupportd :dct_method option type");
+    break;
   }
+
+  if (!RTEST(ret)) ptr->dct_method = dct_method;
+
+  return ret;
 }
 
-static void
-eval_decoder_opt_with_exif(jpeg_decode_t* ptr, VALUE opt)
+static VALUE
+eval_decoder_with_exif_tags_opt(jpeg_decode_t* ptr, VALUE opt)
+{
+  if (opt != Qundef && RTEST(opt)) {
+    SET_FLAG(ptr, F_PARSE_EXIF);
+  } else {
+    CLR_FLAG(ptr, F_PARSE_EXIF);
+  }
+
+  return Qnil;
+}
+
+static VALUE
+eval_decoder_orientation_opt(jpeg_decode_t* ptr, VALUE opt)
 {
-  if (opt != Qundef) {
-    ptr->parse_exif = RTEST(opt);
+  if (opt != Qundef && RTEST(opt)) {
+    SET_FLAG(ptr, F_APPLY_ORIENTATION);
+  } else {
+    CLR_FLAG(ptr, F_APPLY_ORIENTATION);
   }
+
+  return Qnil;
 }
 
-static void
+static VALUE
 set_decoder_context( jpeg_decode_t* ptr, VALUE opt)
 {
+  VALUE ret;
   VALUE opts[N(decoder_opts_ids)];
+  JSAMPARRAY ary;
+
+  /*
+   * initialize
+   */
+  ret = Qnil;
+  ary = NULL;
 
   /*
    * parse options
    */
-  rb_get_kwargs(opt, decoder_opts_ids, 0, N(decoder_opts_ids), opts);
+  do {
+    rb_get_kwargs(opt, decoder_opts_ids, 0, N(decoder_opts_ids), opts);
+
+    /*
+     * set context
+     */
+    ret = eval_decoder_pixel_format_opt(ptr, opts[0]);
+    if (RTEST(ret)) break;
+
+    ret = eval_decoder_output_gamma_opt(ptr, opts[1]);
+    if (RTEST(ret)) break;
+
+    ret = eval_decoder_do_fancy_upsampling_opt(ptr, opts[2]);
+    if (RTEST(ret)) break;
+
+    ret = eval_decoder_do_smoothing_opt(ptr, opts[3]);
+    if (RTEST(ret)) break;
+
+    ret = eval_decoder_dither_opt(ptr, opts[4]);
+    if (RTEST(ret)) break;
+
+#if 0
+    ret = eval_decoder_use_1pass_quantizer_opt(ptr, opts[5]);
+    if (RTEST(ret)) break;
+
+    ret = eval_decoder_use_external_colormap_opt(ptr, opts[6]);
+    if (RTEST(ret)) break;
+
+    ret = eval_decoder_use_2pass_quantizer_opt(ptr, opts[7]);
+    if (RTEST(ret)) break;
+#endif
+
+    ret = eval_decoder_without_meta_opt(ptr, opts[5]);
+    if (RTEST(ret)) break;
+
+    ret = eval_decoder_expand_colormap_opt(ptr, opts[6]);
+    if (RTEST(ret)) break;
+
+    ret = eval_decoder_scale_opt(ptr, opts[7]);
+    if (RTEST(ret)) break;
+
+    ret = eval_decoder_dct_method_opt(ptr, opts[8]);
+    if (RTEST(ret)) break;
+
+    ret = eval_decoder_with_exif_tags_opt(ptr, opts[9]);
+    if (RTEST(ret)) break;
+
+    ret = eval_decoder_orientation_opt(ptr, opts[10]);
+    if (RTEST(ret)) break;
+  } while (0);
+
+  /*
+   * alloc memory
+   */
+  if (!RTEST(ret)) {
+    ary = ALLOC_ARRAY();
+    if (ary == NULL) ret = create_memory_error();
+  }
 
   /*
-   * set context
+   * set the rest context parameter
+   */
+  if (!RTEST(ret)) {
+    ptr->err_mgr.jerr.output_message = output_message;
+    ptr->err_mgr.jerr.emit_message   = emit_message;
+    ptr->err_mgr.jerr.error_exit     = error_exit;
+
+    // 現時点でオプションでの対応をおこなっていないので
+    // ここで値を設定
+    ptr->enable_1pass_quant    = FALSE;
+    ptr->enable_external_quant = FALSE;
+    ptr->enable_2pass_quant    = FALSE;
+    ptr->buffered_image        = FALSE;
+
+#if 0
+    if (ptr->enable_1pass_quant == TRUE ||
+        ptr->enable_external_quant == TRUE ||
+        ptr->enable_2pass_quant == TRUE) {
+      ptr->buffered_image = TRUE;
+
+    } else {
+      ptr->buffered_image = FALSE;
+    }
+#endif
+
+    ptr->array             = ary;
+    ptr->data              = Qnil;
+    ptr->orientation.value = 0;
+    ptr->orientation.buf   = Qnil;
+  }
+
+  /*
+   * setup libjpeg
    */
-  eval_decoder_opt_pixel_format(ptr, opts[0]);
-  eval_decoder_opt_output_gamma(ptr, opts[1]);
-  eval_decoder_opt_do_fancy_upsampling(ptr, opts[2]);
-  eval_decoder_opt_do_smoothing(ptr, opts[3]);
-  eval_decoder_opt_dither(ptr, opts[4]);
-  eval_decoder_opt_use_1pass_quantizer(ptr, opts[5]);
-  eval_decoder_opt_use_external_colormap(ptr, opts[6]);
-  eval_decoder_opt_use_2pass_quantizer(ptr, opts[7]);
-  eval_decoder_opt_without_meta(ptr, opts[8]);
-  eval_decoder_opt_expand_colormap(ptr, opts[9]);
-  eval_decoder_opt_scale(ptr, opts[10]);
-  eval_decoder_opt_dct_method(ptr, opts[11]);
-  eval_decoder_opt_with_exif(ptr, opts[12]);
+  if (!RTEST(ret)) {
+    jpeg_create_decompress(&ptr->cinfo);
+    SET_FLAG(ptr, F_CREAT);
+
+    ptr->cinfo.err = jpeg_std_error(&ptr->err_mgr.jerr);
+  }
+
+  return ret;
 }
 
+/**
+ * initialize decoder object
+ *
+ * @overload initialize(opts)
+ *
+ *   @param opts [Hash] options to initialize object
+ *
+ *   @option opts [Symbol] :pixel_format
+ *     specifies the format of the output image. possible values are:
+ *     YUV422 YUYV RGB565 RGB RGB24 BGR BGR24 YUV444 YCbCr
+ *     RGBX RGB32 BGRX BGR32 GRAYSCALE
+ *
+ *   @option opts [Float] :output_gamma
+ *
+ *   @option opts [Boolean] :fancy_upsampling
+ *
+ *   @option opts [Boolean] :do_smoothing
+ *
+ *   @option opts [Array] :dither
+ *     specifies dithering parameters. A 3-elements array.
+ *     specify the dither type as a string for the 1st element,
+ *     whether to use 2-pass quantize for the 2nd element as a boolean,
+ *     and the number of colors used for the 3rd element as an integer
+ *     from 16 to 256.
+ *
+ *   @option opts [Boolean] :without_meta
+ *     specifies whether or not to include meta information in the
+ *     output data. If true, no meta-information is output.
+ *
+ *   @option opts [Boolean] :expand_colormap
+ *     specifies whether to expand the color map. If dither is specified,
+ *     the output will be a color number of 1 byte per pixel, but if this
+ *     option is set to true, the output will be expanded to color information.
+ *
+ *   @option opts [Ratioanl] :scale
+ *
+ *   @option opts [Symbol] :dct_method
+ *     specifies how decoding is handled. possible values are:
+ *     FASTEST ISLOW IFAST FLOAT
+ *
+ *   @option opts [Boolean] :with_exif_tags
+ *     specifies whether to include Exif tag information in the output data.
+ *     set this option to true to parse the Exif tag information and include
+ *     it in the meta information output.
+ *
+ *   @option opts [Boolean] :with_exif
+ *     alias to :with_exif_tags option.
+ */
 static VALUE
 rb_decoder_initialize( int argc, VALUE *argv, VALUE self)
 {
   jpeg_decode_t* ptr;
+  VALUE exc;
   VALUE opt;
 
   /*
    * initialize
    */
-  Data_Get_Struct(self, jpeg_decode_t, ptr);
+  TypedData_Get_Struct(self, jpeg_decode_t, &jpeg_decoder_data_type, ptr);
 
   /*
    * parse arguments
    */
-  rb_scan_args( argc, argv, "01", &opt);
-
-  if (opt != Qnil) Check_Type(opt, T_HASH);
+  rb_scan_args( argc, argv, "0:", &opt);
 
   /*
    * set context
    */ 
-  set_decoder_context(ptr, opt);
+  exc = set_decoder_context(ptr, opt);
+
+  /*
+   * post process
+   */
+  if (RTEST(exc)) rb_exc_raise(exc);
 
   return Qtrue;
 }
@@ -1197,11 +2032,12 @@ static VALUE
 rb_decoder_set(VALUE self, VALUE opt)
 {
   jpeg_decode_t* ptr;
+  VALUE exc;
 
   /*
    * initialize
    */
-  Data_Get_Struct(self, jpeg_decode_t, ptr);
+  TypedData_Get_Struct(self, jpeg_decode_t, &jpeg_decoder_data_type, ptr);
 
   /*
    * check argument
@@ -1211,13 +2047,16 @@ rb_decoder_set(VALUE self, VALUE opt)
   /*
    * set context
    */ 
-  set_decoder_context(ptr, opt);
+  exc = set_decoder_context(ptr, opt);
+
+  /*
+   * post process
+   */
+  if (RTEST(exc)) rb_exc_raise(exc);
 
   return Qtrue;
 }
 
-
-
 static VALUE
 get_colorspace_str( J_COLOR_SPACE cs)
 {
@@ -1396,7 +2235,7 @@ exif_init(exif_t* ptr, uint8_t* src, size_t size)
   uint32_t off;
 
   /*
-   * Check Exif idntifier
+   * Check Exif identifier
    */
   if (memcmp(src, "Exif\0\0", 6)) {
     rb_raise(decerr_klass, "invalid exif identifier");
@@ -1847,7 +2686,7 @@ exif_read(exif_t* ptr, VALUE dst)
 #define THUMBNAIL_SIZE      ID2SYM(rb_intern("jpeg_interchange_format_length"))
 
 static VALUE
-create_exif_hash(jpeg_decode_t* ptr)
+create_exif_tags_hash(jpeg_decode_t* ptr)
 {
   VALUE ret;
   jpeg_saved_marker_ptr marker;
@@ -1895,99 +2734,291 @@ create_exif_hash(jpeg_decode_t* ptr)
   return ret;
 }
 
-static VALUE
-create_meta(jpeg_decode_t* ptr)
+static void
+pick_exif_orientation(jpeg_decode_t* ptr)
 {
-  VALUE ret;
-  struct jpeg_decompress_struct* cinfo;
+  jpeg_saved_marker_ptr marker;
+  int o9n;
+  uint8_t* p;
+  int be;
+  uint32_t off;
+  int i;
+  int n;
 
-  /* TODO: そのうちディザをかけた場合のカラーマップをメタで返すようにする */
+  o9n = 0;
 
-  ret   = rb_obj_alloc(meta_klass);
-  cinfo = &ptr->cinfo;
+  for (marker = ptr->cinfo.marker_list;
+            marker != NULL; marker = marker->next) {
 
-  rb_ivar_set(ret, id_width, INT2FIX(cinfo->output_width));
-  rb_ivar_set(ret, id_height, INT2FIX(cinfo->output_height));
-  rb_ivar_set(ret, id_orig_cs, get_colorspace_str(cinfo->jpeg_color_space));
+    if (marker->data_length < 14) continue;
 
-  if (ptr->format == FMT_YVU) {
-    rb_ivar_set(ret, id_out_cs, rb_str_new_cstr("YCrCb"));
-  } else {
-    rb_ivar_set(ret, id_out_cs, get_colorspace_str(cinfo->out_color_space));
-  }
+    p = marker->data;
 
-  rb_ivar_set(ret, id_ncompo, INT2FIX(cinfo->output_components));
+    /*
+     * check Exif identifier
+     */
+    if (memcmp(p, "Exif\0\0", 6)) continue;
 
-  if (ptr->parse_exif) {
-    rb_ivar_set(ret, id_exif, create_exif_hash(ptr));
-  }
+    /*
+     * check endian marker
+     */
+    if (!memcmp(p + 6, "MM", 2)) {
+      be = !0;
 
-  return ret;
-}
+    } else if (!memcmp(p + 6, "II", 2)) {
+      be = 0;
 
-static VALUE
-do_read_header(jpeg_decode_t* ptr, uint8_t* jpg, size_t jpg_sz)
-{
-  VALUE ret;
+    } else {
+      continue;
+    }
 
-  switch (ptr->format) {
-  case FMT_YUV422:
-  case FMT_RGB565:
-    RUNTIME_ERROR( "Not implement");
+    /*
+     * check TIFF identifier
+     */
+    if (get_u16(p + 8, be) != 0x002a) continue;
+
+    /*
+     * set 0th IFD address
+     */
+    off = get_u32(p + 10, be);
+    if (off < 8 || off >= marker->data_length - 6) continue;
+
+    p += (6 + off);
+
+    /* ここまでくればAPP1がExifタグなので
+     * 0th IFDをなめてOrientationタグを探す */
+
+    n = get_u16(p, be);
+    p += 2;
+
+    for (i = 0; i < n; i++) {
+      int tag;
+      int type;
+      int num;
+
+      tag  = get_u16(p + 0, be);
+      type = get_u16(p + 2, be);
+      num  = get_u32(p + 4, be);
+
+      if (tag == 0x0112) {
+        if (type == 3 && num == 1) {
+          o9n = get_u16(p + 8, be);
+          goto loop_out;
+
+        } else {
+          fprintf(stderr,
+                  "Illeagal orientation tag found [type:%d, num:%d]\n",
+                  type,
+                  num);
+        }
+      }
+
+      p += 12;
+    }
+  }
+  loop_out:
+
+  ptr->orientation.value = (o9n >= 1 && o9n <= 8)? (o9n - 1): 0;
+}
+
+static VALUE
+create_colormap(jpeg_decode_t* ptr)
+{
+  VALUE ret;
+  struct jpeg_decompress_struct* cinfo;
+  JSAMPARRAY map;
+  int i;   // volatileを外すとaarch64のgcc6でクラッシュする場合がある
+  uint32_t c;
+
+  cinfo = &ptr->cinfo;
+  ret   = rb_ary_new_capa(cinfo->actual_number_of_colors);
+  map   = cinfo->colormap;
+
+  switch (cinfo->out_color_components) {
+  case 1:
+    for (i = 0; i < cinfo->actual_number_of_colors; i++) {
+      c = map[0][i];
+      rb_ary_push(ret, INT2FIX(c));
+    }
+    break;
+
+  case 2:
+    for (i = 0; i < cinfo->actual_number_of_colors; i++) {
+      c = (map[0][i] << 8) | (map[1][i] << 0);
+      rb_ary_push(ret, INT2FIX(c));
+    }
+    break;
+
+  case 3:
+    for (i = 0; i < cinfo->actual_number_of_colors; i++) {
+      c = (map[0][i] << 16) | (map[1][i] << 8) | (map[2][i] << 0);
+
+      rb_ary_push(ret, INT2FIX(c));
+    }
     break;
+
+  default:
+    RUNTIME_ERROR("this number of components is not implemented yet");
   }
 
-  jpeg_create_decompress(&ptr->cinfo);
+  return ret;
+}
 
-  ptr->cinfo.err                   = jpeg_std_error(&ptr->err_mgr.jerr);
-  ptr->err_mgr.jerr.output_message = decode_output_message;
-  ptr->err_mgr.jerr.emit_message   = decode_emit_message;
-  ptr->err_mgr.jerr.error_exit     = decode_error_exit;
+static VALUE
+rb_meta_exif_tags(VALUE self)
+{
+  return rb_ivar_get(self, id_exif_tags);
+}
 
-  ptr->cinfo.raw_data_out          = FALSE;
-  ptr->cinfo.dct_method            = JDCT_FLOAT;
+static VALUE
+create_meta(jpeg_decode_t* ptr)
+{
+  VALUE ret;
+  struct jpeg_decompress_struct* cinfo;
+  int width;
+  int height;
+  int stride;
+
+  ret    = rb_obj_alloc(meta_klass);
+  cinfo  = &ptr->cinfo;
+
+  if (TEST_FLAG(ptr, F_APPLY_ORIENTATION) && (ptr->orientation.value & 4)) {
+    width  = cinfo->output_height;
+    height = cinfo->output_width;
+  } else {
+    width  = cinfo->output_width;
+    height = cinfo->output_height;
+  }
+
+  stride = cinfo->output_width * cinfo->output_components;
+
+  rb_ivar_set(ret, id_width, INT2FIX(width));
+  rb_ivar_set(ret, id_stride, INT2FIX(stride));
+  rb_ivar_set(ret, id_height, INT2FIX(height));
+
+  rb_ivar_set(ret, id_orig_cs, get_colorspace_str(cinfo->jpeg_color_space));
+
+  if (ptr->format == FMT_YVU) {
+    rb_ivar_set(ret, id_out_cs, rb_str_new_cstr("YCrCb"));
+  } else {
+    rb_ivar_set(ret, id_out_cs, get_colorspace_str(cinfo->out_color_space));
+  }
+
+  if (TEST_FLAG_ALL(ptr, F_DITHER | F_EXPAND_COLORMAP)) {
+    rb_ivar_set(ret, id_ncompo, INT2FIX(cinfo->out_color_components));
+  } else {
+    rb_ivar_set(ret, id_ncompo, INT2FIX(cinfo->output_components));
+  }
+
+  if (TEST_FLAG(ptr, F_PARSE_EXIF)) {
+    rb_ivar_set(ret, id_exif_tags, create_exif_tags_hash(ptr));
+    rb_define_singleton_method(ret, "exif_tags", rb_meta_exif_tags, 0);
+    rb_define_singleton_method(ret, "exif", rb_meta_exif_tags, 0);
+  } 
+
+  if (TEST_FLAG(ptr, F_DITHER)) {
+    rb_ivar_set(ret, id_colormap, create_colormap(ptr));
+  }
+  
+  return ret;
+}
+
+static VALUE
+do_read_header(VALUE _ptr)
+{
+  VALUE ret;
+  jpeg_decode_t* ptr;
+  uint8_t* data;
+  size_t size;
+
+  /*
+   * initialize
+   */
+  ret  = Qnil;
+  ptr  = (jpeg_decode_t*)_ptr;
+  data = (uint8_t*)RSTRING_PTR(ptr->data);
+  size = RSTRING_LEN(ptr->data);
+
+  /*
+   * process body
+   */
+  ptr->cinfo.raw_data_out = FALSE;
+  ptr->cinfo.dct_method   = JDCT_FLOAT;
 
   if (setjmp(ptr->err_mgr.jmpbuf)) {
-    jpeg_destroy_decompress(&ptr->cinfo);
+    /*
+     * when error occurred
+     */
     rb_raise(decerr_klass, "%s", ptr->err_mgr.msg);
+
   } else {
-    jpeg_mem_src(&ptr->cinfo, jpg, jpg_sz);
+    /*
+     * normal path
+     */
+    jpeg_mem_src(&ptr->cinfo, data, size);
 
-    if (ptr->parse_exif) {
+    if (TEST_FLAG(ptr, F_PARSE_EXIF | F_APPLY_ORIENTATION)) {
       jpeg_save_markers(&ptr->cinfo, JPEG_APP1, 0xFFFF);
     }
 
     jpeg_read_header(&ptr->cinfo, TRUE);
     jpeg_calc_output_dimensions(&ptr->cinfo);
 
-    ret = create_meta(ptr);
+    if (TEST_FLAG(ptr, F_APPLY_ORIENTATION)) {
+      pick_exif_orientation(ptr);
+    }
 
-    jpeg_destroy_decompress(&ptr->cinfo);
+    ret = create_meta(ptr);
   }
 
   return ret;
 }
 
+/**
+ * read meta data
+ *
+ * @overload read_header(jpeg)
+ *
+ *   @param jpeg [String] input data.
+ *
+ *   @return [JPEG::Meta] metadata.
+ */
 static VALUE
 rb_decoder_read_header(VALUE self, VALUE data)
 {
   VALUE ret;
   jpeg_decode_t* ptr;
+  int state;
 
   /*
    * initialize
    */
-  Data_Get_Struct(self, jpeg_decode_t, ptr);
+  ret   = Qnil;
+  state = 0;
+
+  TypedData_Get_Struct(self, jpeg_decode_t, &jpeg_decoder_data_type, ptr);
 
   /*
    * argument check
    */
   Check_Type(data, T_STRING);
 
+  /*
+   * prepare
+   */
+  SET_DATA(ptr, data);
+
   /*
    * do encode
    */
-  ret = do_read_header(ptr, (uint8_t*)RSTRING_PTR(data), RSTRING_LEN(data));
+  ret = rb_protect(do_read_header, (VALUE)ptr, &state);
+
+  /*
+   * post process
+   */
+  CLR_DATA(ptr);
+
+  if (state != 0) rb_jump_tag(state);
 
   return ret;
 }
@@ -2018,7 +3049,7 @@ expand_colormap(struct jpeg_decompress_struct* cinfo, uint8_t* src)
    */
 
   VALUE ret;
-  int i;
+  volatile int i;   // volatileを外すとaarch64のgcc6でクラッシュする場合がある
   int n;
   uint8_t* dst;
   JSAMPARRAY map;
@@ -2035,6 +3066,15 @@ expand_colormap(struct jpeg_decompress_struct* cinfo, uint8_t* src)
     }
     break;
 
+  case 2:
+    for (i = 0; i < n; i++) {
+      dst[0] = map[0][src[i]];
+      dst[1] = map[1][src[i]];
+
+      dst += 2;
+    }
+    break;
+
   case 3:
     for (i = 0; i < n; i++) {
       dst[0] = map[0][src[i]];
@@ -2046,7 +3086,7 @@ expand_colormap(struct jpeg_decompress_struct* cinfo, uint8_t* src)
     break;
 
   default:
-    RUNTIME_ERROR("Really?");
+    RUNTIME_ERROR("this number of components is not implemented yet");
   }
 
   rb_str_set_len(ret, n * cinfo->out_color_components);
@@ -2067,10 +3107,417 @@ swap_cbcr(uint8_t* p, size_t size)
   }
 }
 
+static void
+do_transpose8(uint8_t* img, int wd, int ht, void* dst)
+{
+  int x;
+  int y;
+
+  uint8_t* sp;
+  uint8_t* dp;
+
+  sp = (uint8_t*)img;
+
+  for (y = 0; y < ht; y++) {
+    dp = (uint8_t*)dst + y;
+
+    for (x = 0; x < wd; x++) {
+      *dp = *sp;
+
+      sp++;
+      dp += ht;
+    }
+  }
+}
+
+static void
+do_transpose16(void* img, int wd, int ht, void* dst)
+{
+  int x;
+  int y;
+
+  uint16_t* sp;
+  uint16_t* dp;
+
+  sp = (uint16_t*)img;
+
+  for (y = 0; y < ht; y++) {
+    dp = (uint16_t*)dst + y;
+
+    for (x = 0; x < wd; x++) {
+      *dp = *sp;
+
+      sp++;
+      dp += ht;
+    }
+  }
+}
+
+static void
+do_transpose24(void* img, int wd, int ht, void* dst)
+{
+  int x;
+  int y;
+  int st;
+
+  uint8_t* sp;
+  uint8_t* dp;
+
+  sp = (uint8_t*)img;
+  st = ht * 3;
+
+  for (y = 0; y < ht; y++) {
+    dp = (uint8_t*)dst + (y * 3);
+
+    for (x = 0; x < wd; x++) {
+      dp[0] = sp[0];
+      dp[1] = sp[1];
+      dp[2] = sp[2];
+
+      sp += 3;
+      dp += st;
+    }
+  }
+}
+
+static void
+do_transpose32(void* img, int wd, int ht, void* dst)
+{
+  int x;
+  int y;
+
+  uint32_t* sp;
+  uint32_t* dp;
+
+  sp = (uint32_t*)img;
+
+  for (y = 0; y < ht; y++) {
+    dp = (uint32_t*)dst + y;
+
+    for (x = 0; x < wd; x++) {
+      *dp = *sp;
+
+      sp++;
+      dp += ht;
+    }
+  }
+}
+
+static void
+do_transpose(void* img, int wd, int ht, int nc, void* dst)
+{
+  switch (nc) {
+  case 1:
+    do_transpose8(img, wd, ht, dst);
+    break;
+
+  case 2:
+    do_transpose16(img, wd, ht, dst);
+    break;
+
+  case 3:
+    do_transpose24(img, wd, ht, dst);
+    break;
+
+  case 4:
+    do_transpose32(img, wd, ht, dst);
+    break;
+  }
+}
+
+static void
+do_upside_down8(void* img, int wd, int ht)
+{
+  uint8_t* sp;
+  uint8_t* dp;
+
+  sp = (uint8_t*)img;
+  dp = (uint8_t*)img + ((wd * ht) - 1);
+
+  while (sp < dp) {
+    SWAP(*sp, *dp, uint8_t);
+
+    sp++;
+    dp--;
+  }
+}
+
+static void
+do_upside_down16(void* img, int wd, int ht)
+{
+  uint16_t* sp;
+  uint16_t* dp;
+
+  sp = (uint16_t*)img;
+  dp = (uint16_t*)img + ((wd * ht) - 1);
+
+  while (sp < dp) {
+    SWAP(*sp, *dp, uint8_t);
+
+    sp++;
+    dp--;
+  }
+}
+
+static void
+do_upside_down24(void* img, int wd, int ht)
+{
+  uint8_t* sp;
+  uint8_t* dp;
+
+  sp = (uint8_t*)img;
+  dp = (uint8_t*)img + ((wd * ht * 3) - 3);
+
+  while (sp < dp) {
+    SWAP(sp[0], dp[0], uint8_t);
+    SWAP(sp[1], dp[1], uint8_t);
+    SWAP(sp[2], dp[2], uint8_t);
+
+    sp += 3;
+    dp -= 3;
+  }
+}
+
+static void
+do_upside_down32(void* img, int wd, int ht)
+{
+  uint32_t* sp;
+  uint32_t* dp;
+
+  sp = (uint32_t*)img;
+  dp = (uint32_t*)img + ((wd * ht) - 1);
+
+  ht /= 2;
+
+  while (sp < dp) {
+    SWAP(*sp, *dp, uint32_t);
+
+    sp++;
+    dp--;
+  }
+}
+
+static void
+do_upside_down(void* img, int wd, int ht, int nc)
+{
+  switch (nc) {
+  case 1:
+    do_upside_down8(img, wd, ht);
+    break;
+
+  case 2:
+    do_upside_down16(img, wd, ht);
+    break;
+
+  case 3:
+    do_upside_down24(img, wd, ht);
+    break;
+
+  case 4:
+    do_upside_down32(img, wd, ht);
+    break;
+  }
+}
+
+static void
+do_flip_horizon8(void* img, int wd, int ht)
+{
+  int y;
+  int st;
+
+  uint8_t* sp;
+  uint8_t* dp;
+
+  st  = wd;
+  wd /= 2;
+
+  sp = (uint8_t*)img;
+  dp = (uint8_t*)img + (st - 1);
+
+  for (y = 0; y < ht; y++) {
+    while (sp < dp) {
+      SWAP(*sp, *dp, uint8_t);
+
+      sp++;
+      dp--;
+    }
+
+    sp = sp - wd + st;
+    dp = sp + (st - 1);
+  }
+}
+
+static void
+do_flip_horizon16(void* img, int wd, int ht)
+{
+  int y;
+  int st;
+
+  uint16_t* sp;
+  uint16_t* dp;
+
+  st  = wd;
+  wd /= 2;
+
+  sp = (uint16_t*)img;
+  dp = (uint16_t*)img + (st - 1);
+
+  for (y = 0; y < ht; y++) {
+    while (sp < dp) {
+      SWAP(*sp, *dp, uint16_t);
+
+      sp++;
+      dp--;
+    }
+
+    sp = sp - wd + st;
+    dp = sp + (st - 1);
+  }
+}
+
+static void
+do_flip_horizon24(void* img, int wd, int ht)
+{
+  int y;
+  int st;
+
+  uint8_t* sp;
+  uint8_t* dp;
+
+  st  = wd * 3;
+  wd /= 2;
+
+  sp = (uint8_t*)img;
+  dp = (uint8_t*)img + (st - 3);
+
+  for (y = 0; y < ht; y++) {
+    while (sp < dp) {
+      SWAP(sp[0], dp[0], uint8_t);
+      SWAP(sp[1], dp[1], uint8_t);
+      SWAP(sp[2], dp[2], uint8_t);
+
+      sp += 3;
+      dp -= 3;
+    }
+
+    sp = (sp - (wd * 3)) + st;
+    dp = sp + (st - 3);
+  }
+}
+
+static void
+do_flip_horizon32(void* img, int wd, int ht)
+{
+  int y;
+  int st;
+
+  uint32_t* sp;
+  uint32_t* dp;
+
+  st  = wd;
+  wd /= 2;
+
+  sp = (uint32_t*)img;
+  dp = (uint32_t*)img + (st - 1);
+
+  for (y = 0; y < ht; y++) {
+    while (sp < dp) {
+      SWAP(*sp, *dp, uint32_t);
+
+      sp++;
+      dp--;
+    }
+
+    sp = sp - wd + st;
+    dp = sp + (st - 1);
+  }
+}
+
+static void
+do_flip_horizon(void* img, int wd, int ht, int nc)
+{
+  switch (nc) {
+  case 1:
+    do_flip_horizon8(img, wd, ht);
+    break;
+
+  case 2:
+    do_flip_horizon16(img, wd, ht);
+    break;
+
+  case 3:
+    do_flip_horizon24(img, wd, ht);
+    break;
+
+  case 4:
+    do_flip_horizon32(img, wd, ht);
+    break;
+  }
+}
+
+static VALUE
+shift_orientation_buffer(jpeg_decode_t* ptr, VALUE img)
+{
+  VALUE ret;
+  int len;
+
+  ret = ptr->orientation.buf;
+  len = RSTRING_LEN(img);
+
+  if (ret == Qnil || RSTRING_LEN(ret) != len) {
+    ret = rb_str_buf_new(len);
+    rb_str_set_len(ret, len);
+  }
+
+  ptr->orientation.buf = img;
+
+  return ret;
+}
+
+static VALUE
+apply_orientation(jpeg_decode_t* ptr, VALUE img)
+{
+  struct jpeg_decompress_struct* cinfo;
+  int wd;
+  int ht;
+  int nc;
+  VALUE tmp;
+
+  cinfo = &ptr->cinfo;
+  wd    = cinfo->output_width;
+  ht    = cinfo->output_height;
+  nc    = cinfo->output_components;
+
+  if (ptr->orientation.value & 4) {
+    /* 転置は交換アルゴリズムでは実装できないので新規バッファを
+       用意する */
+    tmp = img;
+    img = shift_orientation_buffer(ptr, tmp);
+    SWAP(wd, ht, int);
+
+    do_transpose(RSTRING_PTR(tmp), ht, wd, nc, RSTRING_PTR(img)); 
+  }
+
+  if (ptr->orientation.value & 2) {
+    do_upside_down(RSTRING_PTR(img), wd, ht, nc); 
+  }
+
+  if (ptr->orientation.value & 1) {
+    do_flip_horizon(RSTRING_PTR(img), wd, ht, nc); 
+  }
+
+  return img;
+}
+
 static VALUE
-do_decode(jpeg_decode_t* ptr, uint8_t* jpg, size_t jpg_sz)
+do_decode(VALUE _ptr)
 {
   VALUE ret;
+
+  jpeg_decode_t* ptr;
+  uint8_t* data;
+  size_t size;
+
   struct jpeg_decompress_struct* cinfo;
   JSAMPARRAY array;
 
@@ -2080,118 +3527,149 @@ do_decode(jpeg_decode_t* ptr, uint8_t* jpg, size_t jpg_sz)
   int i;
   int j;
 
-  ret   = Qundef; // warning対策
+  /*
+   * initialize
+   */
+  ret   = Qnil; // warning対策
+  ptr   = (jpeg_decode_t*)_ptr;
+  data  = (uint8_t*)RSTRING_PTR(ptr->data);
+  size  = RSTRING_LEN(ptr->data);
   cinfo = &ptr->cinfo;
-  array = ALLOC_ARRAY();
-                  
-  switch (ptr->format) {
-  case FMT_YUV422:
-  case FMT_RGB565:
-    RUNTIME_ERROR( "Not implement");
-    break;
+  array = ptr->array;
 
-  case FMT_GRAYSCALE:
-  case FMT_YUV:
-  case FMT_RGB:
-  case FMT_BGR:
-  case FMT_YVU:
-  case FMT_RGB32:
-  case FMT_BGR32:
-    jpeg_create_decompress(cinfo);
+  /*
+   * do decode
+   */
+  if (setjmp(ptr->err_mgr.jmpbuf)) {
+    /*
+     * when error occurred
+     */
+    jpeg_abort_decompress(&ptr->cinfo);
+    rb_raise(decerr_klass, "%s", ptr->err_mgr.msg);
 
-    cinfo->err                       = jpeg_std_error(&ptr->err_mgr.jerr);
-    ptr->err_mgr.jerr.output_message = decode_output_message;
-    ptr->err_mgr.jerr.emit_message   = decode_emit_message;
-    ptr->err_mgr.jerr.error_exit     = decode_error_exit;
+  } else {
+    /*
+     * initialize
+     */
+    jpeg_mem_src(cinfo, data, size);
 
-    if (setjmp(ptr->err_mgr.jmpbuf)) {
-      jpeg_abort_decompress(cinfo);
-      jpeg_destroy_decompress(&ptr->cinfo);
+    if (TEST_FLAG(ptr, F_PARSE_EXIF | F_APPLY_ORIENTATION)) {
+      jpeg_save_markers(&ptr->cinfo, JPEG_APP1, 0xFFFF);
+    }
 
-      free(array);
-      rb_raise(decerr_klass, "%s", ptr->err_mgr.msg);
+    jpeg_read_header(cinfo, TRUE);
+    jpeg_calc_output_dimensions(cinfo);
 
-    } else {
-      jpeg_mem_src(cinfo, jpg, jpg_sz);
-      jpeg_read_header(cinfo, TRUE);
-
-      cinfo->raw_data_out              = FALSE;
-      cinfo->dct_method                = ptr->dct_method;
-
-      cinfo->out_color_space           = ptr->out_color_space;
-      cinfo->out_color_components      = ptr->out_color_components;
-      cinfo->scale_num                 = ptr->scale_num;
-      cinfo->scale_denom               = ptr->scale_denom;
-      cinfo->output_gamma              = ptr->output_gamma;
-      cinfo->do_fancy_upsampling       = ptr->do_fancy_upsampling;
-      cinfo->do_block_smoothing        = ptr->do_block_smoothing;
-      cinfo->quantize_colors           = ptr->quantize_colors;
-      cinfo->dither_mode               = ptr->dither_mode;
-      cinfo->two_pass_quantize         = ptr->two_pass_quantize;
-      cinfo->desired_number_of_colors  = ptr->desired_number_of_colors;
-      cinfo->enable_1pass_quant        = ptr->enable_1pass_quant;
-      cinfo->enable_external_quant     = ptr->enable_external_quant;
-      cinfo->enable_2pass_quant        = ptr->enable_2pass_quant;
-
-      jpeg_calc_output_dimensions(cinfo);
-      jpeg_start_decompress(cinfo);
-
-      stride = cinfo->output_components * cinfo->output_width;
-      raw_sz = stride * cinfo->output_height;
-      ret    = rb_str_buf_new(raw_sz);
-      raw    = (uint8_t*)RSTRING_PTR(ret);
-
-
-      while (cinfo->output_scanline < cinfo->output_height) {
-        for (i = 0, j = cinfo->output_scanline; i < UNIT_LINES; i++, j++) {
-          array[i] = raw + (j * stride);
-        }
+    /*
+     * configuration
+     */
+    cinfo->raw_data_out             = FALSE;
+    cinfo->dct_method               = ptr->dct_method;
+           
+    cinfo->out_color_space          = ptr->out_color_space;
+    cinfo->out_color_components     = ptr->out_color_components;
+    cinfo->scale_num                = ptr->scale_num;
+    cinfo->scale_denom              = ptr->scale_denom;
+    cinfo->output_gamma             = ptr->output_gamma;
+    cinfo->do_fancy_upsampling      = ptr->do_fancy_upsampling;
+    cinfo->do_block_smoothing       = ptr->do_block_smoothing;
+    cinfo->quantize_colors          = ptr->quantize_colors;
+    cinfo->dither_mode              = ptr->dither_mode;
+    cinfo->two_pass_quantize        = ptr->two_pass_quantize;
+    cinfo->desired_number_of_colors = ptr->desired_number_of_colors;
+    cinfo->enable_1pass_quant       = ptr->enable_1pass_quant;
+    cinfo->enable_external_quant    = ptr->enable_external_quant;
+    cinfo->enable_2pass_quant       = ptr->enable_2pass_quant;
 
-        jpeg_read_scanlines(cinfo, array, UNIT_LINES);
-      }
+    /*
+     * decode process
+     */
+    jpeg_start_decompress(cinfo);
 
-      if (ptr->expand_colormap && IS_COLORMAPPED( cinfo)) {
-        ret = expand_colormap(cinfo, raw);
-      } else {
-        rb_str_set_len( ret, raw_sz);
+    stride = cinfo->output_components * cinfo->output_width;
+    raw_sz = stride * cinfo->output_height;
+    ret    = rb_str_buf_new(raw_sz);
+    raw    = (uint8_t*)RSTRING_PTR(ret);
+
+    while (cinfo->output_scanline < cinfo->output_height) {
+      for (i = 0, j = cinfo->output_scanline; i < UNIT_LINES; i++, j++) {
+        array[i] = raw + (j * stride);
       }
 
-      if (ptr->need_meta) add_meta(ret, ptr);
-      if (ptr->format == FMT_YVU) swap_cbcr(raw, raw_sz);
+      jpeg_read_scanlines(cinfo, array, UNIT_LINES);
+    }
+
+    jpeg_finish_decompress(&ptr->cinfo);
 
-      jpeg_finish_decompress(cinfo);
-      jpeg_destroy_decompress(&ptr->cinfo);
+    /*
+     * build return data
+     */
+    if (TEST_FLAG(ptr, F_EXPAND_COLORMAP) && IS_COLORMAPPED(cinfo)) {
+      ret = expand_colormap(cinfo, raw);
+    } else {
+      rb_str_set_len(ret, raw_sz);
     }
-    break;
-  }
 
-  free(array);
+    if (ptr->format == FMT_YVU) swap_cbcr(raw, raw_sz);
+
+    if (TEST_FLAG(ptr, F_APPLY_ORIENTATION)) {
+      pick_exif_orientation(ptr);
+      ret = apply_orientation(ptr, ret);
+    }
+
+    if (TEST_FLAG(ptr, F_NEED_META)) add_meta(ret, ptr);
+  }
 
   return ret;
 }
 
+/**
+ * decode JPEG data
+ *
+ * @overload decode(jpeg)
+ *
+ *   @param jpeg [String]  JPEG data to decode.
+ *
+ *   @return [String] decoded raw image data.
+ */
 static VALUE
 rb_decoder_decode(VALUE self, VALUE data)
 {
-    VALUE ret;
-    jpeg_decode_t* ptr;
+  VALUE ret;
+  jpeg_decode_t* ptr;
+  int state;
 
-    /*
-     * initialize
-     */
-    Data_Get_Struct(self, jpeg_decode_t, ptr);
+  /*
+   * initialize
+   */
+  ret   = Qnil;
+  state = 0;
 
-    /*
-     * argument check
-     */
-    Check_Type(data, T_STRING);
+  TypedData_Get_Struct(self, jpeg_decode_t, &jpeg_decoder_data_type, ptr);
 
-    /*
-     * do encode
-     */
-    ret = do_decode(ptr, (uint8_t*)RSTRING_PTR(data), RSTRING_LEN(data));
+  /*
+   * argument check
+   */
+  Check_Type(data, T_STRING);
+
+  /*
+   * prepare
+   */
+  SET_DATA(ptr, data);
 
-    return ret;
+  /*
+   * do decode
+   */
+  ret = rb_protect(do_decode, (VALUE)ptr, &state);
+
+  /*
+   * post process
+   */
+  CLR_DATA(ptr);
+
+  if (state != 0) rb_jump_tag(state);
+
+  return ret;
 }
 
 static VALUE
@@ -2201,28 +3679,19 @@ rb_test_image(VALUE self, VALUE data)
   struct jpeg_decompress_struct cinfo;
   ext_error_t err_mgr;
 
-  jpeg_create_decompress(&cinfo);
-
-  cinfo.err                   = jpeg_std_error(&err_mgr.jerr);
-
-  err_mgr.jerr.output_message = decode_output_message;
-  err_mgr.jerr.emit_message   = decode_emit_message;
-  err_mgr.jerr.error_exit     = decode_error_exit;
-
-  cinfo.raw_data_out          = FALSE;
-  cinfo.dct_method            = JDCT_FLOAT;
+  cinfo.raw_data_out = FALSE;
+  cinfo.dct_method   = JDCT_FLOAT;
 
   if (setjmp(err_mgr.jmpbuf)) {
-    ret = Qtrue;
-  } else {
     ret = Qfalse;
 
+  } else {
     jpeg_mem_src(&cinfo, (uint8_t*)RSTRING_PTR(data), RSTRING_LEN(data));
     jpeg_read_header(&cinfo, TRUE);
     jpeg_calc_output_dimensions(&cinfo);
-  }
 
-  jpeg_destroy_decompress(&cinfo);
+    ret = Qtrue;
+  }
 
   return ret;
 }
@@ -2256,11 +3725,12 @@ Init_jpeg()
 
   meta_klass    = rb_define_class_under(module, "Meta", rb_cObject);
   rb_define_attr(meta_klass, "width", 1, 0);
+  rb_define_attr(meta_klass, "stride", 1, 0);
   rb_define_attr(meta_klass, "height", 1, 0);
   rb_define_attr(meta_klass, "original_colorspace", 1, 0);
   rb_define_attr(meta_klass, "output_colorspace", 1, 0);
   rb_define_attr(meta_klass, "num_components", 1, 0);
-  rb_define_attr(meta_klass, "exif", 1, 0);
+  rb_define_attr(meta_klass, "colormap", 1, 0);
 
   decerr_klass  = rb_define_class_under(module,
                                         "DecodeError", rb_eRuntimeError);
@@ -2278,11 +3748,13 @@ Init_jpeg()
       decoder_opts_ids[i] = rb_intern_const(decoder_opts_keys[i]);
   }
 
-  id_meta       = rb_intern_const("@meta");
-  id_width      = rb_intern_const("@width");
-  id_height     = rb_intern_const("@height");
-  id_orig_cs    = rb_intern_const("@original_colorspace");
-  id_out_cs     = rb_intern_const("@output_colorspace");
-  id_ncompo     = rb_intern_const("@num_components");
-  id_exif       = rb_intern_const("@exif");
+  id_meta      = rb_intern_const("@meta");
+  id_width     = rb_intern_const("@width");
+  id_stride    = rb_intern_const("@stride");
+  id_height    = rb_intern_const("@height");
+  id_orig_cs   = rb_intern_const("@original_colorspace");
+  id_out_cs    = rb_intern_const("@output_colorspace");
+  id_ncompo    = rb_intern_const("@num_components");
+  id_exif_tags = rb_intern_const("@exif_tags");
+  id_colormap  = rb_intern_const("@colormap");
 }