libexif/olympus/mnote-olympus-entry.c

   1 /* mnote-olympus-entry.c
   2  *
   3  * Copyright (c) 2002-2009 Lutz Mueller <lutz@users.sourceforge.net> et. al.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18  * Boston, MA  02110-1301  USA.
  19  */
  20
  21 #include <config.h>
  22 #include "mnote-olympus-entry.h"
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 #include <libexif/exif-format.h>
  29 #include <libexif/exif-utils.h>
  30 #include <libexif/exif-entry.h>
  31 #include <libexif/i18n.h>
  32
  33 #define CF(format,target,v,maxlen)                              \
  34 {                                                               \
  35         if (format != target) {                                 \
  36                 snprintf (v, maxlen,                            \
  37                         _("Invalid format '%s', "               \
  38                         "expected '%s'."),                      \
  39                         exif_format_get_name (format),          \
  40                         exif_format_get_name (target));         \
  41                 break;                                          \
  42         }                                                       \
  43 }
  44
  45 #define CF2(format,target1,target2,v,maxlen)                    \
  46 {                                                               \
  47         if ((format != target1) && (format != target2)) {       \
  48                 snprintf (v, maxlen,                            \
  49                         _("Invalid format '%s', "               \
  50                         "expected '%s' or '%s'."),              \
  51                         exif_format_get_name (format),          \
  52                         exif_format_get_name (target1),         \
  53                         exif_format_get_name (target2));        \
  54                 break;                                          \
  55         }                                                       \
  56 }
  57
  58 #define CC(number,target,v,maxlen)                                      \
  59 {                                                                       \
  60         if (number != target) {                                         \
  61                 snprintf (v, maxlen,                                    \
  62                         _("Invalid number of components (%i, "          \
  63                         "expected %i)."), (int) number, (int) target);  \
  64                 break;                                                  \
  65         }                                                               \
  66 }
  67
  68 #define CC2(number,t1,t2,v,maxlen)                                      \
  69 {                                                                       \
  70         if ((number < t1) || (number > t2)) {                           \
  71                 snprintf (v, maxlen,                                    \
  72                         _("Invalid number of components (%i, "          \
  73                         "expected %i or %i)."), (int) number,           \
  74                         (int) t1, (int) t2);                            \
  75                 break;                                                  \
  76         }                                                               \
  77 }
  78
  79 static const struct {
  80         ExifTag tag;
  81         ExifFormat fmt;
  82         struct {
  83                 int index;
  84                 const char *string;
  85         } elem[24];
  86 } items[] = {
  87 #ifndef NO_VERBOSE_TAG_DATA
  88   { MNOTE_NIKON_TAG_LENSTYPE, EXIF_FORMAT_BYTE,
  89     { {0, N_("AF non D lens")},
  90       {1, N_("Manual")},
  91       {2, N_("AF-D or AF-S lens")},
  92       {6, N_("AF-D G lens")},
  93       {10, N_("AF-D VR lens")},
  94       {14, N_("AF-D G VR lens")},
  95       {0, NULL}}},
  96   { MNOTE_NIKON_TAG_FLASHUSED, EXIF_FORMAT_BYTE,
  97     { {0, N_("Flash did not fire")},
  98       {4, N_("Flash unit unknown")},
  99       {7, N_("Flash is external")},
 100       {9, N_("Flash is on camera")},
 101       {0, NULL}}},
 102   { MNOTE_NIKON1_TAG_QUALITY, EXIF_FORMAT_SHORT,
 103     { {1, N_("VGA basic")},
 104       {2, N_("VGA normal")},
 105       {3, N_("VGA fine")},
 106       {4, N_("SXGA basic")},
 107       {5, N_("SXGA normal")},
 108       {6, N_("SXGA fine")},
 109       {10, N_("2 Mpixel basic")},
 110       {11, N_("2 Mpixel normal")},
 111       {12, N_("2 Mpixel fine")},
 112       {0, NULL}}},
 113   { MNOTE_NIKON1_TAG_COLORMODE, EXIF_FORMAT_SHORT,
 114     { {1, N_("Color")},
 115       {2, N_("Monochrome")},
 116       {0, NULL}}},
 117   { MNOTE_NIKON1_TAG_IMAGEADJUSTMENT, EXIF_FORMAT_SHORT,
 118     { {0, N_("Normal")},
 119       {1, N_("Bright+")},
 120       {2, N_("Bright-")},
 121       {3, N_("Contrast+")},
 122       {4, N_("Contrast-")},
 123       {0, NULL}}},
 124   { MNOTE_NIKON1_TAG_CCDSENSITIVITY, EXIF_FORMAT_SHORT,
 125     { {0, N_("ISO 80")},
 126       {2, N_("ISO 160")},
 127       {4, N_("ISO 320")},
 128       {5, N_("ISO 100")},
 129       {0, NULL}}},
 130   { MNOTE_NIKON1_TAG_WHITEBALANCE, EXIF_FORMAT_SHORT,
 131     { {0, N_("Auto")},
 132       {1, N_("Preset")},
 133       {2, N_("Daylight")},
 134       {3, N_("Incandescence")},
 135       {4, N_("Fluorescence")},
 136       {5, N_("Cloudy")},
 137       {6, N_("SpeedLight")},
 138       {0, NULL}}},
 139   { MNOTE_NIKON1_TAG_CONVERTER, EXIF_FORMAT_SHORT,
 140     { {0, N_("No fisheye")},
 141       {1, N_("Fisheye on")},
 142       {0, NULL}}},
 143   { MNOTE_OLYMPUS_TAG_QUALITY, EXIF_FORMAT_SHORT,
 144     { {1, N_("Normal, SQ")},
 145       {2, N_("Normal, HQ")},
 146       {3, N_("Normal, SHQ")},
 147       {4, N_("Normal, RAW")},
 148       {5, N_("Normal, SQ1")},
 149       {6, N_("Normal, SQ2")},
 150       {7, N_("Normal, super high")},
 151       {17, N_("Normal, standard")},
 152       {0x101, N_("Fine, SQ")},
 153       {0x102, N_("Fine, HQ")},
 154       {0x103, N_("Fine, SHQ")},
 155       {0x104, N_("Fine, RAW")},
 156       {0x105, N_("Fine, SQ1")},
 157       {0x106, N_("Fine, SQ2")},
 158       {0x107, N_("Fine, super high")},
 159       {0x201, N_("Super fine, SQ")},
 160       {0x202, N_("Super fine, HQ")},
 161       {0x203, N_("Super fine, SHQ")},
 162       {0x204, N_("Super fine, RAW")},
 163       {0x205, N_("Super fine, SQ1")},
 164       {0x206, N_("Super fine, SQ2")},
 165       {0x207, N_("Super fine, super high")},
 166       {0x211, N_("Super fine, high")},
 167       {0, NULL}}},
 168   { MNOTE_OLYMPUS_TAG_MACRO, EXIF_FORMAT_SHORT,
 169     { {0, N_("No")},
 170       {1, N_("Yes")},
 171       {2, N_("Super macro")},
 172       {0, NULL}}},
 173   { MNOTE_OLYMPUS_TAG_BWMODE, EXIF_FORMAT_SHORT,
 174     { {0, N_("No")},
 175       {1, N_("Yes")},
 176       {0, NULL}}},
 177   { MNOTE_OLYMPUS_TAG_ONETOUCHWB, EXIF_FORMAT_SHORT,
 178     { {0, N_("Off")},
 179       {1, N_("On")},
 180       {2, N_("On (Preset)")},
 181       {0, NULL}}},
 182   { MNOTE_OLYMPUS_TAG_FLASHMODE, EXIF_FORMAT_SHORT,
 183     { {0, N_("Auto")},
 184       {1, N_("Red-eye reduction")},
 185       {2, N_("Fill")},
 186       {3, N_("Off")},
 187       {0, NULL}}},
 188   { MNOTE_OLYMPUS_TAG_FLASHDEVICE, EXIF_FORMAT_SHORT,
 189     { {0, N_("None")},
 190       {1, N_("Internal")},
 191       {4, N_("External")},
 192       {5, N_("Internal + external")},
 193       {0, NULL}}},
 194   { MNOTE_OLYMPUS_TAG_FOCUSRANGE, EXIF_FORMAT_SHORT,
 195     { {0, N_("Normal")},
 196       {1, N_("Macro")},
 197       {0, NULL}}},
 198   { MNOTE_OLYMPUS_TAG_MANFOCUS, EXIF_FORMAT_SHORT,
 199     { {0, N_("Auto")},
 200       {1, N_("Manual")},
 201       {0, NULL}}},
 202   { MNOTE_OLYMPUS_TAG_SHARPNESS, EXIF_FORMAT_SHORT,
 203     { {0, N_("Normal")},
 204       {1, N_("Hard")},
 205       {2, N_("Soft")},
 206       {0, NULL}}},
 207   { MNOTE_OLYMPUS_TAG_EXTERNALFLASHBOUNCE, EXIF_FORMAT_SHORT,
 208     { {0, N_("No")},
 209       {1, N_("Yes")},
 210       {0, NULL}}},
 211   { MNOTE_OLYMPUS_TAG_CONTRAST, EXIF_FORMAT_SHORT,
 212     { {0, N_("Hard")},
 213       {1, N_("Normal")},
 214       {2, N_("Soft")},
 215       {0, NULL}}},
 216   { MNOTE_OLYMPUS_TAG_PREVIEWIMAGEVALID, EXIF_FORMAT_LONG,
 217     { {0, N_("No")},
 218       {1, N_("Yes")},
 219       {0, NULL}}},
 220   { MNOTE_OLYMPUS_TAG_CCDSCANMODE, EXIF_FORMAT_SHORT,
 221     { {0, N_("Interlaced")},
 222       {1, N_("Progressive")},
 223       {0, NULL}}},
 224
 225   { MNOTE_SANYO_TAG_SEQUENTIALSHOT, EXIF_FORMAT_SHORT,
 226     { {0, N_("None")},
 227       {1, N_("Standard")},
 228       {2, N_("Best")},
 229       {3, N_("Adjust exposure")},
 230       {0, NULL}}},
 231   { MNOTE_SANYO_TAG_FOCUSMODE, EXIF_FORMAT_SHORT,
 232     { {1, N_("Spot focus")},
 233       {2, N_("Normal focus")},
 234       {0, NULL}}},
 235   { MNOTE_SANYO_TAG_RECORDSHUTTERRELEASE, EXIF_FORMAT_SHORT,
 236     { {0, N_("Record while down")},
 237       {1, N_("Press start, press stop")},
 238       {0, NULL}}},
 239   { MNOTE_SANYO_TAG_RESAVED, EXIF_FORMAT_SHORT,
 240     { {0, N_("No")},
 241       {1, N_("Yes")},
 242       {0, NULL}}},
 243   { MNOTE_SANYO_TAG_CCDSENSITIVITY, EXIF_FORMAT_SHORT,
 244     { {0, N_("Auto")},
 245       {1, N_("ISO 50")},
 246       {3, N_("ISO 100")},
 247       {4, N_("ISO 200")},
 248       {5, N_("ISO 400")},
 249       {0, NULL}}},
 250   { MNOTE_SANYO_TAG_SCENESELECT, EXIF_FORMAT_SHORT,
 251     { {0, N_("Off")},
 252       {1, N_("Sport")},
 253       {2, N_("TV")},
 254       {3, N_("Night")},
 255       {4, N_("User 1")},
 256       {5, N_("User 2")},
 257       {6, N_("Lamp")},
 258       {0, NULL}}},
 259   { MNOTE_SANYO_TAG_SEQUENCESHOTINTERVAL, EXIF_FORMAT_SHORT,
 260     { {0, N_("5 frames/sec")},
 261       {1, N_("10 frames/sec")},
 262       {2, N_("15 frames/sec")},
 263       {3, N_("20 frames/sec")},
 264       {0, NULL}}},
 265 #endif
 266   { 0, 0, { { 0, NULL } } }
 267 };
 268
 269 char *
 270 mnote_olympus_entry_get_value (MnoteOlympusEntry *entry, char *v, unsigned int maxlen)
 271 {
 272         char         buf[30];
 273         ExifLong     vl;
 274         ExifShort    vs = 0;
 275         ExifSShort   vss = 0;
 276         ExifRational vr, vr2;
 277         ExifSRational vsr;
 278         int          i, j;
 279         double       r, b;
 280
 281         if (!entry)
 282                 return (NULL);
 283
 284         memset (v, 0, maxlen);
 285         maxlen--;
 286
 287         if ((!entry->data) && (entry->components > 0))
 288                 return (v);
 289
 290         switch (entry->tag) {
 291
 292         /* Nikon */
 293         case MNOTE_NIKON_TAG_FIRMWARE:
 294                 CF (entry->format,  EXIF_FORMAT_UNDEFINED, v, maxlen);
 295                 CC (entry->components, 4, v, maxlen);
 296                 vl = exif_get_long (entry->data, entry->order);
 297                 if ((vl & 0xF0F0F0F0) == 0x30303030) {
 298                         memcpy (v, entry->data, MIN (maxlen, 4));
 299                 } else {
 300                         snprintf (v, maxlen, "%04lx", (long unsigned int) vl);
 301                 }
 302                 break;
 303         case MNOTE_NIKON_TAG_ISO:
 304                 CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
 305                 CC (entry->components, 2, v, maxlen);
 306                 /*vs = exif_get_short (entry->data, entry->order);*/
 307                 vs = exif_get_short (entry->data + 2, entry->order);
 308                 snprintf (v, maxlen, "ISO %hd", vs);
 309                 break;
 310         case MNOTE_NIKON_TAG_ISO2:
 311                 CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
 312                 CC (entry->components, 2, v, maxlen);
 313                 /*vs = exif_get_short (entry->data, entry->order);*/
 314                 vs = exif_get_short (entry->data + 2, entry->order);
 315                 snprintf (v, maxlen, "ISO2 %hd", vs);
 316                 break;
 317         case MNOTE_NIKON_TAG_QUALITY:
 318         case MNOTE_NIKON_TAG_COLORMODE:
 319         case MNOTE_NIKON_TAG_COLORMODE1:
 320         case MNOTE_NIKON_TAG_WHITEBALANCE:
 321         case MNOTE_NIKON_TAG_SHARPENING:
 322         case MNOTE_NIKON_TAG_FOCUSMODE:
 323         case MNOTE_NIKON_TAG_FLASHSETTING:
 324         case MNOTE_NIKON_TAG_ISOSELECTION:
 325         case MNOTE_NIKON_TAG_FLASHMODE:
 326         case MNOTE_NIKON_TAG_IMAGEADJUSTMENT:
 327         case MNOTE_NIKON_TAG_ADAPTER:
 328         case MNOTE_NIKON_TAG_SATURATION2:
 329         case MNOTE_EPSON_TAG_SOFTWARE:
 330                 CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
 331                 memcpy(v, entry->data, MIN (maxlen, entry->size));
 332                 break;
 333         case MNOTE_NIKON_TAG_TOTALPICTURES:
 334         case MNOTE_EPSON_TAG_IMAGE_WIDTH:
 335         case MNOTE_EPSON_TAG_IMAGE_HEIGHT:
 336                 CF (entry->format, EXIF_FORMAT_LONG, v, maxlen);
 337                 CC (entry->components, 1, v, maxlen);
 338                 vl =  exif_get_long (entry->data, entry->order);
 339                 snprintf (v, maxlen, "%lu",  (long unsigned int) vl );
 340                 break;
 341         case MNOTE_NIKON_TAG_LENS_FSTOPS:
 342         case MNOTE_NIKON_TAG_EXPOSUREDIFF: {
 343                 unsigned char a,b,c,d;
 344                 CF (entry->format, EXIF_FORMAT_UNDEFINED, v, maxlen);
 345                 CC (entry->components, 4, v, maxlen);
 346                 vl =  exif_get_long (entry->data, entry->order);
 347                 a = (vl>>24)&0xff; b = (vl>>16)&0xff; c = (vl>>8)&0xff; d = (vl)&0xff;
 348                 snprintf (v, maxlen, "%.1f",  c?(float)a*((float)b/(float)c):0 );
 349                 break;
 350         }
 351         case MNOTE_NIKON_TAG_FLASHEXPCOMPENSATION:
 352         case MNOTE_NIKON_TAG_FLASHEXPOSUREBRACKETVAL:
 353                 CF (entry->format, EXIF_FORMAT_UNDEFINED, v, maxlen);
 354                 CC (entry->components, 4, v, maxlen);
 355                 vl =  exif_get_long (entry->data, entry->order);
 356                 snprintf (v, maxlen, "%.1f",  ((long unsigned int) vl>>24)/6.0 );
 357                 break;
 358         case MNOTE_NIKON_TAG_SATURATION:
 359         case MNOTE_NIKON_TAG_WHITEBALANCEFINE:
 360         case MNOTE_NIKON_TAG_HUE:
 361         case MNOTE_OLYMPUS_TAG_SENSORTEMPERATURE:
 362         case MNOTE_OLYMPUS_TAG_LENSTEMPERATURE:
 363                 CF (entry->format, EXIF_FORMAT_SSHORT, v, maxlen);
 364                 CC (entry->components, 1, v, maxlen);
 365                 vs = exif_get_short (entry->data, entry->order);
 366                 snprintf (v, maxlen, "%hd", vs);
 367                 break;
 368         case MNOTE_NIKON_TAG_WHITEBALANCERB:
 369                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
 370                 CC (entry->components, 4, v, maxlen);
 371                 vr = exif_get_rational (entry->data, entry->order);
 372                 r = (double)vr.numerator / vr.denominator;
 373                 vr = exif_get_rational (entry->data+8, entry->order);
 374                 b = (double)vr.numerator / vr.denominator;
 375                 snprintf (v, maxlen, _("Red Correction %f, blue Correction %f"), r,b);
 376                 break;
 377         case MNOTE_NIKON_TAG_MANUALFOCUSDISTANCE:
 378                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
 379                 CC (entry->components, 1, v, maxlen);
 380                 vr = exif_get_rational (entry->data, entry->order);
 381                 if (vr.numerator) {
 382                         r = (double)vr.numerator / vr.denominator;
 383                         snprintf (v, maxlen, _("%2.2f meters"), r);
 384                 } else {
 385                         strncpy (v, _("No manual focus selection"), maxlen);
 386                 }
 387                 break;
 388         case MNOTE_NIKON_TAG_SENSORPIXELSIZE:
 389                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
 390                 CC (entry->components, 2, v, maxlen);
 391                 vr = exif_get_rational (entry->data, entry->order);
 392                 vr2 = exif_get_rational (entry->data+8, entry->order);
 393                 r = (double)vr.numerator / vr.denominator;
 394                 b = (double)vr2.numerator / vr2.denominator;
 395                 snprintf (v, maxlen, "%2.2f x %2.2f um", r, b);
 396                 break;
 397         case MNOTE_NIKON_TAG_BRACKETING:
 398                 CF2 (entry->format, EXIF_FORMAT_BYTE, EXIF_FORMAT_SHORT, v, maxlen);
 399                 CC (entry->components, 1, v, maxlen);
 400                 if (EXIF_FORMAT_SHORT == entry->format) {
 401                         vs = exif_get_short (entry->data, entry->order);
 402                 } else {
 403                         vs = entry->data[0];
 404                 }
 405                 snprintf (v, maxlen, "%hd", vs);
 406                 break;
 407         case MNOTE_NIKON_TAG_AFFOCUSPOSITION:
 408                 CF (entry->format, EXIF_FORMAT_UNDEFINED, v, maxlen);
 409                 CC (entry->components, 4, v, maxlen);
 410                 switch (  *( entry->data+1)  ) {
 411                         case  0: strncpy (v, _("AF position: center"), maxlen); break;
 412                         case  1: strncpy (v, _("AF position: top"), maxlen); break;
 413                         case  2: strncpy (v, _("AF position: bottom"), maxlen); break;
 414                         case  3: strncpy (v, _("AF position: left"), maxlen); break;
 415                         case  4: strncpy (v, _("AF position: right"), maxlen); break;
 416                         case  5: strncpy (v, _("AF position: upper-left"), maxlen); break;
 417                         case  6: strncpy (v, _("AF position: upper-right"), maxlen); break;
 418                         case  7: strncpy (v, _("AF position: lower-left"), maxlen); break;
 419                         case  8: strncpy (v, _("AF position: lower-right"), maxlen); break;
 420                         case  9: strncpy (v, _("AF position: far left"), maxlen); break;
 421                         case  10: strncpy (v, _("AF position: far right"), maxlen); break;
 422                         default: strncpy (v, _("Unknown AF position"), maxlen);
 423                 }
 424                 break;
 425         case MNOTE_OLYMPUS_TAG_FLASHDEVICE:
 426                 CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
 427                 CC (entry->components, 2, v, maxlen);
 428                 vs = exif_get_short(entry->data, entry->order);
 429                 /* search for the tag */
 430                 for (i = 0; (items[i].tag && items[i].tag != entry->tag); i++)
 431                         ;
 432                 if (!items[i].tag) {
 433                         snprintf (v, maxlen, _("Internal error (unknown value %hi)"), vs);
 434                         break;
 435                 }
 436                 CF (entry->format, items[i].fmt, v, maxlen);
 437                 /* find the value */
 438                 for (j = 0; items[i].elem[j].string &&
 439                             (items[i].elem[j].index < vs); j++);
 440                 if (items[i].elem[j].index != vs) {
 441                         snprintf (v, maxlen, _("Unknown value %hi"), vs);
 442                         break;
 443                 }
 444                 strncpy (v, _(items[i].elem[j].string), maxlen);
 445                 break;
 446         case MNOTE_OLYMPUS_TAG_DIGIZOOM:
 447                 if (entry->format == EXIF_FORMAT_RATIONAL) {
 448                         CC (entry->components, 1, v, maxlen);
 449                         vr = exif_get_rational (entry->data, entry->order);
 450                         if (!vr.numerator) {
 451                                 strncpy (v, _("None"), maxlen);
 452                         } else {
 453                                 r = (double)vr.numerator / vr.denominator;
 454                                 snprintf (v, maxlen, "%2.2f", r);
 455                         }
 456                         break;
 457                 }
 458                 /* fall through to handle SHORT version of this tag */
 459         case MNOTE_NIKON_TAG_LENSTYPE:
 460         case MNOTE_NIKON_TAG_FLASHUSED:
 461         case MNOTE_NIKON1_TAG_QUALITY:
 462         case MNOTE_NIKON1_TAG_COLORMODE:
 463         case MNOTE_NIKON1_TAG_IMAGEADJUSTMENT:
 464         case MNOTE_NIKON1_TAG_CCDSENSITIVITY:
 465         case MNOTE_NIKON1_TAG_WHITEBALANCE:
 466         case MNOTE_NIKON1_TAG_CONVERTER:
 467         case MNOTE_OLYMPUS_TAG_QUALITY:
 468         case MNOTE_OLYMPUS_TAG_MACRO:
 469         case MNOTE_OLYMPUS_TAG_BWMODE:
 470         case MNOTE_OLYMPUS_TAG_ONETOUCHWB:
 471         case MNOTE_OLYMPUS_TAG_FLASHMODE:
 472         case MNOTE_OLYMPUS_TAG_FOCUSRANGE:
 473         case MNOTE_OLYMPUS_TAG_MANFOCUS:
 474         case MNOTE_OLYMPUS_TAG_SHARPNESS:
 475         case MNOTE_OLYMPUS_TAG_EXTERNALFLASHBOUNCE:
 476         case MNOTE_OLYMPUS_TAG_CONTRAST:
 477         case MNOTE_OLYMPUS_TAG_PREVIEWIMAGEVALID:
 478         case MNOTE_OLYMPUS_TAG_CCDSCANMODE:
 479         case MNOTE_SANYO_TAG_SEQUENTIALSHOT:
 480         case MNOTE_SANYO_TAG_FOCUSMODE:
 481         case MNOTE_SANYO_TAG_RECORDSHUTTERRELEASE:
 482         case MNOTE_SANYO_TAG_RESAVED:
 483         case MNOTE_SANYO_TAG_CCDSENSITIVITY:
 484         case MNOTE_SANYO_TAG_SCENESELECT:
 485         case MNOTE_SANYO_TAG_SEQUENCESHOTINTERVAL:
 486                 CC (entry->components, 1, v, maxlen);
 487                 switch (entry->format) {
 488                 case EXIF_FORMAT_BYTE:
 489                 case EXIF_FORMAT_UNDEFINED:
 490                         vs = entry->data[0];
 491                         break;
 492                 case EXIF_FORMAT_SHORT:
 493                         vs = exif_get_short(entry->data, entry->order);
 494                         break;
 495                 default:
 496                         vs = 0;
 497                         break;
 498                 }
 499                 /* search for the tag */
 500                 for (i = 0; (items[i].tag && items[i].tag != entry->tag); i++)
 501                         ;
 502                 if (!items[i].tag) {
 503                         snprintf (v, maxlen, _("Internal error (unknown value %hi)"), vs);
 504                         break;
 505                 }
 506                 CF (entry->format, items[i].fmt, v, maxlen);
 507                 /* find the value */
 508                 for (j = 0; items[i].elem[j].string &&
 509                             (items[i].elem[j].index < vs); j++);
 510                 if (items[i].elem[j].index != vs) {
 511                         snprintf (v, maxlen, _("Unknown value %hi"), vs);
 512                         break;
 513                 }
 514                 strncpy (v, _(items[i].elem[j].string), maxlen);
 515                 break;
 516         case MNOTE_OLYMPUS_TAG_NOISEREDUCTION:
 517         case MNOTE_SANYO_TAG_WIDERANGE:
 518         case MNOTE_SANYO_TAG_COLORADJUSTMENTMODE:
 519         case MNOTE_SANYO_TAG_QUICKSHOT:
 520         case MNOTE_SANYO_TAG_VOICEMEMO:
 521         case MNOTE_SANYO_TAG_FLICKERREDUCE:
 522         case MNOTE_SANYO_TAG_OPTICALZOOM:
 523         case MNOTE_SANYO_TAG_DIGITALZOOM:
 524         case MNOTE_SANYO_TAG_LIGHTSOURCESPECIAL:
 525                 CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
 526                 CC (entry->components, 1, v, maxlen);
 527                 vs = exif_get_short (entry->data, entry->order);
 528                 switch (vs) {
 529                 case 0:
 530                         strncpy (v, _("Off"), maxlen);
 531                         break;
 532                 case 1:
 533                         strncpy (v, _("On"), maxlen);
 534                         break;
 535                 default:
 536                         sprintf (buf, _("Unknown %hu"), vs);
 537                         strncat (v, buf, maxlen - strlen (v));
 538                         break;
 539                 }
 540                 break;
 541         case MNOTE_SANYO_TAG_SELFTIMER:
 542                 CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
 543                 CC (entry->components, 1, v, maxlen);
 544                 vs = exif_get_short (entry->data, entry->order);
 545                 switch (vs) {
 546                 case 0:
 547                         strncpy (v, _("Off"), maxlen);
 548                         break;
 549                 case 1:
 550                         strncpy (v, _("On"), maxlen);
 551                         break;
 552                 case 2:
 553                         strncpy (v, _("2 sec."), maxlen);
 554                         break;
 555                 default:
 556                         sprintf (buf, _("Unknown %hu"), vs);
 557                         strncat (v, buf, maxlen - strlen (v));
 558                         break;
 559                 }
 560                 break;
 561         case MNOTE_NIKON_TAG_LENS:
 562                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
 563                 CC (entry->components, 4, v, maxlen);
 564                 {
 565                         double c,d;
 566                         unsigned long a,b;
 567                         vr = exif_get_rational (entry->data, entry->order);
 568                         a = vr.numerator / vr.denominator;
 569                         vr = exif_get_rational (entry->data+8, entry->order);
 570                         b = vr.numerator / vr.denominator;
 571                         vr = exif_get_rational (entry->data+16, entry->order);
 572                         c = (double)vr.numerator / vr.denominator;
 573                         vr = exif_get_rational (entry->data+24, entry->order);
 574                         d = (double)vr.numerator / vr.denominator;
 575                         snprintf (v, maxlen, "%ld-%ldmm 1:%3.1f - %3.1f",a,b,c,d);
 576                 }
 577                 break;
 578
 579         /* Olympus */
 580         case MNOTE_OLYMPUS_TAG_MODE:
 581                 CF (entry->format, EXIF_FORMAT_LONG, v, maxlen);
 582                 CC (entry->components, 3, v, maxlen);
 583                 vl = exif_get_long (entry->data, entry->order);
 584                 switch (vl) {
 585                 case 0:
 586                         strncpy (v, _("Normal"), maxlen);
 587                         break;
 588                 case 1:
 589                         strncpy (v, _("Unknown"), maxlen);
 590                         break;
 591                 case 2:
 592                         strncpy (v, _("Fast"), maxlen);
 593                         break;
 594                 case 3:
 595                         strncpy (v, _("Panorama"), maxlen);
 596                         break;
 597                 default:
 598                         snprintf (v, maxlen, "%li", (long int) vl);
 599                 }
 600                 vl = exif_get_long (entry->data + 4, entry->order);
 601                 snprintf (buf, sizeof (buf), "/%li/", (long int) vl);
 602                 strncat (v, buf, maxlen - strlen (v));
 603                 vl = exif_get_long (entry->data + 8, entry->order);
 604                 switch (vl) {
 605                 case 1:
 606                         strncat (v, _("Left to right"), maxlen - strlen (v));
 607                         break;
 608                 case 2:
 609                         strncat (v, _("Right to left"), maxlen - strlen (v));
 610                         break;
 611                 case 3:
 612                         strncat (v, _("Bottom to top"), maxlen - strlen (v));
 613                         break;
 614                 case 4:
 615                         strncat (v, _("Top to bottom"), maxlen - strlen (v));
 616                         break;
 617                 default:
 618                         snprintf (buf, sizeof (buf), "%li",
 619                                   (long int) vl);
 620                         strncat (v, buf, maxlen - strlen (v));
 621                 }
 622                 break;
 623         case MNOTE_OLYMPUS_TAG_LENSDISTORTION:
 624                 if (entry->format == EXIF_FORMAT_SHORT) {
 625                         /* Epson uses a single SHORT here */
 626                         CC (entry->components, 1, v, maxlen);
 627                         vs = exif_get_short (entry->data, entry->order);
 628                         sprintf (buf, "%hu", vs);
 629                         strncat (v, buf, maxlen - strlen (v));
 630                 } else {
 631                         /* Others use an array of SSHORT here */
 632                         CC (entry->components, 6, v, maxlen);
 633                         CF (entry->format, EXIF_FORMAT_SSHORT, v, maxlen);
 634                         for (i=0; i < (int)entry->components; ++i) {
 635                                 vss = exif_get_sshort (entry->data+2*i, entry->order);
 636                                 sprintf (buf, "%hd ", vss);
 637                                 strncat (v, buf, maxlen - strlen (v));
 638                         }
 639                 }
 640                 break;
 641         case MNOTE_OLYMPUS_TAG_COLORCONTROL:
 642                 CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
 643                 CC (entry->components, 6, v, maxlen);
 644                 for (i=0; i < (int)entry->components; ++i) {
 645                         vs = exif_get_short (entry->data+2*i, entry->order);
 646                         sprintf (buf, "%hu ", vs);
 647                         strncat (v, buf, maxlen - strlen (v));
 648                 }
 649                 break;
 650         case MNOTE_OLYMPUS_TAG_VERSION:
 651                 CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
 652                 CC2 (entry->components, 5, 8, v, maxlen);
 653                 strncpy (v, (char *)entry->data, MIN (maxlen, entry->size));
 654                 break;
 655         case MNOTE_OLYMPUS_TAG_SERIALNUMBER2:
 656                 CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
 657                 strncpy (v, (char *)entry->data, MIN (maxlen, entry->size));
 658                 break;
 659         case MNOTE_OLYMPUS_TAG_INFO:
 660                 CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
 661                 CC2 (entry->components, 52, 60, v, maxlen);
 662                 strncpy (v, (char *)entry->data, MIN (maxlen, entry->size));
 663                 break;
 664         case MNOTE_OLYMPUS_TAG_ID:
 665                 CF (entry->format, EXIF_FORMAT_UNDEFINED, v, maxlen);
 666                 CC (entry->components, 32, v, maxlen);
 667                 strncpy (v, (char *)entry->data, MIN (maxlen, entry->size));
 668                 break;
 669         case MNOTE_OLYMPUS_TAG_UNKNOWN_4:
 670                 CF (entry->format, EXIF_FORMAT_LONG, v, maxlen);
 671                 CC (entry->components, 30, v, maxlen);
 672                 for (i=0; i < (int)entry->components; ++i) {
 673                         vl = exif_get_long (entry->data+4*i, entry->order);
 674                         sprintf (buf, "%lu ", (unsigned long)vl);
 675                         strncat (v, buf, maxlen - strlen (v));
 676                 }
 677                 break;
 678         case MNOTE_OLYMPUS_TAG_FOCUSDIST:
 679                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
 680                 CC (entry->components, 1, v, maxlen);
 681                 vr = exif_get_rational (entry->data, entry->order);
 682                 if (vr.numerator == 0) {
 683                         strncpy (v, _("Unknown"), maxlen);
 684                 }
 685                 else {
 686                         unsigned long tmp = vr.numerator / vr.denominator;
 687                         snprintf (v, maxlen, "%li mm", tmp);
 688                 }
 689                 break;
 690         case MNOTE_OLYMPUS_TAG_WBALANCE:
 691                 CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
 692                 CC (entry->components, 2, v, maxlen);
 693                 vs = exif_get_short (entry->data, entry->order);
 694                 switch (vs) {
 695                 case 1:
 696                         strncpy (v, _("Automatic"), maxlen);
 697                         break;
 698                 case 2:
 699                         {
 700                                 ExifShort v2 = exif_get_short (entry->data + 2, entry->order);
 701                                 unsigned long colorTemp = 0;
 702                                 switch (v2) {
 703                                 case 2:
 704                                         colorTemp = 3000;
 705                                         break;
 706                                 case 3:
 707                                         colorTemp = 3700;
 708                                         break;
 709                                 case 4:
 710                                         colorTemp = 4000;
 711                                         break;
 712                                 case 5:
 713                                         colorTemp = 4500;
 714                                         break;
 715                                 case 6:
 716                                         colorTemp = 5500;
 717                                         break;
 718                                 case 7:
 719                                         colorTemp = 6500;
 720                                         break;
 721                                 case 9:
 722                                         colorTemp = 7500;
 723                                         break;
 724                                 }
 725                                 if (colorTemp) {
 726                                         snprintf (v, maxlen, _("Manual: %liK"), colorTemp);
 727                                 }
 728                                 else {
 729                                         strncpy (v, _("Manual: unknown"), maxlen);
 730                                 }
 731
 732                         }
 733                         break;
 734                 case 3:
 735                         strncpy (v, _("One-touch"), maxlen);
 736                         break;
 737                 default:
 738                         strncpy (v, _("Unknown"), maxlen);
 739                         break;
 740                 }
 741                 break;
 742         case MNOTE_OLYMPUS_TAG_REDBALANCE:
 743         case MNOTE_OLYMPUS_TAG_BLUEBALANCE:
 744                 CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
 745                 CC (entry->components, 2, v, maxlen);
 746                 vs = exif_get_short (entry->data, entry->order);
 747                 snprintf (v, maxlen, "%hu ", vs);
 748                 vs = exif_get_short (entry->data + 2, entry->order);
 749                 sprintf (buf, "%hu", vs);
 750                 strncat (v, buf, maxlen - strlen (v));
 751                 break;
 752         case MNOTE_OLYMPUS_TAG_BLACKLEVEL:
 753         case MNOTE_NIKON_TAG_IMAGEBOUNDARY:
 754                 CC (entry->components, 4, v, maxlen);
 755                 /* Fall through to COLORMATRIX */
 756         case MNOTE_OLYMPUS_TAG_COLORMATRIX:
 757                 CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
 758                 if (entry->tag == MNOTE_OLYMPUS_TAG_COLORMATRIX)
 759                         CC (entry->components, 9, v, maxlen);
 760                 for (i=0; i < (int)entry->components; ++i) {
 761                         vs = exif_get_short (entry->data+2*i, entry->order);
 762                         sprintf (buf, "%hu ", vs);
 763                         strncat (v, buf, maxlen - strlen (v));
 764                 }
 765                 break;
 766         case MNOTE_NIKON1_TAG_FOCUS:
 767         case MNOTE_NIKON_TAG_DIGITALZOOM:
 768         case MNOTE_NIKON1_TAG_DIGITALZOOM:
 769         case MNOTE_OLYMPUS_TAG_FOCALPLANEDIAGONAL:
 770                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
 771                 /* Fall through to default handler for display */
 772         default:
 773                 switch (entry->format) {
 774                 case EXIF_FORMAT_ASCII:
 775                         strncpy (v, (char *)entry->data, MIN (maxlen, entry->size));
 776                         break;
 777                 case EXIF_FORMAT_SHORT:
 778                         CC (entry->components, 1, v, maxlen);
 779                         vs = exif_get_short (entry->data, entry->order);
 780                         snprintf (v, maxlen, "%hu", vs);
 781                         break;
 782                 case EXIF_FORMAT_LONG:
 783                         CC (entry->components, 1, v, maxlen);
 784                         vl = exif_get_long (entry->data, entry->order);
 785                         snprintf (v, maxlen, "%li", (long int) vl);
 786                         break;
 787                 case EXIF_FORMAT_RATIONAL:
 788                         CC (entry->components, 1, v, maxlen);
 789                         vr = exif_get_rational (entry->data, entry->order);
 790                         if (!vr.denominator) {
 791                                 strncpy (v, _("Infinite"), maxlen);
 792                         } else {
 793                                 r = (double)vr.numerator / vr.denominator;
 794                                 snprintf (v, maxlen, "%2.3f", r);
 795                         }
 796                         break;
 797                 case EXIF_FORMAT_SRATIONAL:
 798                         CC (entry->components, 1, v, maxlen);
 799                         vsr = exif_get_srational (entry->data, entry->order);
 800                         if (!vsr.denominator) {
 801                                 strncpy (v, _("Infinite"), maxlen);
 802                         } else {
 803                                 r = (double)vsr.numerator / vsr.denominator;
 804                                 snprintf (v, maxlen, "%2.3f", r);
 805                         }
 806                         break;
 807                 case EXIF_FORMAT_UNDEFINED:
 808                 default:
 809                         snprintf (v, maxlen, _("%i bytes unknown data: "),
 810                                   entry->size);
 811                         for (i = 0; i < (int)entry->size; i++) {
 812                                 sprintf (buf, "%02x", entry->data[i]);
 813                                 strncat (v, buf, maxlen - strlen (v));
 814                         }
 815                         break;
 816                 }
 817                 break;
 818         }
 819
 820         return (v);
 821 }