exif 1.0.1 → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 62ee375b5a2f547b733036b6d45e9f07f9157a7f
-  data.tar.gz: 1777637e0b478a47d4008a0953addbbc1b24f73b
+SHA256:
+  metadata.gz: 2c6e39047ca990d8de0501f004d20125f203f3dc709b8c82e63c41af05689169
+  data.tar.gz: 2f6328707424b868243624554e3909ac7957a1a1dd6fffdedef4dd98d3a20c77
 SHA512:
-  metadata.gz: 47983ae0fb7a3ad48c5b01d973da975c0d74bd1e50abb1db4ff310a4296b29c9ee435286c80a5280f45f804524f82e2f118bce0e8b0219f5674913206e09741d
-  data.tar.gz: f026ead2e3e8c67a13cec1093bba58c7c162d7c67e347c967362ee8c19fe992eba2a077ea91ccd3130004451a1b97d72742a05bc3dcc8a73861a762d91aec272
+  metadata.gz: 5f063d81c93f73a012450e09315aab85afe7c7ac2257d017fa91144f10fc7ea783e6bb3a74470f441b8a373841ac436e2a41ac7340c3bbc989f39f75b311cce0
+  data.tar.gz: 9632cc061012ed9234ce2f1193d72b71119d40b8a970f8e63004f1f0976de751de4bbf2d68c3752f5ba04eef27322c1a3bbe4de9809b2e8a0befbfbfa9d8a537

data/ext/exif/data.c

@@ -1,591 +1,374 @@
+#include "data.h"
+#include "ruby.h"
+
 #include <libexif/exif-data.h>
+#include <libexif/exif-loader.h>
+#include <libexif/exif-log.h>
+#include <stdint.h>
 #include <time.h>
-#include "data.h"
 
