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/i18n.h>
  31
  32 #define CF(format,target,v,maxlen)                              \
  33 {                                                               \
  34         if (format != target) {                                 \
  35                 snprintf (v, maxlen,                            \
  36                         _("Invalid format '%s', "               \
  37                         "expected '%s'."),                      \
  38                         exif_format_get_name (format),          \
  39                         exif_format_get_name (target));         \
  40                 break;                                          \
  41         }                                                       \
  42 }
  43
  44 #define CC(number,target,v,maxlen)                                      \
  45 {                                                                       \
  46         if (number != target) {                                         \
  47                 snprintf (v, maxlen,                                    \
  48                         _("Invalid number of components (%i, "          \
  49                         "expected %i)."), (int) number, (int) target);  \
  50                 break;                                                  \
  51         }                                                               \
  52 }
  53
  54 #undef  MIN
  55 #define MIN(a, b)  (((a) < (b)) ? (a) : (b))
  56
  57 char *
  58 mnote_olympus_entry_get_value (MnoteOlympusEntry *entry, char *val, unsigned int maxlen)
  59 {
  60         char buf[32];
  61         ExifLong vl;
  62         ExifShort vs;
  63         ExifRational vr;
  64
  65         if (!entry)
  66                 return (NULL);
  67
  68         memset (val, 0, maxlen);
  69         maxlen--;
  70
  71         if ((!entry->data) && (entry->components > 0)) return (val);
  72
  73         switch (entry->tag) {
  74         case MNOTE_OLYMPUS_TAG_MODE:
  75                 CF (entry->format, EXIF_FORMAT_LONG, val, maxlen);
  76                 CC (entry->components, 3, val, maxlen);
  77                 vl = exif_get_long (entry->data, entry->order);
  78                 switch (vl) {
  79                 case 0:
  80                         strncpy (val, _("normal"), maxlen);
  81                         break;
  82                 case 1:
  83                         strncpy (val, _("unknown"), maxlen);
  84                         break;
  85                 case 2:
  86                         strncpy (val, _("fast"), maxlen);
  87                         break;
  88                 case 3:
  89                         strncpy (val, _("panorama"), maxlen);
  90                         break;
  91                 default:
  92                         snprintf (val, maxlen, _("%li"), vl);
  93                 }
  94                 vl = exif_get_long (entry->data + 4, entry->order);
  95                 snprintf (buf, sizeof (buf), "/%li/", vl);
  96                 strncat (val, buf, maxlen - strlen(val));
  97                 vl = exif_get_long (entry->data + 4, entry->order);
  98                 switch (vl) {
  99                 case 1:
 100                         strncat (val, _("left to right"), maxlen - strlen(val));
 101                         break;
 102                 case 2:
 103                         strncat (val, _("right to left"), maxlen - strlen(val));
 104                         break;
 105                 case 3:
 106                         strncat (val, _("bottom to top"), maxlen - strlen(val));
 107                         break;
 108                 case 4:
 109                         strncat (val, _("top to bottom"), maxlen - strlen(val));
 110                         break;
 111                 default:
 112                         snprintf (buf, sizeof (buf), _("%li"), vl);
 113                         strncat (val, buf, maxlen - strlen(val));
 114                 }
 115                 break;
 116         case MNOTE_OLYMPUS_TAG_QUALITY:
 117                 CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
 118                 CC (entry->components, 1, val, maxlen);
 119                 vs = exif_get_short (entry->data, entry->order);
 120                 switch (vs) {
 121                 case 1:
 122                         strncpy (val, _("SQ"), maxlen);
 123                         break;
 124                 case 2:
 125                         strncpy (val, _("HQ"), maxlen);
 126                         break;
 127                 case 3:
 128                         strncpy (val, _("SHQ"), maxlen);
 129                         break;
 130                 default:
 131                         snprintf (val, maxlen, _("%i"), vs);
 132                 }
 133                 break;
 134         case MNOTE_OLYMPUS_TAG_MACRO:
 135                 CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
 136                 CC (entry->components, 1, val, maxlen);
 137                 vs = exif_get_short (entry->data, entry->order);
 138                 switch (vs) {
 139                 case 0:
 140                         strncpy (val, _("no"), maxlen);
 141                         break;
 142                 case 1:
 143                         strncpy (val, _("yes"), maxlen);
 144                         break;
 145                 default:
 146                         snprintf (val, maxlen, _("%i"), vs);
 147                 }
 148                 break;
 149         case MNOTE_OLYMPUS_TAG_UNKNOWN_1:
 150                 CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
 151                 CC (entry->components, 1, val, maxlen);
 152                 strncpy (val, _("Unknown tag."), maxlen);
 153                 break;
 154         case MNOTE_OLYMPUS_TAG_DIGIZOOM:
 155                 CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
 156                 CC (entry->components, 1, val, maxlen);
 157                 vs = exif_get_short (entry->data, entry->order);
 158                 switch (vs) {
 159                 case 0:
 160                         strncpy (val, _("1x"), maxlen);
 161                         break;
 162                 case 2:
 163                         strncpy (val, _("2x"), maxlen);
 164                         break;
 165                 default:
 166                         snprintf (val, maxlen, _("%i"), vs);
 167                 }
 168                 break;
 169         case MNOTE_OLYMPUS_TAG_UNKNOWN_2:
 170                 CF (entry->format, EXIF_FORMAT_RATIONAL, val, maxlen);
 171                 CC (entry->components, 1, val, maxlen);
 172                 break;
 173         case MNOTE_OLYMPUS_TAG_UNKNOWN_3:
 174                 CF (entry->format, EXIF_FORMAT_SSHORT, val, maxlen);
 175                 CC (entry->components, 1, val, maxlen);
 176                 break;
 177         case MNOTE_OLYMPUS_TAG_VERSION:
 178                 CF (entry->format, EXIF_FORMAT_ASCII, val, maxlen);
 179                 CC (entry->components, 5, val, maxlen);
 180                 strncpy (val, entry->data, MIN (maxlen, entry->size));
 181                 break;
 182         case MNOTE_OLYMPUS_TAG_INFO:
 183                 CF (entry->format, EXIF_FORMAT_ASCII, val, maxlen);
 184                 CC (entry->components, 52, val, maxlen);
 185                 break;
 186         case MNOTE_OLYMPUS_TAG_ID:
 187                 CF (entry->format, EXIF_FORMAT_UNDEFINED, val, maxlen);
 188                 CC (entry->components, 32, val, maxlen);
 189                 strncpy (val, entry->data, MIN (maxlen, entry->size));
 190                 break;
 191         case MNOTE_OLYMPUS_TAG_UNKNOWN_4:
 192                 CF (entry->format, EXIF_FORMAT_LONG, val, maxlen);
 193                 CC (entry->components, 30, val, maxlen);
 194                 break;
 195         case MNOTE_OLYMPUS_TAG_FLASHMODE:
 196                 CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
 197                 CC (entry->components, 1, val, maxlen);
 198                 vs = exif_get_short (entry->data, entry->order);
 199                 switch (vs) {
 200                 case 0:
 201                         strncpy (val, _("Auto"), maxlen);
 202                         break;
 203                 case 1:
 204                         strncpy (val, _("Red-eye reduction"), maxlen);
 205                         break;
 206                 case 2:
 207                         strncpy (val, _("Fill"), maxlen);
 208                         break;
 209                 case 3:
 210                         strncpy (val, _("Off"), maxlen);
 211                         break;
 212                 default:
 213                         snprintf (val, maxlen, _("%i"), vs);
 214                 }
 215                 break;
 216         case MNOTE_OLYMPUS_TAG_FOCUSDIST:
 217                 CF (entry->format, EXIF_FORMAT_RATIONAL, val, maxlen);
 218                 CC (entry->components, 1, val, maxlen);
 219                 vr = exif_get_rational (entry->data, entry->order);
 220                 if (vr.numerator == 0) {
 221                         strncpy (val, _("Unknown"), maxlen);
 222                 }
 223                 else {
 224                         unsigned long tmp = vr.numerator / vr.denominator;
 225                         /* printf("numerator %li, denominator %li\n", vr.numerator, vr.denominator); */
 226                         snprintf (val, maxlen, "%li mm", tmp);
 227                 }
 228                 break;
 229         case MNOTE_OLYMPUS_TAG_SHARPNESS:
 230                 CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
 231                 CC (entry->components, 1, val, maxlen);
 232                 vs = exif_get_short (entry->data, entry->order);
 233                 switch (vs) {
 234                 case 0:
 235                         strncpy (val, _("Normal"), maxlen);
 236                         break;
 237                 case 1:
 238                         strncpy (val, _("Hard"), maxlen);
 239                         break;
 240                 case 2:
 241                         strncpy (val, _("Soft"), maxlen);
 242                         break;
 243                 default:
 244                         snprintf (val, maxlen, _("%i"), vs);
 245                 }
 246                 break;
 247         case MNOTE_OLYMPUS_TAG_WBALANCE:
 248                 CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
 249                 CC (entry->components, 2, val, maxlen);
 250                 vs = exif_get_short (entry->data, entry->order);
 251                 switch (vs) {
 252                 case 1:
 253                         strncpy (val, _("Automatic"), maxlen);
 254                         break;
 255                 case 2:
 256                         {
 257                                 ExifShort v2 = exif_get_short (entry->data + 2, entry->order);
 258                                 unsigned long colorTemp = 0;
 259                                 switch (v2) {
 260                                 case 2:
 261                                         colorTemp = 3000;
 262                                         break;
 263                                 case 3:
 264                                         colorTemp = 3700;
 265                                         break;
 266                                 case 4:
 267                                         colorTemp = 4000;
 268                                         break;
 269                                 case 5:
 270                                         colorTemp = 4500;
 271                                         break;
 272                                 case 6:
 273                                         colorTemp = 5500;
 274                                         break;
 275                                 case 7:
 276                                         colorTemp = 6500;
 277                                         break;
 278                                 case 9:
 279                                         colorTemp = 7500;
 280                                         break;
 281                                 }
 282                                 if (colorTemp) {
 283                                         snprintf (val, maxlen, "Manual: %liK", colorTemp);
 284                                 }
 285                                 else {
 286                                         strncpy (val, _("Manual: Unknown"), maxlen);
 287                                 }
 288
 289                         }
 290                         break;
 291                 case 3:
 292                         strncpy (val, _("One-touch"), maxlen);
 293                         break;
 294                 default:
 295                         strncpy (val, _("Unknown"), maxlen);
 296                         break;
 297                 }
 298                 break;
 299         case MNOTE_OLYMPUS_TAG_CONTRAST:
 300                 CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
 301                 CC (entry->components, 1, val, maxlen);
 302                 vs = exif_get_short (entry->data, entry->order);
 303                 switch (vs) {
 304                 case 0:
 305                         strncpy (val, _("Hard"), maxlen);
 306                         break;
 307                 case 1:
 308                         strncpy (val, _("Normal"), maxlen);
 309                         break;
 310                 case 2:
 311                         strncpy (val, _("Soft"), maxlen);
 312                         break;
 313                 default:
 314                         snprintf (val, maxlen, "%i", vs);
 315                 }
 316                 break;
 317         case MNOTE_OLYMPUS_TAG_MANFOCUS:
 318                 CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
 319                 CC (entry->components, 1, val, maxlen);
 320                 vs = exif_get_short (entry->data, entry->order);
 321                 switch (vs) {
 322                 case 0:
 323                         strncpy (val, _("No"), maxlen);
 324                         break;
 325                 case 1:
 326                         strncpy (val, _("Yes"), maxlen);
 327                         break;
 328                 default:
 329                         snprintf (val, maxlen, _("%i"), vs);
 330                 }
 331                 break;
 332         default:
 333                 break;
 334         }
 335
 336         return (val);
 337 }