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 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[10];
  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       {0, NULL}}},
  95   { MNOTE_NIKON_TAG_FLASHUSED, EXIF_FORMAT_BYTE,
  96     { {0, N_("Flash did not fire")},
  97       {4, N_("Flash unit unknown")},
  98       {7, N_("Flash is external")},
  99       {9, N_("Flash is on Camera")},
 100       {0, NULL}}},
 101   { MNOTE_NIKON1_TAG_QUALITY, EXIF_FORMAT_SHORT,
 102     { {1, N_("VGA Basic")},
 103       {2, N_("VGA Normal")},
 104       {3, N_("VGA Fine")},
 105       {4, N_("SXGA Basic")},
 106       {5, N_("SXGA Normal")},
 107       {6, N_("SXGA Fine")},
 108       {10, N_("2 MPixel Basic")},
 109       {11, N_("2 MPixel Normal")},
 110       {12, N_("2 MPixel Fine")},
 111       {0, NULL}}},
 112   { MNOTE_NIKON1_TAG_COLORMODE, EXIF_FORMAT_SHORT,
 113     { {1, N_("Color")},
 114       {2, N_("Monochrome")},
 115       {0, NULL}}},
 116   { MNOTE_NIKON1_TAG_IMAGEADJUSTMENT, EXIF_FORMAT_SHORT,
 117     { {0, N_("Normal")},
 118       {1, N_("Bright+")},
 119       {2, N_("Bright-")},
 120       {3, N_("Contrast+")},
 121       {4, N_("Contrast-")},
 122       {0, NULL}}},
 123   { MNOTE_NIKON1_TAG_CCDSENSITIVITY, EXIF_FORMAT_SHORT,
 124     { {0, N_("ISO80")},
 125       {2, N_("ISO160")},
 126       {4, N_("ISO320")},
 127       {5, N_("ISO100")},
 128       {0, NULL}}},
 129   { MNOTE_NIKON1_TAG_WHITEBALANCE, EXIF_FORMAT_SHORT,
 130     { {0, N_("Auto")},
 131       {1, N_("Preset")},
 132       {2, N_("Daylight")},
 133       {3, N_("Incandescence")},
 134       {4, N_("Fluorescence")},
 135       {5, N_("Cloudy")},
 136       {6, N_("SpeedLight")},
 137       {0, NULL}}},
 138   { MNOTE_NIKON1_TAG_CONVERTER, EXIF_FORMAT_SHORT,
 139     { {0, N_("No Fisheye")},
 140       {1, N_("Fisheye On")},
 141       {0, NULL}}},
 142   { MNOTE_OLYMPUS_TAG_QUALITY, EXIF_FORMAT_SHORT,
 143     { {1, N_("SQ")},
 144       {2, N_("HQ")},
 145       {3, N_("SHQ")},
 146       {4, N_("RAW")},
 147       {5, N_("SQ1")},
 148       {6, N_("SQ2")},
 149       {17, N_("Standard")},
 150       {529, N_("High")},
 151       {0, NULL}}},
 152   { MNOTE_OLYMPUS_TAG_MACRO, EXIF_FORMAT_SHORT,
 153     { {0, N_("No")},
 154       {1, N_("Yes")},
 155       {2, N_("Super Macro")},
 156       {0, NULL}}},
 157   { MNOTE_OLYMPUS_TAG_BWMODE, EXIF_FORMAT_SHORT,
 158     { {0, N_("No")},
 159       {1, N_("Yes")},
 160       {0, NULL}}},
 161   { MNOTE_OLYMPUS_TAG_ONETOUCHWB, EXIF_FORMAT_SHORT,
 162     { {0, N_("Off")},
 163       {1, N_("On")},
 164       {2, N_("On (Preset)")},
 165       {0, NULL}}},
 166   { MNOTE_OLYMPUS_TAG_FLASHMODE, EXIF_FORMAT_SHORT,
 167     { {0, N_("Auto")},
 168       {1, N_("Red-eye reduction")},
 169       {2, N_("Fill")},
 170       {3, N_("Off")},
 171       {0, NULL}}},
 172   { MNOTE_OLYMPUS_TAG_FLASHDEVICE, EXIF_FORMAT_SHORT,
 173     { {1, N_("Internal")},
 174       {4, N_("External")},
 175       {5, N_("Internal + External")},
 176       {0, NULL}}},
 177   { MNOTE_OLYMPUS_TAG_FOCUSRANGE, EXIF_FORMAT_SHORT,
 178     { {0, N_("Normal")},
 179       {1, N_("Macro")},
 180       {0, NULL}}},
 181   { MNOTE_OLYMPUS_TAG_MANFOCUS, EXIF_FORMAT_SHORT,
 182     { {0, N_("Auto")},
 183       {1, N_("Manual")},
 184       {0, NULL}}},
 185   { MNOTE_OLYMPUS_TAG_SHARPNESS, EXIF_FORMAT_SHORT,
 186     { {0, N_("Normal")},
 187       {1, N_("Hard")},
 188       {2, N_("Soft")},
 189       {0, NULL}}},
 190   { MNOTE_OLYMPUS_TAG_EXTERNALFLASHBOUNCE, EXIF_FORMAT_SHORT,
 191     { {0, N_("No")},
 192       {1, N_("Yes")},
 193       {0, NULL}}},
 194   { MNOTE_OLYMPUS_TAG_CONTRAST, EXIF_FORMAT_SHORT,
 195     { {0, N_("Hard")},
 196       {1, N_("Normal")},
 197       {2, N_("Soft")},
 198       {0, NULL}}},
 199   { MNOTE_OLYMPUS_TAG_PREVIEWIMAGEVALID, EXIF_FORMAT_LONG,
 200     { {0, N_("No")},
 201       {1, N_("Yes")},
 202       {0, NULL}}},
 203   { MNOTE_OLYMPUS_TAG_CCDSCANMODE, EXIF_FORMAT_SHORT,
 204     { {0, N_("Interlaced")},
 205       {1, N_("Progressive")},
 206       {0, NULL}}},
 207   { MNOTE_SANYO_TAG_SEQUENTIALSHOT, EXIF_FORMAT_SHORT,
 208     { {0, N_("None")},
 209       {1, N_("Standard")},
 210       {2, N_("Best")},
 211       {3, N_("Adjust Exposure")},
 212       {0, NULL}}},
 213   { MNOTE_SANYO_TAG_RECORDSHUTTERRELEASE, EXIF_FORMAT_SHORT,
 214     { {0, N_("Record while down")},
 215       {1, N_("Press start, press stop")},
 216       {0, NULL}}},
 217   { MNOTE_SANYO_TAG_RESAVED, EXIF_FORMAT_SHORT,
 218     { {0, N_("No")},
 219       {1, N_("Yes")},
 220       {0, NULL}}},
 221   { MNOTE_SANYO_TAG_SCENESELECT, EXIF_FORMAT_SHORT,
 222     { {0, N_("Off")},
 223       {1, N_("Sport")},
 224       {2, N_("TV")},
 225       {3, N_("Night")},
 226       {4, N_("User 1")},
 227       {5, N_("User 2")},
 228       {6, N_("Lamp")},
 229       {0, NULL}}},
 230   { MNOTE_SANYO_TAG_SEQUENCESHOTINTERVAL, EXIF_FORMAT_SHORT,
 231     { {0, N_("5 frames/sec")},
 232       {1, N_("10 frames/sec")},
 233       {2, N_("15 frames/sec")},
 234       {3, N_("20 frames/sec")},
 235       {0, NULL}}},
 236 #endif
 237   { 0, 0, { { 0, NULL } } }
 238 };
 239
 240 char *
 241 mnote_olympus_entry_get_value (MnoteOlympusEntry *entry, char *v, unsigned int maxlen)
 242 {
 243         char         buf[30];
 244         ExifLong     vl;
 245         ExifShort    vs = 0;
 246         ExifRational vr, vr2;
 247         ExifSRational vsr;
 248         int          i, j;
 249         double       r, b;
 250
 251         if (!entry)
 252                 return (NULL);
 253
 254         memset (v, 0, maxlen);
 255         maxlen--;
 256
 257         if ((!entry->data) && (entry->components > 0))
 258                 return (v);
 259
 260         switch (entry->tag) {
 261
 262         /* Nikon */
 263         case MNOTE_NIKON_TAG_FIRMWARE:
 264                 CF (entry->format,  EXIF_FORMAT_UNDEFINED, v, maxlen);
 265                 CC (entry->components, 4, v, maxlen);
 266                 vl = exif_get_long (entry->data, entry->order);
 267                 if ((vl & 0xF0F0F0F0) == 0x30303030) {
 268                         memcpy (v, entry->data, MIN (maxlen, 4));
 269                 } else {
 270                         snprintf (v, maxlen, "%04lx", (long unsigned int) vl);
 271                 }
 272                 break;
 273         case MNOTE_NIKON_TAG_ISO:
 274                 CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
 275                 CC (entry->components, 2, v, maxlen);
 276                 //vs = exif_get_short (entry->data, entry->order);
 277                 vs = exif_get_short (entry->data + 2, entry->order);
 278                 snprintf (v, maxlen, "ISO %hd", vs);
 279                 break;
 280         case MNOTE_NIKON_TAG_ISO2:
 281                 CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
 282                 CC (entry->components, 2, v, maxlen);
 283                 //vs = exif_get_short (entry->data, entry->order);
 284                 vs = exif_get_short (entry->data + 2, entry->order);
 285                 snprintf (v, maxlen, "ISO2 %hd", vs);
 286                 break;
 287         case MNOTE_NIKON_TAG_QUALITY:
 288                 CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
 289                 //CC (entry->components, 8, v, maxlen);
 290                 //vl =  exif_get_long (entry->data  , entry->order);
 291                 //printf("-> 0x%04x\n",entry->data);
 292                 //printf("-> 0x%s<\n",entry->data - 0);
 293                 memcpy(v, entry->data, MIN(maxlen, entry->size));
 294                 //snprintf (v, maxlen, "%s<",  ( entry->data - 9  );
 295                 break;
 296         case MNOTE_NIKON_TAG_COLORMODE:
 297         case MNOTE_NIKON_TAG_COLORMODE1:
 298         case MNOTE_NIKON_TAG_WHITEBALANCE:
 299         case MNOTE_NIKON_TAG_SHARPENING:
 300         case MNOTE_NIKON_TAG_FOCUSMODE:
 301         case MNOTE_NIKON_TAG_FLASHSETTING:
 302         case MNOTE_NIKON_TAG_ISOSELECTION:
 303         case MNOTE_NIKON_TAG_FLASHMODE:
 304         case MNOTE_NIKON_TAG_IMAGEADJUSTMENT:
 305         case MNOTE_NIKON_TAG_ADAPTER:
 306         case MNOTE_NIKON_TAG_SATURATION2:
 307                 CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
 308                 memcpy(v, entry->data, MIN (maxlen, entry->size));
 309                 break;
 310         case MNOTE_NIKON_TAG_TOTALPICTURES:
 311                 CF (entry->format, EXIF_FORMAT_LONG, v, maxlen);
 312                 CC (entry->components, 1, v, maxlen);
 313                 vl =  exif_get_long (entry->data, entry->order);
 314                 snprintf (v, maxlen, "%lu",  (long unsigned int) vl );
 315                 break;
 316         case MNOTE_NIKON_TAG_LENS_FSTOPS:
 317         case MNOTE_NIKON_TAG_EXPOSUREDIFF: {
 318                 unsigned char a,b,c,d;
 319                 CF (entry->format, EXIF_FORMAT_UNDEFINED, v, maxlen);
 320                 CC (entry->components, 4, v, maxlen);
 321                 vl =  exif_get_long (entry->data, entry->order);
 322                 a = (vl>>24)&0xff; b = (vl>>16)&0xff; c = (vl>>8)&0xff; d = (vl)&0xff;
 323                 snprintf (v, maxlen, "%.1f",  c?(float)a*((float)b/(float)c):0 );
 324                 break;
 325         }
 326         case MNOTE_NIKON_TAG_FLASHEXPCOMPENSATION:
 327         case MNOTE_NIKON_TAG_FLASHEXPOSUREBRACKETVAL:
 328                 CF (entry->format, EXIF_FORMAT_UNDEFINED, v, maxlen);
 329                 CC (entry->components, 4, v, maxlen);
 330                 vl =  exif_get_long (entry->data, entry->order);
 331                 snprintf (v, maxlen, "%.1f",  ((long unsigned int) vl>>24)/6.0 );
 332                 break;
 333         case MNOTE_NIKON_TAG_SATURATION:
 334         case MNOTE_NIKON_TAG_WHITEBALANCEFINE:
 335                 CF (entry->format, EXIF_FORMAT_SSHORT, v, maxlen);
 336                 CC (entry->components, 1, v, maxlen);
 337                 vs = exif_get_short (entry->data, entry->order);
 338                 snprintf (v, maxlen, "%hd", vs);
 339                 break;
 340         case MNOTE_NIKON_TAG_WHITEBALANCERB:
 341                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
 342                 CC (entry->components, 4, v, maxlen);
 343                 vr = exif_get_rational (entry->data, entry->order);
 344                 r = (double)vr.numerator / vr.denominator;
 345                 vr = exif_get_rational (entry->data+8, entry->order);
 346                 b = (double)vr.numerator / vr.denominator;
 347                 //printf("numerator %li, denominator %li\n", vr.numerator, vr.denominator);
 348                 snprintf (v, maxlen, _("Red Correction %f, Blue Correction %f"), r,b);
 349                 break;
 350         case MNOTE_NIKON_TAG_MANUALFOCUSDISTANCE:
 351                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
 352                 CC (entry->components, 1, v, maxlen);
 353                 vr = exif_get_rational (entry->data, entry->order);
 354                 if (vr.numerator) {
 355                         r = (double)vr.numerator / vr.denominator;
 356                         snprintf (v, maxlen, _("%2.2f meters"), r);
 357                 } else {
 358                         strncpy (v, _("No manual focus selection"), maxlen);
 359                 }
 360                 break;
 361         case MNOTE_NIKON_TAG_SENSORPIXELSIZE:
 362                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
 363                 CC (entry->components, 2, v, maxlen);
 364                 vr = exif_get_rational (entry->data, entry->order);
 365                 vr2 = exif_get_rational (entry->data+8, entry->order);
 366                 r = (double)vr.numerator / vr.denominator;
 367                 b = (double)vr2.numerator / vr2.denominator;
 368                 snprintf (v, maxlen, "%2.2f x %2.2f um", r, b);
 369                 break;
 370         case MNOTE_NIKON_TAG_HUE:
 371                 CF (entry->format, EXIF_FORMAT_SSHORT, v, maxlen);
 372                 CC (entry->components, 1, v, maxlen);
 373                 vs = exif_get_short (entry->data, entry->order);
 374                 snprintf (v, maxlen, "%hd", vs);
 375                 break;
 376         case MNOTE_NIKON_TAG_BRACKETING:
 377                 CF2 (entry->format, EXIF_FORMAT_BYTE, EXIF_FORMAT_SHORT, v, maxlen);
 378                 CC (entry->components, 1, v, maxlen);
 379                 if (EXIF_FORMAT_SHORT == entry->format) {
 380                         vs = exif_get_short (entry->data, entry->order);
 381                 } else {
 382                         vs = entry->data[0];
 383                 }
 384                 snprintf (v, maxlen, "%hd", vs);
 385                 break;
 386         case MNOTE_NIKON_TAG_AFFOCUSPOSITION:
 387                 CF (entry->format, EXIF_FORMAT_UNDEFINED, v, maxlen);
 388                 CC (entry->components, 4, v, maxlen);
 389                 switch (  *( entry->data+1)  ) {
 390                         case  0: strncpy (v, _("AF Position: Center"), maxlen); break;
 391                         case  1: strncpy (v, _("AF Position: Top"), maxlen); break;
 392                         case  2: strncpy (v, _("AF Position: Bottom"), maxlen); break;
 393                         case  3: strncpy (v, _("AF Position: Left"), maxlen); break;
 394                         case  4: strncpy (v, _("AF Position: Right"), maxlen); break;
 395                         case  5: strncpy (v, _("AF Position: Upper-left"), maxlen); break;
 396                         case  6: strncpy (v, _("AF Position: Upper-right"), maxlen); break;
 397                         case  7: strncpy (v, _("AF Position: Lower-left"), maxlen); break;
 398                         case  8: strncpy (v, _("AF Position: Lower-right"), maxlen); break;
 399                         case  9: strncpy (v, _("AF Position: Far Left"), maxlen); break;
 400                         case  10: strncpy (v, _("AF Position: Far Right"), maxlen); break;
 401                         default: strncpy (v, _("Unknown AF Position"), maxlen);
 402                 }
 403                 break;
 404         case MNOTE_OLYMPUS_TAG_DIGIZOOM:
 405                 if (entry->format == EXIF_FORMAT_RATIONAL) {
 406                         CC (entry->components, 1, v, maxlen);
 407                         vr = exif_get_rational (entry->data, entry->order);
 408                         r = (double)vr.numerator / vr.denominator;
 409                         if (!vr.numerator) {
 410                                 strncpy (v, _("None"), maxlen);
 411                         } else {
 412                                 snprintf (v, maxlen, "%2.2f", r);
 413                         }
 414                         break;
 415                 }
 416                 /* fall through to handle SHORT version of this tag */
 417         case MNOTE_NIKON_TAG_LENSTYPE:
 418         case MNOTE_NIKON_TAG_FLASHUSED:
 419         case MNOTE_NIKON1_TAG_QUALITY:
 420         case MNOTE_NIKON1_TAG_COLORMODE:
 421         case MNOTE_NIKON1_TAG_IMAGEADJUSTMENT:
 422         case MNOTE_NIKON1_TAG_CCDSENSITIVITY:
 423         case MNOTE_NIKON1_TAG_WHITEBALANCE:
 424         case MNOTE_NIKON1_TAG_CONVERTER:
 425         case MNOTE_OLYMPUS_TAG_QUALITY:
 426         case MNOTE_OLYMPUS_TAG_MACRO:
 427         case MNOTE_OLYMPUS_TAG_BWMODE:
 428         case MNOTE_OLYMPUS_TAG_ONETOUCHWB:
 429         case MNOTE_OLYMPUS_TAG_FLASHMODE:
 430         case MNOTE_OLYMPUS_TAG_FLASHDEVICE:
 431         case MNOTE_OLYMPUS_TAG_FOCUSRANGE:
 432         case MNOTE_OLYMPUS_TAG_MANFOCUS:
 433         case MNOTE_OLYMPUS_TAG_SHARPNESS:
 434         case MNOTE_OLYMPUS_TAG_EXTERNALFLASHBOUNCE:
 435         case MNOTE_OLYMPUS_TAG_CONTRAST:
 436         case MNOTE_OLYMPUS_TAG_PREVIEWIMAGEVALID:
 437         case MNOTE_OLYMPUS_TAG_CCDSCANMODE:
 438         case MNOTE_SANYO_TAG_SEQUENTIALSHOT:
 439         case MNOTE_SANYO_TAG_RECORDSHUTTERRELEASE:
 440         case MNOTE_SANYO_TAG_RESAVED:
 441         case MNOTE_SANYO_TAG_SCENESELECT:
 442         case MNOTE_SANYO_TAG_SEQUENCESHOTINTERVAL:
 443                 CC (entry->components, 1, v, maxlen);
 444                 switch (entry->format) {
 445                 case EXIF_FORMAT_BYTE:
 446                 case EXIF_FORMAT_UNDEFINED:
 447                         vs = entry->data[0];
 448                         break;
 449                 case EXIF_FORMAT_SHORT:
 450                         vs = exif_get_short(entry->data, entry->order);
 451                         break;
 452                 default:
 453                         vs = 0;
 454                         break;
 455                 }
 456                 /* search for the tag */
 457                 for (i = 0; (items[i].tag && items[i].tag != entry->tag); i++)
 458                         ;
 459                 if (!items[i].tag) {
 460                         snprintf (v, maxlen, _("Internal error (unknown value %hi)"), vs);
 461                         break;
 462                 }
 463                 CF (entry->format, items[i].fmt, v, maxlen);
 464                 /* find the value */
 465                 for (j = 0; items[i].elem[j].string &&
 466                             (items[i].elem[j].index < vs); j++);
 467                 if (items[i].elem[j].index != vs) {
 468                         snprintf (v, maxlen, _("Unknown value %hi"), vs);
 469                         break;
 470                 }
 471                 strncpy (v, _(items[i].elem[j].string), maxlen);
 472                 break;
 473         case MNOTE_OLYMPUS_TAG_NOISEREDUCTION:
 474         case MNOTE_SANYO_TAG_WIDERANGE:
 475         case MNOTE_SANYO_TAG_COLORADJUSTMENTMODE:
 476         case MNOTE_SANYO_TAG_QUICKSHOT:
 477         case MNOTE_SANYO_TAG_SELFTIMER:
 478         case MNOTE_SANYO_TAG_VOICEMEMO:
 479         case MNOTE_SANYO_TAG_FLICKERREDUCE:
 480         case MNOTE_SANYO_TAG_OPTICALZOOM:
 481         case MNOTE_SANYO_TAG_DIGITALZOOM:
 482         case MNOTE_SANYO_TAG_LIGHTSOURCESPECIAL:
 483                 CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
 484                 CC (entry->components, 1, v, maxlen);
 485                 vs = exif_get_short (entry->data, entry->order);
 486                 switch (vs) {
 487                 case 0:
 488                         strncpy (v, _("Off"), maxlen);
 489                         break;
 490                 case 1:
 491                         strncpy (v, _("On"), maxlen);
 492                         break;
 493                 default:
 494                         strncpy (v, _("Unknown"), maxlen);
 495                         break;
 496                 }
 497                 break;
 498         case MNOTE_NIKON_TAG_LENS:
 499                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
 500                 CC (entry->components, 4, v, maxlen);
 501                 {
 502                         double c,d;
 503                         unsigned long a,b;
 504                         vr = exif_get_rational (entry->data, entry->order);
 505                         a = vr.numerator / vr.denominator;
 506                         vr = exif_get_rational (entry->data+8, entry->order);
 507                         b = vr.numerator / vr.denominator;
 508                         vr = exif_get_rational (entry->data+16, entry->order);
 509                         c = (double)vr.numerator / vr.denominator;
 510                         vr = exif_get_rational (entry->data+24, entry->order);
 511                         d = (double)vr.numerator / vr.denominator;
 512                         //printf("numerator %li, denominator %li\n", vr.numerator, vr.denominator);
 513                         snprintf (v, maxlen, "%ld-%ldmm 1:%3.1f - %3.1f",a,b,c,d);
 514                 }
 515                 break;
 516
 517         /* Olympus */
 518         case MNOTE_OLYMPUS_TAG_MODE:
 519                 CF (entry->format, EXIF_FORMAT_LONG, v, maxlen);
 520                 CC (entry->components, 3, v, maxlen);
 521                 vl = exif_get_long (entry->data, entry->order);
 522                 switch (vl) {
 523                 case 0:
 524                         strncpy (v, _("normal"), maxlen);
 525                         break;
 526                 case 1:
 527                         strncpy (v, _("unknown"), maxlen);
 528                         break;
 529                 case 2:
 530                         strncpy (v, _("fast"), maxlen);
 531                         break;
 532                 case 3:
 533                         strncpy (v, _("panorama"), maxlen);
 534                         break;
 535                 default:
 536                         snprintf (v, maxlen, _("%li"), (long int) vl);
 537                 }
 538                 vl = exif_get_long (entry->data + 4, entry->order);
 539                 snprintf (buf, sizeof (buf), "/%li/", (long int) vl);
 540                 strncat (v, buf, maxlen - strlen (v));
 541                 vl = exif_get_long (entry->data + 4, entry->order);
 542                 switch (vl) {
 543                 case 1:
 544                         strncat (v, _("left to right"), maxlen - strlen (v));
 545                         break;
 546                 case 2:
 547                         strncat (v, _("right to left"), maxlen - strlen (v));
 548                         break;
 549                 case 3:
 550                         strncat (v, _("bottom to top"), maxlen - strlen (v));
 551                         break;
 552                 case 4:
 553                         strncat (v, _("top to bottom"), maxlen - strlen (v));
 554                         break;
 555                 default:
 556                         snprintf (buf, sizeof (buf), _("%li"),
 557                                   (long int) vl);
 558                         strncat (v, buf, maxlen - strlen (v));
 559                 }
 560                 break;
 561         case MNOTE_OLYMPUS_TAG_LENSDISTORTION:
 562                 CF (entry->format, EXIF_FORMAT_SSHORT, v, maxlen);
 563                 CC (entry->components, 6, v, maxlen);
 564                 for (i=0; i < (int)entry->components; ++i) {
 565                         vs = exif_get_sshort (entry->data+2*i, entry->order);
 566                         sprintf (buf, "%hd ", vs);
 567                         strncat (v, buf, maxlen - strlen (v));
 568                 }
 569                 break;
 570         case MNOTE_OLYMPUS_TAG_COLORCONTROL:
 571                 CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
 572                 CC (entry->components, 6, v, maxlen);
 573                 for (i=0; i < (int)entry->components; ++i) {
 574                         vs = exif_get_short (entry->data+2*i, entry->order);
 575                         sprintf (buf, "%hu ", vs);
 576                         strncat (v, buf, maxlen - strlen (v));
 577                 }
 578                 break;
 579         case MNOTE_OLYMPUS_TAG_VERSION:
 580                 CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
 581                 CC2 (entry->components, 5, 8, v, maxlen);
 582                 strncpy (v, (char *)entry->data, MIN (maxlen, entry->size));
 583                 break;
 584         case MNOTE_OLYMPUS_TAG_SERIALNUMBER2:
 585                 CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
 586                 strncpy (v, (char *)entry->data, MIN (maxlen, entry->size));
 587                 break;
 588         case MNOTE_OLYMPUS_TAG_INFO:
 589                 CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
 590                 CC2 (entry->components, 52, 60, v, maxlen);
 591                 strncpy (v, (char *)entry->data, MIN (maxlen, entry->size));
 592                 break;
 593         case MNOTE_OLYMPUS_TAG_ID:
 594                 CF (entry->format, EXIF_FORMAT_UNDEFINED, v, maxlen);
 595                 CC (entry->components, 32, v, maxlen);
 596                 strncpy (v, (char *)entry->data, MIN (maxlen, entry->size));
 597                 break;
 598         case MNOTE_OLYMPUS_TAG_UNKNOWN_4:
 599                 CF (entry->format, EXIF_FORMAT_LONG, v, maxlen);
 600                 CC (entry->components, 30, v, maxlen);
 601                 /* TODO: display me */
 602                 break;
 603         case MNOTE_OLYMPUS_TAG_FOCUSDIST:
 604                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
 605                 CC (entry->components, 1, v, maxlen);
 606                 vr = exif_get_rational (entry->data, entry->order);
 607                 if (vr.numerator == 0) {
 608                         strncpy (v, _("Unknown"), maxlen);
 609                 }
 610                 else {
 611                         unsigned long tmp = vr.numerator / vr.denominator;
 612                         /* printf("numerator %li, denominator %li\n", vr.numerator, vr.denominator); */
 613                         snprintf (v, maxlen, "%li mm", tmp);
 614                 }
 615                 break;
 616         case MNOTE_OLYMPUS_TAG_WBALANCE:
 617                 CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
 618                 CC (entry->components, 2, v, maxlen);
 619                 vs = exif_get_short (entry->data, entry->order);
 620                 switch (vs) {
 621                 case 1:
 622                         strncpy (v, _("Automatic"), maxlen);
 623                         break;
 624                 case 2:
 625                         {
 626                                 ExifShort v2 = exif_get_short (entry->data + 2, entry->order);
 627                                 unsigned long colorTemp = 0;
 628                                 switch (v2) {
 629                                 case 2:
 630                                         colorTemp = 3000;
 631                                         break;
 632                                 case 3:
 633                                         colorTemp = 3700;
 634                                         break;
 635                                 case 4:
 636                                         colorTemp = 4000;
 637                                         break;
 638                                 case 5:
 639                                         colorTemp = 4500;
 640                                         break;
 641                                 case 6:
 642                                         colorTemp = 5500;
 643                                         break;
 644                                 case 7:
 645                                         colorTemp = 6500;
 646                                         break;
 647                                 case 9:
 648                                         colorTemp = 7500;
 649                                         break;
 650                                 }
 651                                 if (colorTemp) {
 652                                         snprintf (v, maxlen, _("Manual: %liK"), colorTemp);
 653                                 }
 654                                 else {
 655                                         strncpy (v, _("Manual: Unknown"), maxlen);
 656                                 }
 657
 658                         }
 659                         break;
 660                 case 3:
 661                         strncpy (v, _("One-touch"), maxlen);
 662                         break;
 663                 default:
 664                         strncpy (v, _("Unknown"), maxlen);
 665                         break;
 666                 }
 667                 break;
 668         case MNOTE_OLYMPUS_TAG_REDBALANCE:
 669         case MNOTE_OLYMPUS_TAG_BLUEBALANCE:
 670                 CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
 671                 CC (entry->components, 2, v, maxlen);
 672                 vs = exif_get_short (entry->data, entry->order);
 673                 snprintf (v, maxlen, "%hu ", vs);
 674                 vs = exif_get_short (entry->data + 2, entry->order);
 675                 sprintf (buf, "%hu", vs);
 676                 strncat (v, buf, maxlen - strlen (v));
 677                 break;
 678         case MNOTE_OLYMPUS_TAG_BLACKLEVEL:
 679         case MNOTE_NIKON_TAG_IMAGEBOUNDARY:
 680                 CC (entry->components, 4, v, maxlen);
 681                 /* Fall through to COLORMATRIX */
 682         case MNOTE_OLYMPUS_TAG_COLORMATRIX:
 683                 CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
 684                 if (entry->tag == MNOTE_OLYMPUS_TAG_COLORMATRIX)
 685                         CC (entry->components, 9, v, maxlen);
 686                 for (i=0; i < (int)entry->components; ++i) {
 687                         vs = exif_get_short (entry->data+2*i, entry->order);
 688                         sprintf (buf, "%hu ", vs);
 689                         strncat (v, buf, maxlen - strlen (v));
 690                 }
 691                 break;
 692         case MNOTE_NIKON1_TAG_FOCUS:
 693         case MNOTE_NIKON_TAG_DIGITALZOOM:
 694         case MNOTE_NIKON1_TAG_DIGITALZOOM:
 695         case MNOTE_OLYMPUS_TAG_FOCALPLANEDIAGONAL:
 696                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
 697                 /* Fall through to default handler for display */
 698         default:
 699                 switch (entry->format) {
 700                 case EXIF_FORMAT_ASCII:
 701                         strncpy (v, (char *)entry->data, MIN (maxlen, entry->size));
 702                         break;
 703                 case EXIF_FORMAT_SHORT:
 704                         CC (entry->components, 1, v, maxlen);
 705                         vs = exif_get_short (entry->data, entry->order);
 706                         snprintf (v, maxlen, "%hu", vs);
 707                         break;
 708                 case EXIF_FORMAT_LONG:
 709                         CC (entry->components, 1, v, maxlen);
 710                         vl = exif_get_long (entry->data, entry->order);
 711                         snprintf (v, maxlen, "%li", (long int) vl);
 712                         break;
 713                 case EXIF_FORMAT_RATIONAL:
 714                         CC (entry->components, 1, v, maxlen);
 715                         vr = exif_get_rational (entry->data, entry->order);
 716                         if (!vr.denominator) {
 717                                 strncpy (v, _("Infinite"), maxlen);
 718                         } else {
 719                                 r = (double)vr.numerator / vr.denominator;
 720                                 snprintf (v, maxlen, "%2.3f", r);
 721                         }
 722                         break;
 723                 case EXIF_FORMAT_SRATIONAL:
 724                         CC (entry->components, 1, v, maxlen);
 725                         vsr = exif_get_srational (entry->data, entry->order);
 726                         if (!vsr.denominator) {
 727                                 strncpy (v, _("Infinite"), maxlen);
 728                         } else {
 729                                 r = (double)vsr.numerator / vsr.denominator;
 730                                 snprintf (v, maxlen, "%2.3f", r);
 731                         }
 732                         break;
 733                 case EXIF_FORMAT_UNDEFINED:
 734                 default:
 735                         snprintf (v, maxlen, _("%i bytes unknown data: "),
 736                                   entry->size);
 737                         for (i = 0; i < (int)entry->size; i++) {
 738                                 sprintf (buf, "%02x", entry->data[i]);
 739                                 strncat (v, buf, maxlen - strlen (v));
 740                         }
 741                         break;
 742                 }
 743                 break;
 744         }
 745
 746         return (v);
 747 }