-extern VALUE rb_mExif;
-VALUE rb_cData;
-static VALUE IFD2SYM[5];
+extern VALUE rb_mExif, rb_eNotReadable, rb_eIFDNotFound;
+extern const char *exif_entry_to_ivar(ExifEntry *entry);
+
+VALUE rb_cExifData;
+static const char *ifd_name_mapping[] = {"ifd0", "ifd1", "exif", "gps",
+                                         "interoperability"};
+static const char *attr_readers[] = {"ifds",
+                                     "aperture_value",
+                                     "artist",
+                                     "battery_level",
+                                     "bits_per_sample",
+                                     "brightness_value",
+                                     "cfa_pattern",
+                                     "cfa_repeat_pattern_dim",
+                                     "color_space",
+                                     "components_configuration",
+                                     "compressed_bits_per_pixel",
+                                     "compression",
+                                     "contrast",
+                                     "copyright",
+                                     "custom_rendered",
+                                     "date_time",
+                                     "date_time_digitized",
+                                     "date_time_original",
+                                     "device_setting_description",
+                                     "digital_zoom_ratio",
+                                     "document_name",
+                                     "exif_ifd_pointer",
+                                     "exif_version",
+                                     "exposure_bias_value",
+                                     "exposure_index",
+                                     "exposure_mode",
+                                     "exposure_program",
+                                     "exposure_time",
+                                     "file_source",
+                                     "fill_order",
+                                     "flash",
+                                     "flash_energy",
+                                     "flash_pix_version",
+                                     "fnumber",
+                                     "focal_length",
+                                     "focal_length_in_35mm_film",
+                                     "focal_plane_resolution_unit",
+                                     "focal_plane_x_resolution",
+                                     "focal_plane_y_resolution",
+                                     "gain_control",
+                                     "gamma",
+                                     "gps_altitude",
+                                     "gps_altitude_ref",
+                                     "gps_area_information",
+                                     "gps_date_stamp",
+                                     "gps_dest_bearing",
+                                     "gps_dest_bearing_ref",
+                                     "gps_dest_distance",
+                                     "gps_dest_distance_ref",
+                                     "gps_dest_latitude",
+                                     "gps_dest_latitude_ref",
+                                     "gps_dest_longitude",
+                                     "gps_dest_longitude_ref",
+                                     "gps_differential",
+                                     "gps_dop",
+                                     "gps_img_direction",
+                                     "gps_img_direction_ref",
+                                     "gps_info_ifd_pointer",
+                                     "gps_latitude",
+                                     "gps_latitude_ref",
+                                     "gps_longitude",
+                                     "gps_longitude_ref",
+                                     "gps_map_datum",
+                                     "gps_measure_mode",
+                                     "gps_processing_method",
+                                     "gps_satellites",
+                                     "gps_speed",
+                                     "gps_speed_ref",
+                                     "gps_status",
+                                     "gps_time_stamp",
+                                     "gps_track",
+                                     "gps_track_ref",
+                                     "gps_version_id",
+                                     "image_description",
+                                     "image_length",
+                                     "image_resources",
+                                     "image_unique_id",
+                                     "image_width",
+                                     "inter_color_profile",
+                                     "interoperability_ifd_pointer",
+                                     "interoperability_index",
+                                     "interoperability_version",
+                                     "iptc_naa",
+                                     "iso_speed_ratings",
+                                     "jpeg_interchange_format",
+                                     "jpeg_interchange_format_length",
+                                     "jpeg_proc",
+                                     "light_source",
+                                     "make",
+                                     "maker_note",
+                                     "max_aperture_value",
+                                     "metering_mode",
+                                     "model",
+                                     "new_cfa_pattern",
+                                     "new_subfile_type",
+                                     "oecf",
+                                     "orientation",
+                                     "padding",
+                                     "photometric_interpretation",
+                                     "pixel_x_dimension",
+                                     "pixel_y_dimension",
+                                     "planar_configuration",
+                                     "primary_chromaticities",
+                                     "print_image_matching",
+                                     "reference_black_white",
+                                     "related_image_file_format",
+                                     "related_image_length",
+                                     "related_image_width",
+                                     "related_sound_file",
+                                     "resolution_unit",
+                                     "rows_per_strip",
+                                     "samples_per_pixel",
+                                     "saturation",
+                                     "scene_capture_type",
+                                     "scene_type",
+                                     "sensing_method",
+                                     "sharpness",
+                                     "shutter_speed_value",
+                                     "software",
+                                     "spatial_frequency_response",
+                                     "spectral_sensitivity",
+                                     "strip_byte_counts",
+                                     "strip_offsets",
+                                     "sub_ifds",
+                                     "sub_sec_time",
+                                     "sub_sec_time_digitized",
+                                     "sub_sec_time_original",
+                                     "subject_area",
+                                     "subject_distance",
+                                     "subject_distance_range",
+                                     "subject_location",
+                                     "tiff_ep_standard_id",
+                                     "time_zone_offset",
+                                     "transfer_function",
+                                     "transfer_range",
+                                     "user_comment",
+                                     "white_balance",
+                                     "white_point",
+                                     "x_resolution",
+                                     "xml_packet",
+                                     "xp_author",
+                                     "xp_comment",
+                                     "xp_keywords",
+                                     "xp_subject",
+                                     "xp_title",
+                                     "y_resolution",
+                                     "ycbcr_coefficients",
+                                     "ycbcr_positioning",
+                                     "ycbcr_sub_sampling"};
+
+static VALUE new (VALUE self, VALUE input);
+static VALUE dump(VALUE self);
+static VALUE brackets(VALUE self, VALUE ifd_symbol);
+static void each_content(ExifContent *ec, void *user_data);
+static void each_entry(ExifEntry *, void *user_data);
+static VALUE exif_entry_to_rb_value(ExifEntry *);
+static VALUE rational_to_num(ExifRational rational);
+static VALUE srational_to_num(ExifSRational srational);
+
+static void exif_corrupt_log_func(ExifLog *log, ExifLogCode code,
+                                  const char *domain, const char *format,
+                                  va_list args, void *data) {
+  if (code == EXIF_LOG_CODE_CORRUPT_DATA) {
+    unsigned int *corrupt = (unsigned int *)data;
+    *corrupt = 1;
+  }
+}
+
+void init_data() {
+  int length;
 
-void init_data(){
-  rb_cData = rb_define_class_under(rb_mExif, "Data", rb_cObject);
-  IFD2SYM[EXIF_IFD_0]                = INT2NUM(0);
-  IFD2SYM[EXIF_IFD_1]                = INT2NUM(1);
-  IFD2SYM[EXIF_IFD_EXIF]             = ID2SYM(rb_intern("exif"));
-  IFD2SYM[EXIF_IFD_GPS]              = ID2SYM(rb_intern("gps"));
-  IFD2SYM[EXIF_IFD_INTEROPERABILITY] = ID2SYM(rb_intern("interoperability"));
-  int length = sizeof(attrs) / sizeof(char*);
-  for(int i = 0; i < length; ++i) rb_define_attr(rb_cData, attrs[i], 1, 0);
-  rb_define_attr(rb_cData, "contents", 1, 0);
-  rb_define_alias(rb_cData, "to_h", "contents");
-  rb_define_singleton_method(rb_cData, "new", rb_new, 1);
-  rb_define_method(rb_cData, "dump", rb_dump, 0);
-  rb_define_method(rb_cData, "[]", rb_value, 1);
+  rb_cExifData = rb_define_class_under(rb_mExif, "Data", rb_cObject);
+  length = sizeof(attr_readers) / sizeof(char *);
+  for (int i = 0; i < length; ++i)
+    rb_define_attr(rb_cExifData, attr_readers[i], 1, 0);
+  rb_define_alias(rb_cExifData, "to_h", "ifds");
+  rb_define_singleton_method(rb_cExifData, "new", new, 1);
+  rb_define_method(rb_cExifData, "dump", dump, 0);
+  rb_define_method(rb_cExifData, "[]", brackets, 1);
 }
 
-VALUE rb_new(VALUE self, VALUE file_path){
-  Check_Type(file_path, T_STRING);
-  ExifData *ed = exif_data_new_from_file(StringValueCStr(file_path));
-  if(!ed) rb_raise(rb_eRuntimeError, "File not readable or no EXIF data in file.");
+VALUE new (VALUE self, VALUE input) {
+  ExifData *ed;
+
+  if (TYPE(input) != T_STRING && !rb_respond_to(input, rb_intern("read")))
+    rb_raise(rb_eTypeError, "wrong argument type %s (expected String or IO)",
+             rb_obj_classname(input));
+
+  if (TYPE(input) == T_STRING) {
+    unsigned int corrupt = 0;
+    ExifLog *log = exif_log_new();
+    exif_log_set_func(log, exif_corrupt_log_func, (void *)&corrupt);
+    ed = exif_data_new();
+    exif_data_log(ed, log);
+    exif_data_load_data(ed, (unsigned char *)RSTRING_PTR(input),
+                        (uint32_t)RSTRING_LEN(input));
+    exif_log_unref(log);
+    if (corrupt) {
+      exif_data_free(ed);
+      ed = NULL;
+    }
+  } else {
+    ExifLoader *loader = exif_loader_new();
+    VALUE buffer;
+    while (1) {
+      buffer = rb_funcall(input, rb_intern("read"), 1, INT2FIX(1024));
+      if (TYPE(buffer) == T_NIL)
+        break;
+      if (!exif_loader_write(loader, (unsigned char *)RSTRING_PTR(buffer),
+                             (uint32_t)RSTRING_LEN(buffer)))
+        break;
+    }
+    ed = exif_loader_get_data(loader);
+    exif_loader_unref(loader);
+  }
+  if (!ed)
+    rb_raise(rb_eNotReadable, "File not readable or no EXIF data in file.");
+
   VALUE rb_data = Data_Wrap_Struct(self, NULL, exif_data_free, ed);
-  rb_iv_set(rb_data, "@contents", rb_hash_new());
+  rb_iv_set(rb_data, "@ifds", rb_hash_new());
   exif_data_foreach_content(ed, each_content, &rb_data);
   return rb_data;
 }
 
-VALUE rb_dump(VALUE self){
+static VALUE dump(VALUE self) {
   ExifData *ed;
   Data_Get_Struct(self, ExifData, ed);
   exif_data_dump(ed);
   return Qnil;
 }
 
-VALUE rb_value(VALUE self, VALUE key){
-  VALUE rb_contents = rb_iv_get(self, "@contents");
-  return rb_hash_aref(rb_contents, key);
+static VALUE brackets(VALUE self, VALUE ifd_symbol) {
+  return rb_hash_aref(rb_iv_get(self, "@ifds"), ifd_symbol);
 }
 
-void each_content(ExifContent *ec, void *self_ptr){
-  VALUE *self = (VALUE*)self_ptr;
-  VALUE rb_contents = rb_iv_get(*self, "@contents");
-  Check_Type(rb_contents, T_HASH);
-  ExifIfd ifd = exif_content_get_ifd(ec);
-  VALUE ifd_name = IFD2SYM[ifd]; //rb_str_new_cstr(exif_ifd_get_name(ifd));
-  if(ifd == EXIF_IFD_COUNT) rb_raise(rb_eRuntimeError, "Con't get IFD.");
-  else rb_hash_aset(rb_contents, ifd_name, rb_hash_new());
-  exif_content_foreach_entry(ec, each_entry, self);
+static void each_content(ExifContent *ec, void *self_ptr) {
+  ExifIfd ifd;
+
+  ifd = exif_content_get_ifd(ec);
+  if (ifd == EXIF_IFD_COUNT)
+    rb_raise(rb_eIFDNotFound, "Con't get IFD.");
+  rb_hash_aset(rb_iv_get(*(VALUE *)self_ptr, "@ifds"),
+               ID2SYM(rb_intern(ifd_name_mapping[ifd])), rb_hash_new());
+  exif_content_foreach_entry(ec, each_entry, self_ptr);
 }
 
-void each_entry(ExifEntry *ee, void *self_ptr){
-  VALUE *self = (VALUE*)self_ptr;
-  VALUE rb_contents = rb_iv_get(*self, "@contents");
-  ExifIfd ifd = exif_entry_get_ifd(ee);
-  const char *attr_name = attr_string(ifd, ee->tag);
-  VALUE tag_name = ID2SYM(rb_intern(attr_name + 1));
-  char buf[500];
-  exif_entry_get_value(ee, buf, sizeof(buf));
+static void each_entry(ExifEntry *entry, void *self_ptr) {
   VALUE value;
-  switch(ee->format){
-  // case EXIF_FORMAT_BYTE:
-  //   break;
-  // case EXIF_FORMAT_ASCII:
-  //   break;
-  case EXIF_FORMAT_SHORT:
-    value = INT2NUM(atoi(buf));
-    break;
-  case EXIF_FORMAT_LONG:
-    value = INT2NUM(atol(buf));
-    break;
-  // case EXIF_FORMAT_RATIONAL:
-  //   break;
-  // case EXIF_FORMAT_SBYTE:
-  //   break;
-  // case EXIF_FORMAT_UNDEFINED:
-  //   break;
-  // case EXIF_FORMAT_SSHORT:
-  //   break;
-  // case EXIF_FORMAT_SLONG:
-  //   break;
-  // case EXIF_FORMAT_SRATIONAL:
-  //   break;
-  case EXIF_FORMAT_FLOAT:
-    value = rb_float_new(atof(buf));
-    break;
-  case EXIF_FORMAT_DOUBLE:
-    value = rb_float_new(atof(buf));
-    break;
-  default:
-    value = process_value(self, ifd, ee->tag, buf);
-  }
-  rb_hash_aset(rb_hash_aref(rb_contents, IFD2SYM[ifd]), tag_name, value);
-  rb_hash_aset(rb_contents, tag_name, value);
-  rb_iv_set(*self, attr_name, value);
-}
+  const char *ivar_name;
 
-VALUE process_value(VALUE *self_ptr, ExifIfd ifd, ExifTag tag, char *buf){
-  ExifData *ed;
-  Data_Get_Struct(*self_ptr, ExifData, ed);
-  switch((int)tag){
-  case EXIF_TAG_DATE_TIME:
-  case EXIF_TAG_DATE_TIME_ORIGINAL:
-  case EXIF_TAG_DATE_TIME_DIGITIZED:
-  {
-    struct tm timer;
-    // "2013:09:10 16:31:21"
-    buf[4] = buf[7] = buf[10] = buf[13] = buf[16] = '\0';
-    timer.tm_year = atoi(buf) - 1900;
-    timer.tm_mon  = atoi(buf + 5) - 1;
-    timer.tm_mday = atoi(buf + 8);
-    timer.tm_hour = atoi(buf + 11);
-    timer.tm_min  = atoi(buf + 14);
-    timer.tm_sec  = atoi(buf + 17);
-    return rb_time_new(mktime(&timer), 0);
-    break;
+  ivar_name = exif_entry_to_ivar(entry);
+  value = exif_entry_to_rb_value(entry);
+
+  if (ivar_name == 0x00) {
+    rb_warning("Unsupported tag %x", entry->tag);
+    return;
   }
-  case EXIF_TAG_GPS_LATITUDE:  // EXIF_TAG_INTEROPERABILITY_INDEX
-  case EXIF_TAG_GPS_LONGITUDE: // EXIF_TAG_INTEROPERABILITY_VERSION
-  {
-    if(ifd != EXIF_IFD_GPS) break;
-    char *l = buf, *r = buf + 1;
-    double degrees, minutes, seconds;
-    // "121, 30.7476,  0"
-    while(*r != ',') r++;
-    *r = '\0'; r++;
-    degrees = atof(l); l = r;
-    while(*r != ',') r++;
-    *r = '\0';
-    minutes = atof(l); l = r + 1;
-    seconds = atof(l);
-    ExifTag ref_tag = tag == EXIF_TAG_GPS_LATITUDE ? EXIF_TAG_GPS_LATITUDE_REF : EXIF_TAG_GPS_LONGITUDE_REF;
-    ExifEntry *entry = exif_content_get_entry(ed->ifd[EXIF_IFD_GPS], ref_tag);
-    char ref_value; exif_entry_get_value(entry, &ref_value, 1);
-    double degree = (degrees * 3600 + minutes * 60 + seconds) / 3600;
-    if(ref_value == 'S' || ref_value == 'W') degree *= -1;
-    return rb_float_new(degree);
-  }    
+
+  rb_hash_aset(rb_hash_aref(rb_iv_get(*(VALUE *)self_ptr, "@ifds"),
+                            ID2SYM(rb_intern(
+                                ifd_name_mapping[exif_entry_get_ifd(entry)]))),
+               ID2SYM(rb_intern(ivar_name + 1)), value);
+  if (TYPE(rb_ivar_defined(*(VALUE *)self_ptr, rb_intern(ivar_name))) ==
+      T_FALSE) {
+    rb_iv_set(*(VALUE *)self_ptr, ivar_name, value);
   }
-  return rb_str_new_cstr(buf);
 }
 
-const char* attr_string(ExifIfd ifd, ExifTag tag){
-  switch((int)tag){
-  case EXIF_TAG_INTEROPERABILITY_INDEX: /* EXIF_TAG_GPS_LATITUDE_REF */
-    return ifd == EXIF_IFD_GPS ? "@gps_latitude_ref" : "@interoperability_index";
-    break;
-  case EXIF_TAG_INTEROPERABILITY_VERSION: /* EXIF_TAG_GPS_LATITUDE */
-    return ifd == EXIF_IFD_GPS ? "@gps_latitude" : "@interoperability_version";
-    break;
-  case EXIF_TAG_NEW_SUBFILE_TYPE:
-    return "@new_subfile_type";
-    break;
-  case EXIF_TAG_IMAGE_WIDTH:
-    return "@image_width";
-    break;
-  case EXIF_TAG_IMAGE_LENGTH:
-    return "@image_length";
-    break;
-  case EXIF_TAG_BITS_PER_SAMPLE:
-    return "@bits_per_sample";
-    break;
-  case EXIF_TAG_COMPRESSION:
-    return "@compression";
-    break;
-  case EXIF_TAG_PHOTOMETRIC_INTERPRETATION:
-    return "@photometric_interpretation";
-    break;
-  case EXIF_TAG_FILL_ORDER:
-    return "@fill_order";
-    break;
-  case EXIF_TAG_DOCUMENT_NAME:
-    return "@document_name";
-    break;
-  case EXIF_TAG_IMAGE_DESCRIPTION:
-    return "@image_description";
-    break;
-  case EXIF_TAG_MAKE:
-    return "@make";
-    break;
-  case EXIF_TAG_MODEL:
-    return "@model";
-    break;
-  case EXIF_TAG_STRIP_OFFSETS:
-    return "@strip_offsets";
-    break;
-  case EXIF_TAG_ORIENTATION:
-    return "@orientation";
-    break;
-  case EXIF_TAG_SAMPLES_PER_PIXEL:
-    return "@samples_per_pixel";
-    break;
-  case EXIF_TAG_ROWS_PER_STRIP:
-    return "@rows_per_strip";
-    break;
-  case EXIF_TAG_STRIP_BYTE_COUNTS:
-    return "@strip_byte_counts";
-    break;
-  case EXIF_TAG_X_RESOLUTION:
-    return "@x_resolution";
-    break;
-  case EXIF_TAG_Y_RESOLUTION:
-    return "@y_resolution";
-    break;
-  case EXIF_TAG_PLANAR_CONFIGURATION:
-    return "@planar_configuration";
-    break;
-  case EXIF_TAG_RESOLUTION_UNIT:
-    return "@resolution_unit";
-    break;
-  case EXIF_TAG_TRANSFER_FUNCTION:
-    return "@transfer_function";
-    break;
-  case EXIF_TAG_SOFTWARE:
-    return "@software";
-    break;
-  case EXIF_TAG_DATE_TIME:
-    return "@date_time";
-    break;
-  case EXIF_TAG_ARTIST:
-    return "@artist";
-    break;
-  case EXIF_TAG_WHITE_POINT:
-    return "@white_point";
-    break;
-  case EXIF_TAG_PRIMARY_CHROMATICITIES:
-    return "@primary_chromaticities";
-    break;
-  case EXIF_TAG_SUB_IFDS:
-    return "@sub_ifds";
-    break;
-  case EXIF_TAG_TRANSFER_RANGE:
-    return "@transfer_range";
-    break;
-  case EXIF_TAG_JPEG_PROC:
-    return "@jpeg_proc";
-    break;
-  case EXIF_TAG_JPEG_INTERCHANGE_FORMAT:
-    return "@jpeg_interchange_format";
-    break;
-  case EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH:
-    return "@jpeg_interchange_format_length";
-    break;
-  case EXIF_TAG_YCBCR_COEFFICIENTS:
-    return "@ycbcr_coefficients";
-    break;
-  case EXIF_TAG_YCBCR_SUB_SAMPLING:
-    return "@ycbcr_sub_sampling";
-    break;
-  case EXIF_TAG_YCBCR_POSITIONING:
-    return "@ycbcr_positioning";
-    break;
-  case EXIF_TAG_REFERENCE_BLACK_WHITE:
-    return "@reference_black_white";
-    break;
-  case EXIF_TAG_XML_PACKET:
-    return "@xml_packet";
-    break;
-  case EXIF_TAG_RELATED_IMAGE_FILE_FORMAT:
-    return "@related_image_file_format";
-    break;
-  case EXIF_TAG_RELATED_IMAGE_WIDTH:
-    return "@related_image_width";
-    break;
-  case EXIF_TAG_RELATED_IMAGE_LENGTH:
-    return "@related_image_length";
-    break;
-  case EXIF_TAG_CFA_REPEAT_PATTERN_DIM:
-    return "@cfa_repeat_pattern_dim";
-    break;
-  case EXIF_TAG_CFA_PATTERN:
-    return "@cfa_pattern";
-    break;
-  case EXIF_TAG_BATTERY_LEVEL:
-    return "@battery_level";
-    break;
-  case EXIF_TAG_COPYRIGHT:
-    return "@copyright";
-    break;
-  case EXIF_TAG_EXPOSURE_TIME:
-    return "@exposure_time";
-    break;
-  case EXIF_TAG_FNUMBER:
-    return "@fnumber";
-    break;
-  case EXIF_TAG_IPTC_NAA:
-    return "@iptc_naa";
-    break;
-  case EXIF_TAG_IMAGE_RESOURCES:
-    return "@image_resources";
-    break;
-  case EXIF_TAG_EXIF_IFD_POINTER:
-    return "@exif_ifd_pointer";
-    break;
-  case EXIF_TAG_INTER_COLOR_PROFILE:
-    return "@inter_color_profile";
-    break;
-  case EXIF_TAG_EXPOSURE_PROGRAM:
-    return "@exposure_program";
-    break;
-  case EXIF_TAG_SPECTRAL_SENSITIVITY:
-    return "@spectral_sensitivity";
-    break;
-  case EXIF_TAG_GPS_INFO_IFD_POINTER:
-    return "@gps_info_ifd_pointer";
-    break;
-  case EXIF_TAG_ISO_SPEED_RATINGS:
-    return "@iso_speed_ratings";
-    break;
-  case EXIF_TAG_OECF:
-    return "@oecf";
-    break;
-  case EXIF_TAG_TIME_ZONE_OFFSET:
-    return "@time_zone_offset";
-    break;
-  case EXIF_TAG_EXIF_VERSION:
-    return "@exif_version";
-    break;
-  case EXIF_TAG_DATE_TIME_ORIGINAL:
-    return "@date_time_original";
-    break;
-  case EXIF_TAG_DATE_TIME_DIGITIZED:
-    return "@date_time_digitized";
-    break;
-  case EXIF_TAG_COMPONENTS_CONFIGURATION:
-    return "@components_configuration";
-    break;
-  case EXIF_TAG_COMPRESSED_BITS_PER_PIXEL:
-    return "@compressed_bits_per_pixel";
-    break;
-  case EXIF_TAG_SHUTTER_SPEED_VALUE:
-    return "@shutter_speed_value";
-    break;
-  case EXIF_TAG_APERTURE_VALUE:
-    return "@aperture_value";
-    break;
-  case EXIF_TAG_BRIGHTNESS_VALUE:
-    return "@brightness_value";
-    break;
-  case EXIF_TAG_EXPOSURE_BIAS_VALUE:
-    return "@exposure_bias_value";
-    break;
-  case EXIF_TAG_MAX_APERTURE_VALUE:
-    return "@max_aperture_value";
-    break;
-  case EXIF_TAG_SUBJECT_DISTANCE:
-    return "@subject_distance";
-    break;
-  case EXIF_TAG_METERING_MODE:
-    return "@metering_mode";
-    break;
-  case EXIF_TAG_LIGHT_SOURCE:
-    return "@light_source";
-    break;
-  case EXIF_TAG_FLASH:
-    return "@flash";
-    break;
-  case EXIF_TAG_FOCAL_LENGTH:
-    return "@focal_length";
-    break;
-  case EXIF_TAG_SUBJECT_AREA:
-    return "@subject_area";
-    break;
-  case EXIF_TAG_TIFF_EP_STANDARD_ID:
-    return "@tiff_ep_standard_id";
-    break;
-  case EXIF_TAG_MAKER_NOTE:
-    return "@maker_note";
-    break;
-  case EXIF_TAG_USER_COMMENT:
-    return "@user_comment";
-    break;
-  case EXIF_TAG_SUB_SEC_TIME:
-    return "@sub_sec_time";
-    break;
-  case EXIF_TAG_SUB_SEC_TIME_ORIGINAL:
-    return "@sub_sec_time_original";
-    break;
-  case EXIF_TAG_SUB_SEC_TIME_DIGITIZED:
-    return "@sub_sec_time_digitized";
-    break;
-  case EXIF_TAG_XP_TITLE:
-    return "@xp_title";
-    break;
-  case EXIF_TAG_XP_COMMENT:
-    return "@xp_comment";
-    break;
-  case EXIF_TAG_XP_AUTHOR:
-    return "@xp_author";
-    break;
-  case EXIF_TAG_XP_KEYWORDS:
-    return "@xp_keywords";
-    break;
-  case EXIF_TAG_XP_SUBJECT:
-    return "@xp_subject";
-    break;
-  case EXIF_TAG_FLASH_PIX_VERSION:
-    return "@flash_pix_version";
-    break;
-  case EXIF_TAG_COLOR_SPACE:
-    return "@color_space";
-    break;
-  case EXIF_TAG_PIXEL_X_DIMENSION:
-    return "@pixel_x_dimension";
-    break;
-  case EXIF_TAG_PIXEL_Y_DIMENSION:
-    return "@pixel_y_dimension";
-    break;
-  case EXIF_TAG_RELATED_SOUND_FILE:
-    return "@related_sound_file";
-    break;
-  case EXIF_TAG_INTEROPERABILITY_IFD_POINTER:
-    return "@interoperability_ifd_pointer";
-    break;
-  case EXIF_TAG_FLASH_ENERGY:
-    return "@flash_energy";
-    break;
-  case EXIF_TAG_SPATIAL_FREQUENCY_RESPONSE:
-    return "@spatial_frequency_response";
-    break;
-  case EXIF_TAG_FOCAL_PLANE_X_RESOLUTION:
-    return "@focal_plane_x_resolution";
-    break;
-  case EXIF_TAG_FOCAL_PLANE_Y_RESOLUTION:
-    return "@focal_plane_y_resolution";
-    break;
-  case EXIF_TAG_FOCAL_PLANE_RESOLUTION_UNIT:
-    return "@focal_plane_resolution_unit";
-    break;
-  case EXIF_TAG_SUBJECT_LOCATION:
-    return "@subject_location";
-    break;
-  case EXIF_TAG_EXPOSURE_INDEX:
-    return "@exposure_index";
-    break;
-  case EXIF_TAG_SENSING_METHOD:
-    return "@sensing_method";
-    break;
-  case EXIF_TAG_FILE_SOURCE:
-    return "@file_source";
-    break;
-  case EXIF_TAG_SCENE_TYPE:
-    return "@scene_type";
-    break;
-  case EXIF_TAG_NEW_CFA_PATTERN:
-    return "@new_cfa_pattern";
-    break;
-  case EXIF_TAG_CUSTOM_RENDERED:
-    return "@custom_rendered";
-    break;
-  case EXIF_TAG_EXPOSURE_MODE:
-    return "@exposure_mode";
-    break;
-  case EXIF_TAG_WHITE_BALANCE:
-    return "@white_balance";
-    break;
-  case EXIF_TAG_DIGITAL_ZOOM_RATIO:
-    return "@digital_zoom_ratio";
-    break;
-  case EXIF_TAG_FOCAL_LENGTH_IN_35MM_FILM:
-    return "@focal_length_in_35mm_film";
-    break;
-  case EXIF_TAG_SCENE_CAPTURE_TYPE:
-    return "@scene_capture_type";
-    break;
-  case EXIF_TAG_GAIN_CONTROL:
-    return "@gain_control";
-    break;
-  case EXIF_TAG_CONTRAST:
-    return "@contrast";
-    break;
-  case EXIF_TAG_SATURATION:
-    return "@saturation";
-    break;
-  case EXIF_TAG_SHARPNESS:
-    return "@sharpness";
-    break;
-  case EXIF_TAG_DEVICE_SETTING_DESCRIPTION:
-    return "@device_setting_description";
-    break;
-  case EXIF_TAG_SUBJECT_DISTANCE_RANGE:
-    return "@subject_distance_range";
-    break;
-  case EXIF_TAG_IMAGE_UNIQUE_ID:
-    return "@image_unique_id";
-    break;
-  case EXIF_TAG_GAMMA:
-    return "@gamma";
-    break;
-  case EXIF_TAG_PRINT_IMAGE_MATCHING:
-    return "@print_image_matching";
-    break;
-  case EXIF_TAG_PADDING:
-    return "@padding";
-    break;
-  case EXIF_TAG_GPS_VERSION_ID:
-    return "@gps_version_id";
-    break;
-  case EXIF_TAG_GPS_LONGITUDE_REF:
-    return "@gps_longitude_ref";
-    break;
-  case EXIF_TAG_GPS_LONGITUDE:
-    return "@gps_longitude";
-    break;
-  case EXIF_TAG_GPS_ALTITUDE_REF:
-    return "@gps_altitude_ref";
-    break;
-  case EXIF_TAG_GPS_ALTITUDE:
-    return "@gps_altitude";
-    break;
-  case EXIF_TAG_GPS_TIME_STAMP:
-    return "@gps_time_stamp";
-    break;
-  case EXIF_TAG_GPS_SATELLITES:
-    return "@gps_satellites";
-    break;
-  case EXIF_TAG_GPS_STATUS:
-    return "@gps_status";
-    break;
-  case EXIF_TAG_GPS_MEASURE_MODE:
-    return "@gps_measure_mode";
-    break;
-  case EXIF_TAG_GPS_DOP:
-    return "@gps_dop";
-    break;
-  case EXIF_TAG_GPS_SPEED_REF:
-    return "@gps_speed_ref";
-    break;
-  case EXIF_TAG_GPS_SPEED:
-    return "@gps_speed";
-    break;
-  case EXIF_TAG_GPS_TRACK_REF:
-    return "@gps_track_ref";
-    break;
-  case EXIF_TAG_GPS_TRACK:
-    return "@gps_track";
-    break;
-  case EXIF_TAG_GPS_IMG_DIRECTION_REF:
-    return "@gps_img_direction_ref";
-    break;
-  case EXIF_TAG_GPS_IMG_DIRECTION:
-    return "@gps_img_direction";
-    break;
-  case EXIF_TAG_GPS_MAP_DATUM:
-    return "@gps_map_datum";
-    break;
-  case EXIF_TAG_GPS_DEST_LATITUDE_REF:
-    return "@gps_dest_latitude_ref";
-    break;
-  case EXIF_TAG_GPS_DEST_LATITUDE:
-    return "@gps_dest_latitude";
-    break;
-  case EXIF_TAG_GPS_DEST_LONGITUDE_REF:
-    return "@gps_dest_longitude_ref";
+#define TYPECAST(value1, value2)                                               \
+  do {                                                                         \
+    if (entry->components > 1) {                                               \
+      ret = rb_ary_new2(entry->components);                                    \
+      for (i = 0; i < entry->components; i++)                                  \
+        rb_ary_push(ret, value1);                                              \
+    } else                                                                     \
+      ret = value2;                                                            \
+  } while (0)
+
+#define TYPECAST_BYTE(c_to_rb, type)                                           \
+  TYPECAST(c_to_rb((type)entry->data[i]), c_to_rb((type)entry->data[0]))
+
+#define TYPECAST_EXIF(c_to_rb, exif_get)                                       \
+  TYPECAST(c_to_rb(exif_get_##exif_get(entry->data + i * size, order)),        \
+           c_to_rb(exif_get_##exif_get(entry->data, order)))
+
+static VALUE exif_entry_to_rb_value(ExifEntry *entry) {
+  ExifData *data;
+  ExifByteOrder order;
+  VALUE ret;
+  size_t i;
+  unsigned char size;
+
+  data = entry->parent->parent;
+  order = exif_data_get_byte_order(data);
+  ret = Qnil;
+  size = exif_format_get_size(entry->format);
+
+  switch (entry->format) {
+  case EXIF_FORMAT_UNDEFINED:
+    ret = rb_str_new((const char *)entry->data, entry->size);
     break;
-  case EXIF_TAG_GPS_DEST_LONGITUDE:
-    return "@gps_dest_longitude";
+  case EXIF_FORMAT_BYTE:
+    TYPECAST_BYTE(INT2FIX, uint8_t);
+  case EXIF_FORMAT_SBYTE:
+    TYPECAST_BYTE(INT2FIX, int8_t);
     break;
-  case EXIF_TAG_GPS_DEST_BEARING_REF:
-    return "@gps_dest_bearing_ref";
+  case EXIF_FORMAT_SHORT:
+    TYPECAST_EXIF(INT2FIX, short);
     break;
-  case EXIF_TAG_GPS_DEST_BEARING:
-    return "@gps_dest_bearing";
+  case EXIF_FORMAT_SSHORT:
+    TYPECAST_EXIF(INT2FIX, sshort);
     break;
-  case EXIF_TAG_GPS_DEST_DISTANCE_REF:
-    return "@gps_dest_distance_ref";
+  case EXIF_FORMAT_LONG:
+    TYPECAST_EXIF(ULONG2NUM, long);
     break;
-  case EXIF_TAG_GPS_DEST_DISTANCE:
-    return "@gps_dest_distance";
+  case EXIF_FORMAT_SLONG:
+    TYPECAST_EXIF(LONG2NUM, slong);
     break;
-  case EXIF_TAG_GPS_PROCESSING_METHOD:
-    return "@gps_processing_method";
+  case EXIF_FORMAT_ASCII:
+    ret = rb_str_new2((const char *)entry->data);
     break;
-  case EXIF_TAG_GPS_AREA_INFORMATION:
-    return "@gps_area_information";
+  case EXIF_FORMAT_RATIONAL:
+    TYPECAST_EXIF(rational_to_num, rational);
     break;
-  case EXIF_TAG_GPS_DATE_STAMP:
-    return "@gps_date_stamp";
+  case EXIF_FORMAT_SRATIONAL:
+    TYPECAST_EXIF(srational_to_num, srational);
     break;
-  case EXIF_TAG_GPS_DIFFERENTIAL:
-    return "@gps_differential";
+  case EXIF_FORMAT_DOUBLE:
+  case EXIF_FORMAT_FLOAT:
+    ret = rb_float_new(*(double *)entry->data);
     break;
   }
-  return NULL;
-}
+
+  return ret;
+}
+
+#undef TYPECAST
+#undef TYPECAST_BYTE
+#undef TYPECAST_EXIF
+
+VALUE rational_to_num(ExifRational rational) {
+  if (rational.numerator == 0 && rational.denominator == 0)
+    return DBL2NUM(NAN);
+  else if (rational.denominator == 0)
+    return DBL2NUM(INFINITY);
+  else
+    return rb_rational_new(ULONG2NUM(rational.numerator),
+                           ULONG2NUM(rational.denominator));
+}
+
+VALUE srational_to_num(ExifSRational srational) {
+  if (srational.numerator == 0 && srational.denominator == 0)
+    return DBL2NUM(NAN);
+  else if (srational.denominator == 0)
+    return DBL2NUM(srational.numerator > 0 ? INFINITY : -INFINITY);
+  else
+    return rb_rational_new(LONG2NUM(srational.numerator),
+                           LONG2NUM(srational.denominator));
+}