exif-entry.c

Go to the documentation of this file.
00001 /* exif-entry.c
00002  *
00003  * Copyright © 2001 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 
00023 #include <libexif/exif-entry.h>
00024 #include <libexif/exif-ifd.h>
00025 #include <libexif/exif-utils.h>
00026 #include <libexif/i18n.h>
00027 
00028 #include <ctype.h>
00029 #include <stdlib.h>
00030 #include <stdio.h>
00031 #include <string.h>
00032 #include <time.h>
00033 #include <math.h>
00034 
00035 struct _ExifEntryPrivate
00036 {
00037         unsigned int ref_count;
00038 
00039         ExifMem *mem;
00040 };
00041 
00042 /* This function is hidden in exif-data.c */
00043 ExifLog *exif_data_get_log (ExifData *);
00044 
00045 static void
00046 exif_entry_log (ExifEntry *e, ExifLogCode code, const char *format, ...)
00047 {
00048         va_list args;
00049         ExifLog *l = NULL;
00050 
00051         if (e && e->parent && e->parent->parent)
00052                 l = exif_data_get_log (e->parent->parent);
00053         va_start (args, format);
00054         exif_logv (l, code, "ExifEntry", format, args);
00055         va_end (args);
00056 }
00057 
00058 static void *
00059 exif_entry_alloc (ExifEntry *e, unsigned int i)
00060 {
00061         void *d;
00062         ExifLog *l = NULL;
00063 
00064         if (!e || !e->priv || !i) return NULL;
00065 
00066         d = exif_mem_alloc (e->priv->mem, i);
00067         if (d) return d;
00068 
00069         if (e->parent && e->parent->parent)
00070                 l = exif_data_get_log (e->parent->parent);
00071         EXIF_LOG_NO_MEMORY (l, "ExifEntry", i);
00072         return NULL;
00073 }
00074 
00075 static void *
00076 exif_entry_realloc (ExifEntry *e, void *d_orig, unsigned int i)
00077 {
00078         void *d;
00079         ExifLog *l = NULL;
00080 
00081         if (!e || !e->priv) return NULL;
00082 
00083         if (!i) { exif_mem_free (e->priv->mem, d_orig); return NULL; }
00084 
00085         d = exif_mem_realloc (e->priv->mem, d_orig, i);
00086         if (d) return d;
00087 
00088         if (e->parent && e->parent->parent)
00089                 l = exif_data_get_log (e->parent->parent);
00090         EXIF_LOG_NO_MEMORY (l, "ExifEntry", i);
00091         return NULL;
00092 }
00093 
00094 ExifEntry *
00095 exif_entry_new (void)
00096 {
00097         ExifMem *mem = exif_mem_new_default ();
00098         ExifEntry *e = exif_entry_new_mem (mem);
00099 
00100         exif_mem_unref (mem);
00101 
00102         return e;
00103 }
00104 
00105 ExifEntry *
00106 exif_entry_new_mem (ExifMem *mem)
00107 {
00108         ExifEntry *e = NULL;
00109 
00110         e = exif_mem_alloc (mem, sizeof (ExifEntry));
00111         if (!e) return NULL;
00112         e->priv = exif_mem_alloc (mem, sizeof (ExifEntryPrivate));
00113         if (!e->priv) { exif_mem_free (mem, e); return NULL; }
00114         e->priv->ref_count = 1;
00115 
00116         e->priv->mem = mem;
00117         exif_mem_ref (mem);
00118 
00119         return e;
00120 }
00121 
00122 void
00123 exif_entry_ref (ExifEntry *e)
00124 {
00125         if (!e) return;
00126 
00127         e->priv->ref_count++;
00128 }
00129 
00130 void
00131 exif_entry_unref (ExifEntry *e)
00132 {
00133         if (!e) return;
00134 
00135         e->priv->ref_count--;
00136         if (!e->priv->ref_count)
00137                 exif_entry_free (e);
00138 }
00139 
00140 void
00141 exif_entry_free (ExifEntry *e)
00142 {
00143         if (!e) return;
00144 
00145         if (e->priv) {
00146                 ExifMem *mem = e->priv->mem;
00147                 if (e->data)
00148                         exif_mem_free (mem, e->data);
00149                 exif_mem_free (mem, e->priv);
00150                 exif_mem_free (mem, e);
00151                 exif_mem_unref (mem);
00152         }
00153 }
00154 
00155 void
00156 exif_entry_fix (ExifEntry *e)
00157 {
00158         unsigned int i;
00159         ExifByteOrder o;
00160         ExifRational r;
00161         ExifSRational sr;
00162 
00163         if (!e || !e->priv) return;
00164 
00165         switch (e->tag) {
00166         
00167         /* These tags all need to be of format SHORT. */
00168         case EXIF_TAG_YCBCR_SUB_SAMPLING:
00169         case EXIF_TAG_SUBJECT_AREA:
00170         case EXIF_TAG_COLOR_SPACE:
00171         case EXIF_TAG_PLANAR_CONFIGURATION:
00172         case EXIF_TAG_SENSING_METHOD:
00173         case EXIF_TAG_ORIENTATION:
00174         case EXIF_TAG_YCBCR_POSITIONING:
00175         case EXIF_TAG_PHOTOMETRIC_INTERPRETATION:
00176         case EXIF_TAG_CUSTOM_RENDERED:
00177         case EXIF_TAG_EXPOSURE_MODE:
00178         case EXIF_TAG_WHITE_BALANCE:
00179         case EXIF_TAG_SCENE_CAPTURE_TYPE:
00180         case EXIF_TAG_GAIN_CONTROL:
00181         case EXIF_TAG_SATURATION:
00182         case EXIF_TAG_CONTRAST:
00183         case EXIF_TAG_SHARPNESS:
00184                 switch (e->format) {
00185                 case EXIF_FORMAT_LONG:
00186                         if (!e->parent || !e->parent->parent) break;
00187                         o = exif_data_get_byte_order (e->parent->parent);
00188                         for (i = 0; i < e->components; i++)
00189                                 exif_set_short (
00190                                         e->data + i *
00191                                         exif_format_get_size (
00192                                         EXIF_FORMAT_SHORT), o,
00193                                         (ExifShort) exif_get_long (
00194                                         e->data + i *
00195                                         exif_format_get_size (
00196                                         EXIF_FORMAT_LONG), o));
00197                         e->format = EXIF_FORMAT_SHORT;
00198                         e->size = e->components *
00199                                 exif_format_get_size (e->format);
00200                         e->data = exif_entry_realloc (e, e->data, e->size);
00201                         exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
00202                                 _("Tag '%s' was of format '%s' (which is "
00203                                 "against specification) and has been "
00204                                 "changed to format '%s'."),
00205                                 exif_tag_get_name (e->tag), 
00206                                 exif_format_get_name (EXIF_FORMAT_LONG),
00207                                 exif_format_get_name (EXIF_FORMAT_SHORT));
00208                         break;
00209                 case EXIF_FORMAT_SHORT:
00210                 default:
00211                         break;
00212                 }
00213                 break;
00214 
00215         /* All these tags need to be of format 'Rational'. */
00216         case EXIF_TAG_FNUMBER:
00217         case EXIF_TAG_APERTURE_VALUE:
00218         case EXIF_TAG_EXPOSURE_TIME:
00219         case EXIF_TAG_FOCAL_LENGTH:
00220                 switch (e->format) {
00221                 case EXIF_FORMAT_SRATIONAL:
00222                         if (!e->parent || !e->parent->parent) break;
00223                         o = exif_data_get_byte_order (e->parent->parent);
00224                         for (i = 0; i < e->components; i++) {
00225                                 sr = exif_get_srational (e->data + i * 
00226                                         exif_format_get_size (
00227                                                 EXIF_FORMAT_SRATIONAL), o);
00228                                 r.numerator = (ExifLong) sr.numerator;
00229                                 r.denominator = (ExifLong) sr.denominator;
00230                                 exif_set_rational (e->data + i *
00231                                         exif_format_get_size (
00232                                                 EXIF_FORMAT_RATIONAL), o, r);
00233                         }
00234                         e->format = EXIF_FORMAT_RATIONAL;
00235                         exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
00236                                 _("Tag '%s' was of format '%s' (which is "
00237                                 "against specification) and has been "
00238                                 "changed to format '%s'."),
00239                                 exif_tag_get_name (e->tag),
00240                                 exif_format_get_name (EXIF_FORMAT_SRATIONAL),
00241                                 exif_format_get_name (EXIF_FORMAT_RATIONAL));
00242                         break;
00243                 default:
00244                         break;
00245                 }
00246                 break;
00247 
00248         case EXIF_TAG_USER_COMMENT:
00249 
00250                 /* Format needs to be UNDEFINED. */
00251                 if (e->format != EXIF_FORMAT_UNDEFINED) {
00252                         exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
00253                                 _("Tag 'UserComment' had invalid format '%s'. "
00254                                 "Format has been set to 'undefined'."),
00255                                 exif_format_get_name (e->format));
00256                         e->format = EXIF_FORMAT_UNDEFINED;
00257                 }
00258 
00259                 /* Some packages like Canon ZoomBrowser EX 4.5 store
00260                    only one zero byte followed by 7 bytes of rubbish */
00261                 if ((e->size >= 8) && (e->data[0] == 0)) {
00262                         memcpy(e->data, "\0\0\0\0\0\0\0\0", 8);
00263                 }
00264 
00265                 /* There need to be at least 8 bytes. */
00266                 if (e->size < 8) {
00267                         e->data = exif_entry_realloc (e, e->data, 8 + e->size);
00268                         if (!e->data) {
00269                                 e->size = 0;
00270                                 e->components = 0;
00271                                 return;
00272                         }
00273 
00274                         /* Assume ASCII */
00275                         memmove (e->data + 8, e->data, e->size);
00276                         memcpy (e->data, "ASCII\0\0\0", 8);
00277                         e->size += 8;
00278                         e->components += 8;
00279                         exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
00280                                 _("Tag 'UserComment' has been expanded to at "
00281                                 "least 8 bytes in order to follow the "
00282                                 "specification."));
00283                         break;
00284                 }
00285 
00286                 /*
00287                  * If the first 8 bytes are empty and real data starts
00288                  * afterwards, let's assume ASCII and claim the 8 first
00289                  * bytes for the format specifyer.
00290                  */
00291                 for (i = 0; (i < e->size) && !e->data[i]; i++);
00292                 if (!i) for ( ; (i < e->size) && (e->data[i] == ' '); i++);
00293                 if ((i >= 8) && (i < e->size)) {
00294                         exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
00295                                 "Tag 'UserComment' is not empty but does not start with "
00296                                 "format identifyer. This has been fixed.");
00297                         memcpy (e->data, "ASCII\0\0\0", 8);
00298                         break;
00299                 }
00300 
00301                 /* 
00302                  * First 8 bytes need to follow the specification. If they don't, 
00303                  * assume ASCII.
00304                  */
00305                 if (memcmp (e->data, "ASCII\0\0\0"     , 8) &&
00306                     memcmp (e->data, "UNICODE\0"       , 8) &&
00307                     memcmp (e->data, "JIS\0\0\0\0\0"   , 8) &&
00308                     memcmp (e->data, "\0\0\0\0\0\0\0\0", 8)) {
00309                         e->data = exif_entry_realloc (e, e->data, 8 + e->size);
00310                         if (!e->data) {
00311                                 e->size = 0;
00312                                 e->components = 0;
00313                                 break;
00314                         }
00315 
00316                         /* Assume ASCII */
00317                         memmove (e->data + 8, e->data, e->size);
00318                         memcpy (e->data, "ASCII\0\0\0", 8);
00319                         e->size += 8;
00320                         e->components += 8;
00321                         exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
00322                                 _("Tag 'UserComment' did not start with "
00323                                 "format identifier. This has been fixed."));
00324                         break;
00325                 }
00326 
00327                 break;
00328         default:
00329                 break;
00330         }
00331 }
00332 
00333 void
00334 exif_entry_dump (ExifEntry *e, unsigned int indent)
00335 {
00336         char buf[1024];
00337         char value[1024];
00338         unsigned int i;
00339 
00340         for (i = 0; i < 2 * indent; i++)
00341                 buf[i] = ' ';
00342         buf[i] = '\0';
00343 
00344         if (!e)
00345                 return;
00346 
00347         printf ("%sTag: 0x%x ('%s')\n", buf, e->tag,
00348                 exif_tag_get_name (e->tag));
00349         printf ("%s  Format: %i ('%s')\n", buf, e->format,
00350                 exif_format_get_name (e->format));
00351         printf ("%s  Components: %i\n", buf, (int) e->components);
00352         printf ("%s  Size: %i\n", buf, e->size);
00353         printf ("%s  Value: %s\n", buf, exif_entry_get_value (e, value, sizeof(value)));
00354 }
00355 
00365 static int
00366 match_repeated_char(const unsigned char *data, unsigned char ch, size_t n)
00367 {
00368         int i;
00369         for (i=n; i; --i, ++data) {
00370                 if (*data == 0) {
00371                         i = 0;  /* all bytes before NUL matched */
00372                         break;
00373                 }
00374                 if (*data != ch)
00375                         break;
00376         }
00377         return i;
00378 }
00379 
00380 #define CF(entry,target,v,maxlen)                                       \
00381 {                                                                       \
00382         if (entry->format != target) {                                  \
00383                 exif_entry_log (entry, EXIF_LOG_CODE_CORRUPT_DATA,      \
00384                         _("The tag '%s' contains data of an invalid "   \
00385                         "format ('%s', expected '%s')."),               \
00386                         exif_tag_get_name (entry->tag),                 \
00387                         exif_format_get_name (entry->format),           \
00388                         exif_format_get_name (target));                 \
00389                 break;                                                  \
00390         }                                                               \
00391 }
00392 
00393 #define CC(entry,target,v,maxlen)                                       \
00394 {                                                                       \
00395         if (entry->components != target) {                              \
00396                 exif_entry_log (entry, EXIF_LOG_CODE_CORRUPT_DATA,      \
00397                         _("The tag '%s' contains an invalid number of " \
00398                           "components (%i, expected %i)."),             \
00399                         exif_tag_get_name (entry->tag),         \
00400                         (int) entry->components, (int) target);         \
00401                 break;                                                  \
00402         }                                                               \
00403 }
00404 
00405 static struct {
00406         ExifTag tag;
00407         const char *strings[10];
00408 } list[] = {
00409   { EXIF_TAG_PLANAR_CONFIGURATION,
00410     { N_("chunky format"), N_("planar format"), NULL}},
00411   { EXIF_TAG_SENSING_METHOD,
00412     { "", N_("Not defined"), N_("One-chip color area sensor"),
00413       N_("Two-chip color area sensor"), N_("Three-chip color area sensor"),
00414       N_("Color sequential area sensor"), "", N_("Trilinear sensor"),
00415       N_("Color sequential linear sensor"), NULL}},
00416   { EXIF_TAG_ORIENTATION,
00417     { "", N_("top - left"), N_("top - right"), N_("bottom - right"),
00418       N_("bottom - left"), N_("left - top"), N_("right - top"),
00419       N_("right - bottom"), N_("left - bottom"), NULL}},
00420   { EXIF_TAG_YCBCR_POSITIONING,
00421     { "", N_("centered"), N_("co-sited"), NULL}},
00422   { EXIF_TAG_PHOTOMETRIC_INTERPRETATION, {"", N_("RGB"), N_("YCbCr"), NULL}},
00423   { EXIF_TAG_CUSTOM_RENDERED,
00424     { N_("Normal process"), N_("Custom process"), NULL}},
00425   { EXIF_TAG_EXPOSURE_MODE,
00426     { N_("Auto exposure"), N_("Manual exposure"), N_("Auto bracket"), NULL}},
00427   { EXIF_TAG_WHITE_BALANCE,
00428     { N_("Auto white balance"), N_("Manual white balance"), NULL}},
00429   { EXIF_TAG_SCENE_CAPTURE_TYPE,
00430     { N_("Standard"), N_("Landscape"), N_("Portrait"),
00431       N_("Night scene"), NULL}},
00432   { EXIF_TAG_GAIN_CONTROL,
00433     { N_("Normal"), N_("Low gain up"), N_("High gain up"),
00434       N_("Low gain down"), N_("High gain down"), NULL}},
00435   { EXIF_TAG_SATURATION,
00436     { N_("Normal"), N_("Low saturation"), N_("High saturation"), NULL}},
00437   { EXIF_TAG_CONTRAST , {N_("Normal"), N_("Soft"), N_("Hard"), NULL}},
00438   { EXIF_TAG_SHARPNESS, {N_("Normal"), N_("Soft"), N_("Hard"), NULL}},
00439   { 0, {NULL}}
00440 };
00441 
00442 static struct {
00443   ExifTag tag;
00444   struct {
00445     int index;
00446     const char *values[4];
00447   } elem[25];
00448 } list2[] = {
00449   { EXIF_TAG_METERING_MODE,
00450     { {  0, {N_("Unknown"), NULL}},
00451       {  1, {N_("Average"), N_("avg"), NULL}},
00452       {  2, {N_("Center-Weighted Average"), N_("Center-Weight"), NULL}},
00453       {  3, {N_("Spot"), NULL}},
00454       {  4, {N_("Multi Spot"), NULL}},
00455       {  5, {N_("Pattern"), NULL}},
00456       {  6, {N_("Partial"), NULL}},
00457       {255, {N_("Other"), NULL}},
00458       {  0, {NULL}}}},
00459   { EXIF_TAG_COMPRESSION,
00460     { {1, {N_("Uncompressed"), NULL}},
00461       {5, {N_("LZW compression"), NULL}},
00462       {6, {N_("JPEG compression"), NULL}},
00463       {0, {NULL}}}},
00464   { EXIF_TAG_LIGHT_SOURCE,
00465     { {  0, {N_("Unknown"), NULL}},
00466       {  1, {N_("Daylight"), NULL}},
00467       {  2, {N_("Fluorescent"), NULL}},
00468       {  3, {N_("Tungsten incandescent light"), N_("Tungsten"), NULL}},
00469       {  4, {N_("Flash"), NULL}},
00470       {  9, {N_("Fine weather"), NULL}},
00471       { 10, {N_("Cloudy weather"), N_("cloudy"), NULL}},
00472       { 11, {N_("Shade"), NULL}},
00473       { 12, {N_("Daylight fluorescent"), NULL}},
00474       { 13, {N_("Day white fluorescent"), NULL}},
00475       { 14, {N_("Cool white fluorescent"), NULL}},
00476       { 15, {N_("White fluorescent"), NULL}},
00477       { 17, {N_("Standard light A"), NULL}},
00478       { 18, {N_("Standard light B"), NULL}},
00479       { 19, {N_("Standard light C"), NULL}},
00480       { 20, {N_("D55"), NULL}},
00481       { 21, {N_("D65"), NULL}},
00482       { 22, {N_("D75"), NULL}},
00483       { 24, {N_("ISO studio tungsten"),NULL}},
00484       {255, {N_("Other"), NULL}},
00485       {  0, {NULL}}}},
00486   { EXIF_TAG_FOCAL_PLANE_RESOLUTION_UNIT,
00487     { {2, {N_("Inch"), N_("in"), NULL}},
00488       {3, {N_("Centimeter"), N_("cm"), NULL}},
00489       {0, {NULL}}}},
00490   { EXIF_TAG_RESOLUTION_UNIT,
00491     { {2, {N_("Inch"), N_("in"), NULL}},
00492       {3, {N_("Centimeter"), N_("cm"), NULL}}, 
00493       {0, {NULL}}}},
00494   { EXIF_TAG_EXPOSURE_PROGRAM,
00495     { {0, {N_("Not defined"), NULL}},
00496       {1, {N_("Manual"), NULL}},
00497       {2, {N_("Normal program"), N_("Normal"), NULL}},
00498       {3, {N_("Aperture priority"), N_("Aperture"), NULL}},
00499       {4, {N_("Shutter priority"),N_("Shutter"), NULL}},
00500       {5, {N_("Creative program (biased toward depth of field)"),
00501            N_("Creative"), NULL}},
00502       {6, {N_("Creative program (biased toward fast shutter speed)"),
00503            N_("Action"), NULL}},
00504       {7, {N_("Portrait mode (for closeup photos with the background out "
00505               "of focus)"), N_("Portrait"), NULL}},
00506       {8, {N_("Landscape mode (for landscape photos with the background "
00507               "in focus)"), N_("Landscape"), NULL}},
00508       {0, {NULL}}}},
00509   { EXIF_TAG_FLASH,
00510     { {0x0000, {N_("Flash did not fire."), N_("no flash"), NULL}},
00511       {0x0001, {N_("Flash fired."), N_("flash"), N_("Yes"), NULL}},
00512       {0x0005, {N_("Strobe return light not detected."), N_("W/o strobe"),
00513                 NULL}},
00514       {0x0007, {N_("Strobe return light detected."), N_("W. strobe"), NULL}},
00515       {0x0009, {N_("Flash fired, compulsatory flash mode"), NULL}},
00516       {0x000d, {N_("Flash fired, compulsatory flash mode, return light "
00517                    "not detected."), NULL}},
00518       {0x000f, {N_("Flash fired, compulsatory flash mode, return light "
00519                    "detected."), NULL}},
00520       {0x0010, {N_("Flash did not fire, compulsatory flash mode."), NULL}},
00521       {0x0018, {N_("Flash did not fire, auto mode."), NULL}},
00522       {0x0019, {N_("Flash fired, auto mode."), NULL}},
00523       {0x001d, {N_("Flash fired, auto mode, return light not detected."),
00524                 NULL}},
00525       {0x001f, {N_("Flash fired, auto mode, return light detected."), NULL}},
00526       {0x0020, {N_("No flash function."),NULL}},
00527       {0x0041, {N_("Flash fired, red-eye reduction mode."), NULL}},
00528       {0x0045, {N_("Flash fired, red-eye reduction mode, return light "
00529                    "not detected."), NULL}},
00530       {0x0047, {N_("Flash fired, red-eye reduction mode, return light "
00531                    "detected."), NULL}},
00532       {0x0049, {N_("Flash fired, compulsory flash mode, red-eye reduction "
00533                    "mode."), NULL}},
00534       {0x004d, {N_("Flash fired, compulsory flash mode, red-eye reduction "
00535                   "mode, return light not detected"), NULL}},
00536       {0x004f, {N_("Flash fired, compulsory flash mode, red-eye reduction, "
00537                    "return light detected"), NULL}},
00538       {0x0058, {N_("Flash did not fire, auto mode, red-eye reduction mode"), NULL}},
00539       {0x0059, {N_("Flash fired, auto mode, red-eye reduction mode"), NULL}},
00540       {0x005d, {N_("Flash fired, auto mode, return light not detected, "
00541                    "red-eye reduction mode."), NULL}},
00542       {0x005f, {N_("Flash fired, auto mode, return light detected, "
00543                    "red-eye reduction mode."), NULL}},
00544       {0x0000, {NULL}}}},
00545   {EXIF_TAG_SUBJECT_DISTANCE_RANGE, 
00546     { {0, {N_("Unknown"), N_("?"), NULL}},
00547       {1, {N_("Macro"), NULL}},
00548       {2, {N_("Close view"), N_("close"), NULL}},
00549       {3, {N_("Distant view"), N_("distant"), NULL}},
00550       {0, {NULL}}}},
00551   { EXIF_TAG_COLOR_SPACE,
00552     { {1, {N_("sRGB"), NULL}},
00553       {2, {N_("Adobe RGB"), NULL}},
00554       {0xffff, {N_("Uncalibrated"), NULL}}}},
00555   {0, }
00556 };
00557 
00558 const char *
00559 exif_entry_get_value (ExifEntry *e, char *val, unsigned int maxlen)
00560 {
00561         unsigned int i, j, k, l, ts;
00562         ExifByte v_byte;
00563         ExifShort v_short, v_short2, v_short3, v_short4;
00564         ExifLong v_long;
00565         ExifSLong v_slong;
00566         ExifRational v_rat;
00567         ExifSRational v_srat;
00568         char b[64];
00569         const char *c;
00570         size_t len;
00571         ExifByteOrder o;
00572         double d;
00573         ExifEntry *entry;
00574         static struct {
00575                 char *label;
00576                 char major, minor;
00577         } versions[] = {
00578                 {"0110", 1,  1},
00579                 {"0120", 1,  2},
00580                 {"0200", 2,  0},
00581                 {"0210", 2,  1},
00582                 {"0220", 2,  2},
00583                 {"0221", 2, 21},
00584                 {NULL  , 0,  0}
00585         };
00586 
00587         /* FIXME: This belongs to somewhere else. */
00588         /* libexif should use the default system locale.
00589          * If an application specifically requires UTF-8, then we
00590          * must give the application a way to tell libexif that.
00591          * 
00592          * bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
00593          */
00594         bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
00595 
00596         /* We need the byte order */
00597         if (!e || !e->parent || !e->parent->parent || !maxlen)
00598                 return val;
00599         o = exif_data_get_byte_order (e->parent->parent);
00600 
00601         memset (val, 0, maxlen);
00602         memset (b, 0, sizeof (b));
00603         maxlen--;
00604 
00605         /* Sanity check */
00606         if (e->size != e->components * exif_format_get_size (e->format)) {
00607                 snprintf (val, maxlen, _("Invalid size of entry (%i, "
00608                         "expected %li x %i)."), e->size, e->components,
00609                                 exif_format_get_size (e->format));
00610                 return val;
00611         }
00612 
00613         switch (e->tag) {
00614         case EXIF_TAG_USER_COMMENT:
00615 
00616                 /*
00617                  * The specification says UNDEFINED, but some
00618                  * manufacturers don't care and use ASCII. If this is the
00619                  * case here, only refuse to read it if there is no chance
00620                  * of finding readable data.
00621                  */
00622                 if ((e->format != EXIF_FORMAT_ASCII) || 
00623                     (e->size <= 8) ||
00624                     ( memcmp (e->data, "ASCII\0\0\0"  , 8) &&
00625                       memcmp (e->data, "UNICODE\0"    , 8) &&
00626                       memcmp (e->data, "JIS\0\0\0\0\0", 8) &&
00627                       memcmp (e->data, "\0\0\0\0\0\0\0\0", 8)))
00628                         CF (e, EXIF_FORMAT_UNDEFINED, val, maxlen);
00629 
00630                 /*
00631                  * Note that, according to the specification (V2.1, p 40),
00632                  * the user comment field does not have to be 
00633                  * NULL terminated.
00634                  */
00635                 if ((e->size >= 8) && !memcmp (e->data, "ASCII\0\0\0", 8)) {
00636                         strncpy (val, (char *) e->data + 8, MIN (e->size - 8, maxlen));
00637                         break;
00638                 }
00639                 if ((e->size >= 8) && !memcmp (e->data, "UNICODE\0", 8)) {
00640                         strncpy (val, _("Unsupported UNICODE string"), maxlen);
00641                         break;
00642                 }
00643                 if ((e->size >= 8) && !memcmp (e->data, "JIS\0\0\0\0\0", 8)) {
00644                         strncpy (val, _("Unsupported JIS string"), maxlen);
00645                         break;
00646                 }
00647 
00648                 /* Check if there is really some information in the tag. */
00649                 for (i = 0; (i < e->size) &&
00650                             (!e->data[i] || (e->data[i] == ' ')); i++);
00651                 if (i == e->size) break;
00652 
00653                 /*
00654                  * If we reach this point, the tag does not
00655                  * comply with the standard but seems to contain data.
00656                  * Print as much as possible.
00657                  */
00658                 exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
00659                         _("Tag UserComment does not comply "
00660                         "with standard but contains data."));
00661                 for (j = 0; (i < e->size) && (j < maxlen); i++, j++) {
00662                         exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
00663                                 _("Byte at position %i: 0x%02x"), i, e->data[i]);
00664                         val[j] = isprint (e->data[i]) ? e->data[i] : '.';
00665                 }
00666                 break;
00667 
00668         case EXIF_TAG_EXIF_VERSION:
00669                 CF (e, EXIF_FORMAT_UNDEFINED, val, maxlen);
00670                 CC (e, 4, val, maxlen);
00671                 strncpy (val, _("Unknown Exif Version"), maxlen);
00672                 for (i = 0; versions[i].label; i++) {
00673                         if (!memcmp (e->data, versions[i].label, 4)) {
00674                                 snprintf (val, maxlen,
00675                                         _("Exif Version %d.%d"),
00676                                         versions[i].major,
00677                                         versions[i].minor);
00678                                 break;
00679                         }
00680                 }
00681                 break;
00682         case EXIF_TAG_FLASH_PIX_VERSION:
00683                 CF (e, EXIF_FORMAT_UNDEFINED, val, maxlen);
00684                 CC (e, 4, val, maxlen);
00685                 if (!memcmp (e->data, "0100", 4))
00686                         strncpy (val, _("FlashPix Version 1.0"), maxlen);
00687                 else if (!memcmp (e->data, "0101", 4))
00688                         strncpy (val, _("FlashPix Version 1.01"), maxlen);
00689                 else
00690                         strncpy (val, _("Unknown FlashPix Version"), maxlen);
00691                 break;
00692         case EXIF_TAG_COPYRIGHT:
00693                 CF (e, EXIF_FORMAT_ASCII, val, maxlen);
00694 
00695                 /*
00696                  * First part: Photographer.
00697                  * Some cameras store a string like "   " here. Ignore it.
00698                  * Remember that a corrupted tag might not be NUL-terminated
00699                  */
00700                 if (e->size && e->data && match_repeated_char(e->data, ' ', e->size))
00701                         strncpy (val, (char *) e->data, MIN (maxlen, e->size));
00702                 else
00703                         strncpy (val, _("[None]"), maxlen);
00704                 strncat (val, " ", maxlen - strlen (val));
00705                 strncat (val, _("(Photographer)"), maxlen - strlen (val));
00706 
00707                 /* Second part: Editor. */
00708                 strncat (val, " - ", maxlen - strlen (val));
00709                 k = 0;
00710                 if (e->size && e->data) {
00711                         const unsigned char *tagdata = memchr(e->data, 0, e->size);
00712                         if (tagdata++) {
00713                                 int editor_ofs = tagdata - e->data;
00714                                 int remaining = e->size - editor_ofs;
00715                                 if (match_repeated_char(tagdata, ' ', remaining)) {
00716                                         strncat (val, (const char*)tagdata, MIN (maxlen - strlen (val), remaining));
00717                                         ++k;
00718                                 }
00719                         }
00720                 }
00721                 if (!k)
00722                         strncat (val, _("[None]"), maxlen - strlen (val));
00723                 strncat (val, " ", maxlen - strlen (val));
00724                 strncat (val, _("(Editor)"), maxlen - strlen (val));
00725 
00726                 break;
00727         case EXIF_TAG_FNUMBER:
00728                 CF (e, EXIF_FORMAT_RATIONAL, val, maxlen);
00729                 CC (e, 1, val, maxlen);
00730                 v_rat = exif_get_rational (e->data, o);
00731                 if (!v_rat.denominator) return val;
00732                 snprintf (val, maxlen, "f/%.01f", (float) v_rat.numerator /
00733                                                     (float) v_rat.denominator);
00734                 break;
00735         case EXIF_TAG_APERTURE_VALUE:
00736                 CF (e, EXIF_FORMAT_RATIONAL, val, maxlen);
00737                 CC (e, 1, val, maxlen);
00738                 v_rat = exif_get_rational (e->data, o);
00739                 if (!v_rat.denominator) return val;
00740                 snprintf (val, maxlen, "f/%.01f",
00741                           pow (2 , ((float) v_rat.numerator /
00742                                     (float) v_rat.denominator) / 2.));
00743                 break;
00744         case EXIF_TAG_FOCAL_LENGTH:
00745                 CF (e, EXIF_FORMAT_RATIONAL, val, maxlen);
00746                 CC (e, 1, val, maxlen);
00747                 v_rat = exif_get_rational (e->data, o);
00748                 if (!v_rat.denominator) return val;
00749 
00750                 /*
00751                  * For calculation of the 35mm equivalent,
00752                  * Minolta cameras need a multiplier that depends on the
00753                  * camera model.
00754                  */
00755                 d = 0.;
00756                 entry = exif_content_get_entry (
00757                         e->parent->parent->ifd[EXIF_IFD_0], EXIF_TAG_MAKE);
00758                 if (entry && entry->data &&
00759                     !strncmp ((char *)entry->data, "Minolta", 7)) {
00760                         entry = exif_content_get_entry (
00761                                         e->parent->parent->ifd[EXIF_IFD_0],
00762                                         EXIF_TAG_MODEL);
00763                         if (entry && entry->data) {
00764                                 if (!strncmp ((char *)entry->data, "DiMAGE 7", 8))
00765                                         d = 3.9;
00766                                 else if (!strncmp ((char *)entry->data, "DiMAGE 5", 8))
00767                                         d = 4.9;
00768                         }
00769                 }
00770                 if (d)
00771                         snprintf (b, sizeof (b), _(" (35 equivalent: %d mm)"),
00772                                   (int) (d * (double) v_rat.numerator /
00773                                              (double) v_rat.denominator));
00774 
00775                 snprintf (val, maxlen, "%.1f mm",
00776                         (float) v_rat.numerator / (float) v_rat.denominator);
00777                 if (maxlen > strlen (val) + strlen (b))
00778                         strncat (val, b, maxlen - strlen (val) - 1);
00779                 break;
00780         case EXIF_TAG_SUBJECT_DISTANCE:
00781                 CF (e, EXIF_FORMAT_RATIONAL, val, maxlen);
00782                 CC (e, 1, val, maxlen);
00783                 v_rat = exif_get_rational (e->data, o);
00784                 if (!v_rat.denominator) return val;
00785                 snprintf (val, maxlen, "%.1f m", (float) v_rat.numerator /
00786                                                    (float) v_rat.denominator);
00787                 break;
00788         case EXIF_TAG_EXPOSURE_TIME:
00789                 CF (e, EXIF_FORMAT_RATIONAL, val, maxlen);
00790                 CC (e, 1, val, maxlen);
00791                 v_rat = exif_get_rational (e->data, o);
00792                 if (!v_rat.denominator) return val;
00793                 d = (double) v_rat.numerator / (double) v_rat.denominator;
00794                 if (d < 1)
00795                         snprintf (val, maxlen, _("1/%d"),
00796                                   (int) (1. / d));
00797                 else
00798                         snprintf (val, maxlen, _("%d"), (int) d);
00799                 if (maxlen > strlen (val) + strlen (_(" sec.")))
00800                         strncat (val, _(" sec."), maxlen - strlen (val) - 1);
00801                 break;
00802         case EXIF_TAG_SHUTTER_SPEED_VALUE:
00803                 CF (e, EXIF_FORMAT_SRATIONAL, val, maxlen);
00804                 CC (e, 1, val, maxlen);
00805                 v_srat = exif_get_srational (e->data, o);
00806                 if (!v_srat.denominator) return val;
00807                 snprintf (val, maxlen, "%.0f/%.0f", (float) v_srat.numerator,
00808                           (float) v_srat.denominator);
00809                 if (maxlen > strlen (val) + strlen (_(" sec.")))
00810                         strncat (val, _(" sec."), maxlen - strlen (val) - 1);
00811                 snprintf (b, sizeof (b), " (APEX: %i)",
00812                         (int) pow (sqrt(2), (float) v_srat.numerator /
00813                                             (float) v_srat.denominator));
00814                 if (maxlen > strlen (val) + strlen (b))
00815                         strncat (val, b, maxlen - strlen (val) - 1);
00816                 break;
00817         case EXIF_TAG_BRIGHTNESS_VALUE:
00818                 CF (e, EXIF_FORMAT_SRATIONAL, val, maxlen);
00819                 CC (e, 1, val, maxlen);
00820                 v_srat = exif_get_srational (e->data, o);
00821                 snprintf (val, maxlen, "%i/%i", (int) v_srat.numerator,
00822                                                   (int) v_srat.denominator);
00823                 /* FIXME: How do I calculate the APEX value? */
00824                 break;
00825         case EXIF_TAG_FILE_SOURCE:
00826                 CF (e, EXIF_FORMAT_UNDEFINED, val, maxlen);
00827                 CC (e, 1, val, maxlen);
00828                 switch (e->data[0]) {
00829                 case 0x03: strncpy (val, _("DSC"), maxlen); break;
00830                 default: snprintf (val, maxlen, "0x%02x", e->data[0]); break;
00831                 }
00832                 break;
00833         case EXIF_TAG_COMPONENTS_CONFIGURATION:
00834                 CF (e, EXIF_FORMAT_UNDEFINED, val, maxlen);
00835                 CC (e, 4, val, maxlen);
00836                 for (i = 0; i < 4; i++) {
00837                         switch (e->data[i]) {
00838                         case 0: c = _("-"); break;
00839                         case 1: c = _("Y"); break;
00840                         case 2: c = _("Cb"); break;
00841                         case 3: c = _("Cr"); break;
00842                         case 4: c = _("R"); break;
00843                         case 5: c = _("G"); break;
00844                         case 6: c = _("B"); break;
00845                         default: c = _("reserved"); break;
00846                         }
00847                         strncat (val, c, maxlen - strlen (val));
00848                         if (i < 3) strncat (val, " ", maxlen - strlen (val));
00849                 }
00850                 break;
00851         case EXIF_TAG_EXPOSURE_BIAS_VALUE:
00852                 CF (e, EXIF_FORMAT_SRATIONAL, val, maxlen);
00853                 CC (e, 1, val, maxlen);
00854                 v_srat = exif_get_srational (e->data, o);
00855                 if (!v_srat.denominator) return val;
00856                 snprintf (val, maxlen, "%s%.01f",
00857                           v_srat.denominator * v_srat.numerator > 0 ? "+" : "",
00858                           (double) v_srat.numerator /
00859                           (double) v_srat.denominator);
00860                 break;
00861         case EXIF_TAG_YCBCR_SUB_SAMPLING:
00862                 CF (e, EXIF_FORMAT_SHORT, val, maxlen);
00863                 CC (e, 2, val, maxlen);
00864                 v_short  = exif_get_short (e->data, o);
00865                 v_short2 = exif_get_short (
00866                         e->data + exif_format_get_size (e->format),
00867                         o);
00868                 if ((v_short == 2) && (v_short2 == 1))
00869                         strncpy (val, _("YCbCr4:2:2"), maxlen);
00870                 else if ((v_short == 2) && (v_short2 == 2))
00871                         strncpy (val, _("YCbCr4:2:0"), maxlen);
00872                 else
00873                         snprintf (val, maxlen, "%i, %i", v_short, v_short2);
00874                 break;
00875         case EXIF_TAG_MAKER_NOTE:
00876                 CF (e, EXIF_FORMAT_UNDEFINED, val, maxlen);
00877                 snprintf (val, maxlen, _("%i bytes unknown data"),
00878                           (int) e->components);
00879                 break;
00880         case EXIF_TAG_SUBJECT_AREA:
00881                 CF (e, EXIF_FORMAT_SHORT, val, maxlen);
00882                 switch (e->components) {
00883                 case 2:
00884                         v_short  = exif_get_short (e->data, o);
00885                         v_short2 = exif_get_short (e->data + 2, o);
00886                         snprintf (val, maxlen, "(x,y) = (%i,%i)",
00887                                   v_short, v_short2);
00888                         break;
00889                 case 3:
00890                         v_short  = exif_get_short (e->data, o);
00891                         v_short2 = exif_get_short (e->data + 2, o);
00892                         v_short3 = exif_get_short (e->data + 4, o);
00893                         snprintf (val, maxlen, _("Within distance %i of "
00894                                 "(x,y) = (%i,%i)"), v_short3, v_short,
00895                                 v_short2);
00896                         break;
00897                 case 4:
00898                         v_short  = exif_get_short (e->data, o);
00899                         v_short2 = exif_get_short (e->data + 2, o);
00900                         v_short3 = exif_get_short (e->data + 4, o);
00901                         v_short4 = exif_get_short (e->data + 6, o);
00902                         snprintf (val, maxlen, _("Within rectangle "
00903                                 "(width %i, height %i) around "
00904                                 "(x,y) = (%i,%i)"), v_short3, v_short4,
00905                                 v_short, v_short2);
00906                         break;
00907                 default:
00908                         snprintf (val, maxlen, _("Unexpected number "
00909                                 "of components (%li, expected 2, 3, or 4)."),
00910                                 e->components); 
00911                 }
00912                 break;
00913 
00914         case EXIF_TAG_METERING_MODE:
00915         case EXIF_TAG_COMPRESSION:
00916         case EXIF_TAG_FOCAL_PLANE_RESOLUTION_UNIT:
00917         case EXIF_TAG_RESOLUTION_UNIT:
00918         case EXIF_TAG_EXPOSURE_PROGRAM:
00919         case EXIF_TAG_FLASH:
00920         case EXIF_TAG_SUBJECT_DISTANCE_RANGE:
00921         case EXIF_TAG_COLOR_SPACE:
00922                 CF (e,EXIF_FORMAT_SHORT, val, maxlen);
00923                 CC (e, 1, val, maxlen);
00924                 v_short = exif_get_short (e->data, o);
00925 
00926                 /* Search the tag */
00927                 for (i = 0; list2[i].tag && (list2[i].tag != e->tag); i++);
00928                 if (!list2[i].tag) {
00929                         strncpy (val, _("Internal error."), maxlen - 1);
00930                         break;
00931                 }
00932 
00933                 /* Find the value */
00934                 for (j = 0; list2[i].elem[j].values &&
00935                             (list2[i].elem[j].index < v_short); j++);
00936                 if (list2[i].elem[j].index != v_short || v_short == 65535) {
00937                         snprintf (val, maxlen, _("Internal error (unknown "
00938                                   "value %i)."), v_short);
00939                         break;
00940                 }
00941 
00942                 /* Find a short enough value */
00943                 memset (val, 0, maxlen);
00944                 for (k = 0; list2[i].elem[j].values &&
00945                             list2[i].elem[j].values[k]; k++) {
00946                   l = strlen (_(list2[i].elem[j].values[k]));
00947                   if ((maxlen > l) && (strlen (val) < l))
00948                     strncpy (val, _(list2[i].elem[j].values[k]), maxlen - 1);
00949                 }
00950                 if (!strlen (val)) snprintf (val, maxlen, "%i", v_short);
00951 
00952                 break;
00953         case EXIF_TAG_PLANAR_CONFIGURATION:
00954         case EXIF_TAG_SENSING_METHOD:
00955         case EXIF_TAG_ORIENTATION:
00956         case EXIF_TAG_YCBCR_POSITIONING:
00957         case EXIF_TAG_PHOTOMETRIC_INTERPRETATION:
00958         case EXIF_TAG_CUSTOM_RENDERED:
00959         case EXIF_TAG_EXPOSURE_MODE:
00960         case EXIF_TAG_WHITE_BALANCE:
00961         case EXIF_TAG_SCENE_CAPTURE_TYPE:
00962         case EXIF_TAG_GAIN_CONTROL:
00963         case EXIF_TAG_SATURATION:
00964         case EXIF_TAG_CONTRAST:
00965         case EXIF_TAG_SHARPNESS:
00966                 CF (e, EXIF_FORMAT_SHORT, val, maxlen);
00967                 CC (e, 1, val, maxlen);
00968                 v_short = exif_get_short (e->data, o);
00969 
00970                 /* Search the tag */
00971                 for (i = 0; list[i].tag && (list[i].tag != e->tag); i++);
00972                 if (!list[i].tag) {
00973                         strncpy (val, _("Internal error."), maxlen - 1);
00974                         break;
00975                 }
00976 
00977                 /* Find the value */
00978                 for (j = 0; list[i].strings[j] && (j < v_short); j++);
00979                 if (!list[i].strings[j])
00980                         snprintf (val, maxlen, "%i", v_short);
00981                 else
00982                         strncpy (val, _(list[i].strings[j]), maxlen - 1);
00983                 break;  
00984         default:
00985                 if (!e->components) break;
00986                 switch (e->format) {
00987                 case EXIF_FORMAT_UNDEFINED:
00988                         break;
00989                 case EXIF_FORMAT_BYTE:
00990                 case EXIF_FORMAT_SBYTE:
00991                         v_byte = e->data[0];
00992                         snprintf (val, maxlen, "0x%02x", v_byte);
00993                         len = strlen (val);
00994                         for (i = 1; i < e->components; i++) {
00995                                 v_byte = e->data[i];
00996                                 snprintf (val+len, maxlen-len, ", 0x%02x", v_byte);
00997                                 len += strlen (val+len);
00998                                 if (len >= maxlen-1) break;
00999                         }
01000                         break;
01001                 case EXIF_FORMAT_SHORT:
01002                 case EXIF_FORMAT_SSHORT:
01003                         v_short = exif_get_short (e->data, o);
01004                         snprintf (val, maxlen, "%i", v_short);
01005                         len = strlen (val);
01006                         for (i = 1; i < e->components; i++) {
01007                                 v_short = exif_get_short (e->data +
01008                                         exif_format_get_size (e->format) *
01009                                         i, o);
01010                         snprintf (val+len, maxlen-len, ", %i", v_short);
01011                         len += strlen (val+len);
01012                         if (len >= maxlen-1) break;
01013                         }
01014                         break;
01015                 case EXIF_FORMAT_LONG:
01016                         v_long = exif_get_long (e->data, o);
01017                         snprintf (val, maxlen, "%li", (long int) v_long);
01018                         len = strlen (val);
01019                         for (i = 1; i < e->components; i++) {
01020                                 v_long = exif_get_long (e->data +
01021                                         exif_format_get_size (e->format) *
01022                                         i, o);
01023                                 snprintf (val+len, maxlen-len, ", %li", (unsigned long) v_long);
01024                                 len += strlen (val+len);
01025                                 if (len >= maxlen-1) break;
01026                         }
01027                         break;
01028                 case EXIF_FORMAT_SLONG:
01029                         v_slong = exif_get_slong (e->data, o);
01030                         snprintf (val, maxlen, "%li", (long int) v_slong);
01031                         len = strlen (val);
01032                         for (i = 1; i < e->components; i++) {
01033                                 v_long = exif_get_slong (e->data +
01034                                         exif_format_get_size (e->format) *
01035                                         i, o);
01036                                 snprintf (val+len, maxlen-len, ", %li", (long) v_slong);
01037                                 len += strlen (val+len);
01038                                 if (len >= maxlen-1) break;
01039                         }
01040                         break;
01041                 case EXIF_FORMAT_ASCII:
01042                         strncpy (val, (char *) e->data, MIN (maxlen-1, e->size));
01043                         val[MIN (maxlen-1, e->size)] = 0;
01044                         break;
01045                 case EXIF_FORMAT_RATIONAL:
01046                         len = 0;
01047                         v_rat = exif_get_rational (e->data, o);
01048                         if (v_rat.denominator) {
01049                                 snprintf (val+len, maxlen-len, "%2.2f", (double)v_rat.numerator / v_rat.denominator);
01050                         } else {
01051                                 snprintf (val+len, maxlen-len, "%i/%i", v_rat.numerator,  v_rat.denominator);
01052                         }
01053                         len += strlen (val+len);
01054                         for (i = 1; i < e->components; i++) {
01055                                 v_rat = exif_get_rational (
01056                                         e->data + 8 * i, o);
01057                                 snprintf (val+len, maxlen-len, ", %2.2f",
01058                                            (double)v_rat.numerator / v_rat.denominator);
01059                                 len += strlen (val+len);
01060                                 if (len >= maxlen-1) break;
01061                         }
01062                         break;
01063                 case EXIF_FORMAT_SRATIONAL:
01064                         len = 0;
01065                         v_srat = exif_get_srational (e->data, o);
01066                         if (v_srat.denominator) {
01067                                 snprintf (val+len, maxlen-len, "%2.2f", (double)v_srat.numerator / v_srat.denominator);
01068                         } else {
01069                                 snprintf (val+len, maxlen-len, "%i/%i", v_srat.numerator,  v_srat.denominator);
01070                         }
01071                         len += strlen (val+len);
01072                         for (i = 1; i < e->components; i++) {
01073                                 v_srat = exif_get_srational (
01074                                         e->data + 8 * i, o);
01075                                 snprintf (val+len, maxlen-len, ", %2.2f",
01076                                           (double)v_srat.numerator / v_srat.denominator);
01077                                 len += strlen (val+len);
01078                                 if (len >= maxlen-1) break;
01079                         }
01080                         break;
01081                 case EXIF_FORMAT_DOUBLE:
01082                 case EXIF_FORMAT_FLOAT:
01083                 default:
01084                         /* What to do here? */
01085                         break;
01086                 }
01087         }
01088 
01089         return val;
01090 }
01091 
01092 void
01093 exif_entry_initialize (ExifEntry *e, ExifTag tag)
01094 {
01095         time_t t;
01096         struct tm *tm;
01097         ExifRational r;
01098         ExifByteOrder o;
01099 
01100         /* We need the byte order */
01101         if (!e || !e->parent || e->data || !e->parent->parent)
01102                 return;
01103         o = exif_data_get_byte_order (e->parent->parent);
01104 
01105         e->tag = tag;
01106         switch (tag) {
01107 
01108         /* LONG, 1 component, no default */
01109         case EXIF_TAG_PIXEL_X_DIMENSION:
01110         case EXIF_TAG_PIXEL_Y_DIMENSION:
01111         case EXIF_TAG_EXIF_IFD_POINTER:
01112         case EXIF_TAG_GPS_INFO_IFD_POINTER:
01113         case EXIF_TAG_INTEROPERABILITY_IFD_POINTER:
01114         case EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH:
01115         case EXIF_TAG_JPEG_INTERCHANGE_FORMAT:
01116                 e->components = 1;
01117                 e->format = EXIF_FORMAT_LONG;
01118                 e->size = exif_format_get_size (e->format) * e->components;
01119                 e->data = exif_entry_alloc (e, e->size);
01120                 break;
01121 
01122         /* SHORT, 1 component, no default */
01123         case EXIF_TAG_SUBJECT_LOCATION:
01124         case EXIF_TAG_SENSING_METHOD:
01125         case EXIF_TAG_PHOTOMETRIC_INTERPRETATION:
01126         case EXIF_TAG_COMPRESSION:
01127         case EXIF_TAG_EXPOSURE_MODE:
01128         case EXIF_TAG_WHITE_BALANCE:
01129         case EXIF_TAG_FOCAL_LENGTH_IN_35MM_FILM:
01130         case EXIF_TAG_GAIN_CONTROL:
01131         case EXIF_TAG_SUBJECT_DISTANCE_RANGE:
01132 
01133         /* SHORT, 1 component, default 0 */
01134         case EXIF_TAG_IMAGE_WIDTH:
01135         case EXIF_TAG_IMAGE_LENGTH:
01136         case EXIF_TAG_EXPOSURE_PROGRAM:
01137         case EXIF_TAG_LIGHT_SOURCE:
01138         case EXIF_TAG_METERING_MODE:
01139         case EXIF_TAG_CUSTOM_RENDERED:
01140         case EXIF_TAG_SCENE_CAPTURE_TYPE:
01141         case EXIF_TAG_CONTRAST:
01142         case EXIF_TAG_SATURATION:
01143         case EXIF_TAG_SHARPNESS:
01144                 e->components = 1;
01145                 e->format = EXIF_FORMAT_SHORT;
01146                 e->size = exif_format_get_size (e->format) * e->components;
01147                 e->data = exif_entry_alloc (e, e->size);
01148                 exif_set_short (e->data, o, 0);
01149                 break;
01150 
01151         /* SHORT, 1 component, default 1 */
01152     case EXIF_TAG_ORIENTATION:
01153     case EXIF_TAG_PLANAR_CONFIGURATION:
01154     case EXIF_TAG_YCBCR_POSITIONING:
01155                 e->components = 1;
01156                 e->format = EXIF_FORMAT_SHORT;
01157                 e->size = exif_format_get_size (e->format) * e->components;
01158                 e->data = exif_entry_alloc (e, e->size);
01159                 exif_set_short (e->data, o, 1);
01160                 break;
01161 
01162         /* SHORT, 1 component, default 2 */
01163     case EXIF_TAG_RESOLUTION_UNIT:
01164         case EXIF_TAG_FOCAL_PLANE_RESOLUTION_UNIT:
01165                 e->components = 1;
01166                 e->format = EXIF_FORMAT_SHORT;
01167                 e->size = exif_format_get_size (e->format) * e->components;
01168                 e->data = exif_entry_alloc (e, e->size);
01169                 exif_set_short (e->data, o, 2);
01170                 break;
01171 
01172         /* SHORT, 1 component, default 3 */
01173     case EXIF_TAG_SAMPLES_PER_PIXEL:
01174                 e->components = 1;
01175                 e->format = EXIF_FORMAT_SHORT;
01176                 e->size = exif_format_get_size (e->format) * e->components;
01177                 e->data = exif_entry_alloc (e, e->size);
01178                 exif_set_short (e->data, o, 3);
01179                 break;
01180 
01181         case EXIF_TAG_BITS_PER_SAMPLE:
01182                 e->components = 3;
01183                 e->format = EXIF_FORMAT_SHORT;
01184                 e->size = exif_format_get_size (e->format) * e->components;
01185                 e->data = exif_entry_alloc (e, e->size);
01186                 if (!e->data) break;
01187                 exif_set_short (e->data, o, 8);
01188                 exif_set_short (
01189                         e->data + exif_format_get_size (e->format),
01190                         o, 8);
01191                 exif_set_short (
01192                         e->data + 2 * exif_format_get_size (e->format),
01193                         o, 8);
01194                 break;
01195         case EXIF_TAG_YCBCR_SUB_SAMPLING:
01196                 e->components = 2;
01197                 e->format = EXIF_FORMAT_SHORT;
01198                 e->size = exif_format_get_size (e->format) * e->components;
01199                 e->data = exif_entry_alloc (e, e->size);
01200                 if (!e->data) break;
01201                 exif_set_short (e->data, o, 2);
01202                 exif_set_short (
01203                         e->data + exif_format_get_size (e->format),
01204                         o, 1);
01205                 break;
01206 
01207         /* SRATIONAL, 1 component, no default */
01208         case EXIF_TAG_EXPOSURE_BIAS_VALUE:
01209         case EXIF_TAG_BRIGHTNESS_VALUE:
01210         case EXIF_TAG_SHUTTER_SPEED_VALUE:
01211                 e->components = 1;
01212                 e->format = EXIF_FORMAT_SRATIONAL;
01213                 e->size = exif_format_get_size (e->format) * e->components;
01214                 e->data = exif_entry_alloc (e, e->size);
01215                 break;
01216 
01217         /* RATIONAL, 1 component, no default */
01218         case EXIF_TAG_EXPOSURE_TIME:
01219         case EXIF_TAG_FOCAL_PLANE_X_RESOLUTION:
01220         case EXIF_TAG_FOCAL_PLANE_Y_RESOLUTION:
01221         case EXIF_TAG_EXPOSURE_INDEX:
01222         case EXIF_TAG_FLASH_ENERGY:
01223         case EXIF_TAG_FNUMBER:
01224         case EXIF_TAG_FOCAL_LENGTH:
01225         case EXIF_TAG_SUBJECT_DISTANCE:
01226         case EXIF_TAG_MAX_APERTURE_VALUE:
01227         case EXIF_TAG_APERTURE_VALUE:
01228         case EXIF_TAG_COMPRESSED_BITS_PER_PIXEL:
01229         case EXIF_TAG_PRIMARY_CHROMATICITIES:
01230         case EXIF_TAG_DIGITAL_ZOOM_RATIO:
01231                 e->components = 1;
01232                 e->format = EXIF_FORMAT_RATIONAL;
01233                 e->size = exif_format_get_size (e->format) * e->components;
01234                 e->data = exif_entry_alloc (e, e->size);
01235                 break;
01236 
01237         /* RATIONAL, 1 component, default 72/1 */
01238         case EXIF_TAG_X_RESOLUTION:
01239         case EXIF_TAG_Y_RESOLUTION:
01240                 e->components = 1;
01241                 e->format = EXIF_FORMAT_RATIONAL;
01242                 e->size = exif_format_get_size (e->format) * e->components;
01243                 e->data = exif_entry_alloc (e, e->size);
01244                 r.numerator = 72;
01245                 r.denominator = 1;
01246                 exif_set_rational (e->data, o, r);
01247                 break;
01248 
01249         /* RATIONAL, 2 components, no default */
01250         case EXIF_TAG_WHITE_POINT:
01251                 e->components = 2;
01252                 e->format = EXIF_FORMAT_RATIONAL;
01253                 e->size = exif_format_get_size (e->format) * e->components;
01254                 e->data = exif_entry_alloc (e, e->size);
01255                 break;
01256 
01257         /* RATIONAL, 6 components */
01258         case EXIF_TAG_REFERENCE_BLACK_WHITE:
01259                 e->components = 6;
01260                 e->format = EXIF_FORMAT_RATIONAL;
01261                 e->size = exif_format_get_size (e->format) * e->components;
01262                 e->data = exif_entry_alloc (e, e->size);
01263                 if (!e->data) break;
01264                 r.denominator = 1;
01265                 r.numerator = 0;
01266                 exif_set_rational (e->data, o, r);
01267                 r.numerator = 255;
01268                 exif_set_rational (
01269                         e->data + exif_format_get_size (e->format), o, r);
01270                 r.numerator = 0;
01271                 exif_set_rational (
01272                         e->data + 2 * exif_format_get_size (e->format), o, r);
01273                 r.numerator = 255;
01274                 exif_set_rational (
01275                         e->data + 3 * exif_format_get_size (e->format), o, r);
01276                 r.numerator = 0;
01277                 exif_set_rational (
01278                         e->data + 4 * exif_format_get_size (e->format), o, r);
01279                 r.numerator = 255;
01280                 exif_set_rational (
01281                         e->data + 5 * exif_format_get_size (e->format), o, r);
01282                 break;
01283 
01284         /* ASCII, 20 components */
01285         case EXIF_TAG_DATE_TIME:
01286         case EXIF_TAG_DATE_TIME_ORIGINAL:
01287         case EXIF_TAG_DATE_TIME_DIGITIZED:
01288                 t = time (NULL);
01289                 tm = localtime (&t);
01290                 e->components = 20;
01291                 e->format = EXIF_FORMAT_ASCII;
01292                 e->size = exif_format_get_size (e->format) * e->components;
01293                 e->data = exif_entry_alloc (e, e->size);
01294                 if (!e->data) break;
01295                 snprintf ((char *) e->data, e->size,
01296                           "%04i:%02i:%02i %02i:%02i:%02i",
01297                           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
01298                           tm->tm_hour, tm->tm_min, tm->tm_sec);
01299                 break;
01300 
01301         /* ASCII, no default */
01302         case EXIF_TAG_SUB_SEC_TIME:
01303         case EXIF_TAG_SUB_SEC_TIME_ORIGINAL:
01304         case EXIF_TAG_SUB_SEC_TIME_DIGITIZED:
01305                 e->components = 0;
01306                 e->format = EXIF_FORMAT_ASCII;
01307                 e->size = 0;
01308                 e->data = NULL;
01309                 break;
01310         case EXIF_TAG_IMAGE_DESCRIPTION:
01311         case EXIF_TAG_MAKE:
01312         case EXIF_TAG_MODEL:
01313         case EXIF_TAG_SOFTWARE:
01314         case EXIF_TAG_ARTIST:
01315                 e->components = strlen (_("[None]")) + 1;
01316                 e->format = EXIF_FORMAT_ASCII;
01317                 e->size = exif_format_get_size (e->format) * e->components;
01318                 e->data = exif_entry_alloc (e, e->size);
01319                 if (!e->data) break;
01320                 strncpy ((char *)e->data, _("[None]"), e->size);
01321                 break;
01322         case EXIF_TAG_COPYRIGHT:
01323                 e->components = (strlen (_("[None]")) + 1) * 2;
01324                 e->format = EXIF_FORMAT_ASCII;
01325                 e->size = exif_format_get_size (e->format) * e->components;
01326                 e->data = exif_entry_alloc (e, e->size);
01327                 if (!e->data) break;
01328                 strcpy (((char *)e->data) + 0, _("[None]"));
01329                 strcpy (((char *)e->data) + strlen (_("[None]")) + 1, _("[None]"));
01330                 break;
01331 
01332         /* UNDEFINED, no components, no default */
01333         case EXIF_TAG_MAKER_NOTE:
01334         case EXIF_TAG_USER_COMMENT:
01335                 e->components = 0;
01336                 e->format = EXIF_FORMAT_UNDEFINED;
01337                 e->size = 0;
01338                 e->data = NULL;
01339                 break;
01340 
01341         /* UNDEFINED, 1 component, default 1 */
01342         case EXIF_TAG_SCENE_TYPE:
01343                 e->components = 1;
01344                 e->format = EXIF_FORMAT_UNDEFINED;
01345                 e->size = exif_format_get_size (e->format) * e->components;
01346                 e->data = exif_entry_alloc (e, e->size);
01347                 if (!e->data) break;
01348                 e->data[0] = 0x01;
01349                 break;
01350 
01351         /* UNDEFINED, 1 component, default 3 */
01352         case EXIF_TAG_FILE_SOURCE:
01353                 e->components = 1;
01354                 e->format = EXIF_FORMAT_UNDEFINED;
01355                 e->size = exif_format_get_size (e->format) * e->components;
01356                 e->data = exif_entry_alloc (e, e->size);
01357                 if (!e->data) break;
01358                 e->data[0] = 0x03;
01359                 break;
01360 
01361         /* UNDEFINED, 4 components, default 0 1 0 0 */
01362         case EXIF_TAG_FLASH_PIX_VERSION:
01363                 e->components = 4;
01364                 e->format = EXIF_FORMAT_UNDEFINED;
01365                 e->size = exif_format_get_size (e->format) * e->components;
01366                 e->data = exif_entry_alloc (e, e->size);
01367                 if (!e->data) break;
01368                 memcpy (e->data, "0100", 4);
01369                 break;
01370 
01371         /* UNDEFINED, 4 components, default 0 2 1 0 */
01372         case EXIF_TAG_EXIF_VERSION:
01373                 e->components = 4;
01374                 e->format = EXIF_FORMAT_UNDEFINED;
01375                 e->size = exif_format_get_size (e->format) * e->components;
01376                 e->data = exif_entry_alloc (e, e->size);
01377                 if (!e->data) break;
01378                 memcpy (e->data, "0210", 4);
01379                 break;
01380 
01381         default:
01382                 break;
01383         }
01384 }

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