libjpeg-ruby 0.7.1 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 919842f0b928f7b288efd9f9787401923b75afc65be46060553079ba987d7f7f
-  data.tar.gz: a6ea75d0773e2b4d58debcee6b76c03b944d845716409016cd9fbb471ef6fd26
+  metadata.gz: f282952f089529770d21cff48005d0f9bb3c6b2e5de455bcf0d790c534352f96
+  data.tar.gz: 8e108130fd9a5c5fcf2b1fbdd63f3920ab17e37a1d0713abc9b38ac85dc33d19
 SHA512:
-  metadata.gz: fcb35ccfd0931f01408a511a66b40bc17999b6da5be6a7b3479674209fb1c529de94ec7bcfccfc5956504dd4a5b18aa8b95d6eac0735975c5d5edf2fca4549a9
-  data.tar.gz: e8963a8e0c94abae93314898d500fd207e5e2c98d8c31315d5863a0740ae898521786e9dca1ce37c9180883fdfff667bf56dee58f7f7a2f116387972185dcc54
+  metadata.gz: 70a9a93564144bfd271139316ef2b1b3456516d92b860d7bcf4574503b5393b9d228194948a7651ff53b7e970384ab228a29cac29516082862e06d20e9d5fefd
+  data.tar.gz: df0519c734dd9e1083e29407224fd2cb65a24e9532e90d7f83792179e23a79176c3196b968454f0864baf64e64606561ea2181837fce67936cd1f4568803d1bc

data/ext/jpeg/jpeg.c

@@ -34,7 +34,7 @@
 #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 TEST_FLAG_ALL(ptr, msk)    (((ptr)->flags & (msk)) == (msk))
 
 #define FMT_YUV422                 1
 #define FMT_RGB565                 2
@@ -50,6 +50,8 @@
 #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))
@@ -254,7 +256,8 @@ static const char* encoder_opts_keys[] = {
   "pixel_format",             // {str}
   "quality",                  // {integer}
   "scale",                    // {rational} or {float}
-  "dct_method"                // {str}
+  "dct_method",               // {str}
+  "orientation"               // {integer}
 };
 
 static ID encoder_opts_ids[N(encoder_opts_keys)];
@@ -272,6 +275,8 @@ typedef struct {
 
   JSAMPARRAY array;
   JSAMPROW rows;
+
+  int orientation;
 } jpeg_encode_t;
 
 static const char* decoder_opts_keys[] = {
@@ -306,7 +311,6 @@ typedef struct {
 typedef struct {
   int flags;
   int format;
-  int orientation;
 
   J_COLOR_SPACE out_color_space;
   int scale_num;
@@ -327,6 +331,11 @@ typedef struct {
 
   struct jpeg_decompress_struct cinfo;
   ext_error_t err_mgr;
+
+  struct {
+    int value;
+    VALUE buf;
+  } orientation;
 } jpeg_decode_t;
 
 
@@ -413,8 +422,6 @@ rb_encoder_alloc(VALUE self)
   ptr = ALLOC(jpeg_encode_t);
   memset(ptr, 0, sizeof(*ptr));
 
-  ptr->dct_method = JDCT_FASTEST;
-
   return Data_Wrap_Struct(encoder_klass, 0, rb_encoder_free, ptr);
 }
 
@@ -560,6 +567,25 @@ set_encoder_context(jpeg_encode_t* ptr, int wd, int ht, VALUE opt)
     ARGUMENT_ERROR("Unsupportd :dct_method option value.");
   }
 
+  /*
+   * eval orientation option
+   */
+  switch (TYPE(opts[4])) {
+  case T_UNDEF:
+    ptr->orientation = 0;
+    break;
+
+  case T_FIXNUM:
+    ptr->orientation = FIX2INT(opts[4]);
+    if (ptr->orientation < 1 || ptr->orientation > 8) {
+      RANGE_ERROR("orientation is ouf range");
+    } 
+    break;
+
+  default:
+    ARGUMENT_ERROR("Unsupportd :orientation option value.");
+  }
+
   /*
    * set context
    */
@@ -761,6 +787,34 @@ push_rows(jpeg_encode_t* ptr, uint8_t* data, int nrow)
   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)
 {
@@ -772,11 +826,14 @@ do_encode(jpeg_encode_t* ptr, uint8_t* data)
 
   buf = NULL;
 
-
   jpeg_mem_dest(&ptr->cinfo, &buf, &buf_size); 
 
   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;
@@ -904,7 +961,6 @@ rb_decoder_alloc(VALUE self)
 
   ptr->flags                    = DEFAULT_FLAGS;
   ptr->format                   = FMT_RGB;
-  ptr->orientation              = 0;
 
   ptr->out_color_space          = JCS_RGB;
 
@@ -924,6 +980,9 @@ rb_decoder_alloc(VALUE self)
   ptr->enable_external_quant    = FALSE;
   ptr->enable_2pass_quant       = FALSE;
 
+  ptr->orientation.value        = 0;
+  ptr->orientation.buf          = Qnil;
+
   return Data_Wrap_Struct(decoder_klass, 0, rb_decoder_free, ptr);
 }
 
@@ -2116,9 +2175,7 @@ pick_exif_orientation(jpeg_decode_t* ptr)
   }
   loop_out:
 
-  if (o9n > 0) {
-    ptr->orientation = o9n;
-  }
+  ptr->orientation.value = (o9n >= 1 && o9n <= 8)? (o9n - 1): 0;
 }
 
 static VALUE
@@ -2175,15 +2232,27 @@ 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(cinfo->output_width));
+  rb_ivar_set(ret, id_width, INT2FIX(width));
   rb_ivar_set(ret, id_stride, INT2FIX(stride));
-  rb_ivar_set(ret, id_height, INT2FIX(cinfo->output_height));
+  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) {
@@ -2198,10 +2267,6 @@ create_meta(jpeg_decode_t* ptr)
     rb_ivar_set(ret, id_ncompo, INT2FIX(cinfo->output_components));
   }
 
-  if (TEST_FLAG(ptr, F_APPLY_ORIENTATION)) {
-    pick_exif_orientation(ptr);
-  }
-
   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);
@@ -2375,9 +2440,406 @@ 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
@@ -2475,12 +2937,13 @@ do_decode(jpeg_decode_t* ptr, uint8_t* jpg, size_t jpg_sz)
 
       if (ptr->format == FMT_YVU) swap_cbcr(raw, raw_sz);
 
-      if (TEST_FLAG(ptr, F_NEED_META)) add_meta(ret, ptr);
-
       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);
+
       jpeg_finish_decompress(cinfo);
       jpeg_destroy_decompress(&ptr->cinfo);
     }

data/lib/jpeg/version.rb

@@ -1,3 +1,3 @@
 module JPEG
-  VERSION = "0.7.1"
+  VERSION = "0.7.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: libjpeg-ruby
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.7.2
 platform: ruby
 authors:
 - Hiroshi Kuwagata
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-07-17 00:00:00.000000000 Z
+date: 2019-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler