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 #undef  MIN
  56 #define MIN(a, b)  (((a) < (b)) ? (a) : (b))
  57
  58 static struct {
  59         ExifTag tag;
  60     ExifFormat fmt;
  61         struct {
  62                 int index;
  63                 const char *string;
  64         } elem[8];
  65 } items[] = {
  66   { MNOTE_NIKON_TAG_LENSTYPE, EXIF_FORMAT_BYTE,
  67     { {0, N_("AF non D Lens")},
  68       {1, N_("Manual")},
  69       {2, N_("AF-D or AF-S Lens")},
  70       {6, N_("AF-D G Lens")},
  71       {10, N_("AF-D VR Lens")},
  72       {0, NULL}}},
  73   { MNOTE_NIKON_TAG_FLASHUSED, EXIF_FORMAT_BYTE,
  74     { {0, N_("Flash did not fire")},
  75       {4, N_("Flash unit unknown")},
  76       {7, N_("Flash is external")},
  77       {9, N_("Flash is on Camera")},
  78       {0, NULL}}},
  79   { MNOTE_NIKON1_TAG_QUALITY, EXIF_FORMAT_SHORT,
  80     { {1, N_("VGA Basic")},
  81       {2, N_("VGA Normal")},
  82       {3, N_("VGA Fine")},
  83       {4, N_("SXGA Basic")},
  84       {5, N_("SXGA Normal")},
  85       {6, N_("SXGA Fine")},
  86       {0, NULL}}},
  87   { MNOTE_NIKON1_TAG_COLORMODE, EXIF_FORMAT_SHORT,
  88     { {1, N_("Color")},
  89       {2, N_("Monochrome")},
  90       {0, NULL}}},
  91   { MNOTE_NIKON1_TAG_IMAGEADJUSTMENT, EXIF_FORMAT_SHORT,
  92     { {0, N_("Normal")},
  93       {1, N_("Bright+")},
  94       {2, N_("Bright-")},
  95       {3, N_("Contrast+")},
  96       {4, N_("Contrast-")},
  97       {0, NULL}}},
  98   { MNOTE_NIKON1_TAG_CCDSENSITIVITY, EXIF_FORMAT_SHORT,
  99     { {0, N_("ISO80")},
 100       {2, N_("ISO160")},
 101       {4, N_("ISO320")},
 102       {5, N_("ISO100")},
 103       {0, NULL}}},
 104   { MNOTE_NIKON1_TAG_WHITEBALANCE, EXIF_FORMAT_SHORT,
 105     { {0, N_("Auto")},
 106       {1, N_("Preset")},
 107       {2, N_("Daylight")},
 108       {3, N_("Incandescense")},
 109       {4, N_("Fluorescence")},
 110       {5, N_("Cloudy")},
 111       {6, N_("SpeedLight")},
 112       {0, NULL}}},
 113   { MNOTE_OLYMPUS_TAG_QUALITY, EXIF_FORMAT_SHORT,
 114     { {1, N_("SQ")},
 115       {2, N_("HQ")},
 116       {3, N_("SHQ")},
 117       {0, NULL}}},
 118   { MNOTE_OLYMPUS_TAG_MACRO, EXIF_FORMAT_SHORT,
 119     { {0, N_("No")},
 120       {1, N_("Yes")},
 121       {0, NULL}}},
 122   { MNOTE_OLYMPUS_TAG_DIGIZOOM, EXIF_FORMAT_SHORT,
 123     { {0, N_("1x")},
 124       {2, N_("2x")},
 125       {0, NULL}}},
 126   { MNOTE_OLYMPUS_TAG_FLASHMODE, EXIF_FORMAT_SHORT,
 127     { {0, N_("Auto")},
 128       {1, N_("Red-eye reduction")},
 129       {2, N_("Fill")},
 130       {3, N_("Off")},
 131       {0, NULL}}},
 132   { MNOTE_OLYMPUS_TAG_SHARPNESS, EXIF_FORMAT_SHORT,
 133     { {0, N_("Normal")},
 134       {1, N_("Hard")},
 135       {2, N_("Soft")},
 136       {0, NULL}}},
 137   { MNOTE_OLYMPUS_TAG_CONTRAST, EXIF_FORMAT_SHORT,
 138     { {0, N_("Hard")},
 139       {1, N_("Normal")},
 140       {2, N_("Soft")},
 141       {0, NULL}}},
 142   { MNOTE_OLYMPUS_TAG_MANFOCUS, EXIF_FORMAT_SHORT,
 143     { {0, N_("No")},
 144       {1, N_("Yes")},
 145       {0, NULL}}},
 146   { 0, }
 147 };
 148
 149 char *
 150 mnote_olympus_entry_get_value (MnoteOlympusEntry *entry, char *v, unsigned int maxlen)
 151 {
 152         char         buf[32];
 153         ExifLong     vl;
 154         ExifShort    vs;
 155         ExifRational vr;
 156         int          i, j;
 157
 158         if (!entry)
 159                 return (NULL);
 160
 161         memset (v, 0, maxlen);
 162         maxlen--;
 163
 164         if ((!entry->data) && (entry->components > 0)) return (v);
 165
 166         switch (entry->tag) {
 167
 168         /* Nikon */
 169         case MNOTE_NIKON_TAG_FIRMWARE:
 170                 CF (entry->format,  EXIF_FORMAT_UNDEFINED, v, maxlen);
 171                 CC (entry->components, 4, v, maxlen);
 172                 vl =  exif_get_long (entry->data, entry->order);
 173                 snprintf (v, maxlen, "0x%04lx", vl);
 174                 break;
 175         case MNOTE_NIKON_TAG_ISO:
 176                 CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
 177                 CC (entry->components, 2, v, maxlen);
 178                 //vs = exif_get_short (entry->data, entry->order);
 179                 vs = exif_get_short (entry->data + 2, entry->order);
 180                 snprintf (v, maxlen, "ISO %hd", vs);
 181                 break;
 182         case MNOTE_NIKON_TAG_ISO2:
 183                 CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
 184                 CC (entry->components, 2, v, maxlen);
 185                 //vs = exif_get_short (entry->data, entry->order);
 186                 vs = exif_get_short (entry->data + 2, entry->order);
 187                 snprintf (v, maxlen, "ISO2 %hd", vs);
 188                 break;
 189         case MNOTE_NIKON_TAG_QUALITY:
 190                 CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
 191                 //CC (entry->components, 8, v, maxlen);
 192                 //vl =  exif_get_long (entry->data  , entry->order);
 193                 //printf("-> 0x%04x\n",entry->data);
 194                 //printf("-> 0x%s<\n",entry->data - 0);
 195                 memcpy(v, entry->data ,entry->components);
 196                 //snprintf (v, maxlen, "%s<",  ( entry->data - 9  );
 197                 break;
 198         case MNOTE_NIKON_TAG_COLORMODE:
 199         case MNOTE_NIKON_TAG_COLORMODE1:
 200         case MNOTE_NIKON_TAG_WHITEBALANCE:
 201         case MNOTE_NIKON_TAG_SHARPENING:
 202         case MNOTE_NIKON_TAG_FOCUSMODE:
 203         case MNOTE_NIKON_TAG_FLASHSETTING:
 204         case MNOTE_NIKON_TAG_ISOSELECTION:
 205         case MNOTE_NIKON_TAG_FLASHMODE:
 206         case MNOTE_NIKON_TAG_IMAGEADJUSTMENT:
 207         case MNOTE_NIKON_TAG_ADAPTER:
 208                 CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
 209                 memcpy(v, entry->data, MIN (maxlen, entry->components));
 210                 break;
 211         case MNOTE_NIKON_TAG_TOTALPICTURES:
 212                 CF (entry->format, EXIF_FORMAT_LONG, v, maxlen);
 213                 CC (entry->components, 1, v, maxlen);
 214                 vl =  exif_get_long (entry->data, entry->order);
 215                 snprintf (v, maxlen, "%lu",  vl );
 216                 break;
 217         case MNOTE_NIKON_TAG_WHITEBALANCEFINE:
 218                 CF (entry->format, EXIF_FORMAT_SSHORT, v, maxlen);
 219                 CC (entry->components, 1, v, maxlen);
 220                 vs = exif_get_short (entry->data, entry->order);
 221                 snprintf (v, maxlen, "%hd", vs);
 222                 break;
 223         case MNOTE_NIKON_TAG_WHITEBALANCERB:
 224                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
 225                 CC (entry->components, 4, v, maxlen);
 226                 //vr = exif_get_rational (entry->data, entry->order);
 227                 //if (vr.numerator == 0) {
 228                 //      strncpy (v, _("Unknown"), maxlen);
 229                 //}
 230                 //else {
 231                 {
 232                         float r,b;
 233                         vr = exif_get_rational (entry->data, entry->order);
 234                         r = (1.0*vr.numerator) / vr.denominator;
 235                         vr = exif_get_rational (entry->data+8, entry->order);
 236                         b = (1.0*vr.numerator) / vr.denominator;
 237                         //printf("numerator %li, denominator %li\n", vr.numerator, vr.denominator);
 238                         snprintf (v, maxlen, "Red Correction %f, Blue Correction %f", r,b);
 239                 }
 240                 break;
 241         case MNOTE_NIKON_TAG_AFFOCUSPOSITION:
 242                 CF (entry->format, EXIF_FORMAT_UNDEFINED, v, maxlen);
 243                 CC (entry->components, 4, v, maxlen);
 244                 switch (  *( entry->data+1)  ) {
 245                         case  0: strncpy (v, "AF Position: Center", maxlen); break;
 246                         case  1: strncpy (v, "AF Position: Top", maxlen); break;
 247                         case  2: strncpy (v, "AF Position: Bottom", maxlen); break;
 248                         case  3: strncpy (v, "AF Position: Left", maxlen); break;
 249                         case  4: strncpy (v, "AF Position: Right", maxlen); break;
 250                         default: strncpy (v, "Unknown AF Position", maxlen);
 251                 }
 252                 break;
 253         case MNOTE_NIKON_TAG_LENSTYPE:
 254         case MNOTE_NIKON_TAG_FLASHUSED:
 255         case MNOTE_NIKON1_TAG_QUALITY:
 256         case MNOTE_NIKON1_TAG_COLORMODE:
 257         case MNOTE_NIKON1_TAG_IMAGEADJUSTMENT:
 258         case MNOTE_NIKON1_TAG_CCDSENSITIVITY:
 259         case MNOTE_NIKON1_TAG_WHITEBALANCE:
 260         case MNOTE_OLYMPUS_TAG_QUALITY:
 261         case MNOTE_OLYMPUS_TAG_MACRO:
 262         case MNOTE_OLYMPUS_TAG_DIGIZOOM:
 263         case MNOTE_OLYMPUS_TAG_FLASHMODE:
 264         case MNOTE_OLYMPUS_TAG_SHARPNESS:
 265         case MNOTE_OLYMPUS_TAG_CONTRAST:
 266         case MNOTE_OLYMPUS_TAG_MANFOCUS:
 267                 /* search the tag */
 268                 for (i = 0; (items[i].tag && items[i].tag != entry->tag); i++);
 269                 if (!items[i].tag) {
 270                         strncpy (v, "Internal error", maxlen);
 271                         break;
 272                 }
 273                 CF (entry->format, items[i].fmt, v, maxlen);
 274                 CC (entry->components, 1, v, maxlen);
 275                 switch (entry->format) {
 276                         case EXIF_FORMAT_BYTE:
 277                         case EXIF_FORMAT_UNDEFINED:
 278                                 vs = entry->data[0];
 279                                 break;
 280                         case EXIF_FORMAT_SHORT:
 281                                 vs = exif_get_short(entry->data, entry->order);
 282                                 break;
 283                 }
 284                 /* find the value */
 285                 for (j = 0; items[i].elem[j].string &&
 286                             (items[i].elem[j].index < vs); j++);
 287                 if (items[i].elem[j].index != vs) {
 288                         snprintf (v, maxlen, "Unknown value %hi", vs);
 289                         break;
 290                 }
 291                 strncpy (v, items[i].elem[j].string, maxlen);
 292                 break;
 293
 294         case MNOTE_NIKON_TAG_LENS:
 295                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
 296                 CC (entry->components, 4, v, maxlen);
 297                 {
 298                         float c,d;
 299                         unsigned long a,b;
 300                         vr = exif_get_rational (entry->data, entry->order);
 301                         a = vr.numerator / vr.denominator;
 302                         vr = exif_get_rational (entry->data+8, entry->order);
 303                         b = vr.numerator / vr.denominator;
 304                         vr = exif_get_rational (entry->data+16, entry->order);
 305                         c = (1.0*vr.numerator) / vr.denominator;
 306                         vr = exif_get_rational (entry->data+24, entry->order);
 307                         d = (1.0*vr.numerator) / vr.denominator;
 308                         //printf("numerator %li, denominator %li\n", vr.numerator, vr.denominator);                         snprintf (v, sizeof (v), "%ld-%ldmm 1:%3.1f - %3.1f",a,b,c,d);
 309                 }
 310                 break;
 311
 312         /* Olympus */
 313         case MNOTE_OLYMPUS_TAG_MODE:
 314                 CF (entry->format, EXIF_FORMAT_LONG, v, maxlen);
 315                 CC (entry->components, 3, v, maxlen);
 316                 vl = exif_get_long (entry->data, entry->order);
 317                 switch (vl) {
 318                 case 0:
 319                         strncpy (v, _("normal"), maxlen);
 320                         break;
 321                 case 1:
 322                         strncpy (v, _("unknown"), maxlen);
 323                         break;
 324                 case 2:
 325                         strncpy (v, _("fast"), maxlen);
 326                         break;
 327                 case 3:
 328                         strncpy (v, _("panorama"), maxlen);
 329                         break;
 330                 default:
 331                         snprintf (v, maxlen, _("%li"), vl);
 332                 }
 333                 vl = exif_get_long (entry->data + 4, entry->order);
 334                 snprintf (buf, sizeof (buf), "/%li/", vl);
 335                 strncat (v, buf, maxlen - strlen (v));
 336                 vl = exif_get_long (entry->data + 4, entry->order);
 337                 switch (vl) {
 338                 case 1:
 339                         strncat (v, _("left to right"), maxlen - strlen (v));
 340                         break;
 341                 case 2:
 342                         strncat (v, _("right to left"), maxlen - strlen (v));
 343                         break;
 344                 case 3:
 345                         strncat (v, _("bottom to top"), maxlen - strlen (v));
 346                         break;
 347                 case 4:
 348                         strncat (v, _("top to bottom"), maxlen - strlen (v));
 349                         break;
 350                 default:
 351                         snprintf (buf, sizeof (buf), _("%li"), vl);
 352                         strncat (v, buf, maxlen - strlen (v));
 353                 }
 354                 break;
 355         case MNOTE_OLYMPUS_TAG_UNKNOWN_1:
 356                 CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
 357                 CC (entry->components, 1, v, maxlen);
 358                 strncpy (v, _("Unknown tag."), maxlen);
 359                 break;
 360         case MNOTE_OLYMPUS_TAG_UNKNOWN_2:
 361                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
 362                 CC (entry->components, 1, v, maxlen);
 363                 break;
 364         case MNOTE_OLYMPUS_TAG_UNKNOWN_3:
 365                 CF (entry->format, EXIF_FORMAT_SSHORT, v, maxlen);
 366                 CC (entry->components, 1, v, maxlen);
 367                 break;
 368         case MNOTE_OLYMPUS_TAG_VERSION:
 369                 CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
 370                 CC (entry->components, 5, v, maxlen);
 371                 strncpy (v, entry->data, MIN (maxlen, entry->size));
 372                 break;
 373         case MNOTE_OLYMPUS_TAG_INFO:
 374                 CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
 375                 CC (entry->components, 52, v, maxlen);
 376                 break;
 377         case MNOTE_OLYMPUS_TAG_ID:
 378                 CF (entry->format, EXIF_FORMAT_UNDEFINED, v, maxlen);
 379                 CC (entry->components, 32, v, maxlen);
 380                 strncpy (v, entry->data, MIN (maxlen, entry->size));
 381                 break;
 382         case MNOTE_OLYMPUS_TAG_UNKNOWN_4:
 383                 CF (entry->format, EXIF_FORMAT_LONG, v, maxlen);
 384                 CC (entry->components, 30, v, maxlen);
 385                 break;
 386         case MNOTE_OLYMPUS_TAG_FOCUSDIST:
 387                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
 388                 CC (entry->components, 1, v, maxlen);
 389                 vr = exif_get_rational (entry->data, entry->order);
 390                 if (vr.numerator == 0) {
 391                         strncpy (v, _("Unknown"), maxlen);
 392                 }
 393                 else {
 394                         unsigned long tmp = vr.numerator / vr.denominator;
 395                         /* printf("numerator %li, denominator %li\n", vr.numerator, vr.denominator); */
 396                         snprintf (v, maxlen, "%li mm", tmp);
 397                 }
 398                 break;
 399         case MNOTE_OLYMPUS_TAG_WBALANCE:
 400                 CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
 401                 CC (entry->components, 2, v, maxlen);
 402                 vs = exif_get_short (entry->data, entry->order);
 403                 switch (vs) {
 404                 case 1:
 405                         strncpy (v, _("Automatic"), maxlen);
 406                         break;
 407                 case 2:
 408                         {
 409                                 ExifShort v2 = exif_get_short (entry->data + 2, entry->order);
 410                                 unsigned long colorTemp = 0;
 411                                 switch (v2) {
 412                                 case 2:
 413                                         colorTemp = 3000;
 414                                         break;
 415                                 case 3:
 416                                         colorTemp = 3700;
 417                                         break;
 418                                 case 4:
 419                                         colorTemp = 4000;
 420                                         break;
 421                                 case 5:
 422                                         colorTemp = 4500;
 423                                         break;
 424                                 case 6:
 425                                         colorTemp = 5500;
 426                                         break;
 427                                 case 7:
 428                                         colorTemp = 6500;
 429                                         break;
 430                                 case 9:
 431                                         colorTemp = 7500;
 432                                         break;
 433                                 }
 434                                 if (colorTemp) {
 435                                         snprintf (v, maxlen, "Manual: %liK", colorTemp);
 436                                 }
 437                                 else {
 438                                         strncpy (v, _("Manual: Unknown"), maxlen);
 439                                 }
 440
 441                         }
 442                         break;
 443                 case 3:
 444                         strncpy (v, _("One-touch"), maxlen);
 445                         break;
 446                 default:
 447                         strncpy (v, _("Unknown"), maxlen);
 448                         break;
 449                 }
 450                 break;
 451         default:
 452                 switch (entry->format) {
 453                 case EXIF_FORMAT_ASCII:
 454                   strncpy (v, entry->data, MIN (maxlen, entry->components));
 455                   break;
 456                 case EXIF_FORMAT_SHORT:
 457                   vs = exif_get_short (entry->data, entry->order);
 458                   snprintf (v, maxlen, "%hi", vs);
 459                   break;
 460                 case EXIF_FORMAT_LONG:
 461                   vl = exif_get_long (entry->data, entry->order);
 462                   snprintf (v, maxlen, "%li", vl);
 463                   break;
 464                 case EXIF_FORMAT_UNDEFINED:
 465                 default:
 466                   snprintf (v, maxlen, "%li bytes unknown data",
 467                             entry->size);
 468                   break;
 469                 }
 470                 break;
 471         }
 472
 473         return (v);
 474 }