magro 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0b0bad63e73de3bde86fdd749536f8949fd84e8c
-  data.tar.gz: a6c86139fe5cc7c401a9090a34400bf2387f5cc6
+  metadata.gz: 32deda4c751be24b856a25e98b44e15d66838fb4
+  data.tar.gz: 9d7c6693670cb4c1e7959ff8b11f936d043419d5
 SHA512:
-  metadata.gz: 872b26cc6825cd1bb7954e5104d6b196944798126d2d3ae66f08380d7017e747a8eb4748b6fbe2d688feff6ed79fbdb0d082ec29ed188b6cab38601125d7543e
-  data.tar.gz: 53de5a2b240ce63404a8831f61b6285bf3009d3647c487ac6fb7fa32cada5372dced92d839297af911ee4a6b4c6e062bef88a692aac8d4ccdfa7ca1c7f5f45ea
+  metadata.gz: e61aee7251656d90966217242280f76699ded1c81f291b7aacf24ff70c55e5bc897ee551df112fb3f1a992dd0571200b0bd85984adf89aadb43e13b49c5236bf
+  data.tar.gz: b6560a03645922b6a0cc2cef2c476773f9f7b1bc0ccd41b45ed3e29179066f037329f4075d9465e7c4826f81dd8cfdd60bb3f30f01571e2fb543582ce2cebdda

data/.gitignore

@@ -7,6 +7,8 @@
 /pkg/
 /spec/reports/
 /tmp/
+/spec/files/tmp.jpeg
+/spec/files/tmp.png
 
 # rspec failure tracking
 .rspec_status

data/CHANGELOG.md

@@ -1,2 +1,8 @@
+# 0.1.1
+- Refactor extension codes.
+- Fix to raise IOError when occured file reading / writing error.
+- Fix to raise NoMemoryError when occured memory allocation error.
+- Several documentation improvements.
+
 # 0.1.0
 - First release.

data/README.md

