imexif.c

   1 #include "imexif.h"
   2 #include <stdlib.h>
   3 #include <float.h>
   4
   5 /*
   6 =head1 NAME
   7
   8 imexif.c - EXIF support for Imager
   9
  10 =head1 SYNOPSIS
  11
  12   if (i_int_decode_exif(im, app1data, app1datasize)) {
  13     // exif block seen
  14   }
  15
  16 =head1 DESCRIPTION
  17
  18 This code provides a basic EXIF data decoder.  It is intended to be
  19 called from the JPEG reader code when an APP1 data block is found, and
  20 will set tags in the supplied image.
  21
  22 =cut
  23 */
  24
  25 typedef enum tiff_type_tag {
  26   tt_intel = 'I',
  27   tt_motorola = 'M'
  28 } tiff_type;
  29
  30 typedef enum {
  31   ift_byte = 1,
  32   ift_ascii = 2,
  33   ift_short = 3,
  34   ift_long = 4,
  35   ift_rational = 5,
  36   ift_sbyte = 6,
  37   ift_undefined = 7,
  38   ift_sshort = 8,
  39   ift_slong = 9,
  40   ift_srational = 10,
  41   ift_float = 11,
  42   ift_double = 12,
  43   ift_last = 12 /* keep the same as the highest type code */
  44 } ifd_entry_type;
  45
  46 static int type_sizes[] =
  47   {
  48     0, /* not used */
  49     1, /* byte */
  50     1, /* ascii */
  51     2, /* short */
  52     4, /* long */
  53     8, /* rational */
  54     1, /* sbyte */
  55     1, /* undefined */
  56     2, /* sshort */
  57     4, /* slong */
  58     8, /* srational */
  59     4, /* float */
  60     8, /* double */
  61   };
  62
  63 typedef struct {
  64   int tag;
  65   int type;
  66   int count;
  67   int item_size;
  68   int size;
  69   int offset;
  70 } ifd_entry;
  71
  72 typedef struct {
  73   int tag;
  74   char const *name;
  75 } tag_map;
  76
  77 typedef struct {
  78   int tag;
  79   char const *name;
  80   tag_map const *map;
  81   int map_count;
  82 } tag_value_map;
  83
  84 #define PASTE(left, right) PASTE_(left, right)
  85 #define PASTE_(left, right) left##right
  86 #define QUOTE(value) #value
  87
  88 #define VALUE_MAP_ENTRY(name) \
  89   { \
  90     PASTE(tag_, name), \
  91     "exif_" QUOTE(name) "_name", \
  92     PASTE(name, _values), \
  93     ARRAY_COUNT(PASTE(name, _values)) \
  94   }
  95
  96 /* we don't process every tag */
  97 #define tag_make 271
  98 #define tag_model 272
  99 #define tag_orientation 274
 100 #define tag_x_resolution 282
 101 #define tag_y_resolution 283
 102 #define tag_resolution_unit 296
 103 #define tag_copyright 33432
 104 #define tag_software 305
 105 #define tag_artist 315
 106 #define tag_date_time 306
 107 #define tag_image_description 270
 108
 109 #define tag_exif_ifd 34665
 110 #define tag_gps_ifd 34853
 111
 112 #define resunit_none 1
 113 #define resunit_inch 2
 114 #define resunit_centimeter 3
 115
 116 /* tags from the EXIF ifd */
 117 #define tag_exif_version 0x9000
 118 #define tag_flashpix_version 0xA000
 119 #define tag_color_space 0xA001
 120 #define tag_component_configuration 0x9101
 121 #define tag_component_bits_per_pixel 0x9102
 122 #define tag_pixel_x_dimension 0xA002
 123 #define tag_pixel_y_dimension 0xA003
 124 #define tag_maker_note 0x927C
 125 #define tag_user_comment 0x9286
 126 #define tag_related_sound_file 0xA004
 127 #define tag_date_time_original 0x9003
 128 #define tag_date_time_digitized 0x9004
 129 #define tag_sub_sec_time 0x9290
 130 #define tag_sub_sec_time_original 0x9291
 131 #define tag_sub_sec_time_digitized 0x9292
 132 #define tag_image_unique_id 0xA420
 133 #define tag_exposure_time 0x829a
 134 #define tag_f_number 0x829D
 135 #define tag_exposure_program 0x8822
 136 #define tag_spectral_sensitivity 0x8824
 137 #define tag_iso_speed_ratings 0x8827
 138 #define tag_oecf 0x8828
 139 #define tag_shutter_speed 0x9201
 140 #define tag_aperture 0x9202
 141 #define tag_brightness 0x9203
 142 #define tag_exposure_bias 0x9204
 143 #define tag_max_aperture 0x9205
 144 #define tag_subject_distance 0x9206
 145 #define tag_metering_mode 0x9207
 146 #define tag_light_source 0x9208
 147 #define tag_flash 0x9209
 148 #define tag_focal_length 0x920a
 149 #define tag_subject_area 0x9214
 150 #define tag_flash_energy 0xA20B
 151 #define tag_spatial_frequency_response 0xA20C
 152 #define tag_focal_plane_x_resolution 0xA20e
 153 #define tag_focal_plane_y_resolution 0xA20F
 154 #define tag_focal_plane_resolution_unit 0xA210
 155 #define tag_subject_location 0xA214
 156 #define tag_exposure_index 0xA215
 157 #define tag_sensing_method 0xA217
 158 #define tag_file_source 0xA300
 159 #define tag_scene_type 0xA301
 160 #define tag_cfa_pattern 0xA302
 161 #define tag_custom_rendered 0xA401
 162 #define tag_exposure_mode 0xA402
 163 #define tag_white_balance 0xA403
 164 #define tag_digital_zoom_ratio 0xA404
 165 #define tag_focal_length_in_35mm_film 0xA405
 166 #define tag_scene_capture_type 0xA406
 167 #define tag_gain_control 0xA407
 168 #define tag_contrast 0xA408
 169 #define tag_saturation 0xA409
 170 #define tag_sharpness 0xA40A
 171 #define tag_device_setting_description 0xA40B
 172 #define tag_subject_distance_range 0xA40C
 173
 174 /* GPS tags */
 175 #define tag_gps_version_id 0
 176 #define tag_gps_latitude_ref 1
 177 #define tag_gps_latitude 2
 178 #define tag_gps_longitude_ref 3
 179 #define tag_gps_longitude 4
 180 #define tag_gps_altitude_ref 5
 181 #define tag_gps_altitude 6
 182 #define tag_gps_time_stamp 7
 183 #define tag_gps_satellites 8
 184 #define tag_gps_status 9
 185 #define tag_gps_measure_mode 10
 186 #define tag_gps_dop 11
 187 #define tag_gps_speed_ref 12
 188 #define tag_gps_speed 13
 189 #define tag_gps_track_ref 14
 190 #define tag_gps_track 15
 191 #define tag_gps_img_direction_ref 16
 192 #define tag_gps_img_direction 17
 193 #define tag_gps_map_datum 18
 194 #define tag_gps_dest_latitude_ref 19
 195 #define tag_gps_dest_latitude 20
 196 #define tag_gps_dest_longitude_ref 21
 197 #define tag_gps_dest_longitude 22
 198 #define tag_gps_dest_bearing_ref 23
 199 #define tag_gps_dest_bearing 24
 200 #define tag_gps_dest_distance_ref 25
 201 #define tag_gps_dest_distance 26
 202 #define tag_gps_processing_method 27
 203 #define tag_gps_area_information 28
 204 #define tag_gps_date_stamp 29
 205 #define tag_gps_differential 30
 206
 207 /* don't use this on pointers */
 208 #define ARRAY_COUNT(array) (sizeof(array)/sizeof(*array))
 209
 210 /* in memory tiff structure */
 211 typedef struct {
 212   /* the data we use as a tiff */
 213   unsigned char *base;
 214   size_t size;
 215
 216   /* intel or motorola byte order */
 217   tiff_type type;
 218
 219   /* initial ifd offset */
 220   unsigned long first_ifd_offset;
 221
 222   /* size (in entries) and data */
 223   int ifd_size;
 224   ifd_entry *ifd;
 225   unsigned long next_ifd;
 226 } imtiff;
 227
 228 static int tiff_init(imtiff *tiff, unsigned char *base, size_t length);
 229 static int tiff_load_ifd(imtiff *tiff, unsigned long offset);
 230 static void tiff_final(imtiff *tiff);
 231 static void tiff_clear_ifd(imtiff *tiff);
 232 #if 0 /* currently unused, but that may change */
 233 static int tiff_get_bytes(imtiff *tiff, unsigned char *to, size_t offset,
 234                           size_t count);
 235 #endif
 236 static int tiff_get_tag_double(imtiff *, int index, double *result);
 237 static int tiff_get_tag_int(imtiff *, int index, int *result);
 238 static unsigned tiff_get16(imtiff *, unsigned long offset);
 239 static unsigned tiff_get32(imtiff *, unsigned long offset);
 240 static int tiff_get16s(imtiff *, unsigned long offset);
 241 static int tiff_get32s(imtiff *, unsigned long offset);
 242 static double tiff_get_rat(imtiff *, unsigned long offset);
 243 static double tiff_get_rats(imtiff *, unsigned long offset);
 244 static void save_ifd0_tags(i_img *im, imtiff *tiff, unsigned long *exif_ifd_offset, unsigned long *gps_ifd_offset);
 245 static void save_exif_ifd_tags(i_img *im, imtiff *tiff);
 246 static void save_gps_ifd_tags(i_img *im, imtiff *tiff);
 247 static void
 248 copy_string_tags(i_img *im, imtiff *tiff, tag_map *map, int map_count);
 249 static void
 250 copy_int_tags(i_img *im, imtiff *tiff, tag_map *map, int map_count);
 251 static void
 252 copy_rat_tags(i_img *im, imtiff *tiff, tag_map *map, int map_count);
 253 static void
 254 copy_num_array_tags(i_img *im, imtiff *tiff, tag_map *map, int map_count);
 255 static void
 256 copy_name_tags(i_img *im, imtiff *tiff, tag_value_map *map, int map_count);
 257 static void process_maker_note(i_img *im, imtiff *tiff, unsigned long offset, size_t size);
 258
 259 /*
 260 =head1 PUBLIC FUNCTIONS
 261
 262 These functions are available to other parts of Imager.  They aren't
 263 intended to be called from outside of Imager.
 264
 265 =over
 266
 267 =item i_int_decode_exit
 268
 269 i_int_decode_exif(im, data_base, data_size);
 270
 271 The data from data_base for data_size bytes will be scanned for EXIF
 272 data.
 273
 274 Any data found will be used to set tags in the supplied image.
 275
 276 The intent is that invalid EXIF data will simply fail to set tags, and
 277 write to the log.  In no case should this code exit when supplied
 278 invalid data.
 279
 280 Returns true if an Exif header was seen.
 281
 282 */
 283
 284 int
 285 i_int_decode_exif(i_img *im, unsigned char *data, size_t length) {
 286   imtiff tiff;
 287   unsigned long exif_ifd_offset = 0;
 288   unsigned long gps_ifd_offset = 0;
 289   /* basic checks - must start with "Exif\0\0" */
 290
 291   if (length < 6 || memcmp(data, "Exif\0\0", 6) != 0) {
 292     return 0;
 293   }
 294
 295   data += 6;
 296   length -= 6;
 297
 298   if (!tiff_init(&tiff, data, length)) {
 299     mm_log((2, "Exif header found, but no valid TIFF header\n"));
 300     return 1;
 301   }
 302   if (!tiff_load_ifd(&tiff, tiff.first_ifd_offset)) {
 303     mm_log((2, "Exif header found, but could not load IFD 0\n"));
 304     tiff_final(&tiff);
 305     return 1;
 306   }
 307
 308   save_ifd0_tags(im, &tiff, &exif_ifd_offset, &gps_ifd_offset);
 309
 310   if (exif_ifd_offset) {
 311     if (tiff_load_ifd(&tiff, exif_ifd_offset)) {
 312       save_exif_ifd_tags(im, &tiff);
 313     }
 314     else {
 315       mm_log((2, "Could not load Exif IFD\n"));
 316     }
 317   }
 318
 319   if (gps_ifd_offset) {
 320     if (tiff_load_ifd(&tiff, gps_ifd_offset)) {
 321       save_gps_ifd_tags(im, &tiff);
 322     }
 323     else {
 324       mm_log((2, "Could not load GPS IFD\n"));
 325     }
 326   }
 327
 328   tiff_final(&tiff);
 329
 330   return 1;
 331 }
 332
 333 /*
 334
 335 =back
 336
 337 =head1 INTERNAL FUNCTIONS
 338
 339 =head2 EXIF Processing
 340
 341 =over
 342
 343 =item save_ifd0_tags
 344
 345 save_ifd0_tags(im, tiff, &exif_ifd_offset, &gps_ifd_offset)
 346
 347 Scans the currently loaded IFD for tags expected in IFD0 and sets them
 348 in the image.
 349
 350 Sets *exif_ifd_offset to the offset of the EXIF IFD if found.
 351
 352 =cut
 353
 354 */
 355
 356 static tag_map ifd0_string_tags[] =
 357   {
 358     { tag_make, "exif_make" },
 359     { tag_model, "exif_model" },
 360     { tag_copyright, "exif_copyright" },
 361     { tag_software, "exif_software" },
 362     { tag_artist, "exif_artist" },
 363     { tag_date_time, "exif_date_time" },
 364     { tag_image_description, "exif_image_description" },
 365   };
 366
 367 static const int ifd0_string_tag_count = ARRAY_COUNT(ifd0_string_tags);
 368
 369 static tag_map ifd0_int_tags[] =
 370   {
 371     { tag_orientation, "exif_orientation", },
 372     { tag_resolution_unit, "exif_resolution_unit" },
 373   };
 374
 375 static const int ifd0_int_tag_count = ARRAY_COUNT(ifd0_int_tags);
 376
 377 static tag_map ifd0_rat_tags[] =
 378   {
 379     { tag_x_resolution, "exif_x_resolution" },
 380     { tag_y_resolution, "exif_y_resolution" },
 381   };
 382
 383 static tag_map resolution_unit_values[] =
 384   {
 385     { 1, "none" },
 386     { 2, "inches" },
 387     { 3, "centimeters" },
 388   };
 389
 390 static tag_value_map ifd0_values[] =
 391   {
 392     VALUE_MAP_ENTRY(resolution_unit),
 393   };
 394
 395 static void
 396 save_ifd0_tags(i_img *im, imtiff *tiff, unsigned long *exif_ifd_offset,
 397                unsigned long *gps_ifd_offset) {
 398   int tag_index;
 399   int work;
 400   ifd_entry *entry;
 401
 402   for (tag_index = 0, entry = tiff->ifd;
 403        tag_index < tiff->ifd_size; ++tag_index, ++entry) {
 404     switch (entry->tag) {
 405     case tag_exif_ifd:
 406       if (tiff_get_tag_int(tiff, tag_index, &work))
 407         *exif_ifd_offset = work;
 408       break;
 409
 410     case tag_gps_ifd:
 411       if (tiff_get_tag_int(tiff, tag_index, &work))
 412         *gps_ifd_offset = work;
 413       break;
 414     }
 415   }
 416
 417   copy_string_tags(im, tiff, ifd0_string_tags, ifd0_string_tag_count);
 418   copy_int_tags(im, tiff, ifd0_int_tags, ifd0_int_tag_count);
 419   copy_rat_tags(im, tiff, ifd0_rat_tags, ARRAY_COUNT(ifd0_rat_tags));
 420   copy_name_tags(im, tiff, ifd0_values, ARRAY_COUNT(ifd0_values));
 421   /* copy_num_array_tags(im, tiff, ifd0_num_arrays, ARRAY_COUNT(ifd0_num_arrays)); */
 422 }
 423
 424 /*
 425 =item save_exif_ifd_tags
 426
 427 save_exif_ifd_tags(im, tiff)
 428
 429 Scans the currently loaded IFD for the tags expected in the EXIF IFD
 430 and sets them as tags in the image.
 431
 432 =cut
 433
 434 */
 435
 436 static tag_map exif_ifd_string_tags[] =
 437   {
 438     { tag_exif_version, "exif_version", },
 439     { tag_flashpix_version, "exif_flashpix_version", },
 440     { tag_related_sound_file, "exif_related_sound_file", },
 441     { tag_date_time_original, "exif_date_time_original", },
 442     { tag_date_time_digitized, "exif_date_time_digitized", },
 443     { tag_sub_sec_time, "exif_sub_sec_time" },
 444     { tag_sub_sec_time_original, "exif_sub_sec_time_original" },
 445     { tag_sub_sec_time_digitized, "exif_sub_sec_time_digitized" },
 446     { tag_image_unique_id, "exif_image_unique_id" },
 447     { tag_spectral_sensitivity, "exif_spectral_sensitivity" },
 448   };
 449
 450 static const int exif_ifd_string_tag_count = ARRAY_COUNT(exif_ifd_string_tags);
 451
 452 static tag_map exif_ifd_int_tags[] =
 453   {
 454     { tag_color_space, "exif_color_space" },
 455     { tag_exposure_program, "exif_exposure_program" },
 456     { tag_metering_mode, "exif_metering_mode" },
 457     { tag_light_source, "exif_light_source" },
 458     { tag_flash, "exif_flash" },
 459     { tag_focal_plane_resolution_unit, "exif_focal_plane_resolution_unit" },
 460     { tag_subject_location, "exif_subject_location" },
 461     { tag_sensing_method, "exif_sensing_method" },
 462     { tag_custom_rendered, "exif_custom_rendered" },
 463     { tag_exposure_mode, "exif_exposure_mode" },
 464     { tag_white_balance, "exif_white_balance" },
 465     { tag_focal_length_in_35mm_film, "exif_focal_length_in_35mm_film" },
 466     { tag_scene_capture_type, "exif_scene_capture_type" },
 467     { tag_contrast, "exif_contrast" },
 468     { tag_saturation, "exif_saturation" },
 469     { tag_sharpness, "exif_sharpness" },
 470     { tag_subject_distance_range, "exif_subject_distance_range" },
 471   };
 472
 473
 474 static const int exif_ifd_int_tag_count = ARRAY_COUNT(exif_ifd_int_tags);
 475
 476 static tag_map exif_ifd_rat_tags[] =
 477   {
 478     { tag_exposure_time, "exif_exposure_time" },
 479     { tag_f_number, "exif_f_number" },
 480     { tag_shutter_speed, "exif_shutter_speed" },
 481     { tag_aperture, "exif_aperture" },
 482     { tag_brightness, "exif_brightness" },
 483     { tag_exposure_bias, "exif_exposure_bias" },
 484     { tag_max_aperture, "exif_max_aperture" },
 485     { tag_subject_distance, "exif_subject_distance" },
 486     { tag_focal_length, "exif_focal_length" },
 487     { tag_flash_energy, "exif_flash_energy" },
 488     { tag_focal_plane_x_resolution, "exif_focal_plane_x_resolution" },
 489     { tag_focal_plane_y_resolution, "exif_focal_plane_y_resolution" },
 490     { tag_exposure_index, "exif_exposure_index" },
 491     { tag_digital_zoom_ratio, "exif_digital_zoom_ratio" },
 492     { tag_gain_control, "exif_gain_control" },
 493   };
 494
 495 static const int exif_ifd_rat_tag_count = ARRAY_COUNT(exif_ifd_rat_tags);
 496
 497 static tag_map exposure_mode_values[] =
 498   {
 499     { 0, "Auto exposure" },
 500     { 1, "Manual exposure" },
 501     { 2, "Auto bracket" },
 502   };
 503 static tag_map color_space_values[] =
 504   {
 505     { 1, "sRGB" },
 506     { 0xFFFF, "Uncalibrated" },
 507   };
 508
 509 static tag_map exposure_program_values[] =
 510   {
 511     { 0, "Not defined" },
 512     { 1, "Manual" },
 513     { 2, "Normal program" },
 514     { 3, "Aperture priority" },
 515     { 4, "Shutter priority" },
 516     { 5, "Creative program" },
 517     { 6, "Action program" },
 518     { 7, "Portrait mode" },
 519     { 8, "Landscape mode" },
 520   };
 521
 522 static tag_map metering_mode_values[] =
 523   {
 524     { 0, "unknown" },
 525     { 1, "Average" },
 526     { 2, "CenterWeightedAverage" },
 527     { 3, "Spot" },
 528     { 4, "MultiSpot" },
 529     { 5, "Pattern" },
 530     { 6, "Partial" },
 531     { 255, "other" },
 532   };
 533
 534 static tag_map light_source_values[] =
 535   {
 536     { 0, "unknown" },
 537     { 1, "Daylight" },
 538     { 2, "Fluorescent" },
 539     { 3, "Tungsten (incandescent light)" },
 540     { 4, "Flash" },
 541     { 9, "Fine weather" },
 542     { 10, "Cloudy weather" },
 543     { 11, "Shade" },
 544     { 12, "Daylight fluorescent (D 5700 Ã 7100K)" },
 545     { 13, "Day white fluorescent (N 4600 Ã 5400K)" },
 546     { 14, "Cool white fluorescent (W 3900 Ã 4500K)" },
 547     { 15, "White fluorescent (WW 3200 Ã 3700K)" },
 548     { 17, "Standard light A" },
 549     { 18, "Standard light B" },
 550     { 19, "Standard light C" },
 551     { 20, "D55" },
 552     { 21, "D65" },
 553     { 22, "D75" },
 554     { 23, "D50" },
 555     { 24, "ISO studio tungsten" },
 556     { 255, "other light source" },
 557   };
 558
 559 static tag_map flash_values[] =
 560   {
 561     { 0x0000, "Flash did not fire." },
 562     { 0x0001, "Flash fired." },
 563     { 0x0005, "Strobe return light not detected." },
 564     { 0x0007, "Strobe return light detected." },
 565     { 0x0009, "Flash fired, compulsory flash mode" },
 566     { 0x000D, "Flash fired, compulsory flash mode, return light not detected" },
 567     { 0x000F, "Flash fired, compulsory flash mode, return light detected" },
 568     { 0x0010, "Flash did not fire, compulsory flash mode" },
 569     { 0x0018, "Flash did not fire, auto mode" },
 570     { 0x0019, "Flash fired, auto mode" },
 571     { 0x001D, "Flash fired, auto mode, return light not detected" },
 572     { 0x001F, "Flash fired, auto mode, return light detected" },
 573     { 0x0020, "No flash function" },
 574     { 0x0041, "Flash fired, red-eye reduction mode" },
 575     { 0x0045, "Flash fired, red-eye reduction mode, return light not detected" },
 576     { 0x0047, "Flash fired, red-eye reduction mode, return light detected" },
 577     { 0x0049, "Flash fired, compulsory flash mode, red-eye reduction mode" },
 578     { 0x004D, "Flash fired, compulsory flash mode, red-eye reduction mode, return light not detected" },
 579     { 0x004F, "Flash fired, compulsory flash mode, red-eye reduction mode, return light detected" },
 580     { 0x0059, "Flash fired, auto mode, red-eye reduction mode" },
 581     { 0x005D, "Flash fired, auto mode, return light not detected, red-eye reduction mode" },
 582     { 0x005F, "Flash fired, auto mode, return light detected, red-eye reduction mode" },
 583   };
 584
 585 static tag_map sensing_method_values[] =
 586   {
 587     { 1, "Not defined" },
 588     { 2, "One-chip color area sensor" },
 589     { 3, "Two-chip color area sensor" },
 590     { 4, "Three-chip color area sensor" },
 591     { 5, "Color sequential area sensor" },
 592     { 7, "Trilinear sensor" },
 593     { 8, "Color sequential linear sensor" },
 594   };
 595
 596 static tag_map custom_rendered_values[] =
 597   {
 598     { 0, "Normal process" },
 599     { 1, "Custom process" },
 600   };
 601
 602 static tag_map white_balance_values[] =
 603   {
 604     { 0, "Auto white balance" },
 605     { 1, "Manual white balance" },
 606   };
 607
 608 static tag_map scene_capture_type_values[] =
 609   {
 610     { 0, "Standard" },
 611     { 1, "Landscape" },
 612     { 2, "Portrait" },
 613     { 3, "Night scene" },
 614   };
 615
 616 static tag_map gain_control_values[] =
 617   {
 618     { 0, "None" },
 619     { 1, "Low gain up" },
 620     { 2, "High gain up" },
 621     { 3, "Low gain down" },
 622     { 4, "High gain down" },
 623   };
 624
 625 static tag_map contrast_values[] =
 626   {
 627     { 0, "Normal" },
 628     { 1, "Soft" },
 629     { 2, "Hard" },
 630   };
 631
 632 static tag_map saturation_values[] =
 633   {
 634     { 0, "Normal" },
 635     { 1, "Low saturation" },
 636     { 2, "High saturation" },
 637   };
 638
 639 static tag_map sharpness_values[] =
 640   {
 641     { 0, "Normal" },
 642     { 1, "Soft" },
 643     { 2, "Hard" },
 644   };
 645
 646 static tag_map subject_distance_range_values[] =
 647   {
 648     { 0, "unknown" },
 649     { 1, "Macro" },
 650     { 2, "Close view" },
 651     { 3, "Distant view" },
 652   };
 653
 654 #define focal_plane_resolution_unit_values resolution_unit_values
 655
 656 static tag_value_map exif_ifd_values[] =
 657   {
 658     VALUE_MAP_ENTRY(exposure_mode),
 659     VALUE_MAP_ENTRY(color_space),
 660     VALUE_MAP_ENTRY(exposure_program),
 661     VALUE_MAP_ENTRY(metering_mode),
 662     VALUE_MAP_ENTRY(light_source),
 663     VALUE_MAP_ENTRY(flash),
 664     VALUE_MAP_ENTRY(sensing_method),
 665     VALUE_MAP_ENTRY(custom_rendered),
 666     VALUE_MAP_ENTRY(white_balance),
 667     VALUE_MAP_ENTRY(scene_capture_type),
 668     VALUE_MAP_ENTRY(gain_control),
 669     VALUE_MAP_ENTRY(contrast),
 670     VALUE_MAP_ENTRY(saturation),
 671     VALUE_MAP_ENTRY(sharpness),
 672     VALUE_MAP_ENTRY(subject_distance_range),
 673     VALUE_MAP_ENTRY(focal_plane_resolution_unit),
 674   };
 675
 676 static tag_map exif_num_arrays[] =
 677   {
 678     { tag_iso_speed_ratings, "exif_iso_speed_ratings" },
 679     { tag_subject_area, "exif_subject_area" },
 680     { tag_subject_location, "exif_subject_location" },
 681   };
 682
 683 static void
 684 save_exif_ifd_tags(i_img *im, imtiff *tiff) {
 685   int i, tag_index;
 686   ifd_entry *entry;
 687   char *user_comment;
 688   unsigned long maker_note_offset = 0;
 689   size_t maker_note_size = 0;
 690
 691   for (tag_index = 0, entry = tiff->ifd;
 692        tag_index < tiff->ifd_size; ++tag_index, ++entry) {
 693     switch (entry->tag) {
 694     case tag_user_comment:
 695       /* I don't want to trash the source, so work on a copy */
 696       user_comment = mymalloc(entry->size);
 697       memcpy(user_comment, tiff->base + entry->offset, entry->size);
 698       /* the first 8 bytes indicate the encoding, make them into spaces
 699          for better presentation */
 700       for (i = 0; i < entry->size && i < 8; ++i) {
 701         if (user_comment[i] == '\0')
 702           user_comment[i] = ' ';
 703       }
 704       /* find the actual end of the string */
 705       while (i < entry->size && user_comment[i])
 706         ++i;
 707       i_tags_add(&im->tags, "exif_user_comment", 0, user_comment, i, 0);
 708       myfree(user_comment);
 709       break;
 710
 711     case tag_maker_note:
 712       maker_note_offset = entry->offset;
 713       maker_note_size = entry->size;
 714       break;
 715
 716       /* the following aren't processed yet */
 717     case tag_oecf:
 718     case tag_spatial_frequency_response:
 719     case tag_file_source:
 720     case tag_scene_type:
 721     case tag_cfa_pattern:
 722     case tag_device_setting_description:
 723     case tag_subject_area:
 724       break;
 725     }
 726   }
 727
 728   copy_string_tags(im, tiff, exif_ifd_string_tags, exif_ifd_string_tag_count);
 729   copy_int_tags(im, tiff, exif_ifd_int_tags, exif_ifd_int_tag_count);
 730   copy_rat_tags(im, tiff, exif_ifd_rat_tags, exif_ifd_rat_tag_count);
 731   copy_name_tags(im, tiff, exif_ifd_values, ARRAY_COUNT(exif_ifd_values));
 732   copy_num_array_tags(im, tiff, exif_num_arrays, ARRAY_COUNT(exif_num_arrays));
 733
 734   /* This trashes the IFD - make sure it's done last */
 735   if (maker_note_offset) {
 736     process_maker_note(im, tiff, maker_note_offset, maker_note_size);
 737   }
 738 }
 739
 740 static tag_map gps_ifd_string_tags[] =
 741   {
 742     { tag_gps_version_id, "exif_gps_version_id" },
 743     { tag_gps_latitude_ref, "exif_gps_latitude_ref" },
 744     { tag_gps_longitude_ref, "exif_gps_longitude_ref" },
 745     { tag_gps_altitude_ref, "exif_gps_altitude_ref" },
 746     { tag_gps_satellites, "exif_gps_satellites" },
 747     { tag_gps_status, "exif_gps_status" },
 748     { tag_gps_measure_mode, "exif_gps_measure_mode" },
 749     { tag_gps_speed_ref, "exif_gps_speed_ref" },
 750     { tag_gps_track_ref, "exif_gps_track_ref" },
 751   };
 752
 753 static tag_map gps_ifd_int_tags[] =
 754   {
 755     { tag_gps_differential, "exif_gps_differential" },
 756   };
 757
 758 static tag_map gps_ifd_rat_tags[] =
 759   {
 760     { tag_gps_altitude, "exif_gps_altitude" },
 761     { tag_gps_time_stamp, "exif_gps_time_stamp" },
 762     { tag_gps_dop, "exif_gps_dop" },
 763     { tag_gps_speed, "exif_gps_speed" },
 764     { tag_gps_track, "exif_track" }
 765   };
 766
 767 static tag_map gps_differential_values [] =
 768   {
 769     { 0, "without differential correction" },
 770     { 1, "Differential correction applied" },
 771   };
 772
 773 static tag_value_map gps_ifd_values[] =
 774   {
 775     VALUE_MAP_ENTRY(gps_differential),
 776   };
 777
 778 static tag_map gps_num_arrays[] =
 779   {
 780     { tag_gps_latitude, "exif_gps_latitude" },
 781     { tag_gps_longitude, "exif_gps_longitude" },
 782   };
 783
 784 static void
 785 save_gps_ifd_tags(i_img *im, imtiff *tiff) {
 786   /* int i, tag_index;
 787   int work;
 788   ifd_entry *entry; */
 789
 790   /* for (tag_index = 0, entry = tiff->ifd;
 791        tag_index < tiff->ifd_size; ++tag_index, ++entry) {
 792     switch (entry->tag) {
 793       break;
 794     }
 795     }*/
 796
 797   copy_string_tags(im, tiff, gps_ifd_string_tags,
 798          ARRAY_COUNT(gps_ifd_string_tags));
 799   copy_int_tags(im, tiff, gps_ifd_int_tags, ARRAY_COUNT(gps_ifd_int_tags));
 800   copy_rat_tags(im, tiff, gps_ifd_rat_tags, ARRAY_COUNT(gps_ifd_rat_tags));
 801   copy_name_tags(im, tiff, gps_ifd_values, ARRAY_COUNT(gps_ifd_values));
 802   copy_num_array_tags(im, tiff, gps_num_arrays, ARRAY_COUNT(gps_num_arrays));
 803 }
 804
 805 /*
 806 =item process_maker_note
 807
 808 This is a stub for processing the maker note tag.
 809
 810 Maker notes aren't covered by EXIF itself and in general aren't
 811 documented by the manufacturers.
 812
 813 =cut
 814 */
 815
 816 static void
 817 process_maker_note(i_img *im, imtiff *tiff, unsigned long offset, size_t size) {
 818   /* this will be added in a future release */
 819 }
 820
 821 /*
 822 =back
 823
 824 =head2 High level TIFF functions
 825
 826 To avoid relying upon tifflib when we're not processing an image we
 827 have some simple in-memory TIFF file management.
 828
 829 =over
 830
 831 =item tiff_init
 832
 833 imtiff tiff;
 834 if (tiff_init(tiff, data_base, data_size)) {
 835   // success
 836 }
 837
 838 Initialize the tiff data structure.
 839
 840 Scans for the byte order and version markers, and stores the offset to
 841 the first IFD (IFD0 in EXIF) in first_ifd_offset.
 842
 843 =cut
 844 */
 845
 846 static int
 847 tiff_init(imtiff *tiff, unsigned char *data, size_t length) {
 848   int version;
 849
 850   tiff->base = data;
 851   tiff->size = length;
 852   if (length < 8) /* well... would have to be much bigger to be useful */
 853     return 0;
 854   if (data[0] == 'M' && data[1] == 'M')
 855     tiff->type = tt_motorola;
 856   else if (data[0] == 'I' && data[1] == 'I')
 857     tiff->type = tt_intel;
 858   else
 859     return 0; /* invalid header */
 860
 861   version = tiff_get16(tiff, 2);
 862   if (version != 42)
 863     return 0;
 864
 865   tiff->first_ifd_offset = tiff_get32(tiff, 4);
 866   if (tiff->first_ifd_offset > length || tiff->first_ifd_offset < 8)
 867     return 0;
 868
 869   tiff->ifd_size = 0;
 870   tiff->ifd = NULL;
 871   tiff->next_ifd = 0;
 872
 873   return 1;
 874 }
 875
 876 /*
 877 =item tiff_final
 878
 879 tiff_final(&tiff)
 880
 881 Clean up the tiff structure initialized by tiff_init()
 882
 883 =cut
 884 */
 885
 886 static void
 887 tiff_final(imtiff *tiff) {
 888   tiff_clear_ifd(tiff);
 889 }
 890
 891 /*
 892 =item tiff_load_ifd
 893
 894 if (tiff_load_ifd(tiff, offset)) {
 895   // process the ifd
 896 }
 897
 898 Loads the IFD from the given offset into the tiff objects ifd.
 899
 900 This can fail if the IFD extends beyond end of file, or if any data
 901 offsets combined with their sizes, extends beyond end of file.
 902
 903 Returns true on success.
 904
 905 =cut
 906 */
 907
 908 static int
 909 tiff_load_ifd(imtiff *tiff, unsigned long offset) {
 910   unsigned count;
 911   int ifd_size;
 912   ifd_entry *entries = NULL;
 913   int i;
 914   unsigned long base;
 915
 916   tiff_clear_ifd(tiff);
 917
 918   /* rough check count + 1 entry + next offset */
 919   if (offset + (2+12+4) > tiff->size) {
 920     mm_log((2, "offset %uld beyond end off Exif block"));
 921     return 0;
 922   }
 923
 924   count = tiff_get16(tiff, offset);
 925
 926   /* check we can fit the whole thing */
 927   ifd_size = 2 + count * 12 + 4; /* count + count entries + next offset */
 928   if (offset + ifd_size > tiff->size) {
 929     mm_log((2, "offset %uld beyond end off Exif block"));
 930     return 0;
 931   }
 932
 933   entries = mymalloc(count * sizeof(ifd_entry));
 934   memset(entries, 0, count * sizeof(ifd_entry));
 935   base = offset + 2;
 936   for (i = 0; i < count; ++i) {
 937     ifd_entry *entry = entries + i;
 938     entry->tag = tiff_get16(tiff, base);
 939     entry->type = tiff_get16(tiff, base+2);
 940     entry->count = tiff_get32(tiff, base+4);
 941     if (entry->type >= 1 && entry->type <= ift_last) {
 942       entry->item_size = type_sizes[entry->type];
 943       entry->size = entry->item_size * entry->count;
 944       if (entry->size / entry->item_size != entry->count) {
 945         mm_log((1, "Integer overflow calculating tag data size processing EXIF block\n"));
 946         return 0;
 947       }
 948       else if (entry->size <= 4) {
 949         entry->offset = base + 8;
 950       }
 951       else {
 952         entry->offset = tiff_get32(tiff, base+8);
 953         if (entry->offset + entry->size > tiff->size) {
 954           mm_log((2, "Invalid data offset processing IFD\n"));
 955           myfree(entries);
 956           return 0;
 957         }
 958       }
 959     }
 960     else {
 961       entry->size = 0;
 962       entry->offset = 0;
 963     }
 964     base += 12;
 965   }
 966
 967   tiff->ifd_size = count;
 968   tiff->ifd = entries;
 969   tiff->next_ifd = tiff_get32(tiff, base);
 970
 971   return 1;
 972 }
 973
 974 /*
 975 =item tiff_clear_ifd
 976
 977 tiff_clear_ifd(tiff)
 978
 979 Releases any memory associated with the stored IFD and resets the IFD
 980 pointers.
 981
 982 This is called by tiff_load_ifd() and tiff_final().
 983
 984 =cut
 985 */
 986
 987 static void
 988 tiff_clear_ifd(imtiff *tiff) {
 989   if (tiff->ifd_size && tiff->ifd) {
 990     myfree(tiff->ifd);
 991     tiff->ifd_size = 0;
 992     tiff->ifd = NULL;
 993   }
 994 }
 995
 996 /*
 997 =item tiff_get_tag_double
 998
 999   double value;
1000   if (tiff_get_tag(tiff, index, &value)) {
1001     // process value
1002   }
1003
1004 Attempts to retrieve a double value from the given index in the
1005 current IFD.
1006
1007 The value must have a count of 1.
1008
1009 =cut
1010 */
1011
1012 static int
1013 tiff_get_tag_double_array(imtiff *tiff, int index, double *result,
1014                           int array_index) {
1015   ifd_entry *entry;
1016   unsigned long offset;
1017   if (index < 0 || index >= tiff->ifd_size) {
1018     i_fatal(3, "tiff_get_tag_double_array() tag index out of range");
1019   }
1020
1021   entry = tiff->ifd + index;
1022   if (array_index < 0 || array_index >= entry->count) {
1023     mm_log((3, "tiff_get_tag_double_array() array index out of range"));
1024     return 0;
1025   }
1026
1027   offset = entry->offset + array_index * entry->item_size;
1028
1029   switch (entry->type) {
1030   case ift_short:
1031     *result = tiff_get16(tiff, offset);
1032     return 1;
1033
1034   case ift_long:
1035     *result = tiff_get32(tiff, offset);
1036     return 1;
1037
1038   case ift_rational:
1039     *result = tiff_get_rat(tiff, offset);
1040     return 1;
1041
1042   case ift_sshort:
1043     *result = tiff_get16s(tiff, offset);
1044     return 1;
1045
1046   case ift_slong:
1047     *result = tiff_get32s(tiff, offset);
1048     return 1;
1049
1050   case ift_srational:
1051     *result = tiff_get_rats(tiff, offset);
1052     return 1;
1053
1054   case ift_byte:
1055     *result = *(tiff->base + offset);
1056     return 1;
1057   }
1058
1059   return 0;
1060 }
1061
1062 /*
1063 =item tiff_get_tag_double
1064
1065   double value;
1066   if (tiff_get_tag(tiff, index, &value)) {
1067     // process value
1068   }
1069
1070 Attempts to retrieve a double value from the given index in the
1071 current IFD.
1072
1073 The value must have a count of 1.
1074
1075 =cut
1076 */
1077
1078 static int
1079 tiff_get_tag_double(imtiff *tiff, int index, double *result) {
1080   ifd_entry *entry;
1081   if (index < 0 || index >= tiff->ifd_size) {
1082     i_fatal(3, "tiff_get_tag_double() index out of range");
1083   }
1084
1085   entry = tiff->ifd + index;
1086   if (entry->count != 1) {
1087     mm_log((3, "tiff_get_tag_double() called on tag with multiple values"));
1088     return 0;
1089   }
1090
1091   return tiff_get_tag_double_array(tiff, index, result, 0);
1092 }
1093
1094 /*
1095 =item tiff_get_tag_int_array
1096
1097   int value;
1098   if (tiff_get_tag_int_array(tiff, index, &value, array_index)) {
1099     // process value
1100   }
1101
1102 Attempts to retrieve an integer value from the given index in the
1103 current IFD.
1104
1105 =cut
1106 */
1107
1108 static int
1109 tiff_get_tag_int_array(imtiff *tiff, int index, int *result, int array_index) {
1110   ifd_entry *entry;
1111   unsigned long offset;
1112   if (index < 0 || index >= tiff->ifd_size) {
1113     i_fatal(3, "tiff_get_tag_int_array() tag index out of range");
1114   }
1115
1116   entry = tiff->ifd + index;
1117   if (array_index < 0 || array_index >= entry->count) {
1118     i_fatal(3, "tiff_get_tag_int_array() array index out of range");
1119   }
1120
1121   offset = entry->offset + array_index * entry->item_size;
1122
1123   switch (entry->type) {
1124   case ift_short:
1125     *result = tiff_get16(tiff, offset);
1126     return 1;
1127
1128   case ift_long:
1129     *result = tiff_get32(tiff, offset);
1130     return 1;
1131
1132   case ift_sshort:
1133     *result = tiff_get16s(tiff, offset);
1134     return 1;
1135
1136   case ift_slong:
1137     *result = tiff_get32s(tiff, offset);
1138     return 1;
1139
1140   case ift_byte:
1141     *result = *(tiff->base + offset);
1142     return 1;
1143   }
1144
1145   return 0;
1146 }
1147
1148 /*
1149 =item tiff_get_tag_int
1150
1151   int value;
1152   if (tiff_get_tag_int(tiff, index, &value)) {
1153     // process value
1154   }
1155
1156 Attempts to retrieve an integer value from the given index in the
1157 current IFD.
1158
1159 The value must have a count of 1.
1160
1161 =cut
1162 */
1163
1164 static int
1165 tiff_get_tag_int(imtiff *tiff, int index, int *result) {
1166   ifd_entry *entry;
1167   if (index < 0 || index >= tiff->ifd_size) {
1168     i_fatal(3, "tiff_get_tag_int() index out of range");
1169   }
1170
1171   entry = tiff->ifd + index;
1172   if (entry->count != 1) {
1173     mm_log((3, "tiff_get_tag_int() called on tag with multiple values"));
1174     return 0;
1175   }
1176
1177   return tiff_get_tag_int_array(tiff, index, result, 0);
1178 }
1179
1180 /*
1181 =back
1182
1183 =head2 Table-based tag setters
1184
1185 This set of functions checks for matches between the current IFD and
1186 tags supplied in an array, when there's a match it sets the
1187 appropriate tag in the image.
1188
1189 =over
1190
1191 =item copy_int_tags
1192
1193 Scans the IFD for integer tags and sets them in the image,
1194
1195 =cut
1196 */
1197
1198 static void
1199 copy_int_tags(i_img *im, imtiff *tiff, tag_map *map, int map_count) {
1200   int i, tag_index;
1201   ifd_entry *entry;
1202
1203   for (tag_index = 0, entry = tiff->ifd;
1204        tag_index < tiff->ifd_size; ++tag_index, ++entry) {
1205     for (i = 0; i < map_count; ++i) {
1206       int value;
1207       if (map[i].tag == entry->tag
1208           && tiff_get_tag_int(tiff, tag_index, &value)) {
1209         i_tags_addn(&im->tags, map[i].name, 0, value);
1210         break;
1211       }
1212     }
1213   }
1214 }
1215
1216 /*
1217 =item copy_rat_tags
1218
1219 Scans the IFD for rational tags and sets them in the image.
1220
1221 =cut
1222 */
1223
1224 static void
1225 copy_rat_tags(i_img *im, imtiff *tiff, tag_map *map, int map_count) {
1226   int i, tag_index;
1227   ifd_entry *entry;
1228
1229   for (tag_index = 0, entry = tiff->ifd;
1230        tag_index < tiff->ifd_size; ++tag_index, ++entry) {
1231     for (i = 0; i < map_count; ++i) {
1232       double value;
1233       if (map[i].tag == entry->tag
1234           && tiff_get_tag_double(tiff, tag_index, &value)) {
1235         i_tags_set_float2(&im->tags, map[i].name, 0, value, 6);
1236         break;
1237       }
1238     }
1239   }
1240 }
1241
1242 /*
1243 =item copy_string_tags
1244
1245 Scans the IFD for string tags and sets them in the image.
1246
1247 =cut
1248 */
1249
1250 static void
1251 copy_string_tags(i_img *im, imtiff *tiff, tag_map *map, int map_count) {
1252   int i, tag_index;
1253   ifd_entry *entry;
1254
1255   for (tag_index = 0, entry = tiff->ifd;
1256        tag_index < tiff->ifd_size; ++tag_index, ++entry) {
1257     for (i = 0; i < map_count; ++i) {
1258       if (map[i].tag == entry->tag) {
1259         int len = entry->type == ift_ascii ? entry->size - 1 : entry->size;
1260         i_tags_add(&im->tags, map[i].name, 0,
1261                    (char const *)(tiff->base + entry->offset), len, 0);
1262         break;
1263       }
1264     }
1265   }
1266 }
1267
1268 /*
1269 =item copy_num_array_tags
1270
1271 Scans the IFD for arrays of numbers and sets them in the image.
1272
1273 =cut
1274 */
1275
1276 /* a more general solution would be better in some ways, but we don't need it */
1277 #define MAX_ARRAY_VALUES 10
1278 #define MAX_ARRAY_STRING (MAX_ARRAY_VALUES * 20)
1279
1280 static void
1281 copy_num_array_tags(i_img *im, imtiff *tiff, tag_map *map, int map_count) {
1282   int i, j, tag_index;
1283   ifd_entry *entry;
1284
1285   for (tag_index = 0, entry = tiff->ifd;
1286        tag_index < tiff->ifd_size; ++tag_index, ++entry) {
1287     for (i = 0; i < map_count; ++i) {
1288       if (map[i].tag == entry->tag && entry->count <= MAX_ARRAY_VALUES) {
1289         if (entry->type == ift_rational || entry->type == ift_srational) {
1290           double value;
1291           char workstr[MAX_ARRAY_STRING];
1292           *workstr = '\0';
1293           for (j = 0; j < entry->count; ++j) {
1294             if (!tiff_get_tag_double_array(tiff, tag_index, &value, j)) {
1295               i_fatal(3, "unexpected failure from tiff_get_tag_double_array(..., %d, ..., %d)\n", tag_index, j);
1296             }
1297             if (j)
1298               strcat(workstr, " ");
1299             sprintf(workstr + strlen(workstr), "%.6g", value);
1300           }
1301           i_tags_add(&im->tags, map[i].name, 0, workstr, -1, 0);
1302         }
1303         else if (entry->type == ift_short || entry->type == ift_long
1304                  || entry->type == ift_sshort || entry->type == ift_slong
1305                  || entry->type == ift_byte) {
1306           int value;
1307           char workstr[MAX_ARRAY_STRING];
1308           *workstr = '\0';
1309           for (j = 0; j < entry->count; ++j) {
1310             if (!tiff_get_tag_int_array(tiff, tag_index, &value, j)) {
1311               i_fatal(3, "unexpected failure from tiff_get_tag_int_array(..., %d, ..., %d)\n", tag_index, j);
1312             }
1313             if (j)
1314               strcat(workstr, " ");
1315             sprintf(workstr + strlen(workstr), "%d", value);
1316           }
1317           i_tags_add(&im->tags, map[i].name, 0, workstr, -1, 0);
1318         }
1319         break;
1320       }
1321     }
1322   }
1323 }
1324
1325 /*
1326 =item copy_name_tags
1327
1328 This function maps integer values to descriptions for those values.
1329
1330 In general we handle the integer value through copy_int_tags() and
1331 then the same tage with a "_name" suffix here.
1332
1333 =cut
1334 */
1335
1336 static void
1337 copy_name_tags(i_img *im, imtiff *tiff, tag_value_map *map, int map_count) {
1338   int i, j, tag_index;
1339   ifd_entry *entry;
1340
1341   for (tag_index = 0, entry = tiff->ifd;
1342        tag_index < tiff->ifd_size; ++tag_index, ++entry) {
1343     for (i = 0; i < map_count; ++i) {
1344       int value;
1345       if (map[i].tag == entry->tag
1346           && tiff_get_tag_int(tiff, tag_index, &value)) {
1347         tag_map const *found = NULL;
1348         for (j = 0; j < map[i].map_count; ++j) {
1349           if (value == map[i].map[j].tag) {
1350             found = map[i].map + j;
1351             break;
1352           }
1353         }
1354         if (found) {
1355           i_tags_add(&im->tags, map[i].name, 0, found->name, -1, 0);
1356         }
1357         break;
1358       }
1359     }
1360   }
1361 }
1362
1363
1364 /*
1365 =back
1366
1367 =head2 Low level data access functions
1368
1369 These functions use the byte order in the tiff object to extract
1370 various types of data from the tiff data.
1371
1372 These functions will abort if called with an out of range offset.
1373
1374 The intent is that any offset checks should have been done by the caller.
1375
1376 =over
1377
1378 =item tiff_get16
1379
1380 Retrieve a 16 bit unsigned integer from offset.
1381
1382 =cut
1383 */
1384
1385 static unsigned
1386 tiff_get16(imtiff *tiff, unsigned long offset) {
1387   if (offset + 2 > tiff->size)
1388     i_fatal(3, "attempt to get16 at %uld in %uld image", offset, tiff->size);
1389
1390   if (tiff->type == tt_intel)
1391     return tiff->base[offset] + 0x100 * tiff->base[offset+1];
1392   else
1393     return tiff->base[offset+1] + 0x100 * tiff->base[offset];
1394 }
1395
1396 /*
1397 =item tiff_get32
1398
1399 Retrieve a 32-bit unsigned integer from offset.
1400
1401 =cut
1402 */
1403
1404 static unsigned
1405 tiff_get32(imtiff *tiff, unsigned long offset) {
1406   if (offset + 4 > tiff->size)
1407     i_fatal(3, "attempt to get16 at %uld in %uld image", offset, tiff->size);
1408
1409   if (tiff->type == tt_intel)
1410     return tiff->base[offset] + 0x100 * tiff->base[offset+1]
1411       + 0x10000 * tiff->base[offset+2] + 0x1000000 * tiff->base[offset+3];
1412   else
1413     return tiff->base[offset+3] + 0x100 * tiff->base[offset+2]
1414       + 0x10000 * tiff->base[offset+1] + 0x1000000 * tiff->base[offset];
1415 }
1416
1417 #if 0 /* currently unused, but that may change */
1418
1419 /*
1420 =item tiff_get_bytes
1421
1422 Retrieve a byte string from offset.
1423
1424 This isn't used much, you can usually deal with the data in-situ.
1425 This is intended for use when you need to modify the data in some way.
1426
1427 =cut
1428 */
1429
1430 static int
1431 tiff_get_bytes(imtiff *tiff, unsigned char *data, size_t offset,
1432                size_t size) {
1433   if (offset + size > tiff->size)
1434     return 0;
1435
1436   memcpy(data, tiff->base+offset, size);
1437
1438   return 1;
1439 }
1440
1441 #endif
1442
1443 /*
1444 =item tiff_get16s
1445
1446 Retrieve a 16-bit signed integer from offset.
1447
1448 =cut
1449 */
1450
1451 static int
1452 tiff_get16s(imtiff *tiff, unsigned long offset) {
1453   int result;
1454
1455   if (offset + 2 > tiff->size)
1456     i_fatal(3, "attempt to get16 at %uld in %uld image", offset, tiff->size);
1457
1458   if (tiff->type == tt_intel)
1459     result = tiff->base[offset] + 0x100 * tiff->base[offset+1];
1460   else
1461     result = tiff->base[offset+1] + 0x100 * tiff->base[offset];
1462
1463   if (result > 0x7FFF)
1464     result -= 0x10000;
1465
1466   return result;
1467 }
1468
1469 /*
1470 =item tiff_get32s
1471
1472 Retrieve a 32-bit signed integer from offset.
1473
1474 =cut
1475 */
1476
1477 static int
1478 tiff_get32s(imtiff *tiff, unsigned long offset) {
1479   unsigned work;
1480
1481   if (offset + 4 > tiff->size)
1482     i_fatal(3, "attempt to get16 at %uld in %uld image", offset, tiff->size);
1483
1484   if (tiff->type == tt_intel)
1485     work = tiff->base[offset] + 0x100 * tiff->base[offset+1]
1486       + 0x10000 * tiff->base[offset+2] + 0x1000000 * tiff->base[offset+3];
1487   else
1488     work = tiff->base[offset+3] + 0x100 * tiff->base[offset+2]
1489       + 0x10000 * tiff->base[offset+1] + 0x1000000 * tiff->base[offset];
1490
1491   /* not really needed on 32-bit int machines */
1492   if (work > 0x7FFFFFFFUL)
1493     return work - 0x80000000UL;
1494   else
1495     return work;
1496 }
1497
1498 /*
1499 =item tiff_get_rat
1500
1501 Retrieve an unsigned rational from offset.
1502
1503 =cut
1504 */
1505
1506 static double
1507 tiff_get_rat(imtiff *tiff, unsigned long offset) {
1508   unsigned long numer, denom;
1509   if (offset + 8 > tiff->size)
1510     i_fatal(3, "attempt to get_rat at %lu in %lu image", offset, tiff->size);
1511
1512   numer = tiff_get32(tiff, offset);
1513   denom = tiff_get32(tiff, offset+4);
1514
1515   if (denom == 0) {
1516     return -DBL_MAX;
1517   }
1518
1519   return (double)numer / denom;
1520 }
1521
1522 /*
1523 =item tiff_get_rats
1524
1525 Retrieve an signed rational from offset.
1526
1527 =cut
1528 */
1529
1530 static double
1531 tiff_get_rats(imtiff *tiff, unsigned long offset) {
1532   long numer, denom;
1533   if (offset + 8 > tiff->size)
1534     i_fatal(3, "attempt to get_rat at %lu in %lu image", offset, tiff->size);
1535
1536   numer = tiff_get32s(tiff, offset);
1537   denom = tiff_get32s(tiff, offset+4);
1538
1539   if (denom == 0) {
1540     return -DBL_MAX;
1541   }
1542
1543   return (double)numer / denom;
1544 }
1545
1546 /*
1547 =back
1548
1549 =head1 SEE ALSO
1550
1551 L<Imager>, jpeg.c
1552
1553 http://www.exif.org/
1554
1555 =head1 AUTHOR
1556
1557 Tony Cook <tony@imager.perl.org>
1558
1559 =head1 REVISION
1560
1561 $Revision$
1562
1563 =cut
1564 */