mnote-olympus-entry.c

Go to the documentation of this file.
00001 /* mnote-olympus-entry.c
00002  *
00003  * Copyright © 2002 Lutz Müller <lutz@users.sourceforge.net>
00004  *
00005  * This library is free software; you can redistribute it and/or
00006  * modify it under the terms of the GNU Lesser General Public
00007  * License as published by the Free Software Foundation; either
00008  * version 2 of the License, or (at your option) any later version.
00009  *
00010  * This library is distributed in the hope that it will be useful,
00011  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00012  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00013  * Lesser General Public License for more details.
00014  *
00015  * You should have received a copy of the GNU Lesser General Public
00016  * License along with this library; if not, write to the
00017  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
00018  * Boston, MA 02111-1307, USA.
00019  */
00020 
00021 #include <config.h>
00022 #include "mnote-olympus-entry.h"
00023 
00024 #include <stdio.h>
00025 #include <stdlib.h>
00026 #include <string.h>
00027 
00028 #include <libexif/exif-format.h>
00029 #include <libexif/exif-utils.h>
00030 #include <libexif/exif-entry.h>
00031 #include <libexif/i18n.h>
00032 
00033 #define CF(format,target,v,maxlen)                              \
00034 {                                                               \
00035         if (format != target) {                                 \
00036                 snprintf (v, maxlen,                            \
00037                         _("Invalid format '%s', "               \
00038                         "expected '%s'."),                      \
00039                         exif_format_get_name (format),          \
00040                         exif_format_get_name (target));         \
00041                 break;                                          \
00042         }                                                       \
00043 }
00044 
00045 #define CC(number,target,v,maxlen)                                      \
00046 {                                                                       \
00047         if (number != target) {                                         \
00048                 snprintf (v, maxlen,                                    \
00049                         _("Invalid number of components (%i, "          \
00050                         "expected %i)."), (int) number, (int) target);  \
00051                 break;                                                  \
00052         }                                                               \
00053 }
00054 
00055 #define CC2(number,t1,t2,v,maxlen)                                      \
00056 {                                                                       \
00057         if ((number != t1) && (number != t2)) {                         \
00058                 snprintf (v, maxlen,                                    \
00059                         _("Invalid number of components (%i, "          \
00060                         "expected %i or %i)."), (int) number,           \
00061                         (int) t1, (int) t2);                            \
00062                 break;                                                  \
00063         }                                                               \
00064 }
00065 
00066 #define R2L(n) ((n).denominator ? (long)(n).numerator/(n).denominator : 0L)
00067 #define R2D(n) ((n).denominator ? (double)(n).numerator/(n).denominator : 0.0)
00068 
00069 static struct {
00070         ExifTag tag;
00071     ExifFormat fmt;
00072         struct {
00073                 int index;
00074                 const char *string;
00075         } elem[10];
00076 } items[] = {
00077   { MNOTE_NIKON_TAG_LENSTYPE, EXIF_FORMAT_BYTE,
00078     { {0, N_("AF non D Lens")},
00079       {1, N_("Manual")},
00080       {2, N_("AF-D or AF-S Lens")},
00081       {6, N_("AF-D G Lens")},
00082       {10, N_("AF-D VR Lens")},
00083       {0, NULL}}},
00084   { MNOTE_NIKON_TAG_FLASHUSED, EXIF_FORMAT_BYTE,
00085     { {0, N_("Flash did not fire")},
00086       {4, N_("Flash unit unknown")},
00087       {7, N_("Flash is external")},
00088       {9, N_("Flash is on Camera")},
00089       {0, NULL}}},
00090   { MNOTE_NIKON1_TAG_QUALITY, EXIF_FORMAT_SHORT,
00091     { {1, N_("VGA Basic")},
00092       {2, N_("VGA Normal")},
00093       {3, N_("VGA Fine")},
00094       {4, N_("SXGA Basic")},
00095       {5, N_("SXGA Normal")},
00096       {6, N_("SXGA Fine")},
00097       {10, N_("2 MPixel Basic")},
00098       {11, N_("2 MPixel Normal")},
00099       {12, N_("2 MPixel Fine")},
00100       {0, NULL}}},
00101   { MNOTE_NIKON1_TAG_COLORMODE, EXIF_FORMAT_SHORT,
00102     { {1, N_("Color")},
00103       {2, N_("Monochrome")},
00104       {0, NULL}}},
00105   { MNOTE_NIKON1_TAG_IMAGEADJUSTMENT, EXIF_FORMAT_SHORT,
00106     { {0, N_("Normal")},
00107       {1, N_("Bright+")},
00108       {2, N_("Bright-")},
00109       {3, N_("Contrast+")},
00110       {4, N_("Contrast-")},
00111       {0, NULL}}},
00112   { MNOTE_NIKON1_TAG_CCDSENSITIVITY, EXIF_FORMAT_SHORT,
00113     { {0, N_("ISO80")},
00114       {2, N_("ISO160")},
00115       {4, N_("ISO320")},
00116       {5, N_("ISO100")},
00117       {0, NULL}}},
00118   { MNOTE_NIKON1_TAG_WHITEBALANCE, EXIF_FORMAT_SHORT,
00119     { {0, N_("Auto")},
00120       {1, N_("Preset")},
00121       {2, N_("Daylight")},
00122       {3, N_("Incandescense")},
00123       {4, N_("Fluorescence")},
00124       {5, N_("Cloudy")},
00125       {6, N_("SpeedLight")},
00126       {0, NULL}}},
00127   { MNOTE_NIKON1_TAG_CONVERTER, EXIF_FORMAT_SHORT,
00128     { {0, N_("No Fisheye")},
00129       {1, N_("Fisheye On")},
00130       {0, NULL}}},
00131   { MNOTE_OLYMPUS_TAG_QUALITY, EXIF_FORMAT_SHORT,
00132     { {1, N_("SQ")},
00133       {2, N_("HQ")},
00134       {3, N_("SHQ")},
00135       {0, NULL}}},
00136   { MNOTE_OLYMPUS_TAG_MACRO, EXIF_FORMAT_SHORT,
00137     { {0, N_("No")},
00138       {1, N_("Yes")},
00139       {0, NULL}}},
00140   { MNOTE_OLYMPUS_TAG_DIGIZOOM, EXIF_FORMAT_SHORT,
00141     { {0, N_("1x")},
00142       {2, N_("2x")},
00143       {0, NULL}}},
00144   { MNOTE_OLYMPUS_TAG_FLASHMODE, EXIF_FORMAT_SHORT,
00145     { {0, N_("Auto")},
00146       {1, N_("Red-eye reduction")},
00147       {2, N_("Fill")},
00148       {3, N_("Off")},
00149       {0, NULL}}},
00150   { MNOTE_OLYMPUS_TAG_SHARPNESS, EXIF_FORMAT_SHORT,
00151     { {0, N_("Normal")},
00152       {1, N_("Hard")},
00153       {2, N_("Soft")},
00154       {0, NULL}}},
00155   { MNOTE_OLYMPUS_TAG_CONTRAST, EXIF_FORMAT_SHORT,
00156     { {0, N_("Hard")},
00157       {1, N_("Normal")},
00158       {2, N_("Soft")},
00159       {0, NULL}}},
00160   { MNOTE_OLYMPUS_TAG_MANFOCUS, EXIF_FORMAT_SHORT,
00161     { {0, N_("No")},
00162       {1, N_("Yes")},
00163       {0, NULL}}},
00164   { 0, }
00165 };
00166 
00167 char *
00168 mnote_olympus_entry_get_value (MnoteOlympusEntry *entry, char *v, unsigned int maxlen)
00169 {
00170         char         buf[30];
00171         ExifLong     vl;
00172         ExifShort    vs = 0;
00173         ExifRational vr;
00174         int          i, j;
00175         double       r, b;
00176 
00177         if (!entry)
00178                 return (NULL);
00179 
00180         memset (v, 0, maxlen);
00181         maxlen--;
00182 
00183         if ((!entry->data) && (entry->components > 0)) return (v);
00184 
00185         switch (entry->tag) {
00186         
00187         /* Nikon */
00188         case MNOTE_NIKON_TAG_FIRMWARE:
00189                 CF (entry->format,  EXIF_FORMAT_UNDEFINED, v, maxlen);
00190                 CC (entry->components, 4, v, maxlen);
00191                 vl = exif_get_long (entry->data, entry->order);
00192                 if ((vl & 0xF0F0F0F0) == 0x30303030) {
00193                         memcpy (v, entry->data, MIN (maxlen, 4));
00194                 } else {
00195                         snprintf (v, maxlen, "%04lx", (long unsigned int) vl);
00196                 }
00197                 break;
00198         case MNOTE_NIKON_TAG_ISO:
00199                 CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
00200                 CC (entry->components, 2, v, maxlen);
00201                 //vs = exif_get_short (entry->data, entry->order);
00202                 vs = exif_get_short (entry->data + 2, entry->order);
00203                 snprintf (v, maxlen, "ISO %hd", vs);
00204                 break;
00205         case MNOTE_NIKON_TAG_ISO2:
00206                 CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
00207                 CC (entry->components, 2, v, maxlen);
00208                 //vs = exif_get_short (entry->data, entry->order);
00209                 vs = exif_get_short (entry->data + 2, entry->order);
00210                 snprintf (v, maxlen, "ISO2 %hd", vs);
00211                 break;
00212         case MNOTE_NIKON_TAG_QUALITY:
00213                 CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
00214                 //CC (entry->components, 8, v, maxlen);
00215                 //vl =  exif_get_long (entry->data  , entry->order);
00216                 //printf("-> 0x%04x\n",entry->data);
00217                 //printf("-> 0x%s<\n",entry->data - 0);
00218                 memcpy(v, entry->data ,entry->components);
00219                 //snprintf (v, maxlen, "%s<",  ( entry->data - 9  );
00220                 break;
00221         case MNOTE_NIKON_TAG_COLORMODE:
00222         case MNOTE_NIKON_TAG_COLORMODE1:
00223         case MNOTE_NIKON_TAG_WHITEBALANCE:
00224         case MNOTE_NIKON_TAG_SHARPENING:
00225         case MNOTE_NIKON_TAG_FOCUSMODE:
00226         case MNOTE_NIKON_TAG_FLASHSETTING:
00227         case MNOTE_NIKON_TAG_ISOSELECTION:
00228         case MNOTE_NIKON_TAG_FLASHMODE:
00229         case MNOTE_NIKON_TAG_IMAGEADJUSTMENT:
00230         case MNOTE_NIKON_TAG_ADAPTER:
00231                 CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
00232                 memcpy(v, entry->data, MIN (maxlen, entry->components));
00233                 break;
00234         case MNOTE_NIKON_TAG_TOTALPICTURES:
00235                 CF (entry->format, EXIF_FORMAT_LONG, v, maxlen);
00236                 CC (entry->components, 1, v, maxlen);
00237                 vl =  exif_get_long (entry->data, entry->order);
00238                 snprintf (v, maxlen, "%lu",  (long unsigned int) vl );
00239                 break;
00240         case MNOTE_NIKON_TAG_WHITEBALANCEFINE:
00241                 CF (entry->format, EXIF_FORMAT_SSHORT, v, maxlen);
00242                 CC (entry->components, 1, v, maxlen);
00243                 vs = exif_get_short (entry->data, entry->order);
00244                 snprintf (v, maxlen, "%hd", vs);
00245                 break;
00246         case MNOTE_NIKON_TAG_WHITEBALANCERB:
00247                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
00248                 CC (entry->components, 4, v, maxlen);
00249                 vr = exif_get_rational (entry->data, entry->order);
00250                 r = R2D(vr);
00251                 vr = exif_get_rational (entry->data+8, entry->order);
00252                 b = R2D(vr);
00253                 //printf("numerator %li, denominator %li\n", vr.numerator, vr.denominator);
00254                 snprintf (v, maxlen, _("Red Correction %f, Blue Correction %f"), r,b);
00255                 break;
00256         case MNOTE_NIKON_TAG_MANUALFOCUSDISTANCE:
00257                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
00258                 CC (entry->components, 1, v, maxlen);
00259                 vr = exif_get_rational (entry->data, entry->order);
00260                 if (!vr.numerator || !vr.denominator) {
00261                         strncpy (v, _("No manual focus selection"), maxlen);
00262                 } else {
00263                         r = R2D(vr);
00264                         snprintf (v, maxlen, _("%2.2f meters"), r);
00265                 }
00266                 break;
00267         case MNOTE_NIKON_TAG_DIGITALZOOM:
00268         case MNOTE_NIKON1_TAG_DIGITALZOOM:
00269                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
00270                 CC (entry->components, 1, v, maxlen);
00271                 vr = exif_get_rational (entry->data, entry->order);
00272                 r = R2D(vr);
00273                 snprintf (v, maxlen, "%2.2f", r);
00274                 break;
00275         case MNOTE_NIKON_TAG_AFFOCUSPOSITION:
00276                 CF (entry->format, EXIF_FORMAT_UNDEFINED, v, maxlen);
00277                 CC (entry->components, 4, v, maxlen);
00278                 switch (  *( entry->data+1)  ) {
00279                         case  0: strncpy (v, _("AF Position: Center"), maxlen); break;
00280                         case  1: strncpy (v, _("AF Position: Top"), maxlen); break;
00281                         case  2: strncpy (v, _("AF Position: Bottom"), maxlen); break;
00282                         case  3: strncpy (v, _("AF Position: Left"), maxlen); break;
00283                         case  4: strncpy (v, _("AF Position: Right"), maxlen); break;
00284                         default: strncpy (v, _("Unknown AF Position"), maxlen);
00285                 }     
00286                 break;
00287         case MNOTE_OLYMPUS_TAG_DIGIZOOM:
00288                 if (entry->format == EXIF_FORMAT_RATIONAL) {
00289                         CC (entry->components, 1, v, maxlen);
00290                         vr = exif_get_rational (entry->data, entry->order);
00291                         if (!vr.numerator || !vr.denominator) {
00292                                 strncpy (v, _("None"), maxlen);
00293                         } else {
00294                                 r = R2D(vr);
00295                                 snprintf (v, maxlen, "%2.2f", r);
00296                         }
00297                         break;
00298                 }
00299                 /* fall through to handle SHORT version of this tag */
00300         case MNOTE_NIKON_TAG_LENSTYPE:
00301         case MNOTE_NIKON_TAG_FLASHUSED:
00302         case MNOTE_NIKON1_TAG_QUALITY:
00303         case MNOTE_NIKON1_TAG_COLORMODE:
00304         case MNOTE_NIKON1_TAG_IMAGEADJUSTMENT:
00305         case MNOTE_NIKON1_TAG_CCDSENSITIVITY:
00306         case MNOTE_NIKON1_TAG_WHITEBALANCE:
00307         case MNOTE_NIKON1_TAG_CONVERTER:
00308         case MNOTE_OLYMPUS_TAG_QUALITY:
00309         case MNOTE_OLYMPUS_TAG_MACRO:
00310         case MNOTE_OLYMPUS_TAG_FLASHMODE:
00311         case MNOTE_OLYMPUS_TAG_SHARPNESS:
00312         case MNOTE_OLYMPUS_TAG_CONTRAST:
00313         case MNOTE_OLYMPUS_TAG_MANFOCUS:
00314                 /* search the tag */
00315                 for (i = 0; (items[i].tag && items[i].tag != entry->tag); i++);
00316                 if (!items[i].tag) {
00317                         strncpy (v, _("Internal error"), maxlen);
00318                         break;
00319                 }
00320                 CF (entry->format, items[i].fmt, v, maxlen);
00321                 CC (entry->components, 1, v, maxlen);
00322                 switch (entry->format) {
00323                 case EXIF_FORMAT_BYTE:
00324                 case EXIF_FORMAT_UNDEFINED:
00325                         vs = entry->data[0];
00326                         break;
00327                 case EXIF_FORMAT_SHORT:
00328                         vs = exif_get_short(entry->data, entry->order);
00329                         break;
00330                 default:
00331                         vs = 0;
00332                         break;
00333                 }
00334                 /* find the value */
00335                 for (j = 0; items[i].elem[j].string &&
00336                             (items[i].elem[j].index < vs); j++);
00337                 if (items[i].elem[j].index != vs) {
00338                         snprintf (v, maxlen, _("Unknown value %hi"), vs);
00339                         break;
00340                 }
00341                 strncpy (v, items[i].elem[j].string, maxlen);
00342                 break;
00343 
00344         case MNOTE_NIKON_TAG_LENS:
00345                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
00346                 CC (entry->components, 4, v, maxlen);
00347                 {
00348                         double c,d;
00349                         unsigned long a,b;
00350                         vr = exif_get_rational (entry->data, entry->order);
00351                         a = R2L(vr);
00352                         vr = exif_get_rational (entry->data+8, entry->order);
00353                         b = R2L(vr);
00354                         vr = exif_get_rational (entry->data+16, entry->order);
00355                         c = R2D(vr);
00356                         vr = exif_get_rational (entry->data+24, entry->order);
00357                         d = R2D(vr);
00358                         //printf("numerator %li, denominator %li\n", vr.numerator, vr.denominator);
00359                         snprintf (v, maxlen, "%ld-%ldmm 1:%3.1f - %3.1f",a,b,c,d);
00360                 }
00361                 break;
00362         case MNOTE_NIKON1_TAG_FOCUS:
00363                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
00364                 CC (entry->components, 1, v, maxlen);
00365                 vr = exif_get_rational (entry->data, entry->order);
00366                 if (!vr.denominator) {
00367                         strncpy (v, _("Infinite"), maxlen);
00368                 } else {
00369                         r = R2D(vr);
00370                         snprintf (v, maxlen, "%2.2f", r);
00371                 }
00372                 break;
00373 
00374         /* Olympus */
00375         case MNOTE_OLYMPUS_TAG_MODE:
00376                 CF (entry->format, EXIF_FORMAT_LONG, v, maxlen);
00377                 CC (entry->components, 3, v, maxlen);
00378                 vl = exif_get_long (entry->data, entry->order);
00379                 switch (vl) {
00380                 case 0:
00381                         strncpy (v, _("normal"), maxlen);
00382                         break;
00383                 case 1:
00384                         strncpy (v, _("unknown"), maxlen);
00385                         break;
00386                 case 2:
00387                         strncpy (v, _("fast"), maxlen);
00388                         break;
00389                 case 3:
00390                         strncpy (v, _("panorama"), maxlen);
00391                         break;
00392                 default:
00393                         snprintf (v, maxlen, _("%li"), (long int) vl);
00394                 }
00395                 vl = exif_get_long (entry->data + 4, entry->order);
00396                 snprintf (buf, sizeof (buf), "/%li/", (long int) vl);
00397                 strncat (v, buf, maxlen - strlen (v));
00398                 vl = exif_get_long (entry->data + 4, entry->order);
00399                 switch (vl) {
00400                 case 1:
00401                         strncat (v, _("left to right"), maxlen - strlen (v));
00402                         break;
00403                 case 2:
00404                         strncat (v, _("right to left"), maxlen - strlen (v));
00405                         break;
00406                 case 3:
00407                         strncat (v, _("bottom to top"), maxlen - strlen (v));
00408                         break;
00409                 case 4:
00410                         strncat (v, _("top to bottom"), maxlen - strlen (v));
00411                         break;
00412                 default:
00413                         snprintf (buf, sizeof (buf), _("%li"),
00414                                   (long int) vl);
00415                         strncat (v, buf, maxlen - strlen (v));
00416                 }
00417                 break;
00418         case MNOTE_OLYMPUS_TAG_UNKNOWN_1:
00419                 CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
00420                 CC (entry->components, 1, v, maxlen);
00421                 strncpy (v, _("Unknown tag."), maxlen);
00422                 break;
00423         case MNOTE_OLYMPUS_TAG_UNKNOWN_2:
00424                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
00425                 CC (entry->components, 1, v, maxlen);
00426                 break;
00427         case MNOTE_OLYMPUS_TAG_UNKNOWN_3:
00428                 CF (entry->format, EXIF_FORMAT_SSHORT, v, maxlen);
00429                 CC (entry->components, 1, v, maxlen);
00430                 break;
00431         case MNOTE_OLYMPUS_TAG_VERSION:
00432                 CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
00433                 CC2 (entry->components, 5, 8, v, maxlen);
00434                 strncpy (v, (char *)entry->data, MIN (maxlen, entry->size));
00435                 break;
00436         case MNOTE_OLYMPUS_TAG_INFO:
00437                 CF (entry->format, EXIF_FORMAT_ASCII, v, maxlen);
00438                 CC2 (entry->components, 52, 53, v, maxlen);
00439                 strncpy (v, (char *)entry->data, MIN (maxlen, entry->size));
00440                 break;
00441         case MNOTE_OLYMPUS_TAG_ID:
00442                 CF (entry->format, EXIF_FORMAT_UNDEFINED, v, maxlen);
00443                 CC (entry->components, 32, v, maxlen);
00444                 strncpy (v, (char *)entry->data, MIN (maxlen, entry->size));
00445                 break;
00446         case MNOTE_OLYMPUS_TAG_UNKNOWN_4:
00447                 CF (entry->format, EXIF_FORMAT_LONG, v, maxlen);
00448                 CC (entry->components, 30, v, maxlen);
00449                 break;
00450         case MNOTE_OLYMPUS_TAG_FOCUSDIST:
00451                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
00452                 CC (entry->components, 1, v, maxlen);
00453                 vr = exif_get_rational (entry->data, entry->order);
00454                 if (!vr.numerator || !vr.denominator) {
00455                         strncpy (v, _("Unknown"), maxlen);
00456                 }
00457                 else {
00458                         unsigned long tmp = R2L(vr);
00459                         /* printf("numerator %li, denominator %li\n", vr.numerator, vr.denominator); */
00460                         snprintf (v, maxlen, "%li mm", tmp);
00461                 }
00462                 break;
00463         case MNOTE_OLYMPUS_TAG_WBALANCE:
00464                 CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
00465                 CC (entry->components, 2, v, maxlen);
00466                 vs = exif_get_short (entry->data, entry->order);
00467                 switch (vs) {
00468                 case 1:
00469                         strncpy (v, _("Automatic"), maxlen);
00470                         break;
00471                 case 2:
00472                         {
00473                                 ExifShort v2 = exif_get_short (entry->data + 2, entry->order);
00474                                 unsigned long colorTemp = 0;
00475                                 switch (v2) {
00476                                 case 2:
00477                                         colorTemp = 3000;
00478                                         break;
00479                                 case 3:
00480                                         colorTemp = 3700;
00481                                         break;
00482                                 case 4:
00483                                         colorTemp = 4000;
00484                                         break;
00485                                 case 5:
00486                                         colorTemp = 4500;
00487                                         break;
00488                                 case 6:
00489                                         colorTemp = 5500;
00490                                         break;
00491                                 case 7:
00492                                         colorTemp = 6500;
00493                                         break;
00494                                 case 9:
00495                                         colorTemp = 7500;
00496                                         break;
00497                                 }
00498                                 if (colorTemp) {
00499                                         snprintf (v, maxlen, "Manual: %liK", colorTemp);
00500                                 }
00501                                 else {
00502                                         strncpy (v, _("Manual: Unknown"), maxlen);
00503                                 }
00504 
00505                         }
00506                         break;
00507                 case 3:
00508                         strncpy (v, _("One-touch"), maxlen);
00509                         break;
00510                 default:
00511                         strncpy (v, _("Unknown"), maxlen);
00512                         break;
00513                 }
00514                 break;
00515         default:
00516                 switch (entry->format) {
00517                 case EXIF_FORMAT_ASCII:
00518                         strncpy (v, (char *)entry->data,
00519                                  MIN (maxlen, entry->components));
00520                         break;
00521                 case EXIF_FORMAT_SHORT:
00522                         vs = exif_get_short (entry->data, entry->order);
00523                         snprintf (v, maxlen, "%hi", vs);
00524                         break;
00525                 case EXIF_FORMAT_LONG:
00526                         vl = exif_get_long (entry->data, entry->order);
00527                         snprintf (v, maxlen, "%li", (long int) vl);
00528                         break;
00529                 case EXIF_FORMAT_UNDEFINED:
00530                 default:
00531                         snprintf (v, maxlen, _("%li bytes unknown data: "),
00532                                   (long int) entry->size);
00533                         for (i = 0; i < (int)entry->size; i++) {
00534                                 sprintf (buf, "%02x", entry->data[i]);
00535                                 strncat (v, buf, maxlen - strlen (v));
00536                         }
00537                         break;
00538                 }
00539                 break;
00540         }
00541 
00542         return (v);
00543 }

Generated on Fri Oct 19 13:37:46 2012 for EXIF library (libexif) Internals by  doxygen 1.5.1