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 
00356 #define CF(entry,target,v,maxlen)                                       \
00357 {                                                                       \
00358         if (entry->format != target) {                                  \
00359                 exif_entry_log (entry, EXIF_LOG_CODE_CORRUPT_DATA,      \
00360                         _("The tag '%s' contains data of an invalid "   \
00361                         "format ('%s', expected '%s')."),               \
00362                         exif_tag_get_name (entry->tag),                 \
00363                         exif_format_get_name (entry->format),           \
00364                         exif_format_get_name (target));                 \
00365                 break;                                                  \
00366         }                                                               \
00367 }
00368 
00369 #define CC(entry,target,v,maxlen)                                       \
00370 {                                                                       \
00371         if (entry->components != target) {                              \
00372                 exif_entry_log (entry, EXIF_LOG_CODE_CORRUPT_DATA,      \
00373                         _("The tag '%s' contains an invalid number of " \
00374                           "components (%i, expected %i)."),             \
00375                         exif_tag_get_name (entry->tag),         \
00376                         (int) entry->components, (int) target);         \
00377                 break;                                                  \
00378         }                                                               \
00379 }
00380 
00381 static struct {
00382         ExifTag tag;
00383         const char *strings[10];
00384 } list[] = {
00385   { EXIF_TAG_PLANAR_CONFIGURATION,
00386     { N_("chunky format"), N_("planar format"), NULL}},
00387   { EXIF_TAG_SENSING_METHOD,
00388     { "", N_("Not defined"), N_("One-chip color area sensor"),
00389       N_("Two-chip color area sensor"), N_("Three-chip color area sensor"),
00390       N_("Color sequential area sensor"), "", N_("Trilinear sensor"),
00391       N_("Color sequential linear sensor"), NULL}},
00392   { EXIF_TAG_ORIENTATION,
00393     { "", N_("top - left"), N_("top - right"), N_("bottom - right"),
00394       N_("bottom - left"), N_("left - top"), N_("right - top"),
00395       N_("right - bottom"), N_("left - bottom"), NULL}},
00396   { EXIF_TAG_YCBCR_POSITIONING,
00397     { "", N_("centered"), N_("co-sited"), NULL}},
00398   { EXIF_TAG_PHOTOMETRIC_INTERPRETATION, {"", N_("RGB"), N_("YCbCr"), NULL}},
00399   { EXIF_TAG_CUSTOM_RENDERED,
00400     { N_("Normal process"), N_("Custom process"), NULL}},
00401   { EXIF_TAG_EXPOSURE_MODE,
00402     { N_("Auto exposure"), N_("Manual exposure"), N_("Auto bracket"), NULL}},
00403   { EXIF_TAG_WHITE_BALANCE,
00404     { N_("Auto white balance"), N_("Manual white balance"), NULL}},
00405   { EXIF_TAG_SCENE_CAPTURE_TYPE,
00406     { N_("Standard"), N_("Landscape"), N_("Portrait"),
00407       N_("Night scene"), NULL}},
00408   { EXIF_TAG_GAIN_CONTROL,
00409     { N_("Normal"), N_("Low gain up"), N_("High gain up"),
00410       N_("Low gain down"), N_("High gain down"), NULL}},
00411   { EXIF_TAG_SATURATION,
00412     { N_("Normal"), N_("Low saturation"), N_("High saturation"), NULL}},
00413   { EXIF_TAG_CONTRAST , {N_("Normal"), N_("Soft"), N_("Hard"), NULL}},
00414   { EXIF_TAG_SHARPNESS, {N_("Normal"), N_("Soft"), N_("Hard"), NULL}},
00415   { 0, {NULL}}
00416 };
00417 
00418 static struct {
00419   ExifTag tag;
00420   struct {
00421     int index;
00422     const char *values[4];
00423   } elem[25];
00424 } list2[] = {
00425   { EXIF_TAG_METERING_MODE,
00426     { {  0, {N_("Unknown"), NULL}},
00427       {  1, {N_("Average"), N_("avg"), NULL}},
00428       {  2, {N_("Center-Weighted Average"), N_("Center-Weight"), NULL}},
00429       {  3, {N_("Spot"), NULL}},
00430       {  4, {N_("Multi Spot"), NULL}},
00431       {  5, {N_("Pattern"), NULL}},
00432       {  6, {N_("Partial"), NULL}},
00433       {255, {N_("Other"), NULL}},
00434       {  0, {NULL}}}},
00435   { EXIF_TAG_COMPRESSION,
00436     { {1, {N_("Uncompressed"), NULL}},
00437       {5, {N_("LZW compression"), NULL}},
00438       {6, {N_("JPEG compression"), NULL}},
00439       {0, {NULL}}}},
00440   { EXIF_TAG_LIGHT_SOURCE,
00441     { {  0, {N_("Unknown"), NULL}},
00442       {  1, {N_("Daylight"), NULL}},
00443       {  2, {N_("Fluorescent"), NULL}},
00444       {  3, {N_("Tungsten incandescent light"), N_("Tungsten"), NULL}},
00445       {  4, {N_("Flash"), NULL}},
00446       {  9, {N_("Fine weather"), NULL}},
00447       { 10, {N_("Cloudy weather"), N_("cloudy"), NULL}},
00448       { 11, {N_("Shade"), NULL}},
00449       { 12, {N_("Daylight fluorescent"), NULL}},
00450       { 13, {N_("Day white fluorescent"), NULL}},
00451       { 14, {N_("Cool white fluorescent"), NULL}},
00452       { 15, {N_("White fluorescent"), NULL}},
00453       { 17, {N_("Standard light A"), NULL}},
00454       { 18, {N_("Standard light B"), NULL}},
00455       { 19, {N_("Standard light C"), NULL}},
00456       { 20, {N_("D55"), NULL}},
00457       { 21, {N_("D65"), NULL}},
00458       { 22, {N_("D75"), NULL}},
00459       { 24, {N_("ISO studio tungsten"),NULL}},
00460       {255, {N_("Other"), NULL}},
00461       {  0, {NULL}}}},
00462   { EXIF_TAG_FOCAL_PLANE_RESOLUTION_UNIT,
00463     { {2, {N_("Inch"), N_("in"), NULL}},
00464       {3, {N_("Centimeter"), N_("cm"), NULL}},
00465       {0, {NULL}}}},
00466   { EXIF_TAG_RESOLUTION_UNIT,
00467     { {2, {N_("Inch"), N_("in"), NULL}},
00468       {3, {N_("Centimeter"), N_("cm"), NULL}}, 
00469       {0, {NULL}}}},
00470   { EXIF_TAG_EXPOSURE_PROGRAM,
00471     { {0, {N_("Not defined"), NULL}},
00472       {1, {N_("Manual"), NULL}},
00473       {2, {N_("Normal program"), N_("Normal"), NULL}},
00474       {3, {N_("Aperture priority"), N_("Aperture"), NULL}},
00475       {4, {N_("Shutter priority"),N_("Shutter"), NULL}},
00476       {5, {N_("Creative program (biased toward depth of field)"),
00477            N_("Creative"), NULL}},
00478       {6, {N_("Creative program (biased toward fast shutter speed)"),
00479            N_("Action"), NULL}},
00480       {7, {N_("Portrait mode (for closeup photos with the background out "
00481               "of focus)"), N_("Portrait"), NULL}},
00482       {8, {N_("Landscape mode (for landscape photos with the background "
00483               "in focus)"), N_("Landscape"), NULL}},
00484       {0, {NULL}}}},
00485   { EXIF_TAG_FLASH,
00486     { {0x0000, {N_("Flash did not fire."), N_("no flash"), NULL}},
00487       {0x0001, {N_("Flash fired."), N_("flash"), N_("Yes"), NULL}},
00488       {0x0005, {N_("Strobe return light not detected."), N_("W/o strobe"),
00489                 NULL}},
00490       {0x0007, {N_("Strobe return light detected."), N_("W. strobe"), NULL}},
00491       {0x0009, {N_("Flash fired, compulsatory flash mode"), NULL}},
00492       {0x000d, {N_("Flash fired, compulsatory flash mode, return light "
00493                    "not detected."), NULL}},
00494       {0x000f, {N_("Flash fired, compulsatory flash mode, return light "
00495                    "detected."), NULL}},
00496       {0x0010, {N_("Flash did not fire, compulsatory flash mode."), NULL}},
00497       {0x0018, {N_("Flash did not fire, auto mode."), NULL}},
00498       {0x0019, {N_("Flash fired, auto mode."), NULL}},
00499       {0x001d, {N_("Flash fired, auto mode, return light not detected."),
00500                 NULL}},
00501       {0x001f, {N_("Flash fired, auto mode, return light detected."), NULL}},
00502       {0x0020, {N_("No flash function."),NULL}},
00503       {0x0041, {N_("Flash fired, red-eye reduction mode."), NULL}},
00504       {0x0045, {N_("Flash fired, red-eye reduction mode, return light "
00505                    "not detected."), NULL}},
00506       {0x0047, {N_("Flash fired, red-eye reduction mode, return light "
00507                    "detected."), NULL}},
00508       {0x0049, {N_("Flash fired, compulsory flash mode, red-eye reduction "
00509                    "mode."), NULL}},
00510       {0x004d, {N_("Flash fired, compulsory flash mode, red-eye reduction "
00511                   "mode, return light not detected"), NULL}},
00512       {0x004f, {N_("Flash fired, compulsory flash mode, red-eye reduction, "
00513                    "return light detected"), NULL}},
00514       {0x0058, {N_("Flash did not fire, auto mode, red-eye reduction mode"), NULL}},
00515       {0x0059, {N_("Flash fired, auto mode, red-eye reduction mode"), NULL}},
00516       {0x005d, {N_("Flash fired, auto mode, return light not detected, "
00517                    "red-eye reduction mode."), NULL}},
00518       {0x005f, {N_("Flash fired, auto mode, return light detected, "
00519                    "red-eye reduction mode."), NULL}},
00520       {0x0000, {NULL}}}},
00521   {EXIF_TAG_SUBJECT_DISTANCE_RANGE, 
00522     { {0, {N_("Unknown"), N_("?"), NULL}},
00523       {1, {N_("Macro"), NULL}},
00524       {2, {N_("Close view"), N_("close"), NULL}},
00525       {3, {N_("Distant view"), N_("distant"), NULL}},
00526       {0, {NULL}}}},
00527   { EXIF_TAG_COLOR_SPACE,
00528     { {1, {N_("sRGB"), NULL}},
00529       {2, {N_("Adobe RGB"), NULL}},
00530       {0xffff, {N_("Uncalibrated"), NULL}}}},
00531   {0, }
00532 };
00533 
00534 const char *
00535 exif_entry_get_value (ExifEntry *e, char *val, unsigned int maxlen)
00536 {
00537         unsigned int i, j, k, l, ts;
00538         const unsigned char *t;
00539         ExifByte v_byte;
00540         ExifShort v_short, v_short2, v_short3, v_short4;
00541         ExifLong v_long;
00542         ExifSLong v_slong;
00543         ExifRational v_rat;
00544         ExifSRational v_srat;
00545         char b[64];
00546         const char *c;
00547         ExifByteOrder o;
00548         double d;
00549         ExifEntry *entry;
00550         static struct {
00551                 char *label;
00552                 char major, minor;
00553         } versions[] = {
00554                 {"0110", 1,  1},
00555                 {"0120", 1,  2},
00556                 {"0200", 2,  0},
00557                 {"0210", 2,  1},
00558                 {"0220", 2,  2},
00559                 {"0221", 2, 21},
00560                 {NULL  , 0,  0}
00561         };
00562 
00563         /* FIXME: This belongs to somewhere else. */
00564         /* libexif should use the default system locale.
00565          * If an application specifically requires UTF-8, then we
00566          * must give the application a way to tell libexif that.
00567          * 
00568          * bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
00569          */
00570         bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
00571 
00572         /* We need the byte order */
00573         if (!e || !e->parent || !e->parent->parent)
00574                 return val;
00575         o = exif_data_get_byte_order (e->parent->parent);
00576 
00577         memset (val, 0, maxlen);
00578         memset (b, 0, sizeof (b));
00579         maxlen--;
00580 
00581         /* Sanity check */
00582         if (e->size != e->components * exif_format_get_size (e->format)) {
00583                 snprintf (val, maxlen, _("Invalid size of entry (%i, "
00584                         "expected %li x %i)."), e->size, e->components,
00585                                 exif_format_get_size (e->format));
00586                 return val;
00587         }
00588 
00589         switch (e->tag) {
00590         case EXIF_TAG_USER_COMMENT:
00591 
00592                 /*
00593                  * The specification says UNDEFINED, but some
00594                  * manufacturers don't care and use ASCII. If this is the
00595                  * case here, only refuse to read it if there is no chance
00596                  * of finding readable data.
00597                  */
00598                 if ((e->format != EXIF_FORMAT_ASCII) || 
00599                     (e->size <= 8) ||
00600                     ( memcmp (e->data, "ASCII\0\0\0"  , 8) &&
00601                       memcmp (e->data, "UNICODE\0"    , 8) &&
00602                       memcmp (e->data, "JIS\0\0\0\0\0", 8) &&
00603                       memcmp (e->data, "\0\0\0\0\0\0\0\0", 8)))
00604                         CF (e, EXIF_FORMAT_UNDEFINED, val, maxlen);
00605 
00606                 /*
00607                  * Note that, according to the specification (V2.1, p 40),
00608                  * the user comment field does not have to be 
00609                  * NULL terminated.
00610                  */
00611                 if ((e->size >= 8) && !memcmp (e->data, "ASCII\0\0\0", 8)) {
00612                         strncpy (val, (char *) e->data + 8, MIN (e->size - 8, maxlen));
00613                         break;
00614                 }
00615                 if ((e->size >= 8) && !memcmp (e->data, "UNICODE\0", 8)) {
00616                         strncpy (val, _("Unsupported UNICODE string"), maxlen);
00617                         break;
00618                 }
00619                 if ((e->size >= 8) && !memcmp (e->data, "JIS\0\0\0\0\0", 8)) {
00620                         strncpy (val, _("Unsupported JIS string"), maxlen);
00621                         break;
00622                 }
00623 
00624                 /* Check if there is really some information in the tag. */
00625                 for (i = 0; (i < e->size) &&
00626                             (!e->data[i] || (e->data[i] == ' ')); i++);
00627                 if (i == e->size) break;
00628 
00629                 /*
00630                  * If we reach this point, the tag does not
00631                  * comply with the standard and seems to contain data.
00632                  * Print as much as possible.
00633                  */
00634                 exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
00635                         _("Tag UserComment does not comply "
00636                         "with standard but contains data."));
00637                 for (; (i < e->size)  && (strlen (val) < maxlen - 1); i++) {
00638                         exif_entry_log (e, EXIF_LOG_CODE_DEBUG,
00639                                 _("Byte at position %i: 0x%02x"), i, e->data[i]);
00640                         val[strlen (val)] =
00641                                 isprint (e->data[i]) ? e->data[i] : '.';
00642                 }
00643                 break;
00644 
00645         case EXIF_TAG_EXIF_VERSION:
00646                 CF (e, EXIF_FORMAT_UNDEFINED, val, maxlen);
00647                 CC (e, 4, val, maxlen);
00648                 strncpy (val, _("Unknown Exif Version"), maxlen);
00649                 for (i = 0; versions[i].label; i++) {
00650                         if (!memcmp (e->data, versions[i].label, 4)) {
00651                                 snprintf (val, maxlen,
00652                                         _("Exif Version %d.%d"),
00653                                         versions[i].major,
00654                                         versions[i].minor);
00655                                 break;
00656                         }
00657                 }
00658                 break;
00659         case EXIF_TAG_FLASH_PIX_VERSION:
00660                 CF (e, EXIF_FORMAT_UNDEFINED, val, maxlen);
00661                 CC (e, 4, val, maxlen);
00662                 if (!memcmp (e->data, "0100", 4))
00663                         strncpy (val, _("FlashPix Version 1.0"), maxlen);
00664                 else if (!memcmp (e->data, "0101", 4))
00665                         strncpy (val, _("FlashPix Version 1.01"), maxlen);
00666                 else
00667                         strncpy (val, _("Unknown FlashPix Version"), maxlen);
00668                 break;
00669         case EXIF_TAG_COPYRIGHT:
00670                 CF (e, EXIF_FORMAT_ASCII, val, maxlen);
00671 
00672                 /*
00673                  * First part: Photographer.
00674                  * Some cameras store a string like "   " here. Ignore it.
00675                  */
00676                 if (e->size && e->data &&
00677                     (strspn ((char *)e->data, " ") != strlen ((char *) e->data)))
00678                         strncpy (val, (char *) e->data, MIN (maxlen, e->size));
00679                 else
00680                         strncpy (val, _("[None]"), maxlen);
00681                 strncat (val, " ", maxlen - strlen (val));
00682                 strncat (val, _("(Photographer)"), maxlen - strlen (val));
00683 
00684                 /* Second part: Editor. */
00685                 strncat (val, " - ", maxlen - strlen (val));
00686                 if (e->size && e->data) {
00687                     t = e->data + strlen ((char *) e->data) + 1;
00688                     ts = e->data + e->size - t;
00689                     if ((ts > 0) && (strspn ((char *)t, " ") != ts))
00690                         strncat (val, (char *)t, MIN (maxlen - strlen (val), ts));
00691                 } else {
00692                         strncat (val, _("[None]"), maxlen - strlen (val));
00693                 }
00694                 strncat (val, " ", maxlen - strlen (val));
00695                 strncat (val, _("(Editor)"), maxlen - strlen (val));
00696 
00697                 break;
00698         case EXIF_TAG_FNUMBER:
00699                 CF (e, EXIF_FORMAT_RATIONAL, val, maxlen);
00700                 CC (e, 1, val, maxlen);
00701                 v_rat = exif_get_rational (e->data, o);
00702                 if (!v_rat.denominator) return val;
00703                 snprintf (val, maxlen, "f/%.01f", (float) v_rat.numerator /
00704                                                     (float) v_rat.denominator);
00705                 break;
00706         case EXIF_TAG_APERTURE_VALUE:
00707                 CF (e, EXIF_FORMAT_RATIONAL, val, maxlen);
00708                 CC (e, 1, val, maxlen);
00709                 v_rat = exif_get_rational (e->data, o);
00710                 if (!v_rat.denominator) return val;
00711                 snprintf (val, maxlen, "f/%.01f",
00712                           pow (2 , ((float) v_rat.numerator /
00713                                     (float) v_rat.denominator) / 2.));
00714                 break;
00715         case EXIF_TAG_FOCAL_LENGTH:
00716                 CF (e, EXIF_FORMAT_RATIONAL, val, maxlen);
00717                 CC (e, 1, val, maxlen);
00718                 v_rat = exif_get_rational (e->data, o);
00719                 if (!v_rat.denominator) return val;
00720 
00721                 /*
00722                  * For calculation of the 35mm equivalent,
00723                  * Minolta cameras need a multiplier that depends on the
00724                  * camera model.
00725                  */
00726                 d = 0.;
00727                 entry = exif_content_get_entry (
00728                         e->parent->parent->ifd[EXIF_IFD_0], EXIF_TAG_MAKE);
00729                 if (entry && entry->data &&
00730                     !strncmp ((char *)entry->data, "Minolta", 7)) {
00731                         entry = exif_content_get_entry (
00732                                         e->parent->parent->ifd[EXIF_IFD_0],
00733                                         EXIF_TAG_MODEL);
00734                         if (entry && entry->data) {
00735                                 if (!strncmp ((char *)entry->data, "DiMAGE 7", 8))
00736                                         d = 3.9;
00737                                 else if (!strncmp ((char *)entry->data, "DiMAGE 5", 8))
00738                                         d = 4.9;
00739                         }
00740                 }
00741                 if (d)
00742                         snprintf (b, sizeof (b), _(" (35 equivalent: %d mm)"),
00743                                   (int) (d * (double) v_rat.numerator /
00744                                              (double) v_rat.denominator));
00745 
00746                 snprintf (val, maxlen, "%.1f mm",
00747                         (float) v_rat.numerator / (float) v_rat.denominator);
00748                 if (maxlen > strlen (val) + strlen (b))
00749                         strncat (val, b, maxlen - strlen (val) - 1);
00750                 break;
00751         case EXIF_TAG_SUBJECT_DISTANCE:
00752                 CF (e, EXIF_FORMAT_RATIONAL, val, maxlen);
00753                 CC (e, 1, val, maxlen);
00754                 v_rat = exif_get_rational (e->data, o);
00755                 if (!v_rat.denominator) return val;
00756                 snprintf (val, maxlen, "%.1f m", (float) v_rat.numerator /
00757                                                    (float) v_rat.denominator);
00758                 break;
00759         case EXIF_TAG_EXPOSURE_TIME:
00760                 CF (e, EXIF_FORMAT_RATIONAL, val, maxlen);
00761                 CC (e, 1, val, maxlen);
00762                 v_rat = exif_get_rational (e->data, o);
00763                 if (!v_rat.denominator) return val;
00764                 d = (double) v_rat.numerator / (double) v_rat.denominator;
00765                 if (d < 1)
00766                         snprintf (val, maxlen, _("1/%d"),
00767                                   (int) (1. / d));
00768                 else
00769                         snprintf (val, maxlen, _("%d"), (int) d);
00770                 if (maxlen > strlen (val) + strlen (_(" sec.")))
00771                         strncat (val, _(" sec."), maxlen - strlen (val) - 1);
00772                 break;
00773         case EXIF_TAG_SHUTTER_SPEED_VALUE:
00774                 CF (e, EXIF_FORMAT_SRATIONAL, val, maxlen);
00775                 CC (e, 1, val, maxlen);
00776                 v_srat = exif_get_srational (e->data, o);
00777                 if (!v_srat.denominator) return val;
00778                 snprintf (val, maxlen, "%.0f/%.0f", (float) v_srat.numerator,
00779                           (float) v_srat.denominator);
00780                 if (maxlen > strlen (val) + strlen (_(" sec.")))
00781                         strncat (val, _(" sec."), maxlen - strlen (val) - 1);
00782                 snprintf (b, sizeof (b), " (APEX: %i)",
00783                         (int) pow (sqrt(2), (float) v_srat.numerator /
00784                                             (float) v_srat.denominator));
00785                 if (maxlen > strlen (val) + strlen (b))
00786                         strncat (val, b, maxlen - strlen (val) - 1);
00787                 break;
00788         case EXIF_TAG_BRIGHTNESS_VALUE:
00789                 CF (e, EXIF_FORMAT_SRATIONAL, val, maxlen);
00790                 CC (e, 1, val, maxlen);
00791                 v_srat = exif_get_srational (e->data, o);
00792                 snprintf (val, maxlen, "%i/%i", (int) v_srat.numerator,
00793                                                   (int) v_srat.denominator);
00794                 /* FIXME: How do I calculate the APEX value? */
00795                 break;
00796         case EXIF_TAG_FILE_SOURCE:
00797                 CF (e, EXIF_FORMAT_UNDEFINED, val, maxlen);
00798                 CC (e, 1, val, maxlen);
00799                 switch (e->data[0]) {
00800                 case 0x03: strncpy (val, _("DSC"), maxlen); break;
00801                 default: snprintf (val, maxlen, "0x%02x", e->data[0]); break;
00802                 }
00803                 break;
00804         case EXIF_TAG_COMPONENTS_CONFIGURATION:
00805                 CF (e, EXIF_FORMAT_UNDEFINED, val, maxlen);
00806                 CC (e, 4, val, maxlen);
00807                 for (i = 0; i < 4; i++) {
00808                         switch (e->data[i]) {
00809                         case 0: c = _("-"); break;
00810                         case 1: c = _("Y"); break;
00811                         case 2: c = _("Cb"); break;
00812                         case 3: c = _("Cr"); break;
00813                         case 4: c = _("R"); break;
00814                         case 5: c = _("G"); break;
00815                         case 6: c = _("B"); break;
00816                         default: c = _("reserved"); break;
00817                         }
00818                         strncat (val, c, maxlen - strlen (val));
00819                         if (i < 3) strncat (val, " ", maxlen - strlen (val));
00820                 }
00821                 break;
00822         case EXIF_TAG_EXPOSURE_BIAS_VALUE:
00823                 CF (e, EXIF_FORMAT_SRATIONAL, val, maxlen);
00824                 CC (e, 1, val, maxlen);
00825                 v_srat = exif_get_srational (e->data, o);
00826                 if (!v_srat.denominator) return val;
00827                 snprintf (val, maxlen, "%s%.01f",
00828                           v_srat.denominator * v_srat.numerator > 0 ? "+" : "",
00829                           (double) v_srat.numerator /
00830                           (double) v_srat.denominator);
00831                 break;
00832         case EXIF_TAG_YCBCR_SUB_SAMPLING:
00833                 CF (e, EXIF_FORMAT_SHORT, val, maxlen);
00834                 CC (e, 2, val, maxlen);
00835                 v_short  = exif_get_short (e->data, o);
00836                 v_short2 = exif_get_short (
00837                         e->data + exif_format_get_size (e->format),
00838                         o);
00839                 if ((v_short == 2) && (v_short2 == 1))
00840                         strncpy (val, _("YCbCr4:2:2"), maxlen);
00841                 else if ((v_short == 2) && (v_short2 == 2))
00842                         strncpy (val, _("YCbCr4:2:0"), maxlen);
00843                 else
00844                         snprintf (val, maxlen, "%i, %i", v_short, v_short2);
00845                 break;
00846         case EXIF_TAG_MAKER_NOTE:
00847                 CF (e, EXIF_FORMAT_UNDEFINED, val, maxlen);
00848                 snprintf (val, maxlen, _("%i bytes unknown data"),
00849                           (int) e->components);
00850                 break;
00851         case EXIF_TAG_SUBJECT_AREA:
00852                 CF (e, EXIF_FORMAT_SHORT, val, maxlen);
00853                 switch (e->components) {
00854                 case 2:
00855                         v_short  = exif_get_short (e->data, o);
00856                         v_short2 = exif_get_short (e->data + 2, o);
00857                         snprintf (val, maxlen, "(x,y) = (%i,%i)",
00858                                   v_short, v_short2);
00859                         break;
00860                 case 3:
00861                         v_short  = exif_get_short (e->data, o);
00862                         v_short2 = exif_get_short (e->data + 2, o);
00863                         v_short3 = exif_get_short (e->data + 4, o);
00864                         snprintf (val, maxlen, _("Within distance %i of "
00865                                 "(x,y) = (%i,%i)"), v_short3, v_short,
00866                                 v_short2);
00867                         break;
00868                 case 4:
00869                         v_short  = exif_get_short (e->data, o);
00870                         v_short2 = exif_get_short (e->data + 2, o);
00871                         v_short3 = exif_get_short (e->data + 4, o);
00872                         v_short4 = exif_get_short (e->data + 6, o);
00873                         snprintf (val, maxlen, _("Within rectangle "
00874                                 "(width %i, height %i) around "
00875                                 "(x,y) = (%i,%i)"), v_short3, v_short4,
00876                                 v_short, v_short2);
00877                         break;
00878                 default:
00879                         snprintf (val, maxlen, _("Unexpected number "
00880                                 "of components (%li, expected 2, 3, or 4)."),
00881                                 e->components); 
00882                 }
00883                 break;
00884 
00885         case EXIF_TAG_METERING_MODE:
00886         case EXIF_TAG_COMPRESSION:
00887         case EXIF_TAG_FOCAL_PLANE_RESOLUTION_UNIT:
00888         case EXIF_TAG_RESOLUTION_UNIT:
00889         case EXIF_TAG_EXPOSURE_PROGRAM:
00890         case EXIF_TAG_FLASH:
00891         case EXIF_TAG_SUBJECT_DISTANCE_RANGE:
00892         case EXIF_TAG_COLOR_SPACE:
00893                 CF (e,EXIF_FORMAT_SHORT, val, maxlen);
00894                 CC (e, 1, val, maxlen);
00895                 v_short = exif_get_short (e->data, o);
00896 
00897                 /* Search the tag */
00898                 for (i = 0; list2[i].tag && (list2[i].tag != e->tag); i++);
00899                 if (!list2[i].tag) {
00900                         strncpy (val, _("Internal error."), maxlen - 1);
00901                         break;
00902                 }
00903 
00904                 /* Find the value */
00905                 for (j = 0; list2[i].elem[j].values &&
00906                             (list2[i].elem[j].index < v_short); j++);
00907                 if (list2[i].elem[j].index != v_short) {
00908                         snprintf (val, maxlen, _("Internal error (unknown "
00909                                   "value %i)."), v_short);
00910                         break;
00911                 }
00912 
00913                 /* Find a short enough value */
00914                 memset (val, 0, maxlen);
00915                 for (k = 0; list2[i].elem[j].values &&
00916                             list2[i].elem[j].values[k]; k++) {
00917                   l = strlen (_(list2[i].elem[j].values[k]));
00918                   if ((maxlen > l) && (strlen (val) < l))
00919                     strncpy (val, _(list2[i].elem[j].values[k]), maxlen - 1);
00920                 }
00921                 if (!strlen (val)) snprintf (val, maxlen, "%i", v_short);
00922 
00923                 break;
00924         case EXIF_TAG_PLANAR_CONFIGURATION:
00925         case EXIF_TAG_SENSING_METHOD:
00926         case EXIF_TAG_ORIENTATION:
00927         case EXIF_TAG_YCBCR_POSITIONING:
00928         case EXIF_TAG_PHOTOMETRIC_INTERPRETATION:
00929         case EXIF_TAG_CUSTOM_RENDERED:
00930         case EXIF_TAG_EXPOSURE_MODE:
00931         case EXIF_TAG_WHITE_BALANCE:
00932         case EXIF_TAG_SCENE_CAPTURE_TYPE:
00933         case EXIF_TAG_GAIN_CONTROL:
00934         case EXIF_TAG_SATURATION:
00935         case EXIF_TAG_CONTRAST:
00936         case EXIF_TAG_SHARPNESS:
00937                 CF (e, EXIF_FORMAT_SHORT, val, maxlen);
00938                 CC (e, 1, val, maxlen);
00939                 v_short = exif_get_short (e->data, o);
00940 
00941                 /* Search the tag */
00942                 for (i = 0; list[i].tag && (list[i].tag != e->tag); i++);
00943                 if (!list[i].tag) {
00944                         strncpy (val, _("Internal error."), maxlen - 1);
00945                         break;
00946                 }
00947 
00948                 /* Find the value */
00949                 for (j = 0; list[i].strings[j] && (j < v_short); j++);
00950                 if (!list[i].strings[j])
00951                         snprintf (val, maxlen, "%i", v_short);
00952                 else
00953                         strncpy (val, _(list[i].strings[j]), maxlen - 1);
00954                 break;  
00955         default:
00956                 if (!e->components) break;
00957                 switch (e->format) {
00958                 case EXIF_FORMAT_UNDEFINED:
00959                         break;
00960                 case EXIF_FORMAT_BYTE:
00961                 case EXIF_FORMAT_SBYTE:
00962                         v_byte = e->data[0];
00963                         snprintf (val, maxlen, "0x%02x", v_byte);
00964                         maxlen -= strlen (val);
00965                         for (i = 1; i < e->components; i++) {
00966                                 v_byte = e->data[i];
00967                                 snprintf (b, sizeof (b), ", 0x%02x", v_byte);
00968                                 strncat (val, b, maxlen);
00969                                 maxlen -= strlen (b);
00970                                 if ((signed)maxlen <= 0) break;
00971                         }
00972                         break;
00973                 case EXIF_FORMAT_SHORT:
00974                 case EXIF_FORMAT_SSHORT:
00975                         v_short = exif_get_short (e->data, o);
00976                         snprintf (val, maxlen, "%i", v_short);
00977                         maxlen -= strlen (val);
00978                         for (i = 1; i < e->components; i++) {
00979                                 v_short = exif_get_short (e->data +
00980                                         exif_format_get_size (e->format) *
00981                                         i, o);
00982                                 snprintf (b, sizeof (b), ", %i", v_short);
00983                                 strncat (val, b, maxlen);
00984                                 maxlen -= strlen (b);
00985                                 if ((signed)maxlen <= 0) break;
00986                         }
00987                         break;
00988                 case EXIF_FORMAT_LONG:
00989                         v_long = exif_get_long (e->data, o);
00990                         snprintf (val, maxlen, "%li", (long int) v_long);
00991                         maxlen -= strlen (val);
00992                         for (i = 1; i < e->components; i++) {
00993                                 v_long = exif_get_long (e->data +
00994                                         exif_format_get_size (e->format) *
00995                                         i, o);
00996                                 snprintf (b, sizeof (b), ", %li",
00997                                         (long int) v_long);
00998                                 strncat (val, b, maxlen);
00999                                 maxlen -= strlen (b);
01000                                 if ((signed)maxlen <= 0) break;
01001                         }
01002                         break;
01003                 case EXIF_FORMAT_SLONG:
01004                         v_slong = exif_get_slong (e->data, o);
01005                         snprintf (val, maxlen, "%li", (long int) v_slong);
01006                         maxlen -= strlen (val);
01007                         for (i = 1; i < e->components; i++) {
01008                                 v_long = exif_get_slong (e->data +
01009                                         exif_format_get_size (e->format) *
01010                                         i, o);
01011                                 snprintf (b, sizeof (b), ", %li",
01012                                                 (long int) v_long);
01013                                 strncat (val, b, maxlen);
01014                                 maxlen -= strlen (b);
01015                                 if ((signed)maxlen <= 0) break;
01016                         }
01017                         break;
01018                 case EXIF_FORMAT_ASCII:
01019                         strncpy (val, (char *) e->data, MIN (maxlen, e->size));
01020                         break;
01021                 case EXIF_FORMAT_RATIONAL:
01022                         v_rat = exif_get_rational (e->data, o);
01023                         if (v_rat.denominator) {
01024                                 snprintf (val, maxlen, "%2.2f", (double)v_rat.numerator / v_rat.denominator);
01025                         } else {
01026                                 snprintf (val, maxlen, "%i/%i", v_rat.numerator,  v_rat.denominator);
01027                         }
01028                         maxlen -= strlen (val);
01029                         for (i = 1; i < e->components; i++) {
01030                                 v_rat = exif_get_rational (
01031                                         e->data + 8 * i, o);
01032                                 snprintf (b, sizeof (b), ", %2.2f",
01033                                            (double)v_rat.numerator / v_rat.denominator);
01034                                 strncat (val, b, maxlen);
01035                                 maxlen -= strlen (b);
01036                                 if ((signed)maxlen <= 0) break;
01037                         }
01038                         break;
01039                 case EXIF_FORMAT_SRATIONAL:
01040                         v_srat = exif_get_srational (e->data, o);
01041                         if (v_srat.denominator) {
01042                                 snprintf (val, maxlen, "%2.2f", (double)v_srat.numerator / v_srat.denominator);
01043                         } else {
01044                                 snprintf (val, maxlen, "%i/%i", v_srat.numerator,  v_srat.denominator);
01045                         }
01046                         maxlen -= strlen (val);
01047                         for (i = 1; i < e->components; i++) {
01048                                 v_srat = exif_get_srational (
01049                                         e->data + 8 * i, o);
01050                                 snprintf (b, sizeof (b), ", %2.2f",
01051                                           (double)v_srat.numerator / v_srat.denominator);
01052                                 strncat (val, b, maxlen);
01053                                 maxlen -= strlen (b);
01054                                 if ((signed) maxlen <= 0) break;
01055                         }
01056                         break;
01057                 case EXIF_FORMAT_DOUBLE:
01058                 case EXIF_FORMAT_FLOAT:
01059                 default:
01060                         /* What to do here? */
01061                         break;
01062                 }
01063         }
01064 
01065         return val;
01066 }
01067 
01068 void
01069 exif_entry_initialize (ExifEntry *e, ExifTag tag)
01070 {
01071         time_t t;
01072         struct tm *tm;
01073         ExifRational r;
01074         ExifByteOrder o;
01075 
01076         /* We need the byte order */
01077         if (!e || !e->parent || e->data || !e->parent->parent)
01078                 return;
01079         o = exif_data_get_byte_order (e->parent->parent);
01080 
01081         e->tag = tag;
01082         switch (tag) {
01083 
01084         /* LONG, 1 component, no default */
01085         case EXIF_TAG_PIXEL_X_DIMENSION:
01086         case EXIF_TAG_PIXEL_Y_DIMENSION:
01087         case EXIF_TAG_EXIF_IFD_POINTER:
01088         case EXIF_TAG_GPS_INFO_IFD_POINTER:
01089         case EXIF_TAG_INTEROPERABILITY_IFD_POINTER:
01090         case EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH:
01091         case EXIF_TAG_JPEG_INTERCHANGE_FORMAT:
01092                 e->components = 1;
01093                 e->format = EXIF_FORMAT_LONG;
01094                 e->size = exif_format_get_size (e->format) * e->components;
01095                 e->data = exif_entry_alloc (e, e->size);
01096                 break;
01097 
01098         /* SHORT, 1 component, no default */
01099         case EXIF_TAG_SUBJECT_LOCATION:
01100         case EXIF_TAG_SENSING_METHOD:
01101         case EXIF_TAG_PHOTOMETRIC_INTERPRETATION:
01102         case EXIF_TAG_COMPRESSION:
01103         case EXIF_TAG_EXPOSURE_MODE:
01104         case EXIF_TAG_WHITE_BALANCE:
01105         case EXIF_TAG_FOCAL_LENGTH_IN_35MM_FILM:
01106         case EXIF_TAG_GAIN_CONTROL:
01107         case EXIF_TAG_SUBJECT_DISTANCE_RANGE:
01108 
01109         /* SHORT, 1 component, default 0 */
01110         case EXIF_TAG_IMAGE_WIDTH:
01111         case EXIF_TAG_IMAGE_LENGTH:
01112         case EXIF_TAG_EXPOSURE_PROGRAM:
01113         case EXIF_TAG_LIGHT_SOURCE:
01114         case EXIF_TAG_METERING_MODE:
01115         case EXIF_TAG_CUSTOM_RENDERED:
01116         case EXIF_TAG_SCENE_CAPTURE_TYPE:
01117         case EXIF_TAG_CONTRAST:
01118         case EXIF_TAG_SATURATION:
01119         case EXIF_TAG_SHARPNESS:
01120                 e->components = 1;
01121                 e->format = EXIF_FORMAT_SHORT;
01122                 e->size = exif_format_get_size (e->format) * e->components;
01123                 e->data = exif_entry_alloc (e, e->size);
01124                 exif_set_short (e->data, o, 0);
01125                 break;
01126 
01127         /* SHORT, 1 component, default 1 */
01128     case EXIF_TAG_ORIENTATION:
01129     case EXIF_TAG_PLANAR_CONFIGURATION:
01130     case EXIF_TAG_YCBCR_POSITIONING:
01131                 e->components = 1;
01132                 e->format = EXIF_FORMAT_SHORT;
01133                 e->size = exif_format_get_size (e->format) * e->components;
01134                 e->data = exif_entry_alloc (e, e->size);
01135                 exif_set_short (e->data, o, 1);
01136                 break;
01137 
01138         /* SHORT, 1 component, default 2 */
01139     case EXIF_TAG_RESOLUTION_UNIT:
01140         case EXIF_TAG_FOCAL_PLANE_RESOLUTION_UNIT:
01141                 e->components = 1;
01142                 e->format = EXIF_FORMAT_SHORT;
01143                 e->size = exif_format_get_size (e->format) * e->components;
01144                 e->data = exif_entry_alloc (e, e->size);
01145                 exif_set_short (e->data, o, 2);
01146                 break;
01147 
01148         /* SHORT, 1 component, default 3 */
01149     case EXIF_TAG_SAMPLES_PER_PIXEL:
01150                 e->components = 1;
01151                 e->format = EXIF_FORMAT_SHORT;
01152                 e->size = exif_format_get_size (e->format) * e->components;
01153                 e->data = exif_entry_alloc (e, e->size);
01154                 exif_set_short (e->data, o, 3);
01155                 break;
01156 
01157         case EXIF_TAG_BITS_PER_SAMPLE:
01158                 e->components = 3;
01159                 e->format = EXIF_FORMAT_SHORT;
01160                 e->size = exif_format_get_size (e->format) * e->components;
01161                 e->data = exif_entry_alloc (e, e->size);
01162                 if (!e->data) break;
01163                 exif_set_short (e->data, o, 8);
01164                 exif_set_short (
01165                         e->data + exif_format_get_size (e->format),
01166                         o, 8);
01167                 exif_set_short (
01168                         e->data + 2 * exif_format_get_size (e->format),
01169                         o, 8);
01170                 break;
01171         case EXIF_TAG_YCBCR_SUB_SAMPLING:
01172                 e->components = 2;
01173                 e->format = EXIF_FORMAT_SHORT;
01174                 e->size = exif_format_get_size (e->format) * e->components;
01175                 e->data = exif_entry_alloc (e, e->size);
01176                 if (!e->data) break;
01177                 exif_set_short (e->data, o, 2);
01178                 exif_set_short (
01179                         e->data + exif_format_get_size (e->format),
01180                         o, 1);
01181                 break;
01182 
01183         /* SRATIONAL, 1 component, no default */
01184         case EXIF_TAG_EXPOSURE_BIAS_VALUE:
01185         case EXIF_TAG_BRIGHTNESS_VALUE:
01186         case EXIF_TAG_SHUTTER_SPEED_VALUE:
01187                 e->components = 1;
01188                 e->format = EXIF_FORMAT_SRATIONAL;
01189                 e->size = exif_format_get_size (e->format) * e->components;
01190                 e->data = exif_entry_alloc (e, e->size);
01191                 break;
01192 
01193         /* RATIONAL, 1 component, no default */
01194         case EXIF_TAG_EXPOSURE_TIME:
01195         case EXIF_TAG_FOCAL_PLANE_X_RESOLUTION:
01196         case EXIF_TAG_FOCAL_PLANE_Y_RESOLUTION:
01197         case EXIF_TAG_EXPOSURE_INDEX:
01198         case EXIF_TAG_FLASH_ENERGY:
01199         case EXIF_TAG_FNUMBER:
01200         case EXIF_TAG_FOCAL_LENGTH:
01201         case EXIF_TAG_SUBJECT_DISTANCE:
01202         case EXIF_TAG_MAX_APERTURE_VALUE:
01203         case EXIF_TAG_APERTURE_VALUE:
01204         case EXIF_TAG_COMPRESSED_BITS_PER_PIXEL:
01205         case EXIF_TAG_PRIMARY_CHROMATICITIES:
01206         case EXIF_TAG_DIGITAL_ZOOM_RATIO:
01207                 e->components = 1;
01208                 e->format = EXIF_FORMAT_RATIONAL;
01209                 e->size = exif_format_get_size (e->format) * e->components;
01210                 e->data = exif_entry_alloc (e, e->size);
01211                 break;
01212 
01213         /* RATIONAL, 1 component, default 72/1 */
01214         case EXIF_TAG_X_RESOLUTION:
01215         case EXIF_TAG_Y_RESOLUTION:
01216                 e->components = 1;
01217                 e->format = EXIF_FORMAT_RATIONAL;
01218                 e->size = exif_format_get_size (e->format) * e->components;
01219                 e->data = exif_entry_alloc (e, e->size);
01220                 r.numerator = 72;
01221                 r.denominator = 1;
01222                 exif_set_rational (e->data, o, r);
01223                 break;
01224 
01225         /* RATIONAL, 2 components, no default */
01226         case EXIF_TAG_WHITE_POINT:
01227                 e->components = 2;
01228                 e->format = EXIF_FORMAT_RATIONAL;
01229                 e->size = exif_format_get_size (e->format) * e->components;
01230                 e->data = exif_entry_alloc (e, e->size);
01231                 break;
01232 
01233         /* RATIONAL, 6 components */
01234         case EXIF_TAG_REFERENCE_BLACK_WHITE:
01235                 e->components = 6;
01236                 e->format = EXIF_FORMAT_RATIONAL;
01237                 e->size = exif_format_get_size (e->format) * e->components;
01238                 e->data = exif_entry_alloc (e, e->size);
01239                 if (!e->data) break;
01240                 r.denominator = 1;
01241                 r.numerator = 0;
01242                 exif_set_rational (e->data, o, r);
01243                 r.numerator = 255;
01244                 exif_set_rational (
01245                         e->data + exif_format_get_size (e->format), o, r);
01246                 r.numerator = 0;
01247                 exif_set_rational (
01248                         e->data + 2 * exif_format_get_size (e->format), o, r);
01249                 r.numerator = 255;
01250                 exif_set_rational (
01251                         e->data + 3 * exif_format_get_size (e->format), o, r);
01252                 r.numerator = 0;
01253                 exif_set_rational (
01254                         e->data + 4 * exif_format_get_size (e->format), o, r);
01255                 r.numerator = 255;
01256                 exif_set_rational (
01257                         e->data + 5 * exif_format_get_size (e->format), o, r);
01258                 break;
01259 
01260         /* ASCII, 20 components */
01261         case EXIF_TAG_DATE_TIME:
01262         case EXIF_TAG_DATE_TIME_ORIGINAL:
01263         case EXIF_TAG_DATE_TIME_DIGITIZED:
01264                 t = time (NULL);
01265                 tm = localtime (&t);
01266                 e->components = 20;
01267                 e->format = EXIF_FORMAT_ASCII;
01268                 e->size = exif_format_get_size (e->format) * e->components;
01269                 e->data = exif_entry_alloc (e, e->size);
01270                 if (!e->data) break;
01271                 snprintf ((char *) e->data, e->size,
01272                           "%04i:%02i:%02i %02i:%02i:%02i",
01273                           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
01274                           tm->tm_hour, tm->tm_min, tm->tm_sec);
01275                 break;
01276 
01277         /* ASCII, no default */
01278         case EXIF_TAG_SUB_SEC_TIME:
01279         case EXIF_TAG_SUB_SEC_TIME_ORIGINAL:
01280         case EXIF_TAG_SUB_SEC_TIME_DIGITIZED:
01281                 e->components = 0;
01282                 e->format = EXIF_FORMAT_ASCII;
01283                 e->size = 0;
01284                 e->data = NULL;
01285                 break;
01286         case EXIF_TAG_IMAGE_DESCRIPTION:
01287         case EXIF_TAG_MAKE:
01288         case EXIF_TAG_MODEL:
01289         case EXIF_TAG_SOFTWARE:
01290         case EXIF_TAG_ARTIST:
01291                 e->components = strlen (_("[None]")) + 1;
01292                 e->format = EXIF_FORMAT_ASCII;
01293                 e->size = exif_format_get_size (e->format) * e->components;
01294                 e->data = exif_entry_alloc (e, e->size);
01295                 if (!e->data) break;
01296                 strncpy ((char *)e->data, _("[None]"), e->size);
01297                 break;
01298         case EXIF_TAG_COPYRIGHT:
01299                 e->components = (strlen (_("[None]")) + 1) * 2;
01300                 e->format = EXIF_FORMAT_ASCII;
01301                 e->size = exif_format_get_size (e->format) * e->components;
01302                 e->data = exif_entry_alloc (e, e->size);
01303                 if (!e->data) break;
01304                 strcpy (((char *)e->data) + 0, _("[None]"));
01305                 strcpy (((char *)e->data) + strlen (_("[None]")) + 1, _("[None]"));
01306                 break;
01307 
01308         /* UNDEFINED, no components, no default */
01309         case EXIF_TAG_MAKER_NOTE:
01310         case EXIF_TAG_USER_COMMENT:
01311                 e->components = 0;
01312                 e->format = EXIF_FORMAT_UNDEFINED;
01313                 e->size = 0;
01314                 e->data = NULL;
01315                 break;
01316 
01317         /* UNDEFINED, 1 component, default 1 */
01318         case EXIF_TAG_SCENE_TYPE:
01319                 e->components = 1;
01320                 e->format = EXIF_FORMAT_UNDEFINED;
01321                 e->size = exif_format_get_size (e->format) * e->components;
01322                 e->data = exif_entry_alloc (e, e->size);
01323                 if (!e->data) break;
01324                 e->data[0] = 0x01;
01325                 break;
01326 
01327         /* UNDEFINED, 1 component, default 3 */
01328         case EXIF_TAG_FILE_SOURCE:
01329                 e->components = 1;
01330                 e->format = EXIF_FORMAT_UNDEFINED;
01331                 e->size = exif_format_get_size (e->format) * e->components;
01332                 e->data = exif_entry_alloc (e, e->size);
01333                 if (!e->data) break;
01334                 e->data[0] = 0x03;
01335                 break;
01336 
01337         /* UNDEFINED, 4 components, default 0 1 0 0 */
01338         case EXIF_TAG_FLASH_PIX_VERSION:
01339                 e->components = 4;
01340                 e->format = EXIF_FORMAT_UNDEFINED;
01341                 e->size = exif_format_get_size (e->format) * e->components;
01342                 e->data = exif_entry_alloc (e, e->size);
01343                 if (!e->data) break;
01344                 memcpy (e->data, "0100", 4);
01345                 break;
01346 
01347         /* UNDEFINED, 4 components, default 0 2 1 0 */
01348         case EXIF_TAG_EXIF_VERSION:
01349                 e->components = 4;
01350                 e->format = EXIF_FORMAT_UNDEFINED;
01351                 e->size = exif_format_get_size (e->format) * e->components;
01352                 e->data = exif_entry_alloc (e, e->size);
01353                 if (!e->data) break;
01354                 memcpy (e->data, "0210", 4);
01355                 break;
01356 
01357         default:
01358                 break;
01359         }
01360 }

Generated on Tue Dec 19 14:33:53 2006 for EXIF library (libexif) Internals by  doxygen 1.5.1