@@ -1,7 +1,9 @@
 # Magro
 
 [![Build Status](https://travis-ci.org/yoshoku/magro.svg?branch=master)](https://travis-ci.org/yoshoku/magro)
+[![Gem Version](https://badge.fury.io/rb/magro.svg)](https://badge.fury.io/rb/magro)
 [![BSD 3-Clause License](https://img.shields.io/badge/License-BSD%203--Clause-orange.svg)](https://github.com/yoshoku/numo-liblinear/blob/master/LICENSE.txt)
+[![Documentation](http://img.shields.io/badge/docs-rdoc.info-blue.svg)](https://www.rubydoc.info/gems/magro/0.1.1)
 
 Magro is an image processing library in Ruby.
 Magro uses [Numo::NArray](https://github.com/ruby-numo/numo-narray) arrays as image objects.

data/ext/magro/io.c

@@ -0,0 +1,411 @@
+#include "io.h"
+
+RUBY_EXTERN VALUE mMagro;
+
+/**
+ * @!visibility private
+ */
+static
+VALUE magro_io_read_png(VALUE self, VALUE filename_)
+{
+  char* filename = StringValuePtr(filename_);
+  FILE* file_ptr = fopen(filename, "rb");
+  unsigned char header[8];
+  png_structp png_ptr;
+  png_infop info_ptr;
+  png_bytep* row_ptr_ptr;
+  png_bytep row_ptr;
+  png_uint_32 width, height;
+  int color_type;
+  int bit_depth;
+  png_uint_32 y;
+  int n_dims = 0;
+  int n_ch;
+  size_t shape[3] = { 0 };
+  VALUE nary;
+  uint8_t* nary_ptr;
+
+  if (file_ptr == NULL) {
+    rb_raise(rb_eIOError, "Failed to open file '%s'", filename);
+    return Qnil;
+  }
+
+  if (fread(header, 1, 8, file_ptr) < 8) {
+    fclose(file_ptr);
+    rb_raise(rb_eIOError, "Failed to read header info '%s'", filename);
+    return Qnil;
+  }
+
+  if (png_sig_cmp(header, 0, 8)) {
+    fclose(file_ptr);
+    rb_raise(rb_eIOError, "Failed to read header info '%s'", filename);
+    return Qnil;
+  }
+
+  png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+  if (png_ptr == NULL) {
+    fclose(file_ptr);
+    rb_raise(rb_eNoMemError, "Failed to allocate memory.");
+    return Qnil;
+  }
+  info_ptr = png_create_info_struct(png_ptr);
+  if (info_ptr == NULL) {
+    png_destroy_read_struct(&png_ptr, NULL, NULL);
+    fclose(file_ptr);
+    rb_raise(rb_eNoMemError, "Failed to allocate memory.");
+    return Qnil;
+  }
+  if (setjmp(png_jmpbuf(png_ptr))) {
+    png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+    fclose(file_ptr);
+    rb_raise(rb_eIOError, "Error happened while reading file '%s'", filename);
+    return Qnil;
+  }
+
+  png_init_io(png_ptr, file_ptr);
+  png_set_sig_bytes(png_ptr, 8);
+
+  png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_PACKING | PNG_TRANSFORM_EXPAND | PNG_TRANSFORM_STRIP_16, NULL);
+  row_ptr_ptr = png_get_rows(png_ptr, info_ptr);
+  png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, NULL, NULL, NULL);
+
+  if (color_type == PNG_COLOR_TYPE_PALETTE) {
+    png_set_palette_to_rgb(png_ptr);
+    png_read_update_info(png_ptr, info_ptr);
+    png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, NULL, NULL, NULL);
+  }
+
+  switch (color_type) {
+    case PNG_COLOR_TYPE_GRAY:
+      n_ch = 1;
+      n_dims = 2;
+      shape[0] = height;
+      shape[1] = width;
+      break;
+    case PNG_COLOR_TYPE_GRAY_ALPHA:
+      n_ch = 2;
+      n_dims = 3;
+      shape[0] = height;
+      shape[1] = width;
+      shape[2] = 2;
+      break;
+    case PNG_COLOR_TYPE_RGB:
+      n_ch = 3;
+      n_dims = 3;
+      shape[0] = height;
+      shape[1] = width;
+      shape[2] = 3;
+      break;
+    case PNG_COLOR_TYPE_RGB_ALPHA:
+      n_ch = 4;
+      n_dims = 3;
+      shape[0] = height;
+      shape[1] = width;
+      shape[2] = 4;
+      break;
+    default:
+      n_dims = 0;
+      break;
+  }
+
+  if (n_dims == 0) {
+    fclose(file_ptr);
+    png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+    rb_raise(rb_eIOError, "Unsupported color type of input file '%s'", filename);
+    return Qnil;
+  }
+
+  nary = rb_narray_new(numo_cUInt8, n_dims, shape);
+  nary_ptr = (uint8_t*)na_get_pointer_for_write(nary);
+
+  for (y = 0; y < height; y++) {
+    row_ptr = row_ptr_ptr[y];
+    memcpy(nary_ptr + y * width * n_ch, row_ptr, width * n_ch);
+  }
+
+  fclose(file_ptr);
+  png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+
+  return nary;
+}
+
+/**
+ * @!visibility private
+ */
+static
+VALUE magro_io_save_png(VALUE self, VALUE filename_, VALUE image)
+{
+  char* filename = StringValuePtr(filename_);
+  FILE* file_ptr = fopen(filename, "wb");
+  png_structp png_ptr;
+  png_infop info_ptr;
+  png_bytep* row_ptr_ptr;
+  png_uint_32 width, height;
+  int color_type;
+  int bit_depth = 8;
+  png_uint_32 y;
+  int n_ch;
+  int n_dims;
+  narray_t* image_nary;
+  uint8_t* image_ptr;
+
+  if (file_ptr == NULL) {
+    rb_raise(rb_eIOError, "Failed to open file '%s'", filename);
+    return Qfalse;
+  }
+
+  if (CLASS_OF(image) != numo_cUInt8) {
+    image = rb_funcall(numo_cUInt8, rb_intern("cast"), 1, image);
+  }
+  if (!RTEST(nary_check_contiguous(image))) {
+    image = nary_dup(image);
+  }
+
+  GetNArray(image, image_nary);
+  n_dims = NA_NDIM(image_nary);
+  height = (png_uint_32)NA_SHAPE(image_nary)[0];
+  width = (png_uint_32)NA_SHAPE(image_nary)[1];
+  image_ptr = (uint8_t*)na_get_pointer_for_read(image);
+
+  n_ch = 1;
+  if (n_dims == 3) {
+    n_ch = (int)NA_SHAPE(image_nary)[2];
+  }
+
+  switch (n_ch) {
+    case 4:
+      color_type = PNG_COLOR_TYPE_RGBA;
+      break;
+    case 3:
+      color_type = PNG_COLOR_TYPE_RGB;
+      break;
+    case 2:
+      color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
+      break;
+    default:
+      color_type = PNG_COLOR_TYPE_GRAY;
+      break;
+  }
+
+  png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+  if (png_ptr == NULL) {
+    fclose(file_ptr);
+    rb_raise(rb_eNoMemError, "Failed to allocate memory.");
+    return Qfalse;
+  }
+  info_ptr = png_create_info_struct(png_ptr);
+  if (info_ptr == NULL) {
+    png_destroy_read_struct(&png_ptr, NULL, NULL);
+    fclose(file_ptr);
+    rb_raise(rb_eNoMemError, "Failed to allocate memory.");
+    return Qfalse;
+  }
+  if (setjmp(png_jmpbuf(png_ptr))) {
+    png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+    fclose(file_ptr);
+    return Qfalse;
+  }
+
+  png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, color_type,
+    PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+
+  row_ptr_ptr = png_malloc(png_ptr, height * sizeof(png_bytep));
+  for (y = 0; y < height; y++) {
+    row_ptr_ptr[y] = png_malloc(png_ptr, width * n_ch * sizeof(png_byte));
+    memcpy(row_ptr_ptr[y], image_ptr + y * width * n_ch, width * n_ch);
+  }
+
+  png_init_io(png_ptr, file_ptr);
+  png_set_rows(png_ptr, info_ptr, row_ptr_ptr);
+  png_write_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, NULL);
+
+  fclose(file_ptr);
+  for (y = 0; y < height; y++) {
+    png_free(png_ptr, row_ptr_ptr[y]);
+  }
+  png_free(png_ptr, row_ptr_ptr);
+  png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+
+  return Qtrue;
+}
+
+struct my_error_mgr {
+  struct jpeg_error_mgr pub;
+  jmp_buf setjmp_buffer;
+};
+
+static void
+my_error_exit(j_common_ptr cinfo)
+{
+  struct my_error_mgr* my_err = (struct my_error_mgr*)cinfo->err;
+  (*cinfo->err->output_message)(cinfo);
+  longjmp(my_err->setjmp_buffer, 1);
+}
+
+/**
+ * @!visibility private
+ */
+static
+VALUE magro_io_read_jpg(VALUE self, VALUE filename_)
+{
+  char* filename = StringValuePtr(filename_);
+  FILE* file_ptr = fopen(filename, "rb");
+  struct jpeg_decompress_struct jpeg;
+  struct my_error_mgr err;
+  unsigned int width, height;
+  int n_colors;
+  size_t shape[3] = { 0 };
+  int n_dims;
+  unsigned int y;
+  VALUE nary;
+  uint8_t* nary_ptr;
+  JSAMPLE* tmp;
+
+  if (file_ptr == NULL) {
+    rb_raise(rb_eIOError, "Failed to open file '%s'", filename);
+    return Qnil;
+  }
+
+  jpeg.err = jpeg_std_error(&err.pub);
+  err.pub.error_exit = my_error_exit;
+  if (setjmp(err.setjmp_buffer)) {
+    rb_raise(rb_eIOError, "Error happened while reading file '%s'", filename);
+    return Qnil;
+  }
+
+  jpeg_create_decompress(&jpeg);
+  jpeg_stdio_src(&jpeg, file_ptr);
+  jpeg_read_header(&jpeg, TRUE);
+  jpeg_start_decompress(&jpeg);
+
+  width = jpeg.output_width;
+  height = jpeg.output_height;
+  n_colors = jpeg.out_color_components;
+
+  n_dims = n_colors == 1 ? 2 : 3;
+  shape[0] = height;
+  shape[1] = width;
+  shape[2] = n_colors;
+  nary = rb_narray_new(numo_cUInt8, n_dims, shape);
+  nary_ptr = (uint8_t*)na_get_pointer_for_write(nary);
+
+  for (y = 0; y < height; y++) {
+    tmp = nary_ptr + y * width * n_colors;
+    jpeg_read_scanlines(&jpeg, &tmp, 1);
+  }
+
+  fclose(file_ptr);
+  jpeg_finish_decompress(&jpeg);
+  jpeg_destroy_decompress(&jpeg);
+
+  return nary;
+}
+
+/**
+ * @!visibility private
+ */
+static
+VALUE magro_io_save_jpg(int argc, VALUE* argv, VALUE self)
+{
+  VALUE filename_;
+  VALUE image;
+  VALUE quality_;
+  char* filename;
+  FILE* file_ptr;
+  struct jpeg_compress_struct jpeg;
+  struct my_error_mgr err;
+  narray_t* image_nary;
+  int quality;
+  int n_dims, n_ch;
+  unsigned int width, height, y;
+  uint8_t* image_ptr;
+  JSAMPLE* tmp;
+
+  rb_scan_args(argc, argv, "21", &filename_, &image, &quality_);
+
+  if (NIL_P(quality_)) {
+    quality = 95;
+  } else {
+    quality = NUM2INT(quality_);
+  }
+
+  filename = StringValuePtr(filename_);
+
+  if (CLASS_OF(image) != numo_cUInt8) {
+    image = rb_funcall(numo_cUInt8, rb_intern("cast"), 1, image);
+  }
+  if (!RTEST(nary_check_contiguous(image))) {
+    image = nary_dup(image);
+  }
+
+  jpeg.err = jpeg_std_error(&err.pub);
+  err.pub.error_exit = my_error_exit;
+  if (setjmp(err.setjmp_buffer)) {
+    return Qfalse;
+  }
+
+  jpeg_create_compress(&jpeg);
+
+  file_ptr = fopen(filename, "wb");
+  if (file_ptr == NULL) {
+    rb_raise(rb_eIOError, "Failed to open file '%s'", filename);
+    jpeg_destroy_compress(&jpeg);
+    return Qfalse;
+  }
+
+  GetNArray(image, image_nary);
+  n_dims = NA_NDIM(image_nary);
+  height = (unsigned int)NA_SHAPE(image_nary)[0];
+  width = (unsigned int)NA_SHAPE(image_nary)[1];
+  image_ptr = (uint8_t*)na_get_pointer_for_read(image);
+
+  n_ch = 1;
+  if (n_dims == 3) {
+    n_ch = (int)NA_SHAPE(image_nary)[2];
+  }
+
+  jpeg_stdio_dest(&jpeg, file_ptr);
+
+  jpeg.image_height = height;
+  jpeg.image_width = width;
+  jpeg.input_components = n_ch;
+
+  switch (n_ch) {
+    case 3:
+      jpeg.in_color_space = JCS_RGB;
+      break;
+    case 1:
+      jpeg.in_color_space = JCS_GRAYSCALE;
+      break;
+    default:
+      jpeg.in_color_space = JCS_UNKNOWN;
+      break;
+  }
+
+  jpeg_set_defaults(&jpeg);
+
+  jpeg_set_quality(&jpeg, quality, TRUE);
+
+  jpeg_start_compress(&jpeg, TRUE);
+
+  for (y = 0; y < height; y++) {
+    tmp = image_ptr + y * width * n_ch;
+    jpeg_write_scanlines(&jpeg, &tmp, 1);
+  }
+
+  jpeg_finish_compress(&jpeg);
+  jpeg_destroy_compress(&jpeg);
+
+  fclose(file_ptr);
+
+  return Qtrue;
+}
+
+void init_io_module()
+{
+  VALUE mIO = rb_define_module_under(mMagro, "IO");
+  rb_define_module_function(mIO, "read_png", magro_io_read_png, 1);
+  rb_define_module_function(mIO, "save_png", magro_io_save_png, 2);
+  rb_define_module_function(mIO, "read_jpg", magro_io_read_jpg, 1);
+  rb_define_module_function(mIO, "save_jpg", magro_io_save_jpg, -1);
+}

data/ext/magro/io.h

@@ -0,0 +1,18 @@
+#ifndef MAGRO_IO_H
+#define MAGRO_IO_H 1
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <setjmp.h>
+#include <png.h>
+#include <jpeglib.h>
+
+#include <ruby.h>
+#include <numo/narray.h>
+#include <numo/template.h>
+
+void init_io_module();
+
+#endif /* MAGRO_IO_H */

data/ext/magro/magro.c

@@ -1,403 +1,10 @@
 #include "magro.h"
 
 VALUE mMagro;
-VALUE mIO;
-
-/**
- * @!visibility private
- */
-static
-VALUE magro_io_read_png(VALUE self, VALUE filename_)
-{
-  char* filename = StringValuePtr(filename_);
-  FILE* file_ptr = fopen(filename, "rb");
-  unsigned char header[8];
-  png_structp png_ptr;
-  png_infop info_ptr;
-  png_bytep* row_ptr_ptr;
-  png_bytep row_ptr;
-  png_uint_32 width, height;
-  int color_type;
-  int bit_depth;
-  png_uint_32 y;
-  int n_dims = 0;
-  int n_ch;
-  size_t shape[3] = { 0 };
-  VALUE nary;
-  uint8_t* nary_ptr;
-
-  if (file_ptr == NULL) {
-    return Qnil;
-  }
-
-  if (fread(header, 1, 8, file_ptr) < 8) {
-    fclose(file_ptr);
-    return Qnil;
-  }
-
-  if (png_sig_cmp(header, 0, 8)) {
-    fclose(file_ptr);
-    return Qnil;
-  }
-
-  png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
-  if (png_ptr == NULL) {
-    fclose(file_ptr);
-    return Qnil;
-  }
-  info_ptr = png_create_info_struct(png_ptr);
-  if (info_ptr == NULL) {
-    png_destroy_read_struct(&png_ptr, NULL, NULL);
-    fclose(file_ptr);
-    return Qnil;
-  }
-  if (setjmp(png_jmpbuf(png_ptr))) {
-    png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
-    fclose(file_ptr);
-    return Qnil;
-  }
-
-  png_init_io(png_ptr, file_ptr);
-  png_set_sig_bytes(png_ptr, 8);
-
-  png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_PACKING | PNG_TRANSFORM_EXPAND | PNG_TRANSFORM_STRIP_16, NULL);
-  row_ptr_ptr = png_get_rows(png_ptr, info_ptr);
-  png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, NULL, NULL, NULL);
-
-  if (color_type == PNG_COLOR_TYPE_PALETTE) {
-    png_set_palette_to_rgb(png_ptr);
-    png_read_update_info(png_ptr, info_ptr);
-    png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, NULL, NULL, NULL);
-  }
-
-  switch (color_type) {
-    case PNG_COLOR_TYPE_GRAY:
-      n_ch = 1;
-      n_dims = 2;
-      shape[0] = height;
-      shape[1] = width;
-      break;
-    case PNG_COLOR_TYPE_GRAY_ALPHA:
-      n_ch = 2;
-      n_dims = 3;
-      shape[0] = height;
-      shape[1] = width;
-      shape[2] = 2;
-      break;
-    case PNG_COLOR_TYPE_RGB:
-      n_ch = 3;
-      n_dims = 3;
-      shape[0] = height;
-      shape[1] = width;
-      shape[2] = 3;
-      break;
-    case PNG_COLOR_TYPE_RGB_ALPHA:
-      n_ch = 4;
-      n_dims = 3;
-      shape[0] = height;
-      shape[1] = width;
-      shape[2] = 4;
-      break;
-    default:
-      n_dims = 0;
-      break;
-  }
-
-  if (n_dims == 0) {
-    fclose(file_ptr);
-    png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
-    return Qnil;
-  }
-
-  nary = rb_narray_new(numo_cUInt8, n_dims, shape);
-  nary_ptr = (uint8_t*)na_get_pointer_for_write(nary);
-
-  for (y = 0; y < height; y++) {
-    row_ptr = row_ptr_ptr[y];
-    memcpy(nary_ptr + y * width * n_ch, row_ptr, width * n_ch);
-  }
-
-  fclose(file_ptr);
-  png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
-
-  return nary;
-}
-
-/**
- * @!visibility private
- */
-static
-VALUE magro_io_save_png(VALUE self, VALUE filename_, VALUE image)
-{
-  char* filename = StringValuePtr(filename_);
-  FILE* file_ptr = fopen(filename, "wb");
-  png_structp png_ptr;
-  png_infop info_ptr;
-  png_bytep* row_ptr_ptr;
-  png_uint_32 width, height;
-  int color_type;
-  int bit_depth = 8;
-  png_uint_32 y;
-  int n_ch;
-  int n_dims;
-  narray_t* image_nary;
-  uint8_t* image_ptr;
-
-  if (CLASS_OF(image) != numo_cUInt8) {
-    image = rb_funcall(numo_cUInt8, rb_intern("cast"), 1, image);
-  }
-  if (!RTEST(nary_check_contiguous(image))) {
-    image = nary_dup(image);
-  }
-
-  GetNArray(image, image_nary);
-  n_dims = NA_NDIM(image_nary);
-  height = (png_uint_32)NA_SHAPE(image_nary)[0];
-  width = (png_uint_32)NA_SHAPE(image_nary)[1];
-  image_ptr = (uint8_t*)na_get_pointer_for_read(image);
-
-  n_ch = 1;
-  if (n_dims == 3) {
-    n_ch = (int)NA_SHAPE(image_nary)[2];
-  }
-
-  switch (n_ch) {
-    case 4:
-      color_type = PNG_COLOR_TYPE_RGBA;
-      break;
-    case 3:
-      color_type = PNG_COLOR_TYPE_RGB;
-      break;
-    case 2:
-      color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
-      break;
-    default:
-      color_type = PNG_COLOR_TYPE_GRAY;
-      break;
-  }
-
-  if (file_ptr == NULL) {
-    return Qfalse;
-  }
-  png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
-  if (png_ptr == NULL) {
-    fclose(file_ptr);
-    return Qfalse;
-  }
-  info_ptr = png_create_info_struct(png_ptr);
-  if (info_ptr == NULL) {
-    png_destroy_read_struct(&png_ptr, NULL, NULL);
-    fclose(file_ptr);
-    return Qfalse;
-  }
-  if (setjmp(png_jmpbuf(png_ptr))) {
-    png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
-    fclose(file_ptr);
-    return Qfalse;
-  }
-
-  png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, color_type,
-    PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
-
-  row_ptr_ptr = png_malloc(png_ptr, height * sizeof(png_bytep));
-  for (y = 0; y < height; y++) {
-    row_ptr_ptr[y] = png_malloc(png_ptr, width * n_ch * sizeof(png_byte));
-    memcpy(row_ptr_ptr[y], image_ptr + y * width * n_ch, width * n_ch);
-  }
-
-  png_init_io(png_ptr, file_ptr);
-  png_set_rows(png_ptr, info_ptr, row_ptr_ptr);
-  png_write_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, NULL);
-
-  fclose(file_ptr);
-  for (y = 0; y < height; y++) {
-    png_free(png_ptr, row_ptr_ptr[y]);
-  }
-  png_free(png_ptr, row_ptr_ptr);
-  png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
-
-  return Qtrue;
-}
-
-struct my_error_mgr {
-  struct jpeg_error_mgr pub;
-  jmp_buf setjmp_buffer;
-};
-
-static void
-my_error_exit(j_common_ptr cinfo)
-{
-  struct my_error_mgr* my_err = (struct my_error_mgr*)cinfo->err;
-  (*cinfo->err->output_message)(cinfo);
-  longjmp(my_err->setjmp_buffer, 1);
-}
-
-/**
- * @!visibility private
- */
-static
-VALUE magro_io_read_jpg(VALUE self, VALUE filename_)
-{
-  char* filename = StringValuePtr(filename_);
-  FILE* file_ptr = fopen(filename, "rb");
-  struct jpeg_decompress_struct jpeg;
-  struct my_error_mgr err;
-  unsigned int width, height;
-  int n_colors;
-  size_t shape[3] = { 0 };
-  int n_dims;
-  unsigned int y;
-  VALUE nary;
-  uint8_t* nary_ptr;
-  JSAMPLE* tmp;
-
-
-  if (file_ptr == NULL) {
-    return Qnil;
-  }
-
-  jpeg.err = jpeg_std_error(&err.pub);
-  err.pub.error_exit = my_error_exit;
-  if (setjmp(err.setjmp_buffer)) {
-    return Qnil;
-  }
-
-  jpeg_create_decompress(&jpeg);
-  jpeg_stdio_src(&jpeg, file_ptr);
-  jpeg_read_header(&jpeg, TRUE);
-  jpeg_start_decompress(&jpeg);
-
-  width = jpeg.output_width;
-  height = jpeg.output_height;
-  n_colors = jpeg.out_color_components;
-
-  n_dims = n_colors == 1 ? 2 : 3;
-  shape[0] = height;
-  shape[1] = width;
-  shape[2] = n_colors;
-  nary = rb_narray_new(numo_cUInt8, n_dims, shape);
-  nary_ptr = (uint8_t*)na_get_pointer_for_write(nary);
-
-  for (y = 0; y < height; y++) {
-    tmp = nary_ptr + y * width * n_colors;
-    jpeg_read_scanlines(&jpeg, &tmp, 1);
-  }
-
-  fclose(file_ptr);
-  jpeg_finish_decompress(&jpeg);
-  jpeg_destroy_decompress(&jpeg);
-
-  return nary;
-}
-
-/**
- * @!visibility private
- */
-static
-VALUE magro_io_save_jpg(int argc, VALUE* argv, VALUE self)
-{
-  VALUE filename_;
-  VALUE image;
-  VALUE quality_;
-  char* filename;
-  FILE* file_ptr;
-  struct jpeg_compress_struct jpeg;
-  struct my_error_mgr err;
-  narray_t* image_nary;
-  int quality;
-  int n_dims, n_ch;
-  unsigned int width, height, y;
-  uint8_t* image_ptr;
-  JSAMPLE* tmp;
-
-  rb_scan_args(argc, argv, "21", &filename_, &image, &quality_);
-
-  if (NIL_P(quality_)) {
-    quality = 95;
-  } else {
-    quality = NUM2INT(quality_);
-  }
-
-  filename = StringValuePtr(filename_);
-
-  if (CLASS_OF(image) != numo_cUInt8) {
-    image = rb_funcall(numo_cUInt8, rb_intern("cast"), 1, image);
-  }
-  if (!RTEST(nary_check_contiguous(image))) {
-    image = nary_dup(image);
-  }
-
-  jpeg.err = jpeg_std_error(&err.pub);
-  err.pub.error_exit = my_error_exit;
-  if (setjmp(err.setjmp_buffer)) {
-    return Qfalse;
-  }
-
-  jpeg_create_compress(&jpeg);
-
-  file_ptr = fopen(filename, "wb");
-  if (file_ptr == NULL) {
-    jpeg_destroy_compress(&jpeg);
-    return Qfalse;
-  }
-
-  GetNArray(image, image_nary);
-  n_dims = NA_NDIM(image_nary);
-  height = (unsigned int)NA_SHAPE(image_nary)[0];
-  width = (unsigned int)NA_SHAPE(image_nary)[1];
-  image_ptr = (uint8_t*)na_get_pointer_for_read(image);
-
-  n_ch = 1;
-  if (n_dims == 3) {
-    n_ch = (int)NA_SHAPE(image_nary)[2];
-  }
-
-  jpeg_stdio_dest(&jpeg, file_ptr);
-
-  jpeg.image_height = height;
-  jpeg.image_width = width;
-  jpeg.input_components = n_ch;
-
-  switch (n_ch) {
-    case 3:
-      jpeg.in_color_space = JCS_RGB;
-      break;
-    case 1:
-      jpeg.in_color_space = JCS_GRAYSCALE;
-      break;
-    default:
-      jpeg.in_color_space = JCS_UNKNOWN;
-      break;
-  }
-
-  jpeg_set_defaults(&jpeg);
-
-  jpeg_set_quality(&jpeg, quality, TRUE);
-
-  jpeg_start_compress(&jpeg, TRUE);
-
-  for (y = 0; y < height; y++) {
-    tmp = image_ptr + y * width * n_ch;
-    jpeg_write_scanlines(&jpeg, &tmp, 1);
-  }
-
-  jpeg_finish_compress(&jpeg);
-  jpeg_destroy_compress(&jpeg);
-
-  fclose(file_ptr);
-
-  return Qtrue;
-}
 
 void Init_magro()
 {
-  rb_require("numo/narray");
-
   mMagro = rb_define_module("Magro");
 
-  mIO = rb_define_module_under(mMagro, "IO");
-  rb_define_module_function(mIO, "read_png", magro_io_read_png, 1);
-  rb_define_module_function(mIO, "save_png", magro_io_save_png, 2);
-  rb_define_module_function(mIO, "read_jpg", magro_io_read_jpg, 1);
-  rb_define_module_function(mIO, "save_jpg", magro_io_save_jpg, -1);
+  init_io_module();
 }

data/ext/magro/magro.h

@@ -1,15 +1,8 @@
 #ifndef MAGRO_H
 #define MAGRO_H 1
 
-#include <math.h>
-#include <string.h>
-
-#include <setjmp.h>
-#include <png.h>
-#include <jpeglib.h>
-
 #include <ruby.h>
-#include <numo/narray.h>
-#include <numo/template.h>
+
+#include "io.h"
 
 #endif /* MAGRO_H */

data/lib/magro/io.rb

@@ -9,6 +9,9 @@ module Magro
     # @param filename [String] Path to image file to be loaded.
     #   Currently, the following file formats are support:
     #   Portbale Network Graphics (*.png) and JPEG files (*.jpeg, *.jpg, *jpe).
+    # @raise [ArgumentError] This error is raised when filename is not String.
+    # @raise [IOError] This error is raised when failed to read image file.
+    # @raise [NoMemoryError] If memory allocation of image data fails, this error is raised.
     # @return [Numo::UInt8] (shape: [height, width, n_channels]) Loaded image.
     def imread(filename)
       raise ArgumentError, 'Expect class of filename to be String.' unless filename.is_a?(String)
@@ -22,6 +25,9 @@ module Magro
     #   Portbale Network Graphics (*.png) and JPEG files (*.jpeg, *.jpg, *jpe).
     # @param image [Numo::UInt8] (shape: [height, width, n_channels]) Image data to be saved.
     # @param quality [Integer] Quality parameter of jpeg image that takes a value between 0 to 100.
+    # @raise [ArgumentError] If filename is not String or image is not Numo::NArray, this error is raised.
+    # @raise [IOError] This error is raised when failed to read image file.
+    # @raise [NoMemoryError] If memory allocation of image data fails, this error is raised.
     # @return [Boolean] true if file save is successful.
     def imsave(filename, image, quality: nil)
       raise ArgumentError, 'Expect class of filename to be String.' unless filename.is_a?(String)

data/lib/magro/version.rb

@@ -3,5 +3,5 @@
 # Magro is an image processing library in Ruby.
 module Magro
   # The version of Magro you are using.
-  VERSION = '0.1.0'
+  VERSION = '0.1.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: magro
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - yoshoku
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-04 00:00:00.000000000 Z
+date: 2019-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -100,6 +100,8 @@ files:
 - bin/console
 - bin/setup
 - ext/magro/extconf.rb
+- ext/magro/io.c
+- ext/magro/io.h
 - ext/magro/magro.c
 - ext/magro/magro.h
 - lib/magro.rb