2004-05-04 Lutz Mueller <lutz@users.sourceforge.net>

	* libexif/olympus: Make it support Nikon maker notes, too.
	  Code based on work by Serge Droz <serge.droz@psi.ch>.

diff --git a/ChangeLog b/ChangeLog
index fd169c1..3a4dab7 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,8 @@
+2004-05-04  Lutz Mueller <lutz@users.sourceforge.net>
+
+       * libexif/olympus: Make it support Nikon maker notes, too. 
+         Code based on work by Serge Droz <serge.droz@psi.ch>.
+
 2004-05-03  Lutz Mueller <lutz@users.sourceforge.net>
 
        * libexif/exif-entry.c (exif_entry_initialize):

diff --git a/libexif/exif-data.c b/libexif/exif-data.c
index d66c90d..c16d819 100644 (file)
--- a/libexif/exif-data.c
+++ b/libexif/exif-data.c
@@ -660,7 +660,8 @@ exif_data_load_data (ExifData *data, const unsigned char *d_orig,
        if (e) {
 
            /* Olympus */
-           if ((e->size >= 5) && (!memcmp (e->data, "OLYMP", 5)))
+           if ((e->size >= 5) && (!memcmp (e->data, "OLYMP", 5) ||
+                                  !memcmp (e->data, "Nikon", 5)))
                data->priv->md = exif_mnote_data_olympus_new ();
 
            /* Pentax */

diff --git a/libexif/olympus/exif-mnote-data-olympus.c b/libexif/olympus/exif-mnote-data-olympus.c
index 38d21a6..9d5ef28 100644 (file)
--- a/libexif/olympus/exif-mnote-data-olympus.c
+++ b/libexif/olympus/exif-mnote-data-olympus.c
@@ -128,9 +128,13 @@ exif_mnote_data_olympus_load (ExifMnoteData *en,
         * Olympus headers start with "OLYMP" and need to have at least
         * a size of 22 bytes (6 for 'OLYMP', 2 other bytes, 2 for the
         * number of entries, and 12 for one entry.
+        *
+        * Nikon headers start with "Nikon".
         */
+       if (buf_size - n->offset - 6 < 5) return;
+       if (memcmp (buf + 6 + n->offset, "Nikon", 5) ||
+           memcmp (buf + 6 + n->offset, "OLYMP", 5)) return;
        if (buf_size - n->offset < 22) return;
-       if (memcmp (buf + 6 + n->offset, "OLYMP", 5)) return;
 
        /* Read the number of entries and remove old ones. */
        c = exif_get_short (buf + 6 + n->offset + 8, n->order);

diff --git a/libexif/olympus/mnote-olympus-entry.c b/libexif/olympus/mnote-olympus-entry.c
index f170bc0..ba610e9 100644 (file)
--- a/libexif/olympus/mnote-olympus-entry.c
+++ b/libexif/olympus/mnote-olympus-entry.c
@@ -55,7 +55,7 @@
 #define MIN(a, b)  (((a) < (b)) ? (a) : (b))
 
 char *
-mnote_olympus_entry_get_value (MnoteOlympusEntry *entry, char *val, unsigned int maxlen)
+mnote_olympus_entry_get_value (MnoteOlympusEntry *entry, char *v, unsigned int maxlen)
 {
        char buf[32];
        ExifLong vl;
@@ -65,192 +65,338 @@ mnote_olympus_entry_get_value (MnoteOlympusEntry *entry, char *val, unsigned int
        if (!entry)
                return (NULL);
 
-       memset (val, 0, maxlen);
+       memset (v, 0, maxlen);
        maxlen--;
 
-       if ((!entry->data) && (entry->components > 0)) return (val);
+       if ((!entry->data) && (entry->components > 0)) return (v);
 
        switch (entry->tag) {
+       
+       /* Nikon */
+        case MNOTE_NIKON_TAG_FIRMWARE:
+                CF (entry->format,  EXIF_FORMAT_UNDEFINED, v, maxlen);
+                CC (entry->components, 4, v, maxlen);
+                vl =  exif_get_long (entry->data, entry->order);
+                snprintf (v, sizeof (v), "0x%04lx", vl);
+                break;
+        case MNOTE_NIKON_TAG_ISO:
+                CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
+                CC (entry->components, 2, v, maxlen);
+                //vs = exif_get_short (entry->data, entry->order);
+                vs = exif_get_short (entry->data + 2, entry->order);
+                snprintf (v, sizeof (v), "ISO %hd", vs);
+                break;
+        case MNOTE_NIKON_TAG_ISO2:
+                CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
+                CC (entry->components, 2, v, maxlen);
+                //vs = exif_get_short (entry->data, entry->order);
+                vs = exif_get_short (entry->data + 2, entry->order);
+                snprintf (v, sizeof (v), "ISO2 %hd", vs);
+                break;
+        case MNOTE_NIKON_TAG_QUALITY:
+                CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
+                //CC (entry->components, 8, v, maxlen);
+                //vl =  exif_get_long (entry->data  , entry->order);
+                //printf("-> 0x%04x\n",entry->data);
+                //printf("-> 0x%s<\n",entry->data - 0);
+                memcpy(v, entry->data ,entry->components);
+                //snprintf (v, sizeof (v), "%s<",  ( entry->data - 9  );
+                break;
+        case MNOTE_NIKON_TAG_COLORMODE:
+                CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
+                memcpy(v, entry->data ,entry->components);
+                break;
+        case MNOTE_NIKON_TAG_COLORMODE1:
+                CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
+                memcpy(v, entry->data ,entry->components);
+                break;
+        case MNOTE_NIKON_TAG_TOTALPICTURES:
+                CF (entry->format, EXIF_FORMAT_LONG, v, maxlen);
+                CC (entry->components, 1, v, maxlen);
+                vl =  exif_get_long (entry->data  , entry->order);
+                snprintf (v, sizeof (v), "%lu",  vl  );
+                break;
+        case MNOTE_NIKON_TAG_WHITEBALANCE:
+                CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
+                memcpy(v, entry->data ,entry->components);
+                break;
+        case MNOTE_NIKON_TAG_SHARPENING:
+                CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
+                memcpy(v, entry->data ,entry->components);
+                break;
+        case MNOTE_NIKON_TAG_FOCUSMODE:
+                CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
+                memcpy(v, entry->data ,entry->components);
+                break;
+        case MNOTE_NIKON_TAG_FLASHSETTING:
+                CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
+                memcpy(v, entry->data ,entry->components);
+                break;
+        case MNOTE_NIKON_TAG_ISOSELECTION:
+                CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
+                memcpy(v, entry->data ,entry->components);
+                break;
+        case MNOTE_NIKON_TAG_FLASHMODE:
+                CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
+                memcpy(v, entry->data ,entry->components);
+                break;
+        case MNOTE_NIKON_TAG_WHITEBALANCEFINE:
+                CF (entry->format, EXIF_FORMAT_SSHORT, v, maxlen);
+                CC (entry->components, 1, v, maxlen);
+                vs =  exif_get_short (entry->data, entry->order);
+                snprintf (v, sizeof (v), "%hd", vs);
+                break;
+        case MNOTE_NIKON_TAG_WHITEBALANCERB:
+                CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
+                CC (entry->components, 4, v, maxlen);
+                //vr = exif_get_rational (entry->data, entry->order);
+                //if (vr.numerator == 0) {
+                //      strncpy (v, _("Unknown"), sizeof (v));
+                //}
+                //else {
+                {
+                        float r,b;
+                        vr = exif_get_rational (entry->data, entry->order);
+                        r = (1.0*vr.numerator) / vr.denominator;
+                        vr = exif_get_rational (entry->data+8, entry->order);
+                        b = (1.0*vr.numerator) / vr.denominator;
+                        //printf("numerator %li, denominator %li\n", vr.numerator, vr.denominator);
+                        snprintf (v, sizeof (v), "Red Correction %f, Blue Correction %f", r,b);
+                }
+                break;
+        case MNOTE_NIKON_TAG_LENSTYPE:
+                CF (entry->format, EXIF_FORMAT_BYTE, v, maxlen);
+                CC (entry->components, 1, v, maxlen);
+                switch (  *( entry->data)  ) {
+                   case  0: snprintf (v, sizeof (v), "AF non D Lens"); break;
+                   case  1: snprintf (v, sizeof (v), "manual"); break;
+                   case  2: snprintf (v, sizeof (v), "AF-D or AF-S Lens"); break;
+                   case  6: snprintf (v, sizeof (v), "AF-D G Lens"); break;
+                   case 10: snprintf (v, sizeof (v), "AF-D VR Lens"); break;
+                   default: snprintf (v, sizeof (v), "unknown Lens");
+                }
+               break;
+        case MNOTE_NIKON_TAG_LENS:
+                CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
+                CC (entry->components, 4, v, maxlen);
+                {
+                        float c,d;
+                        unsigned long a,b;
+                        vr = exif_get_rational (entry->data, entry->order);
+                        a = vr.numerator / vr.denominator;
+                        vr = exif_get_rational (entry->data+8, entry->order);
+                        b = vr.numerator / vr.denominator;
+                        vr = exif_get_rational (entry->data+16, entry->order);
+                        c = (1.0*vr.numerator) / vr.denominator;
+                        vr = exif_get_rational (entry->data+24, entry->order);
+                        d = (1.0*vr.numerator) / vr.denominator;
+                                                                                                         //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);
+                }
+                break;
+        case MNOTE_NIKON_TAG_FLASHUSED:
+                CF (entry->format, EXIF_FORMAT_BYTE, v, maxlen);
+                CC (entry->components, 1, v, maxlen);
+                switch (  *( entry->data)  ) {
+                   case  0: snprintf (v, sizeof (v), "Flash did not fire"); break;
+                   case  4: snprintf (v, sizeof (v), "Flash unit unknown"); break;
+                   case  7: snprintf (v, sizeof (v), "Flash is external"); break;
+                   case  9: snprintf (v, sizeof (v), "Flash is on Camera"); break;
+                   default: snprintf (v, sizeof (v), "unknown Flash status");
+                }
+                break;
+        case MNOTE_NIKON_TAG_AFFOCUSPOSITION:
+                CF (entry->format, EXIF_FORMAT_UNDEFINED, v, maxlen);
+                CC (entry->components, 4, v, maxlen);
+                switch (  *( entry->data+1)  ) {
+                   case  0: snprintf (v, sizeof (v), "AF Position: Center"); break;
+                   case  1: snprintf (v, sizeof (v), "AF Position: Top"); break;                   case  2: snprintf (v, sizeof (v), "AF Position: Bottom"); break;
+                   case  3: snprintf (v, sizeof (v), "AF Position: Left"); break;
+                   case  4: snprintf (v, sizeof (v), "AF Position: Right"); break;
+                   default: snprintf (v, sizeof (v), "unknown AF Position");
+                }
+                break;
+
+       /* Olympus */
        case MNOTE_OLYMPUS_TAG_MODE:
-               CF (entry->format, EXIF_FORMAT_LONG, val, maxlen);
-               CC (entry->components, 3, val, maxlen);
+               CF (entry->format, EXIF_FORMAT_LONG, v, maxlen);
+               CC (entry->components, 3, v, maxlen);
                vl = exif_get_long (entry->data, entry->order);
                switch (vl) {
                case 0:
-                       strncpy (val, _("normal"), maxlen);
+                       strncpy (v, _("normal"), maxlen);
                        break;
                case 1:
-                       strncpy (val, _("unknown"), maxlen);
+                       strncpy (v, _("unknown"), maxlen);
                        break;
                case 2:
-                       strncpy (val, _("fast"), maxlen);
+                       strncpy (v, _("fast"), maxlen);
                        break;
                case 3:
-                       strncpy (val, _("panorama"), maxlen);
+                       strncpy (v, _("panorama"), maxlen);
                        break;
                default:
-                       snprintf (val, maxlen, _("%li"), vl);
+                       snprintf (v, maxlen, _("%li"), vl);
                }
                vl = exif_get_long (entry->data + 4, entry->order);
                snprintf (buf, sizeof (buf), "/%li/", vl);
-               strncat (val, buf, maxlen - strlen(val));
+               strncat (v, buf, maxlen - strlen (v));
                vl = exif_get_long (entry->data + 4, entry->order);
                switch (vl) {
                case 1:
-                       strncat (val, _("left to right"), maxlen - strlen(val));
+                       strncat (v, _("left to right"), maxlen - strlen (v));
                        break;
                case 2:
-                       strncat (val, _("right to left"), maxlen - strlen(val));
+                       strncat (v, _("right to left"), maxlen - strlen (v));
                        break;
                case 3:
-                       strncat (val, _("bottom to top"), maxlen - strlen(val));
+                       strncat (v, _("bottom to top"), maxlen - strlen (v));
                        break;
                case 4:
-                       strncat (val, _("top to bottom"), maxlen - strlen(val));
+                       strncat (v, _("top to bottom"), maxlen - strlen (v));
                        break;
                default:
                        snprintf (buf, sizeof (buf), _("%li"), vl);
-                       strncat (val, buf, maxlen - strlen(val));
+                       strncat (v, buf, maxlen - strlen (v));
                }
                break;
        case MNOTE_OLYMPUS_TAG_QUALITY:
-               CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
-               CC (entry->components, 1, val, maxlen);
+               CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
+               CC (entry->components, 1, v, maxlen);
                vs = exif_get_short (entry->data, entry->order);
                switch (vs) {
                case 1:
-                       strncpy (val, _("SQ"), maxlen);
+                       strncpy (v, _("SQ"), maxlen);
                        break;
                case 2:
-                       strncpy (val, _("HQ"), maxlen);
+                       strncpy (v, _("HQ"), maxlen);
                        break;
                case 3:
-                       strncpy (val, _("SHQ"), maxlen);
+                       strncpy (v, _("SHQ"), maxlen);
                        break;
                default:
-                       snprintf (val, maxlen, _("%i"), vs);
+                       snprintf (v, maxlen, _("%i"), vs);
                }
                break;
        case MNOTE_OLYMPUS_TAG_MACRO:
-               CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
-               CC (entry->components, 1, val, maxlen);
+               CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
+               CC (entry->components, 1, v, maxlen);
                vs = exif_get_short (entry->data, entry->order);
                switch (vs) {
                case 0:
-                       strncpy (val, _("no"), maxlen);
+                       strncpy (v, _("no"), maxlen);
                        break;
                case 1:
-                       strncpy (val, _("yes"), maxlen);
+                       strncpy (v, _("yes"), maxlen);
                        break;
                default:
-                       snprintf (val, maxlen, _("%i"), vs);
+                       snprintf (v, maxlen, _("%i"), vs);
                }
                break;
        case MNOTE_OLYMPUS_TAG_UNKNOWN_1:
-               CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
-               CC (entry->components, 1, val, maxlen);
-               strncpy (val, _("Unknown tag."), maxlen);
+               CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
+               CC (entry->components, 1, v, maxlen);
+               strncpy (v, _("Unknown tag."), maxlen);
                break;
        case MNOTE_OLYMPUS_TAG_DIGIZOOM:
-               CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
-               CC (entry->components, 1, val, maxlen);
+               CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
+               CC (entry->components, 1, v, maxlen);
                vs = exif_get_short (entry->data, entry->order);
                switch (vs) {
                case 0:
-                       strncpy (val, _("1x"), maxlen);
+                       strncpy (v, _("1x"), maxlen);
                        break;
                case 2:
-                       strncpy (val, _("2x"), maxlen);
+                       strncpy (v, _("2x"), maxlen);
                        break;
                default:
-                       snprintf (val, maxlen, _("%i"), vs);
+                       snprintf (v, maxlen, _("%i"), vs);
                }
                break;
        case MNOTE_OLYMPUS_TAG_UNKNOWN_2:
-               CF (entry->format, EXIF_FORMAT_RATIONAL, val, maxlen);
-               CC (entry->components, 1, val, maxlen);
+               CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
+               CC (entry->components, 1, v, maxlen);
                break;
        case MNOTE_OLYMPUS_TAG_UNKNOWN_3:
-               CF (entry->format, EXIF_FORMAT_SSHORT, val, maxlen);
-               CC (entry->components, 1, val, maxlen);
+               CF (entry->format, EXIF_FORMAT_SSHORT, v, maxlen);
+               CC (entry->components, 1, v, maxlen);
                break;
        case MNOTE_OLYMPUS_TAG_VERSION:
-               CF (entry->format, EXIF_FORMAT_ASCII, val, maxlen);
-               CC (entry->components, 5, val, maxlen);
-               strncpy (val, entry->data, MIN (maxlen, entry->size));
+               CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
+               CC (entry->components, 5, v, maxlen);
+               strncpy (v, entry->data, MIN (maxlen, entry->size));
                break;
        case MNOTE_OLYMPUS_TAG_INFO:
-               CF (entry->format, EXIF_FORMAT_ASCII, val, maxlen);
-               CC (entry->components, 52, val, maxlen);
+               CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
+               CC (entry->components, 52, v, maxlen);
                break;
        case MNOTE_OLYMPUS_TAG_ID:
-               CF (entry->format, EXIF_FORMAT_UNDEFINED, val, maxlen);
-               CC (entry->components, 32, val, maxlen);
-               strncpy (val, entry->data, MIN (maxlen, entry->size));
+               CF (entry->format, EXIF_FORMAT_UNDEFINED, v, maxlen);
+               CC (entry->components, 32, v, maxlen);
+               strncpy (v, entry->data, MIN (maxlen, entry->size));
                break;
        case MNOTE_OLYMPUS_TAG_UNKNOWN_4:
-               CF (entry->format, EXIF_FORMAT_LONG, val, maxlen);
-               CC (entry->components, 30, val, maxlen);
+               CF (entry->format, EXIF_FORMAT_LONG, v, maxlen);
+               CC (entry->components, 30, v, maxlen);
                break;
        case MNOTE_OLYMPUS_TAG_FLASHMODE:
-               CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
-               CC (entry->components, 1, val, maxlen);
+               CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
+               CC (entry->components, 1, v, maxlen);
                vs = exif_get_short (entry->data, entry->order);
                switch (vs) {
                case 0:
-                       strncpy (val, _("Auto"), maxlen);
+                       strncpy (v, _("Auto"), maxlen);
                        break;
                case 1:
-                       strncpy (val, _("Red-eye reduction"), maxlen);
+                       strncpy (v, _("Red-eye reduction"), maxlen);
                        break;
                case 2:
-                       strncpy (val, _("Fill"), maxlen);
+                       strncpy (v, _("Fill"), maxlen);
                        break;
                case 3:
-                       strncpy (val, _("Off"), maxlen);
+                       strncpy (v, _("Off"), maxlen);
                        break;
                default:
-                       snprintf (val, maxlen, _("%i"), vs);
+                       snprintf (v, maxlen, _("%i"), vs);
                }
                break;
        case MNOTE_OLYMPUS_TAG_FOCUSDIST:
-               CF (entry->format, EXIF_FORMAT_RATIONAL, val, maxlen);
-               CC (entry->components, 1, val, maxlen);
+               CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
+               CC (entry->components, 1, v, maxlen);
                vr = exif_get_rational (entry->data, entry->order);
                if (vr.numerator == 0) {
-                       strncpy (val, _("Unknown"), maxlen);
+                       strncpy (v, _("Unknown"), maxlen);
                }
                else {
                        unsigned long tmp = vr.numerator / vr.denominator;
                        /* printf("numerator %li, denominator %li\n", vr.numerator, vr.denominator); */
-                       snprintf (val, maxlen, "%li mm", tmp);
+                       snprintf (v, maxlen, "%li mm", tmp);
                }
                break;
        case MNOTE_OLYMPUS_TAG_SHARPNESS:
-               CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
-               CC (entry->components, 1, val, maxlen);
+               CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
+               CC (entry->components, 1, v, maxlen);
                vs = exif_get_short (entry->data, entry->order);
                switch (vs) {
                case 0:
-                       strncpy (val, _("Normal"), maxlen);
+                       strncpy (v, _("Normal"), maxlen);
                        break;
                case 1:
-                       strncpy (val, _("Hard"), maxlen);
+                       strncpy (v, _("Hard"), maxlen);
                        break;
                case 2:
-                       strncpy (val, _("Soft"), maxlen);
+                       strncpy (v, _("Soft"), maxlen);
                        break;
                default:
-                       snprintf (val, maxlen, _("%i"), vs);
+                       snprintf (v, maxlen, _("%i"), vs);
                }
                break;
        case MNOTE_OLYMPUS_TAG_WBALANCE:
-               CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
-               CC (entry->components, 2, val, maxlen);
+               CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
+               CC (entry->components, 2, v, maxlen);
                vs = exif_get_short (entry->data, entry->order);
                switch (vs) {
                case 1:
-                       strncpy (val, _("Automatic"), maxlen);
+                       strncpy (v, _("Automatic"), maxlen);
                        break;
                case 2:
                        {
@@ -280,58 +426,58 @@ mnote_olympus_entry_get_value (MnoteOlympusEntry *entry, char *val, unsigned int
                                        break;
                                }
                                if (colorTemp) {
-                                       snprintf (val, maxlen, "Manual: %liK", colorTemp);
+                                       snprintf (v, maxlen, "Manual: %liK", colorTemp);
                                }
                                else {
-                                       strncpy (val, _("Manual: Unknown"), maxlen);
+                                       strncpy (v, _("Manual: Unknown"), maxlen);
                                }
 
                        }
                        break;
                case 3:
-                       strncpy (val, _("One-touch"), maxlen);
+                       strncpy (v, _("One-touch"), maxlen);
                        break;
                default:
-                       strncpy (val, _("Unknown"), maxlen);
+                       strncpy (v, _("Unknown"), maxlen);
                        break;
                }
                break;
        case MNOTE_OLYMPUS_TAG_CONTRAST:
-               CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
-               CC (entry->components, 1, val, maxlen);
+               CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
+               CC (entry->components, 1, v, maxlen);
                vs = exif_get_short (entry->data, entry->order);
                switch (vs) {
                case 0:
-                       strncpy (val, _("Hard"), maxlen);
+                       strncpy (v, _("Hard"), maxlen);
                        break;
                case 1:
-                       strncpy (val, _("Normal"), maxlen);
+                       strncpy (v, _("Normal"), maxlen);
                        break;
                case 2:
-                       strncpy (val, _("Soft"), maxlen);
+                       strncpy (v, _("Soft"), maxlen);
                        break;
                default:
-                       snprintf (val, maxlen, "%i", vs);
+                       snprintf (v, maxlen, "%i", vs);
                }
                break;
        case MNOTE_OLYMPUS_TAG_MANFOCUS:
-               CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
-               CC (entry->components, 1, val, maxlen);
+               CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
+               CC (entry->components, 1, v, maxlen);
                vs = exif_get_short (entry->data, entry->order);
                switch (vs) {
                case 0:
-                       strncpy (val, _("No"), maxlen);
+                       strncpy (v, _("No"), maxlen);
                        break;
                case 1:
-                       strncpy (val, _("Yes"), maxlen);
+                       strncpy (v, _("Yes"), maxlen);
                        break;
                default:
-                       snprintf (val, maxlen, _("%i"), vs);
+                       snprintf (v, maxlen, _("%i"), vs);
                }
                break;
        default:
                break;
        }
 
-       return (val);
+       return (v);
 }

diff --git a/libexif/olympus/mnote-olympus-tag.c b/libexif/olympus/mnote-olympus-tag.c
index fe266ad..f5249e5 100644 (file)
--- a/libexif/olympus/mnote-olympus-tag.c
+++ b/libexif/olympus/mnote-olympus-tag.c
@@ -31,6 +31,57 @@ static struct {
        const char *title;
        const char *description;
 } table[] = {
+
+       /* Nikon */
+        {MNOTE_NIKON_TAG_FIRMWARE, "Firmware", N_("Firmware Version"), ""},
+        {MNOTE_NIKON_TAG_ISO,          "ISO", N_("ISO Setting"), ""},
+        {MNOTE_NIKON_TAG_COLORMODE1,      "COLORMODE1", N_("Colormode (?)"), ""},
+        {MNOTE_NIKON_TAG_QUALITY,      "QUALITY", N_("Quality"), ""},
+        {MNOTE_NIKON_TAG_WHITEBALANCE, "WHITEBALANCE", N_("Whitebalance"), ""},
+        {MNOTE_NIKON_TAG_SHARPENING,   "SHARPENING",   N_("Image Sharpening"), ""},
+        {MNOTE_NIKON_TAG_FOCUSMODE,    "FOCUSMODE",   N_("Focus Mode"), ""},
+        {MNOTE_NIKON_TAG_FLASHSETTING, "FLASHSETTING",   N_("Flash Setting"), ""},
+        {MNOTE_NIKON_TAG_FLASHMODE,    "FLASHMODE",    N_("Flash Mode"), ""},
+        {MNOTE_NIKON_TAG_WHITEBALANCEFINE,"WHITEBALANCEFINE",N_("Whitebalance fine ajustment"), ""},
+        {MNOTE_NIKON_TAG_WHITEBALANCERB,  "WHITEBALANCERB", N_("Whitebalance RB"), ""},
+        {MNOTE_NIKON_TAG_UNKNOWN_0X000D,  "UNKNOWN_0X000D", N_("Unknown tag 0x000d"), ""},
+        {MNOTE_NIKON_TAG_ISOSELECTION,  "ISOSELECTION", N_("Isoselection"), ""},        {MNOTE_NIKON_TAG_UNKNOWN_0X0011,  "UNKNOWN_0X0011", N_("Unknown tag 0x0011"), ""},
+        {MNOTE_NIKON_TAG_EXPOSUREDIFF,  "EXPOSUREDIFF", N_("Exposurediff ?"), ""},
+        {MNOTE_NIKON_TAG_FLASHCOMPENSATION,     "FLASHCOMPENSATION", N_("Flashcompensation ?"), ""},
+        {MNOTE_NIKON_TAG_ISO2,          "ISO", N_("ISO Setting"), ""},
+        {MNOTE_NIKON_TAG_UNKNOWN_0X0016,  "UNKNOWN_0X0016", N_("Unknown tag 0x0016"), ""},
+        {MNOTE_NIKON_TAG_UNKNOWN_0X0017,  "UNKNOWN_0X0017", N_("Unknown tag 0x0017"), ""},
+        {MNOTE_NIKON_TAG_UNKNOWN_0X0018,  "UNKNOWN_0X0018", N_("Unknown tag 0x0018"), ""},
+        {MNOTE_NIKON_TAG_UNKNOWN_0X0019,  "UNKNOWN_0X0019", N_("Unknown tag 0x0019"), ""},
+        {MNOTE_NIKON_TAG_TONECOMPENSATION,  "TONECOMPENSATION", N_("Tonecompensation"), ""},
+        {MNOTE_NIKON_TAG_LENSTYPE,          "LENSTYPE", N_("Lenstype"), ""},
+        {MNOTE_NIKON_TAG_LENS,          "LENS", N_("Lens"), ""},                                                                                 
+        {MNOTE_NIKON_TAG_MANUALFOCUSDISTANCE,   "MANUALFOCUSDISTANCE", N_("Manual Focus Distance"), ""},
+        {MNOTE_NIKON_TAG_FLASHUSED,          "FLASHUSED", N_("Flash used"), ""},                                                                                
+        {MNOTE_NIKON_TAG_AFFOCUSPOSITION,  "AFFOCUSPOSITION", N_("AF Focus position"), ""},
+        {MNOTE_NIKON_TAG_BRACKETING,          "BRACKETING", N_("Bracketing"), ""},
+        {MNOTE_NIKON_TAG_UNKNOWN_0X008A,  "UNKNOWN_0X008A", N_("Unknown tag 0x008a"), ""},
+        {MNOTE_NIKON_TAG_UNKNOWN_0X008B,  "UNKNOWN_0X008B", N_("Unknown tag 0x008b"), ""},
+        {MNOTE_NIKON_TAG_CURVE,          "CURVE,", N_("Contrast curve"), ""},                                                                                 
+        {MNOTE_NIKON_TAG_COLORMODE,          "COLORMODE,", N_("Colormode"), ""},                                                                                
+        {MNOTE_NIKON_TAG_LIGHTYPE,          "LIGHTYPE,", N_("Lightype"), ""},
+        {MNOTE_NIKON_TAG_UNKNOWN_0X0091,  "UNKNOWN_0X0091", N_("Unknown tag 0x0091"), ""},
+        {MNOTE_NIKON_TAG_HUE,          "Hue,", N_("Hue Adjustment"), ""}, 
+        {MNOTE_NIKON_TAG_NOISEREDUCTION ,  "NOISEREDUCTION,", N_("Noisereduction"), ""},
+        {MNOTE_NIKON_TAG_UNKNOWN_0X0097,  "UNKNOWN_0X0097", N_("Unknown tag 0x0097"), ""},
+        {MNOTE_NIKON_TAG_UNKNOWN_0X0098,  "UNKNOWN_0X0098", N_("Unknown tag 0x0098"), ""},
+        {MNOTE_NIKON_TAG_UNKNOWN_0X009A,  "UNKNOWN_0X009A", N_("Unknown tag 0x009a"), ""},
+        {MNOTE_NIKON_TAG_UNKNOWN_0X00A0,  "UNKNOWN_0X00A0", N_("Unknown tag 0x00a0"), ""},
+        {MNOTE_NIKON_TAG_UNKNOWN_0X00A2,  "UNKNOWN_0X00A2", N_("Unknown tag 0x00a2"), ""},
+        {MNOTE_NIKON_TAG_UNKNOWN_0X00A3,  "UNKNOWN_0X00A3", N_("Unknown tag 0x00a3"), ""},
+        {MNOTE_NIKON_TAG_TOTALPICTURES  ,  "TOTALPICTURES,", N_("Total number of pictures taken"), ""},
+        {MNOTE_NIKON_TAG_UNKNOWN_0X00A8,  "UNKNOWN_0X00A8", N_("Unknown tag 0x00a8"), ""},
+        {MNOTE_NIKON_TAG_OPTIMIZATION   ,  "OPTIMIZATION,", N_("Optimize Image"), ""},
+        {MNOTE_NIKON_TAG_UNKNOWN_0X00AA,  "UNKNOWN_0X00AA", N_("Unknown tag 0x00aa"), ""},
+        {MNOTE_NIKON_TAG_UNKNOWN_0X00AB,  "UNKNOWN_0X00AB", N_("Unknown tag 0x00ab"), ""},
+        {MNOTE_NIKON_TAG_CAPTUREEDITORDATA,  "CAPTUREEDITORDATA,", N_("Capture Editor Data"), ""},
+
+       /* Olympus */
        {MNOTE_OLYMPUS_TAG_MODE, "Mode", N_("Speed/Sequence/Panorama direction"), ""},
        {MNOTE_OLYMPUS_TAG_QUALITY, "Quality", N_("Quality"), ""},
        {MNOTE_OLYMPUS_TAG_MACRO, "Macro", N_("Macro"), ""},

diff --git a/libexif/olympus/mnote-olympus-tag.h b/libexif/olympus/mnote-olympus-tag.h
index 7edcd59..435a06b 100644 (file)
--- a/libexif/olympus/mnote-olympus-tag.h
+++ b/libexif/olympus/mnote-olympus-tag.h
@@ -26,6 +26,58 @@ extern "C" {
 #endif /* __cplusplus */
 
 enum _MnoteOlympusTag {
+
+       /* Nikon */
+       MNOTE_NIKON_TAG_FIRMWARE                = 0x0001,
+        MNOTE_NIKON_TAG_ISO                     = 0x0002,
+        MNOTE_NIKON_TAG_COLORMODE1              = 0x0003,
+        MNOTE_NIKON_TAG_QUALITY                 = 0x0004,
+        MNOTE_NIKON_TAG_WHITEBALANCE            = 0x0005,
+        MNOTE_NIKON_TAG_SHARPENING              = 0x0006,
+        MNOTE_NIKON_TAG_FOCUSMODE               = 0x0007,
+        MNOTE_NIKON_TAG_FLASHSETTING            = 0x0008,
+        MNOTE_NIKON_TAG_FLASHMODE               = 0x0009,
+        MNOTE_NIKON_TAG_WHITEBALANCEFINE        = 0x000b,
+        MNOTE_NIKON_TAG_WHITEBALANCERB          = 0x000c,
+        MNOTE_NIKON_TAG_UNKNOWN_0X000D          = 0x000d,
+        MNOTE_NIKON_TAG_EXPOSUREDIFF            = 0x000e,
+        MNOTE_NIKON_TAG_ISOSELECTION            = 0x000f,
+        MNOTE_NIKON_TAG_UNKNOWN_0X0011          = 0x0011,
+        MNOTE_NIKON_TAG_FLASHCOMPENSATION       = 0x0012,
+        MNOTE_NIKON_TAG_ISO2                    = 0x0013,
+        MNOTE_NIKON_TAG_UNKNOWN_0X0016          = 0x0016,
+        MNOTE_NIKON_TAG_UNKNOWN_0X0017          = 0x0017,
+        MNOTE_NIKON_TAG_UNKNOWN_0X0018          = 0x0018,
+        MNOTE_NIKON_TAG_UNKNOWN_0X0019          = 0x0019,
+        MNOTE_NIKON_TAG_TONECOMPENSATION        = 0x0081,
+        MNOTE_NIKON_TAG_LENSTYPE                = 0x0083,
+        MNOTE_NIKON_TAG_LENS                    = 0x0084,
+        MNOTE_NIKON_TAG_MANUALFOCUSDISTANCE     = 0x0085,
+        MNOTE_NIKON_TAG_FLASHUSED               = 0x0087,
+        MNOTE_NIKON_TAG_AFFOCUSPOSITION         = 0x0088,
+        MNOTE_NIKON_TAG_BRACKETING              = 0x0089,
+        MNOTE_NIKON_TAG_UNKNOWN_0X008A          = 0x008a,
+        MNOTE_NIKON_TAG_UNKNOWN_0X008B          = 0x008b,
+        MNOTE_NIKON_TAG_CURVE                   = 0x008c,
+        MNOTE_NIKON_TAG_COLORMODE               = 0x008d,
+        MNOTE_NIKON_TAG_LIGHTYPE                = 0x0090,
+        MNOTE_NIKON_TAG_UNKNOWN_0X0091          = 0x0091,
+        MNOTE_NIKON_TAG_HUE                     = 0x0092,
+        MNOTE_NIKON_TAG_NOISEREDUCTION          = 0x0095,
+        MNOTE_NIKON_TAG_UNKNOWN_0X0097          = 0x0097,
+        MNOTE_NIKON_TAG_UNKNOWN_0X0098          = 0x0098,
+        MNOTE_NIKON_TAG_UNKNOWN_0X009A          = 0x009a,
+        MNOTE_NIKON_TAG_UNKNOWN_0X00A0          = 0x00a0,
+        MNOTE_NIKON_TAG_UNKNOWN_0X00A2          = 0x00a2,
+        MNOTE_NIKON_TAG_UNKNOWN_0X00A3          = 0x00a3,
+        MNOTE_NIKON_TAG_TOTALPICTURES           = 0x00a7,
+        MNOTE_NIKON_TAG_UNKNOWN_0X00A8          = 0x00a8,
+        MNOTE_NIKON_TAG_OPTIMIZATION            = 0x00a9,
+        MNOTE_NIKON_TAG_UNKNOWN_0X00AA          = 0x00aa,
+        MNOTE_NIKON_TAG_UNKNOWN_0X00AB          = 0x00ab,
+        MNOTE_NIKON_TAG_CAPTUREEDITORDATA       = 0x0e01,
+
+       /* Olympus */
        MNOTE_OLYMPUS_TAG_MODE          = 0x0200,
        MNOTE_OLYMPUS_TAG_QUALITY       = 0x0201,
        MNOTE_OLYMPUS_TAG_MACRO         = 0x0202,