/* mnote-olympus-entry.c

 *

 * Copyright (c) 2002-2009 Lutz Mueller <lutz@users.sourceforge.net> et. al.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

 * Boston, MA  02110-1301  USA.

 *

 * SPDX-License-Identifier: LGPL-2.0-or-later

 */

#include <config.h>

#include "mnote-olympus-entry.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <libexif/exif-format.h>

#include <libexif/exif-utils.h>

#include <libexif/exif-entry.h>

#include <libexif/i18n.h>

#define CF(format,target,v,maxlen)                              \

{                                                               \

        if (format != target) {                                 \

                snprintf (v, maxlen,                          \

                        _("Invalid format '%s', "               \

                        "expected '%s'."),                      \

                        exif_format_get_name (format),          \

                        exif_format_get_name (target));         \

                break;                                          \

        }                                                       \

}

#define CF2(format,target1,target2,v,maxlen)                    \

{                                                               \

        if ((format != target1) && (format != target2)) {       \

                snprintf (v, maxlen,                          \

                        _("Invalid format '%s', "               \

                        "expected '%s' or '%s'."),              \

                        exif_format_get_name (format),          \

                        exif_format_get_name (target1),         \

                        exif_format_get_name (target2));        \

                break;                                          \

        }                                                       \

}

#define CC(number,target,v,maxlen)                                      \

{                                                                       \

        if (number != target) {                                         \

                snprintf (v, maxlen,                                    \

                        _("Invalid number of components (%i, "          \

                        "expected %i)."), (int) number, (int) target);  \

                break;                                                  \

        }                                                               \

}

#define CC2(number,t1,t2,v,maxlen)                                      \

{                                                                       \

  if ((number < t1) || (number > t2)) {                           \

    snprintf (v, maxlen,                                    \

      _("Invalid number of components (%i, "          \

      "expected %i or %i)."), (int) number,   \

      (int) t1, (int) t2);          \

    break;                                                  \

  }                                                               \

}

#define R2L(n) ((n).denominator ? (unsigned long)(n).numerator/(n).denominator : 0L)

#define R2D(n) ((n).denominator ? (double)(n).numerator/(n).denominator : 0.0)

static const struct {

  MnoteOlympusTag tag;

  ExifFormat fmt;

  struct {

    int index;

    const char *string;

  } elem[24];

} items[] = {

#ifndef NO_VERBOSE_TAG_DATA

  { MNOTE_NIKON_TAG_LENSTYPE, EXIF_FORMAT_BYTE,

    { {0, N_("AF non D lens")},

      {1, N_("Manual")},

      {2, N_("AF-D or AF-S lens")},

      {6, N_("AF-D G lens")},

      {10, N_("AF-D VR lens")},

      {14, N_("AF-D G VR lens")},

      {0, NULL}}},

  { MNOTE_NIKON_TAG_FLASHUSED, EXIF_FORMAT_BYTE,

    { {0, N_("Flash did not fire")},

      {4, N_("Flash unit unknown")},

      {7, N_("Flash is external")},

      {9, N_("Flash is on camera")},

      {0, NULL}}},

  { MNOTE_NIKON1_TAG_QUALITY, EXIF_FORMAT_SHORT,

    { {1, N_("VGA basic")},

      {2, N_("VGA normal")},

      {3, N_("VGA fine")},

      {4, N_("SXGA basic")},

      {5, N_("SXGA normal")},

      {6, N_("SXGA fine")},

      {10, N_("2 Mpixel basic")},

      {11, N_("2 Mpixel normal")},

      {12, N_("2 Mpixel fine")},

      {0, NULL}}},

  { MNOTE_NIKON1_TAG_COLORMODE, EXIF_FORMAT_SHORT,

    { {1, N_("Color")},

      {2, N_("Monochrome")},

      {0, NULL}}},

  { MNOTE_NIKON1_TAG_IMAGEADJUSTMENT, EXIF_FORMAT_SHORT,

    { {0, N_("Normal")},

      {1, N_("Bright+")},

      {2, N_("Bright-")},

      {3, N_("Contrast+")},

      {4, N_("Contrast-")},

      {0, NULL}}},

  { MNOTE_NIKON1_TAG_CCDSENSITIVITY, EXIF_FORMAT_SHORT,

    { {0, N_("ISO 80")},

      {2, N_("ISO 160")},

      {4, N_("ISO 320")},

      {5, N_("ISO 100")},

      {0, NULL}}},

  { MNOTE_NIKON1_TAG_WHITEBALANCE, EXIF_FORMAT_SHORT,

    { {0, N_("Auto")},

      {1, N_("Preset")},

      {2, N_("Daylight")},

      {3, N_("Incandescence")},

      {4, N_("Fluorescence")},

      {5, N_("Cloudy")},

      {6, N_("SpeedLight")},

      {0, NULL}}},

  { MNOTE_NIKON1_TAG_CONVERTER, EXIF_FORMAT_SHORT,

    { {0, N_("No fisheye")},

      {1, N_("Fisheye on")},

      {0, NULL}}},

  { MNOTE_OLYMPUS_TAG_QUALITY, EXIF_FORMAT_SHORT,

    { {1, N_("Normal, SQ")},

      {2, N_("Normal, HQ")},

      {3, N_("Normal, SHQ")},

      {4, N_("Normal, RAW")},

      {5, N_("Normal, SQ1")},

      {6, N_("Normal, SQ2")},

      {7, N_("Normal, super high")},

      {17, N_("Normal, standard")},

      {0x101, N_("Fine, SQ")},

      {0x102, N_("Fine, HQ")},

      {0x103, N_("Fine, SHQ")},

      {0x104, N_("Fine, RAW")},

      {0x105, N_("Fine, SQ1")},

      {0x106, N_("Fine, SQ2")},

      {0x107, N_("Fine, super high")},

      {0x201, N_("Super fine, SQ")},

      {0x202, N_("Super fine, HQ")},

      {0x203, N_("Super fine, SHQ")},

      {0x204, N_("Super fine, RAW")},

      {0x205, N_("Super fine, SQ1")},

      {0x206, N_("Super fine, SQ2")},

      {0x207, N_("Super fine, super high")},

      {0x211, N_("Super fine, high")},

      {0, NULL}}},

  { MNOTE_OLYMPUS_TAG_MACRO, EXIF_FORMAT_SHORT,

    { {0, N_("No")},

      {1, N_("Yes")},

      {2, N_("Super macro")},

      {0, NULL}}},

  { MNOTE_OLYMPUS_TAG_BWMODE, EXIF_FORMAT_SHORT,

    { {0, N_("No")},

      {1, N_("Yes")},

      {0, NULL}}},

  { MNOTE_OLYMPUS_TAG_ONETOUCHWB, EXIF_FORMAT_SHORT,

    { {0, N_("Off")},

      {1, N_("On")},

      {2, N_("On (Preset)")},

      {0, NULL}}},

  { MNOTE_OLYMPUS_TAG_FLASHMODE, EXIF_FORMAT_SHORT,

    { {0, N_("Auto")},

      {1, N_("Red-eye reduction")},

      {2, N_("Fill")},

      {3, N_("Off")},

      {0, NULL}}},

  { MNOTE_OLYMPUS_TAG_FLASHDEVICE, EXIF_FORMAT_SHORT,

    { {0, N_("None")},

      {1, N_("Internal")},

      {4, N_("External")},

      {5, N_("Internal + external")},

      {0, NULL}}},

  { MNOTE_OLYMPUS_TAG_FOCUSRANGE, EXIF_FORMAT_SHORT,

    { {0, N_("Normal")},

      {1, N_("Macro")},

      {0, NULL}}},

  { MNOTE_OLYMPUS_TAG_MANFOCUS, EXIF_FORMAT_SHORT,

    { {0, N_("Auto")},

      {1, N_("Manual")},

      {0, NULL}}},

  { MNOTE_OLYMPUS_TAG_SHARPNESS, EXIF_FORMAT_SHORT,

    { {0, N_("Normal")},

      {1, N_("Hard")},

      {2, N_("Soft")},

      {0, NULL}}},

  { MNOTE_OLYMPUS_TAG_EXTERNALFLASHBOUNCE, EXIF_FORMAT_SHORT,

    { {0, N_("No")},

      {1, N_("Yes")},

      {0, NULL}}},

  { MNOTE_OLYMPUS_TAG_CONTRAST, EXIF_FORMAT_SHORT,

    { {0, N_("Hard")},

      {1, N_("Normal")},

      {2, N_("Soft")},

      {0, NULL}}},

  { MNOTE_OLYMPUS_TAG_PREVIEWIMAGEVALID, EXIF_FORMAT_LONG,

    { {0, N_("No")},

      {1, N_("Yes")},

      {0, NULL}}},

  { MNOTE_OLYMPUS_TAG_CCDSCANMODE, EXIF_FORMAT_SHORT,

    { {0, N_("Interlaced")},

      {1, N_("Progressive")},

      {0, NULL}}},

  { MNOTE_SANYO_TAG_SEQUENTIALSHOT, EXIF_FORMAT_SHORT,

    { {0, N_("None")},

      {1, N_("Standard")},

      {2, N_("Best")},

      {3, N_("Adjust exposure")},

      {0, NULL}}},

  { MNOTE_SANYO_TAG_FOCUSMODE, EXIF_FORMAT_SHORT,

    { {1, N_("Spot focus")},

      {2, N_("Normal focus")},

      {0, NULL}}},

  { MNOTE_SANYO_TAG_RECORDSHUTTERRELEASE, EXIF_FORMAT_SHORT,

    { {0, N_("Record while down")},

      {1, N_("Press start, press stop")},

      {0, NULL}}},

  { MNOTE_SANYO_TAG_RESAVED, EXIF_FORMAT_SHORT,

    { {0, N_("No")},

      {1, N_("Yes")},

      {0, NULL}}},

  { MNOTE_SANYO_TAG_CCDSENSITIVITY, EXIF_FORMAT_SHORT,

    { {0, N_("Auto")},

      {1, N_("ISO 50")},

      {3, N_("ISO 100")},

      {4, N_("ISO 200")},

      {5, N_("ISO 400")},

      {0, NULL}}},

  { MNOTE_SANYO_TAG_SCENESELECT, EXIF_FORMAT_SHORT,

    { {0, N_("Off")},

      {1, N_("Sport")},

      {2, N_("TV")},

      {3, N_("Night")},

      {4, N_("User 1")},

      {5, N_("User 2")},

      {6, N_("Lamp")},

      {0, NULL}}},

  { MNOTE_SANYO_TAG_SEQUENCESHOTINTERVAL, EXIF_FORMAT_SHORT,

    { {0, N_("5 frames/sec")},

      {1, N_("10 frames/sec")},

      {2, N_("15 frames/sec")},

      {3, N_("20 frames/sec")},

      {0, NULL}}},

#endif

  { 0, 0, { { 0, NULL } } }

};

char *

mnote_olympus_entry_get_value (MnoteOlympusEntry *entry, char *v, unsigned int maxlen)

{

  char         buf[30];

  ExifLong     vl;

  ExifSLong    vsl;

  ExifShort    vs = 0;

  ExifSShort   vss = 0;

  ExifRational vr, vr2;

  ExifSRational vsr;

  int          i, j;

  double       r, b;

  if (!entry)

    return (NULL);

  if (maxlen < 1)

    return NULL;

  memset (v, 0, maxlen);

  maxlen--;

  if ((!entry->data) && (entry->components > 0)) 

    return (v);

  if ((!entry->data) && (entry->size > 0))

    return NULL;  /* internal inconsistency error */

  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, EXIF_BYTE_ORDER_INTEL);

    if ((vl & 0xF0F0F0F0) == 0x30303030) {

      memcpy (v, entry->data, MIN (maxlen, 4));

    } else {

      snprintf (v, maxlen, "%04lx", (long unsigned int) 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, maxlen, "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, maxlen, "ISO2 %hd", vs);

                break;

  case MNOTE_NIKON_TAG_QUALITY:

  case MNOTE_NIKON_TAG_COLORMODE:

  case MNOTE_NIKON_TAG_COLORMODE1:

  case MNOTE_NIKON_TAG_WHITEBALANCE:

  case MNOTE_NIKON_TAG_SHARPENING:

  case MNOTE_NIKON_TAG_FOCUSMODE:

  case MNOTE_NIKON_TAG_FLASHSETTING:

  case MNOTE_NIKON_TAG_ISOSELECTION:

  case MNOTE_NIKON_TAG_FLASHMODE:

  case MNOTE_NIKON_TAG_IMAGEADJUSTMENT:

  case MNOTE_NIKON_TAG_ADAPTER:

  case MNOTE_NIKON_TAG_SATURATION2:

  case MNOTE_EPSON_TAG_SOFTWARE:

    CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen)

    memcpy(v, entry->data, MIN (maxlen, entry->size));

    break;

  case MNOTE_NIKON_TAG_TOTALPICTURES:

  case MNOTE_EPSON_TAG_IMAGE_WIDTH:

  case MNOTE_EPSON_TAG_IMAGE_HEIGHT:

    CF (entry->format, EXIF_FORMAT_LONG, v, maxlen)

    CC (entry->components, 1, v, maxlen)

    vl =  exif_get_long (entry->data, entry->order);

    snprintf (v, maxlen, "%lu",  (long unsigned int) vl );

    break;

  case MNOTE_NIKON_TAG_LENS_FSTOPS:

  case MNOTE_NIKON_TAG_EXPOSUREDIFF: {

    unsigned char h,m,l;

    CF (entry->format, EXIF_FORMAT_UNDEFINED, v, maxlen)

    CC (entry->components, 4, v, maxlen)

    vl =  exif_get_long (entry->data, entry->order);

    h = (vl>>24)&0xff; m = (vl>>16)&0xff; l = (vl>>8)&0xff;

    snprintf (v, maxlen, "%.1f",  l?(double)h*((double)m/(double)l):0 );

    break;

  }

  case MNOTE_NIKON_TAG_FLASHEXPCOMPENSATION:

  case MNOTE_NIKON_TAG_FLASHEXPOSUREBRACKETVAL:

    CF (entry->format, EXIF_FORMAT_UNDEFINED, v, maxlen)

    CC (entry->components, 4, v, maxlen)

    vl =  exif_get_long (entry->data, entry->order);

    snprintf (v, maxlen, "%.1f",  ((long unsigned int) vl>>24)/6.0 );

    break;

  case MNOTE_NIKON_TAG_SATURATION:

  case MNOTE_NIKON_TAG_WHITEBALANCEFINE:

  case MNOTE_NIKON_TAG_HUE:

  case MNOTE_OLYMPUS_TAG_SENSORTEMPERATURE:

  case MNOTE_OLYMPUS_TAG_LENSTEMPERATURE:

    CF (entry->format, EXIF_FORMAT_SSHORT, v, maxlen)

    CC (entry->components, 1, v, maxlen)

    vs = exif_get_short (entry->data, entry->order);

    snprintf (v, maxlen, "%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);

    r = R2D(vr);

    vr = exif_get_rational (entry->data+8, entry->order);

    b = R2D(vr);

    snprintf (v, maxlen, _("Red Correction %f, blue Correction %f"), r,b);

    break;

  case MNOTE_NIKON_TAG_MANUALFOCUSDISTANCE:

    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 || !vr.denominator) {

      strncpy (v, _("No manual focus selection"), maxlen);

    } else {

      r = R2D(vr);

      snprintf (v, maxlen, _("%2.2f meters"), r);

    }

    break;

  case MNOTE_NIKON_TAG_SENSORPIXELSIZE:

    CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen)

    CC (entry->components, 2, v, maxlen)

    vr = exif_get_rational (entry->data, entry->order);

    vr2 = exif_get_rational (entry->data+8, entry->order);

    r = R2D(vr);

    b = R2D(vr2);

    snprintf (v, maxlen, "%2.2f x %2.2f um", r, b);

    break;

  case MNOTE_NIKON_TAG_BRACKETING:

    CF2 (entry->format, EXIF_FORMAT_BYTE, EXIF_FORMAT_SHORT, v, maxlen)

    CC (entry->components, 1, v, maxlen)

    if (EXIF_FORMAT_SHORT == entry->format) {

      vs = exif_get_short (entry->data, entry->order);

    } else {

      vs = entry->data[0];

    }

    snprintf (v, maxlen, "%hd", vs);

    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: strncpy (v, _("AF position: center"), maxlen); break;

        case  1: strncpy (v, _("AF position: top"), maxlen); break;

        case  2: strncpy (v, _("AF position: bottom"), maxlen); break;

        case  3: strncpy (v, _("AF position: left"), maxlen); break;

        case  4: strncpy (v, _("AF position: right"), maxlen); break;

      case  5: strncpy (v, _("AF position: upper-left"), maxlen); break;

        case  6: strncpy (v, _("AF position: upper-right"), maxlen); break;

        case  7: strncpy (v, _("AF position: lower-left"), maxlen); break;

        case  8: strncpy (v, _("AF position: lower-right"), maxlen); break;

        case  9: strncpy (v, _("AF position: far left"), maxlen); break;

        case  10: strncpy (v, _("AF position: far right"), maxlen); break;

        default: strncpy (v, _("Unknown AF position"), maxlen);

    }     

    break;

  case MNOTE_OLYMPUS_TAG_FLASHDEVICE:

    CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen)

    CC (entry->components, 2, v, maxlen)

    vs = exif_get_short(entry->data, entry->order);

    /* search for the tag */

    for (i = 0; (items[i].tag && items[i].tag != entry->tag); i++)

      ;

    if (!items[i].tag) {

        snprintf (v, maxlen, _("Internal error (unknown value %hi)"), vs);

        break;

    }

    CF (entry->format, items[i].fmt, v, maxlen)

    /* find the value */

    for (j = 0; items[i].elem[j].string &&

          (items[i].elem[j].index < vs); j++);

    if (items[i].elem[j].index != vs) {

      snprintf (v, maxlen, _("Unknown value %hi"), vs);

      break;

    }

    strncpy (v, _(items[i].elem[j].string), maxlen);

    break;

  case MNOTE_OLYMPUS_TAG_DIGIZOOM:

    if (entry->format == EXIF_FORMAT_RATIONAL) {

      CC (entry->components, 1, v, maxlen)

      vr = exif_get_rational (entry->data, entry->order);

      if (!vr.numerator || !vr.denominator) {

        strncpy (v, _("None"), maxlen);

      } else {

        r = R2D(vr);

        snprintf (v, maxlen, "%2.2f", r);

      }

      break;

    }

    /* to handle SHORT version of this tag, */

    /* fall through */

  case MNOTE_NIKON_TAG_LENSTYPE:

  case MNOTE_NIKON_TAG_FLASHUSED:

  case MNOTE_NIKON1_TAG_QUALITY:

  case MNOTE_NIKON1_TAG_COLORMODE:

  case MNOTE_NIKON1_TAG_IMAGEADJUSTMENT:

  case MNOTE_NIKON1_TAG_CCDSENSITIVITY:

  case MNOTE_NIKON1_TAG_WHITEBALANCE:

  case MNOTE_NIKON1_TAG_CONVERTER:

  case MNOTE_OLYMPUS_TAG_QUALITY:

  case MNOTE_OLYMPUS_TAG_MACRO:

  case MNOTE_OLYMPUS_TAG_BWMODE:

  case MNOTE_OLYMPUS_TAG_ONETOUCHWB:

  case MNOTE_OLYMPUS_TAG_FLASHMODE:

  case MNOTE_OLYMPUS_TAG_FOCUSRANGE:

  case MNOTE_OLYMPUS_TAG_MANFOCUS:

  case MNOTE_OLYMPUS_TAG_SHARPNESS:

  case MNOTE_OLYMPUS_TAG_EXTERNALFLASHBOUNCE:

  case MNOTE_OLYMPUS_TAG_CONTRAST:

  case MNOTE_OLYMPUS_TAG_PREVIEWIMAGEVALID:

  case MNOTE_OLYMPUS_TAG_CCDSCANMODE:

  case MNOTE_SANYO_TAG_SEQUENTIALSHOT:

  case MNOTE_SANYO_TAG_FOCUSMODE:

  case MNOTE_SANYO_TAG_RECORDSHUTTERRELEASE:

  case MNOTE_SANYO_TAG_RESAVED:

  case MNOTE_SANYO_TAG_CCDSENSITIVITY:

  case MNOTE_SANYO_TAG_SCENESELECT:

  case MNOTE_SANYO_TAG_SEQUENCESHOTINTERVAL:

    CC (entry->components, 1, v, maxlen)

    switch (entry->format) {

    case EXIF_FORMAT_BYTE:

    case EXIF_FORMAT_UNDEFINED:

      vs = entry->data[0];

      break;

    case EXIF_FORMAT_SHORT:

      vs = exif_get_short(entry->data, entry->order);

      break;

    default:

      vs = 0;

      break;

    }

    /* search for the tag */

    for (i = 0; (items[i].tag && items[i].tag != entry->tag); i++)

      ;

    if (!items[i].tag) {

        snprintf (v, maxlen, _("Internal error (unknown value %hi)"), vs);

        break;

    }

    CF (entry->format, items[i].fmt, v, maxlen)

    /* find the value */

    for (j = 0; items[i].elem[j].string &&

          (items[i].elem[j].index < vs); j++);

    if (items[i].elem[j].index != vs) {

      snprintf (v, maxlen, _("Unknown value %hi"), vs);

      break;

    }

    strncpy (v, _(items[i].elem[j].string), maxlen);

    break;

  case MNOTE_OLYMPUS_TAG_NOISEREDUCTION:

  case MNOTE_SANYO_TAG_WIDERANGE:

  case MNOTE_SANYO_TAG_COLORADJUSTMENTMODE:

  case MNOTE_SANYO_TAG_QUICKSHOT:

  case MNOTE_SANYO_TAG_VOICEMEMO:

  case MNOTE_SANYO_TAG_FLICKERREDUCE:

  case MNOTE_SANYO_TAG_OPTICALZOOM:

  case MNOTE_SANYO_TAG_DIGITALZOOM:

  case MNOTE_SANYO_TAG_LIGHTSOURCESPECIAL:

    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 (v, _("Off"), maxlen);

      break;

    case 1:

      strncpy (v, _("On"), maxlen);

      break;

    default:

      sprintf (buf, _("Unknown %hu"), vs);

      strncat (v, buf, maxlen - strlen (v));

      break;

    }

    break;

  case MNOTE_SANYO_TAG_SELFTIMER:

    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 (v, _("Off"), maxlen);

      break;

    case 1:

      strncpy (v, _("On"), maxlen);

      break;

    case 2:

      strncpy (v, _("2 sec."), maxlen);

      break;

    default:

      sprintf (buf, _("Unknown %hu"), vs);

      strncat (v, buf, maxlen - strlen (v));

      break;

    }

    break;

  case MNOTE_NIKON_TAG_LENS:

    CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen)

    CC (entry->components, 4, v, maxlen)

    {

      double ao,ac;

      unsigned long fs,fl;

      vr = exif_get_rational (entry->data, entry->order);

      fs = R2L(vr);

      vr = exif_get_rational (entry->data+8, entry->order);

      fl = R2L(vr);

      vr = exif_get_rational (entry->data+16, entry->order);

      ao = R2D(vr);

      vr = exif_get_rational (entry->data+24, entry->order);

      ac = R2D(vr);

      snprintf (v, maxlen, "%ld-%ldmm 1:%3.1f - %3.1f",fs,fl,ao,ac);

    }

    break;

  /* Olympus */

  case MNOTE_OLYMPUS_TAG_MODE:

    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 (v, _("Normal"), maxlen);

      break;

    case 1:

      strncpy (v, _("Unknown"), maxlen);

      break;

    case 2:

      strncpy (v, _("Fast"), maxlen);

      break;

    case 3:

      strncpy (v, _("Panorama"), maxlen);

      break;

    default:

      snprintf (v, maxlen, "%li", (long int) vl);

    }

    vl = exif_get_long (entry->data + 4, entry->order);

    snprintf (buf, sizeof (buf), "/%li/", (long int) vl);

    strncat (v, buf, maxlen - strlen (v));

    vl = exif_get_long (entry->data + 8, entry->order);

    switch (vl) {

    case 1:

      strncat (v, _("Left to right"), maxlen - strlen (v));

      break;

    case 2:

      strncat (v, _("Right to left"), maxlen - strlen (v));

      break;

    case 3:

      strncat (v, _("Bottom to top"), maxlen - strlen (v));

      break;

    case 4:

      strncat (v, _("Top to bottom"), maxlen - strlen (v));

      break;

    default:

      snprintf (buf, sizeof (buf), "%li",

          (long int) vl);

      strncat (v, buf, maxlen - strlen (v));

    }

    break;

  case MNOTE_OLYMPUS_TAG_LENSDISTORTION:

    if (entry->format == EXIF_FORMAT_SHORT) {

      /* Epson uses a single SHORT here */

      CC (entry->components, 1, v, maxlen)

      vs = exif_get_short (entry->data, entry->order);

      sprintf (buf, "%hu", vs);

      strncat (v, buf, maxlen - strlen (v));

    } else {

      /* Others use an array of SSHORT here */

      CC (entry->components, 6, v, maxlen)

      CF (entry->format, EXIF_FORMAT_SSHORT, v, maxlen)

      for (i=0; i < (int)entry->components; ++i) {

        vss = exif_get_sshort (entry->data+2*i, entry->order);

        sprintf (buf, "%hd ", vss);

        strncat (v, buf, maxlen - strlen (v));

      }

    }

    break;

  case MNOTE_OLYMPUS_TAG_COLORCONTROL:

    CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen)

    CC (entry->components, 6, v, maxlen)

    for (i=0; i < (int)entry->components; ++i) {

      vs = exif_get_short (entry->data+2*i, entry->order);

      sprintf (buf, "%hu ", vs);

      strncat (v, buf, maxlen - strlen (v));

    }

    break;

  case MNOTE_OLYMPUS_TAG_VERSION:

    CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen)

    CC2 (entry->components, 5, 8, v, maxlen)

    strncpy (v, (char *)entry->data, MIN (maxlen, entry->size));

    break;

  case MNOTE_OLYMPUS_TAG_SERIALNUMBER2:

    CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen)

    strncpy (v, (char *)entry->data, MIN (maxlen, entry->size));

    break;

  case MNOTE_OLYMPUS_TAG_INFO:

    CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen)

    CC2 (entry->components, 52, 60, v, maxlen)

    strncpy (v, (char *)entry->data, MIN (maxlen, entry->size));

    break;

  case MNOTE_OLYMPUS_TAG_ID:

    CF (entry->format, EXIF_FORMAT_UNDEFINED, v, maxlen)

    CC (entry->components, 32, v, maxlen)

    strncpy (v, (char *)entry->data, MIN (maxlen, entry->size));

    break;

  case MNOTE_OLYMPUS_TAG_UNKNOWN_4:

    CF (entry->format, EXIF_FORMAT_LONG, v, maxlen)

    CC (entry->components, 30, v, maxlen)

    for (i=0; i < (int)entry->components; ++i) {

      vl = exif_get_long (entry->data+4*i, entry->order);

      sprintf (buf, "%lu ", (unsigned long)vl);

      strncat (v, buf, maxlen - strlen (v));

    }

    break;

  case MNOTE_OLYMPUS_TAG_FOCUSDIST:

    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 || !vr.denominator) {

      strncpy (v, _("Unknown"), maxlen);

    }

    else {

      unsigned long tmp = vr.numerator / vr.denominator;

      snprintf (v, maxlen, "%li mm", tmp);

    }

    break;

  case MNOTE_OLYMPUS_TAG_WBALANCE:

    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 (v, _("Automatic"), maxlen);

      break;

    case 2:

      {

        ExifShort v2 = exif_get_short (entry->data + 2, entry->order);

        unsigned long colorTemp = 0;

        switch (v2) {

        case 2:

          colorTemp = 3000;

          break;

        case 3:

          colorTemp = 3700;

          break;

        case 4:

          colorTemp = 4000;

          break;

        case 5:

          colorTemp = 4500;

          break;

        case 6:

          colorTemp = 5500;

          break;

        case 7:

          colorTemp = 6500;

          break;

        case 9:

          colorTemp = 7500;

          break;

        }

        if (colorTemp) {

          snprintf (v, maxlen, _("Manual: %liK"), colorTemp);

        }

        else {

          strncpy (v, _("Manual: unknown"), maxlen);

        }

      }

      break;

    case 3:

      strncpy (v, _("One-touch"), maxlen);

      break;

    default:

      strncpy (v, _("Unknown"), maxlen);

      break;

    }

    break;

  case MNOTE_OLYMPUS_TAG_REDBALANCE:

  case MNOTE_OLYMPUS_TAG_BLUEBALANCE:

    CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen)

    CC (entry->components, 2, v, maxlen)

    vs = exif_get_short (entry->data, entry->order);

    snprintf (v, maxlen, "%hu ", vs);

    vs = exif_get_short (entry->data + 2, entry->order);

    sprintf (buf, "%hu", vs);

    strncat (v, buf, maxlen - strlen (v));

    break;

  case MNOTE_OLYMPUS_TAG_BLACKLEVEL:

  case MNOTE_NIKON_TAG_IMAGEBOUNDARY:

    CC (entry->components, 4, v, maxlen)

    /* Fall through to COLORMATRIX */

    /* fall through */

  case MNOTE_OLYMPUS_TAG_COLORMATRIX:

    CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen)

    if (entry->tag == MNOTE_OLYMPUS_TAG_COLORMATRIX)

      CC (entry->components, 9, v, maxlen)

    for (i=0; i < (int)entry->components; ++i) {

      vs = exif_get_short (entry->data+2*i, entry->order);

      sprintf (buf, "%hu ", vs);

      strncat (v, buf, maxlen - strlen (v));

    }

    break;

  case MNOTE_NIKON1_TAG_FOCUS:

  case MNOTE_NIKON_TAG_DIGITALZOOM:

  case MNOTE_NIKON1_TAG_DIGITALZOOM:

  case MNOTE_OLYMPUS_TAG_FOCALPLANEDIAGONAL:

    CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen)

    /* Fall through to default handler for display */

    /* fall through */

  default:

    switch (entry->format) {

    case EXIF_FORMAT_ASCII:

      strncpy (v, (char *)entry->data, MIN (maxlen, entry->size));

      break;

    case EXIF_FORMAT_SHORT:

      CC (entry->components, 1, v, maxlen)

      vs = exif_get_short (entry->data, entry->order);

      snprintf (v, maxlen, "%hu", vs);

      break;

    case EXIF_FORMAT_SSHORT:

      CC (entry->components, 1, v, maxlen)

      vss = exif_get_sshort (entry->data, entry->order);

      snprintf (v, maxlen, "%hi", vss);

      break;

    case EXIF_FORMAT_LONG:

      CC (entry->components, 1, v, maxlen)

      vl = exif_get_long (entry->data, entry->order);

      snprintf (v, maxlen, "%lu", (long unsigned) vl);

      break;

    case EXIF_FORMAT_SLONG:

      CC (entry->components, 1, v, maxlen)

      vsl = exif_get_slong (entry->data, entry->order);

      snprintf (v, maxlen, "%li", (long int) vsl);

      break;

    case EXIF_FORMAT_RATIONAL:

      CC (entry->components, 1, v, maxlen)

      vr = exif_get_rational (entry->data, entry->order);

      if (!vr.denominator) {

        strncpy (v, _("Infinite"), maxlen);

      } else {

        r = R2D(vr);

        snprintf (v, maxlen, "%2.3f", r);

      }

      break;

    case EXIF_FORMAT_SRATIONAL:

      CC (entry->components, 1, v, maxlen)

      vsr = exif_get_srational (entry->data, entry->order);

      if (!vsr.denominator) {

        strncpy (v, _("Infinite"), maxlen);

      } else {

        r = R2D(vsr);

        snprintf (v, maxlen, "%2.3f", r);

      }

      break;

    case EXIF_FORMAT_UNDEFINED:

    default:

      snprintf (v, maxlen, _("%i bytes unknown data: "),

          entry->size);

      for (i = 0; i < (int)entry->size; i++) {

        sprintf (buf, "%02x", entry->data[i]);

        strncat (v, buf, maxlen - strlen (v));

      }

      break;

    }

    break;

  }

  return (v);

}