libexif/olympus/mnote-olympus-entry.c

   1 /* mnote-olympus-entry.c
   2  *
   3  * Copyright © 2002 Lutz Müller <lutz@users.sourceforge.net>
   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., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, 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 CC(number,target,v,maxlen)                                      \
  46 {                                                                       \
  47         if (number != target) {                                         \
  48                 snprintf (v, maxlen,                                    \
  49                         _("Invalid number of components (%i, "          \
  50                         "expected %i)."), (int) number, (int) target);  \
  51                 break;                                                  \
  52         }                                                               \
  53 }
  54
  55 #define CC2(number,t1,t2,v,maxlen)                                      \
  56 {                                                                       \
  57         if ((number < t1) || (number > t2)) {                           \
  58                 snprintf (v, maxlen,                                    \
  59                         _("Invalid number of components (%i, "          \
  60                         "expected %i or %i)."), (int) number,           \
  61                         (int) t1, (int) t2);                            \
  62                 break;                                                  \
  63         }                                                               \
  64 }
  65
  66 static struct {
  67         ExifTag tag;
  68     ExifFormat fmt;
  69         struct {
  70                 int index;
  71                 const char *string;
  72         } elem[10];
  73 } items[] = {
  74   { MNOTE_NIKON_TAG_LENSTYPE, EXIF_FORMAT_BYTE,
  75     { {0, N_("AF non D Lens")},
  76       {1, N_("Manual")},
  77       {2, N_("AF-D or AF-S Lens")},
  78       {6, N_("AF-D G Lens")},
  79       {10, N_("AF-D VR Lens")},
  80       {0, NULL}}},
  81   { MNOTE_NIKON_TAG_FLASHUSED, EXIF_FORMAT_BYTE,
  82     { {0, N_("Flash did not fire")},
  83       {4, N_("Flash unit unknown")},
  84       {7, N_("Flash is external")},
  85       {9, N_("Flash is on Camera")},
  86       {0, NULL}}},
  87   { MNOTE_NIKON1_TAG_QUALITY, EXIF_FORMAT_SHORT,
  88     { {1, N_("VGA Basic")},
  89       {2, N_("VGA Normal")},
  90       {3, N_("VGA Fine")},
  91       {4, N_("SXGA Basic")},
  92       {5, N_("SXGA Normal")},
  93       {6, N_("SXGA Fine")},
  94       {10, N_("2 MPixel Basic")},
  95       {11, N_("2 MPixel Normal")},
  96       {12, N_("2 MPixel Fine")},
  97       {0, NULL}}},
  98   { MNOTE_NIKON1_TAG_COLORMODE, EXIF_FORMAT_SHORT,
  99     { {1, N_("Color")},
 100       {2, N_("Monochrome")},
 101       {0, NULL}}},
 102   { MNOTE_NIKON1_TAG_IMAGEADJUSTMENT, EXIF_FORMAT_SHORT,
 103     { {0, N_("Normal")},
 104       {1, N_("Bright+")},
 105       {2, N_("Bright-")},
 106       {3, N_("Contrast+")},
 107       {4, N_("Contrast-")},
 108       {0, NULL}}},
 109   { MNOTE_NIKON1_TAG_CCDSENSITIVITY, EXIF_FORMAT_SHORT,
 110     { {0, N_("ISO80")},
 111       {2, N_("ISO160")},
 112       {4, N_("ISO320")},
 113       {5, N_("ISO100")},
 114       {0, NULL}}},
 115   { MNOTE_NIKON1_TAG_WHITEBALANCE, EXIF_FORMAT_SHORT,
 116     { {0, N_("Auto")},
 117       {1, N_("Preset")},
 118       {2, N_("Daylight")},
 119       {3, N_("Incandescence")},
 120       {4, N_("Fluorescence")},
 121       {5, N_("Cloudy")},
 122       {6, N_("SpeedLight")},
 123       {0, NULL}}},
 124   { MNOTE_NIKON1_TAG_CONVERTER, EXIF_FORMAT_SHORT,
 125     { {0, N_("No Fisheye")},
 126       {1, N_("Fisheye On")},
 127       {0, NULL}}},
 128   { MNOTE_OLYMPUS_TAG_QUALITY, EXIF_FORMAT_SHORT,
 129     { {1, N_("SQ")},
 130       {2, N_("HQ")},
 131       {3, N_("SHQ")},
 132       {4, N_("RAW")},
 133       {5, N_("SQ1")},
 134       {6, N_("SQ2")},
 135       {0, NULL}}},
 136   { MNOTE_OLYMPUS_TAG_MACRO, EXIF_FORMAT_SHORT,
 137     { {0, N_("No")},
 138       {1, N_("Yes")},
 139       {0, NULL}}},
 140   { MNOTE_OLYMPUS_TAG_DIGIZOOM, EXIF_FORMAT_SHORT,
 141     { {0, N_("1x")},
 142       {2, N_("2x")},
 143       {0, NULL}}},
 144   { MNOTE_OLYMPUS_TAG_FLASHMODE, EXIF_FORMAT_SHORT,
 145     { {0, N_("Auto")},
 146       {1, N_("Red-eye reduction")},
 147       {2, N_("Fill")},
 148       {3, N_("Off")},
 149       {0, NULL}}},
 150   { MNOTE_OLYMPUS_TAG_SHARPNESS, EXIF_FORMAT_SHORT,
 151     { {0, N_("Normal")},
 152       {1, N_("Hard")},
 153       {2, N_("Soft")},
 154       {0, NULL}}},
 155   { MNOTE_OLYMPUS_TAG_CONTRAST, EXIF_FORMAT_SHORT,
 156     { {0, N_("Hard")},
 157       {1, N_("Normal")},
 158       {2, N_("Soft")},
 159       {0, NULL}}},
 160   { MNOTE_OLYMPUS_TAG_MANFOCUS, EXIF_FORMAT_SHORT,
 161     { {0, N_("No")},
 162       {1, N_("Yes")},
 163       {0, NULL}}},
 164   { 0, }
 165 };
 166
 167 char *
 168 mnote_olympus_entry_get_value (MnoteOlympusEntry *entry, char *v, unsigned int maxlen)
 169 {
 170         char         buf[30];
 171         ExifLong     vl;
 172         ExifShort    vs = 0;
 173         ExifRational vr, vr2;
 174         int          i, j;
 175         double       r, b;
 176
 177         if (!entry)
 178                 return (NULL);
 179
 180         memset (v, 0, maxlen);
 181         maxlen--;
 182
 183         if ((!entry->data) && (entry->components > 0))
 184                 return (v);
 185
 186         switch (entry->tag) {
 187
 188         /* Nikon */
 189         case MNOTE_NIKON_TAG_FIRMWARE:
 190                 CF (entry->format,  EXIF_FORMAT_UNDEFINED, v, maxlen);
 191                 CC (entry->components, 4, v, maxlen);
 192                 vl = exif_get_long (entry->data, entry->order);
 193                 if ((vl & 0xF0F0F0F0) == 0x30303030) {
 194                         memcpy (v, entry->data, MIN (maxlen, 4));
 195                 } else {
 196                         snprintf (v, maxlen, "%04lx", (long unsigned int) vl);
 197                 }
 198                 break;
 199         case MNOTE_NIKON_TAG_ISO:
 200                 CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
 201                 CC (entry->components, 2, v, maxlen);
 202                 //vs = exif_get_short (entry->data, entry->order);
 203                 vs = exif_get_short (entry->data + 2, entry->order);
 204                 snprintf (v, maxlen, "ISO %hd", vs);
 205                 break;
 206         case MNOTE_NIKON_TAG_ISO2:
 207                 CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
 208                 CC (entry->components, 2, v, maxlen);
 209                 //vs = exif_get_short (entry->data, entry->order);
 210                 vs = exif_get_short (entry->data + 2, entry->order);
 211                 snprintf (v, maxlen, "ISO2 %hd", vs);
 212                 break;
 213         case MNOTE_NIKON_TAG_QUALITY:
 214                 CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
 215                 //CC (entry->components, 8, v, maxlen);
 216                 //vl =  exif_get_long (entry->data  , entry->order);
 217                 //printf("-> 0x%04x\n",entry->data);
 218                 //printf("-> 0x%s<\n",entry->data - 0);
 219                 memcpy(v, entry->data, MIN(maxlen, entry->size));
 220                 //snprintf (v, maxlen, "%s<",  ( entry->data - 9  );
 221                 break;
 222         case MNOTE_NIKON_TAG_COLORMODE:
 223         case MNOTE_NIKON_TAG_COLORMODE1:
 224         case MNOTE_NIKON_TAG_WHITEBALANCE:
 225         case MNOTE_NIKON_TAG_SHARPENING:
 226         case MNOTE_NIKON_TAG_FOCUSMODE:
 227         case MNOTE_NIKON_TAG_FLASHSETTING:
 228         case MNOTE_NIKON_TAG_ISOSELECTION:
 229         case MNOTE_NIKON_TAG_FLASHMODE:
 230         case MNOTE_NIKON_TAG_IMAGEADJUSTMENT:
 231         case MNOTE_NIKON_TAG_ADAPTER:
 232         case MNOTE_NIKON_TAG_SATURATION2:
 233                 CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
 234                 memcpy(v, entry->data, MIN (maxlen, entry->size));
 235                 break;
 236         case MNOTE_NIKON_TAG_TOTALPICTURES:
 237                 CF (entry->format, EXIF_FORMAT_LONG, v, maxlen);
 238                 CC (entry->components, 1, v, maxlen);
 239                 vl =  exif_get_long (entry->data, entry->order);
 240                 snprintf (v, maxlen, "%lu",  (long unsigned int) vl );
 241                 break;
 242         case MNOTE_NIKON_TAG_LENS_FSTOPS:
 243         case MNOTE_NIKON_TAG_EXPOSUREDIFF: {
 244                 unsigned char a,b,c,d;
 245                 CF (entry->format, EXIF_FORMAT_UNDEFINED, v, maxlen);
 246                 CC (entry->components, 4, v, maxlen);
 247                 vl =  exif_get_long (entry->data, entry->order);
 248                 a = (vl>>24)&0xff; b = (vl>>16)&0xff; c = (vl>>8)&0xff; d = (vl)&0xff;
 249                 snprintf (v, maxlen, "%.1f",  c?(float)a*((float)b/(float)c):0 );
 250                 break;
 251         }
 252         case MNOTE_NIKON_TAG_FLASHEXPCOMPENSATION:
 253         case MNOTE_NIKON_TAG_FLASHEXPOSUREBRACKETVAL:
 254                 CF (entry->format, EXIF_FORMAT_UNDEFINED, v, maxlen);
 255                 CC (entry->components, 4, v, maxlen);
 256                 vl =  exif_get_long (entry->data, entry->order);
 257                 snprintf (v, maxlen, "%.1f",  ((long unsigned int) vl>>24)/6.0 );
 258                 break;
 259         case MNOTE_NIKON_TAG_SATURATION:
 260         case MNOTE_NIKON_TAG_WHITEBALANCEFINE:
 261                 CF (entry->format, EXIF_FORMAT_SSHORT, v, maxlen);
 262                 CC (entry->components, 1, v, maxlen);
 263                 vs = exif_get_short (entry->data, entry->order);
 264                 snprintf (v, maxlen, "%hd", vs);
 265                 break;
 266         case MNOTE_NIKON_TAG_WHITEBALANCERB:
 267                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
 268                 CC (entry->components, 4, v, maxlen);
 269                 vr = exif_get_rational (entry->data, entry->order);
 270                 r = (double)vr.numerator / vr.denominator;
 271                 vr = exif_get_rational (entry->data+8, entry->order);
 272                 b = (double)vr.numerator / vr.denominator;
 273                 //printf("numerator %li, denominator %li\n", vr.numerator, vr.denominator);
 274                 snprintf (v, maxlen, _("Red Correction %f, Blue Correction %f"), r,b);
 275                 break;
 276         case MNOTE_NIKON_TAG_MANUALFOCUSDISTANCE:
 277                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
 278                 CC (entry->components, 1, v, maxlen);
 279                 vr = exif_get_rational (entry->data, entry->order);
 280                 if (vr.numerator) {
 281                         r = (double)vr.numerator / vr.denominator;
 282                         snprintf (v, maxlen, _("%2.2f meters"), r);
 283                 } else {
 284                         strncpy (v, _("No manual focus selection"), maxlen);
 285                 }
 286                 break;
 287         case MNOTE_NIKON_TAG_DIGITALZOOM:
 288         case MNOTE_NIKON1_TAG_DIGITALZOOM:
 289                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
 290                 CC (entry->components, 1, v, maxlen);
 291                 vr = exif_get_rational (entry->data, entry->order);
 292                 r = (double)vr.numerator / vr.denominator;
 293                 snprintf (v, maxlen, "%2.2f", r);
 294                 break;
 295         case MNOTE_NIKON_TAG_SENSORPIXELSIZE:
 296                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
 297                 CC (entry->components, 2, v, maxlen);
 298                 vr = exif_get_rational (entry->data, entry->order);
 299                 vr2 = exif_get_rational (entry->data+8, entry->order);
 300                 r = (double)vr.numerator / vr.denominator;
 301                 b = (double)vr2.numerator / vr2.denominator;
 302                 snprintf (v, maxlen, "%2.2f x %2.2f um", r, b);
 303                 break;
 304         case MNOTE_NIKON_TAG_HUE:
 305                 CF (entry->format, EXIF_FORMAT_SSHORT, v, maxlen);
 306                 CC (entry->components, 1, v, maxlen);
 307                 vs = exif_get_short (entry->data, entry->order);
 308                 snprintf (v, maxlen, "%hd", vs);
 309                 break;
 310         case MNOTE_NIKON_TAG_AFFOCUSPOSITION:
 311                 CF (entry->format, EXIF_FORMAT_UNDEFINED, v, maxlen);
 312                 CC (entry->components, 4, v, maxlen);
 313                 switch (  *( entry->data+1)  ) {
 314                         case  0: strncpy (v, _("AF Position: Center"), maxlen); break;
 315                         case  1: strncpy (v, _("AF Position: Top"), maxlen); break;
 316                         case  2: strncpy (v, _("AF Position: Bottom"), maxlen); break;
 317                         case  3: strncpy (v, _("AF Position: Left"), maxlen); break;
 318                         case  4: strncpy (v, _("AF Position: Right"), maxlen); break;
 319          case  5: strncpy (v, _("AF Position: Upper-left"), maxlen); break;
 320                         case  6: strncpy (v, _("AF Position: Upper-right"), maxlen); break;
 321                         case  7: strncpy (v, _("AF Position: Lower-left"), maxlen); break;
 322                         case  8: strncpy (v, _("AF Position: Lower-right"), maxlen); break;
 323                         case  9: strncpy (v, _("AF Position: Far Left"), maxlen); break;
 324                         case  10: strncpy (v, _("AF Position: Far Right"), maxlen); break;
 325                         default: strncpy (v, _("Unknown AF Position"), maxlen);
 326                 }
 327                 break;
 328         case MNOTE_OLYMPUS_TAG_DIGIZOOM:
 329                 if (entry->format == EXIF_FORMAT_RATIONAL) {
 330                         CC (entry->components, 1, v, maxlen);
 331                         vr = exif_get_rational (entry->data, entry->order);
 332                         r = (double)vr.numerator / vr.denominator;
 333                         if (!vr.numerator) {
 334                                 strncpy (v, _("None"), maxlen);
 335                         } else {
 336                                 snprintf (v, maxlen, "%2.2f", r);
 337                         }
 338                         break;
 339                 }
 340                 /* fall through to handle SHORT version of this tag */
 341         case MNOTE_NIKON_TAG_LENSTYPE:
 342         case MNOTE_NIKON_TAG_FLASHUSED:
 343         case MNOTE_NIKON1_TAG_QUALITY:
 344         case MNOTE_NIKON1_TAG_COLORMODE:
 345         case MNOTE_NIKON1_TAG_IMAGEADJUSTMENT:
 346         case MNOTE_NIKON1_TAG_CCDSENSITIVITY:
 347         case MNOTE_NIKON1_TAG_WHITEBALANCE:
 348         case MNOTE_NIKON1_TAG_CONVERTER:
 349         case MNOTE_OLYMPUS_TAG_QUALITY:
 350         case MNOTE_OLYMPUS_TAG_MACRO:
 351         case MNOTE_OLYMPUS_TAG_FLASHMODE:
 352         case MNOTE_OLYMPUS_TAG_SHARPNESS:
 353         case MNOTE_OLYMPUS_TAG_CONTRAST:
 354         case MNOTE_OLYMPUS_TAG_MANFOCUS:
 355                 /* search the tag */
 356                 for (i = 0; (items[i].tag && items[i].tag != entry->tag); i++);
 357                 if (!items[i].tag) {
 358                         strncpy (v, _("Internal error"), maxlen);
 359                         break;
 360                 }
 361                 CF (entry->format, items[i].fmt, v, maxlen);
 362                 CC (entry->components, 1, v, maxlen);
 363                 switch (entry->format) {
 364                 case EXIF_FORMAT_BYTE:
 365                 case EXIF_FORMAT_UNDEFINED:
 366                         vs = entry->data[0];
 367                         break;
 368                 case EXIF_FORMAT_SHORT:
 369                         vs = exif_get_short(entry->data, entry->order);
 370                         break;
 371                 default:
 372                         vs = 0;
 373                         break;
 374                 }
 375                 /* find the value */
 376                 for (j = 0; items[i].elem[j].string &&
 377                             (items[i].elem[j].index < vs); j++);
 378                 if (items[i].elem[j].index != vs) {
 379                         snprintf (v, maxlen, _("Unknown value %hi"), vs);
 380                         break;
 381                 }
 382                 strncpy (v, items[i].elem[j].string, maxlen);
 383                 break;
 384
 385         case MNOTE_NIKON_TAG_LENS:
 386                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
 387                 CC (entry->components, 4, v, maxlen);
 388                 {
 389                         double c,d;
 390                         unsigned long a,b;
 391                         vr = exif_get_rational (entry->data, entry->order);
 392                         a = vr.numerator / vr.denominator;
 393                         vr = exif_get_rational (entry->data+8, entry->order);
 394                         b = vr.numerator / vr.denominator;
 395                         vr = exif_get_rational (entry->data+16, entry->order);
 396                         c = (double)vr.numerator / vr.denominator;
 397                         vr = exif_get_rational (entry->data+24, entry->order);
 398                         d = (double)vr.numerator / vr.denominator;
 399                         //printf("numerator %li, denominator %li\n", vr.numerator, vr.denominator);
 400                         snprintf (v, maxlen, "%ld-%ldmm 1:%3.1f - %3.1f",a,b,c,d);
 401                 }
 402                 break;
 403         case MNOTE_NIKON1_TAG_FOCUS:
 404                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
 405                 CC (entry->components, 1, v, maxlen);
 406                 vr = exif_get_rational (entry->data, entry->order);
 407                 if (!vr.denominator) {
 408                         strncpy (v, _("Infinite"), maxlen);
 409                 } else {
 410                         r = (double)vr.numerator / vr.denominator;
 411                         snprintf (v, maxlen, "%2.2f", r);
 412                 }
 413                 break;
 414
 415         /* Olympus */
 416         case MNOTE_OLYMPUS_TAG_MODE:
 417                 CF (entry->format, EXIF_FORMAT_LONG, v, maxlen);
 418                 CC (entry->components, 3, v, maxlen);
 419                 vl = exif_get_long (entry->data, entry->order);
 420                 switch (vl) {
 421                 case 0:
 422                         strncpy (v, _("normal"), maxlen);
 423                         break;
 424                 case 1:
 425                         strncpy (v, _("unknown"), maxlen);
 426                         break;
 427                 case 2:
 428                         strncpy (v, _("fast"), maxlen);
 429                         break;
 430                 case 3:
 431                         strncpy (v, _("panorama"), maxlen);
 432                         break;
 433                 default:
 434                         snprintf (v, maxlen, _("%li"), (long int) vl);
 435                 }
 436                 vl = exif_get_long (entry->data + 4, entry->order);
 437                 snprintf (buf, sizeof (buf), "/%li/", (long int) vl);
 438                 strncat (v, buf, maxlen - strlen (v));
 439                 vl = exif_get_long (entry->data + 4, entry->order);
 440                 switch (vl) {
 441                 case 1:
 442                         strncat (v, _("left to right"), maxlen - strlen (v));
 443                         break;
 444                 case 2:
 445                         strncat (v, _("right to left"), maxlen - strlen (v));
 446                         break;
 447                 case 3:
 448                         strncat (v, _("bottom to top"), maxlen - strlen (v));
 449                         break;
 450                 case 4:
 451                         strncat (v, _("top to bottom"), maxlen - strlen (v));
 452                         break;
 453                 default:
 454                         snprintf (buf, sizeof (buf), _("%li"),
 455                                   (long int) vl);
 456                         strncat (v, buf, maxlen - strlen (v));
 457                 }
 458                 break;
 459         case MNOTE_OLYMPUS_TAG_UNKNOWN_1:
 460                 CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
 461                 CC (entry->components, 1, v, maxlen);
 462                 strncpy (v, _("Unknown tag."), maxlen);
 463                 break;
 464         case MNOTE_OLYMPUS_TAG_UNKNOWN_2:
 465                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
 466                 CC (entry->components, 1, v, maxlen);
 467                 break;
 468         case MNOTE_OLYMPUS_TAG_UNKNOWN_3:
 469                 CF (entry->format, EXIF_FORMAT_SSHORT, v, maxlen);
 470                 CC (entry->components, 1, v, maxlen);
 471                 break;
 472         case MNOTE_OLYMPUS_TAG_VERSION:
 473                 CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
 474                 CC2 (entry->components, 5, 8, v, maxlen);
 475                 strncpy (v, (char *)entry->data, MIN (maxlen, entry->size));
 476                 break;
 477         case MNOTE_OLYMPUS_TAG_INFO:
 478                 CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
 479                 CC2 (entry->components, 52, 60, v, maxlen);
 480                 strncpy (v, (char *)entry->data, MIN (maxlen, entry->size));
 481                 break;
 482         case MNOTE_OLYMPUS_TAG_ID:
 483                 CF (entry->format, EXIF_FORMAT_UNDEFINED, v, maxlen);
 484                 CC (entry->components, 32, v, maxlen);
 485                 strncpy (v, (char *)entry->data, MIN (maxlen, entry->size));
 486                 break;
 487         case MNOTE_OLYMPUS_TAG_UNKNOWN_4:
 488                 CF (entry->format, EXIF_FORMAT_LONG, v, maxlen);
 489                 CC (entry->components, 30, v, maxlen);
 490                 break;
 491         case MNOTE_OLYMPUS_TAG_FOCUSDIST:
 492                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
 493                 CC (entry->components, 1, v, maxlen);
 494                 vr = exif_get_rational (entry->data, entry->order);
 495                 if (vr.numerator == 0) {
 496                         strncpy (v, _("Unknown"), maxlen);
 497                 }
 498                 else {
 499                         unsigned long tmp = vr.numerator / vr.denominator;
 500                         /* printf("numerator %li, denominator %li\n", vr.numerator, vr.denominator); */
 501                         snprintf (v, maxlen, "%li mm", tmp);
 502                 }
 503                 break;
 504         case MNOTE_OLYMPUS_TAG_WBALANCE:
 505                 CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
 506                 CC (entry->components, 2, v, maxlen);
 507                 vs = exif_get_short (entry->data, entry->order);
 508                 switch (vs) {
 509                 case 1:
 510                         strncpy (v, _("Automatic"), maxlen);
 511                         break;
 512                 case 2:
 513                         {
 514                                 ExifShort v2 = exif_get_short (entry->data + 2, entry->order);
 515                                 unsigned long colorTemp = 0;
 516                                 switch (v2) {
 517                                 case 2:
 518                                         colorTemp = 3000;
 519                                         break;
 520                                 case 3:
 521                                         colorTemp = 3700;
 522                                         break;
 523                                 case 4:
 524                                         colorTemp = 4000;
 525                                         break;
 526                                 case 5:
 527                                         colorTemp = 4500;
 528                                         break;
 529                                 case 6:
 530                                         colorTemp = 5500;
 531                                         break;
 532                                 case 7:
 533                                         colorTemp = 6500;
 534                                         break;
 535                                 case 9:
 536                                         colorTemp = 7500;
 537                                         break;
 538                                 }
 539                                 if (colorTemp) {
 540                                         snprintf (v, maxlen, "Manual: %liK", colorTemp);
 541                                 }
 542                                 else {
 543                                         strncpy (v, _("Manual: Unknown"), maxlen);
 544                                 }
 545
 546                         }
 547                         break;
 548                 case 3:
 549                         strncpy (v, _("One-touch"), maxlen);
 550                         break;
 551                 default:
 552                         strncpy (v, _("Unknown"), maxlen);
 553                         break;
 554                 }
 555                 break;
 556         default:
 557                 switch (entry->format) {
 558                 case EXIF_FORMAT_ASCII:
 559                         strncpy (v, (char *)entry->data, MIN (maxlen, entry->size));
 560                         break;
 561                 case EXIF_FORMAT_SHORT:
 562                         vs = exif_get_short (entry->data, entry->order);
 563                         snprintf (v, maxlen, "%hi", vs);
 564                         break;
 565                 case EXIF_FORMAT_LONG:
 566                         vl = exif_get_long (entry->data, entry->order);
 567                         snprintf (v, maxlen, "%li", (long int) vl);
 568                         break;
 569                 case EXIF_FORMAT_UNDEFINED:
 570                 default:
 571                         snprintf (v, maxlen, _("%i bytes unknown data: "),
 572                                   entry->size);
 573                         for (i = 0; i < (int)entry->size; i++) {
 574                                 sprintf (buf, "%02x", entry->data[i]);
 575                                 strncat (v, buf, maxlen - strlen (v));
 576                         }
 577                         break;
 578                 }
 579                 break;
 580         }
 581
 582         return (v);
 583 }