← Back to branch summary

~ubuntu-branches/ubuntu/lucid/libexif/lucid

« back to all changes in this revision

Viewing changes to libexif/exif-entry.c

  • Committer: Bazaar Package Importer
  • Author(s): Emmanuel Bouthenot
  • Date: 2009-04-19 17:53:15 UTC
  • mfrom: (6.1.1 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090419175315-5aiwj7jbm26srabc
Tags: 0.6.17-1
http://bugs.debian.org/447907
* Adopt the package within pkg-phototools:
  - Set the Maintainer to the group
  - Add Frederic Peters and myself as Uploaders.
  - Add Vcs-Browser and Vcs-Git fields accordingly.
* New upstream release:
  - remove patches merged upsteam:
    + 30_olympus_makernote.dpatch
    + 40_crash_looking_up_invalid_values.dpatch
    + 50_relibtoolize.dpatch
    + CVE-2007-6351.dpatch
    + CVE-2007-6352.dpatch
  - convert existing patches from dpatch to quilt.
  - Fix a bug while reading exif datas in some cases (Closes: #447907)
* Switch packaging to debhelper 7
* Update debian/control:
  - Drop duplicate section field for exif12
  - Bump Standards-Version to 3.8.1
  - Replace deprecated ${Source-Version} by ${binary:Version}
  - Enhance libexif-dev long description.
  - Add homepage field.
  - Add DM-Upload-Allowed field.
* Force remove of files not fully cleaned
* Remove empty doc files in libexif-dev.
* Update debian/copyright.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libexif/exif-entry.c
1
1
/* exif-entry.c
2
2
 *
3
 
 * Copyright � 2001 Lutz M�ller <lutz@users.sourceforge.net>
 
3
 * Copyright (c) 2001 Lutz Mueller <lutz@users.sourceforge.net>
4
4
 *
5
5
 * This library is free software; you can redistribute it and/or
6
6
 * modify it under the terms of the GNU Lesser General Public
42
42
/* This function is hidden in exif-data.c */
43
43
ExifLog *exif_data_get_log (ExifData *);
44
44
 
 
45
#ifndef NO_VERBOSE_TAG_STRINGS
45
46
static void
46
47
exif_entry_log (ExifEntry *e, ExifLogCode code, const char *format, ...)
47
48
{
54
55
        exif_logv (l, code, "ExifEntry", format, args);
55
56
        va_end (args);
56
57
}
 
58
#else
 
59
#if defined(__STDC_VERSION__) &&  __STDC_VERSION__ >= 199901L
 
60
#define exif_entry_log(...) do { } while (0)
 
61
#elif defined(__GNUC__)
 
62
#define exif_entry_log(x...) do { } while (0)
 
63
#else
 
64
#define exif_entry_log (void)
 
65
#endif
 
66
#endif
57
67
 
58
68
static void *
59
69
exif_entry_alloc (ExifEntry *e, unsigned int i)
378
388
        }                                                               \
379
389
}
380
390
 
381
 
static struct {
 
391
static const struct {
382
392
        ExifTag tag;
383
393
        const char *strings[10];
384
394
} list[] = {
 
395
#ifndef NO_VERBOSE_TAG_DATA
385
396
  { EXIF_TAG_PLANAR_CONFIGURATION,
386
397
    { N_("chunky format"), N_("planar format"), NULL}},
387
398
  { EXIF_TAG_SENSING_METHOD,
414
425
    { N_("Normal"), N_("Low saturation"), N_("High saturation"), NULL}},
415
426
  { EXIF_TAG_CONTRAST , {N_("Normal"), N_("Soft"), N_("Hard"), NULL}},
416
427
  { EXIF_TAG_SHARPNESS, {N_("Normal"), N_("Soft"), N_("Hard"), NULL}},
 
428
#endif
417
429
  { 0, {NULL}}
418
430
};
419
431
 
420
 
static struct {
 
432
static const struct {
421
433
  ExifTag tag;
422
434
  struct {
423
435
    int index;
424
436
    const char *values[4];
425
437
  } elem[25];
426
438
} list2[] = {
 
439
#ifndef NO_VERBOSE_TAG_DATA
427
440
  { EXIF_TAG_METERING_MODE,
428
441
    { {  0, {N_("Unknown"), NULL}},
429
442
      {  1, {N_("Average"), N_("avg"), NULL}},
449
462
      {  3, {N_("Tungsten incandescent light"), N_("Tungsten"), NULL}},
450
463
      {  4, {N_("Flash"), NULL}},
451
464
      {  9, {N_("Fine weather"), NULL}},
452
 
      { 10, {N_("Cloudy weather"), N_("cloudy"), NULL}},
 
465
      { 10, {N_("Cloudy weather"), N_("Cloudy"), NULL}},
453
466
      { 11, {N_("Shade"), NULL}},
454
467
      { 12, {N_("Daylight fluorescent"), NULL}},
455
468
      { 13, {N_("Day white fluorescent"), NULL}},
527
540
  {EXIF_TAG_SUBJECT_DISTANCE_RANGE, 
528
541
    { {0, {N_("Unknown"), N_("?"), NULL}},
529
542
      {1, {N_("Macro"), NULL}},
530
 
      {2, {N_("Close view"), N_("close"), NULL}},
531
 
      {3, {N_("Distant view"), N_("distant"), NULL}},
 
543
      {2, {N_("Close view"), N_("Close"), NULL}},
 
544
      {3, {N_("Distant view"), N_("Distant"), NULL}},
532
545
      {0, {NULL}}}},
533
546
  { EXIF_TAG_COLOR_SPACE,
534
547
    { {1, {N_("sRGB"), NULL}},
535
548
      {2, {N_("Adobe RGB"), NULL}},
536
549
      {0xffff, {N_("Uncalibrated"), NULL}},
537
550
      {0x0000, {NULL}}}},
538
 
  {0, }
 
551
#endif
 
552
  {0, { { 0, {NULL}}} }
539
553
};
540
554
 
541
555
const char *
554
568
        ExifByteOrder o;
555
569
        double d;
556
570
        ExifEntry *entry;
557
 
        static struct {
558
 
                char *label;
 
571
        static const struct {
 
572
                const char *label;
559
573
                char major, minor;
560
574
        } versions[] = {
561
575
                {"0110", 1,  1},
576
590
         */
577
591
        bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
578
592
 
579
 
        /* We need the byte order */
580
 
        if (!e || !e->parent || !e->parent->parent)
581
 
                return val;
582
 
        o = exif_data_get_byte_order (e->parent->parent);
583
 
 
 
593
        /* make sure the returned string is zero terminated */
584
594
        memset (val, 0, maxlen);
 
595
        maxlen--;
585
596
        memset (b, 0, sizeof (b));
586
 
        maxlen--;
 
597
 
 
598
        /* We need the byte order */
 
599
        if (!e || !e->parent || !e->parent->parent)
 
600
                return val;
 
601
        o = exif_data_get_byte_order (e->parent->parent);
587
602
 
588
603
        /* Sanity check */
589
604
        if (e->size != e->components * exif_format_get_size (e->format)) {
707
722
                CC (e, 1, val, maxlen);
708
723
                v_rat = exif_get_rational (e->data, o);
709
724
                if (!v_rat.denominator) return val;
710
 
                snprintf (val, maxlen, "f/%.01f", (float) v_rat.numerator /
711
 
                                                    (float) v_rat.denominator);
 
725
                d = (double) v_rat.numerator / (double) v_rat.denominator;
 
726
                snprintf (val, maxlen, "f/%.01lf", d);
712
727
                break;
713
728
        case EXIF_TAG_APERTURE_VALUE:
714
729
        case EXIF_TAG_MAX_APERTURE_VALUE:
717
732
                v_rat = exif_get_rational (e->data, o);
718
733
                if (!v_rat.denominator) return val;
719
734
                d = (double) v_rat.numerator / (double) v_rat.denominator;
720
 
                snprintf (val, maxlen, _("%.02f EV"), d);
 
735
                snprintf (val, maxlen, _("%.02lf EV"), d);
721
736
                snprintf (b, sizeof (b), _(" (f/%.01f)"), pow (2, d / 2.));
722
737
                if (maxlen > strlen (val) + strlen (b))
723
738
                        strncat (val, b, maxlen - strlen (val) - 1);
753
768
                                  (int) (d * (double) v_rat.numerator /
754
769
                                             (double) v_rat.denominator));
755
770
 
756
 
                snprintf (val, maxlen, "%.1f mm",
757
 
                        (float) v_rat.numerator / (float) v_rat.denominator);
 
771
                d = (double) v_rat.numerator / (double) v_rat.denominator;
 
772
                snprintf (val, maxlen, "%.1lf mm", d);
758
773
                if (maxlen > strlen (val) + strlen (b))
759
774
                        strncat (val, b, maxlen - strlen (val) - 1);
760
775
                break;
763
778
                CC (e, 1, val, maxlen);
764
779
                v_rat = exif_get_rational (e->data, o);
765
780
                if (!v_rat.denominator) return val;
766
 
                snprintf (val, maxlen, "%.1f m", (float) v_rat.numerator /
767
 
                                                   (float) v_rat.denominator);
 
781
                d = (double) v_rat.numerator / (double) v_rat.denominator;
 
782
                snprintf (val, maxlen, "%.1lf m", d);
768
783
                break;
769
784
        case EXIF_TAG_EXPOSURE_TIME:
770
785
                CF (e, EXIF_FORMAT_RATIONAL, val, maxlen);
773
788
                if (!v_rat.denominator) return val;
774
789
                d = (double) v_rat.numerator / (double) v_rat.denominator;
775
790
                if (d < 1)
776
 
                        snprintf (val, maxlen, _("1/%d"),
777
 
                                  (int) (1. / d));
 
791
                        snprintf (val, maxlen, _("1/%d"), (int) (0.5 + 1. / d));
778
792
                else
779
793
                        snprintf (val, maxlen, _("%d"), (int) d);
780
794
                if (maxlen > strlen (val) + strlen (_(" sec.")))
860
874
                else
861
875
                        snprintf (val, maxlen, "%i, %i", v_short, v_short2);
862
876
                break;
863
 
        case EXIF_TAG_MAKER_NOTE:
864
 
                CF (e, EXIF_FORMAT_UNDEFINED, val, maxlen);
865
 
                snprintf (val, maxlen, _("%i bytes unknown data"),
866
 
                          (int) e->components);
867
 
                break;
868
877
        case EXIF_TAG_SUBJECT_AREA:
869
878
                CF (e, EXIF_FORMAT_SHORT, val, maxlen);
870
879
                switch (e->components) {
914
923
                /* Search the tag */
915
924
                for (i = 0; list2[i].tag && (list2[i].tag != e->tag); i++);
916
925
                if (!list2[i].tag) {
917
 
                        strncpy (val, _("Internal error."), maxlen - 1);
 
926
                        snprintf (val, maxlen, _("Internal error (unknown "
 
927
                                  "value %i)"), v_short);
918
928
                        break;
919
929
                }
920
930
 
923
933
                            (list2[i].elem[j].index < v_short); j++);
924
934
                if (list2[i].elem[j].index != v_short) {
925
935
                        snprintf (val, maxlen, _("Internal error (unknown "
926
 
                                  "value %i)."), v_short);
 
936
                                  "value %i)"), v_short);
927
937
                        break;
928
938
                }
929
939
 
932
942
                for (k = 0; list2[i].elem[j].values[k]; k++) {
933
943
                  l = strlen (_(list2[i].elem[j].values[k]));
934
944
                  if ((maxlen > l) && (strlen (val) < l))
935
 
                    strncpy (val, _(list2[i].elem[j].values[k]), maxlen - 1);
 
945
                    strncpy (val, _(list2[i].elem[j].values[k]), maxlen);
936
946
                }
937
947
                if (!strlen (val)) snprintf (val, maxlen, "%i", v_short);
938
948
 
957
967
                /* Search the tag */
958
968
                for (i = 0; list[i].tag && (list[i].tag != e->tag); i++);
959
969
                if (!list[i].tag) {
960
 
                        strncpy (val, _("Internal error."), maxlen - 1);
 
970
                        snprintf (val, maxlen, _("Internal error (unknown "
 
971
                                  "value %i)"), v_short);
961
972
                        break;
962
973
                }
963
974
 
965
976
                for (j = 0; list[i].strings[j] && (j < v_short); j++);
966
977
                if (!list[i].strings[j])
967
978
                        snprintf (val, maxlen, "%i", v_short);
 
979
                else if (!*list[i].strings[j])
 
980
                        val[0] = 0;
968
981
                else
969
 
                        strncpy (val, _(list[i].strings[j]), maxlen - 1);
 
982
                        strncpy (val, _(list[i].strings[j]), maxlen);
970
983
                break;
971
984
        case EXIF_TAG_XP_TITLE:
972
985
        case EXIF_TAG_XP_COMMENT:
988
1001
                case EXIF_FORMAT_UNDEFINED:
989
1002
                        if ((e->tag == EXIF_TAG_SCENE_TYPE) && (e->size == 1)) {
990
1003
                                snprintf (val, maxlen, "%i", e->data[0]);
 
1004
                        } else {
 
1005
                                snprintf (val, maxlen, _("%i bytes undefined data"),
 
1006
                                          e->size);
991
1007
                        }
992
1008
                        break;
993
1009
                case EXIF_FORMAT_BYTE:
1053
1069
                        break;
1054
1070
                case EXIF_FORMAT_RATIONAL:
1055
1071
                        v_rat = exif_get_rational (e->data, o);
1056
 
                        if (v_rat.denominator) {
1057
 
                                snprintf (val, maxlen, "%2.2f", (double)v_rat.numerator / v_rat.denominator);
1058
 
                        } else {
1059
 
                                snprintf (val, maxlen, "%i/%i", v_rat.numerator,  v_rat.denominator);
1060
 
                        }
 
1072
                        if (v_rat.denominator)
 
1073
                                snprintf (val, maxlen, "%2.2lf",
 
1074
                                          (double) v_rat.numerator /
 
1075
                                          (double) v_rat.denominator);
 
1076
                        else
 
1077
                                snprintf (val, maxlen, "%2.2lf/%2.2lf",
 
1078
                                          (double) v_rat.numerator,
 
1079
                                          (double) v_rat.denominator);
1061
1080
                        maxlen -= strlen (val);
1062
1081
                        for (i = 1; i < e->components; i++) {
1063
1082
                                v_rat = exif_get_rational (
1064
1083
                                        e->data + 8 * i, o);
1065
 
                                snprintf (b, sizeof (b), ", %2.2f",
1066
 
                                           (double)v_rat.numerator / v_rat.denominator);
 
1084
                                if (v_rat.denominator)
 
1085
                                        snprintf (b, sizeof (b), ", %2.2lf",
 
1086
                                                  (double) v_rat.numerator /
 
1087
                                                  (double) v_rat.denominator);
 
1088
                                else
 
1089
                                        snprintf (b, sizeof (b), ", %2.2lf/%2.2lf",
 
1090
                                                  (double) v_rat.numerator,
 
1091
                                                  (double) v_rat.denominator);
1067
1092
                                strncat (val, b, maxlen);
1068
1093
                                maxlen -= strlen (b);
1069
 
                                if ((signed)maxlen <= 0) break;
 
1094
                                if ((signed) maxlen <= 0) break;
1070
1095
                        }
1071
1096
                        break;
1072
1097
                case EXIF_FORMAT_SRATIONAL:
1098
1123
        return val;
1099
1124
}
1100
1125
 
 
1126
 
 
1127
/**
 
1128
 * \bug Log and report failed exif_mem_malloc() calls.
 
1129
 */
1101
1130
void
1102
1131
exif_entry_initialize (ExifEntry *e, ExifTag tag)
1103
1132
{
1126
1155
                e->format = EXIF_FORMAT_LONG;
1127
1156
                e->size = exif_format_get_size (e->format) * e->components;
1128
1157
                e->data = exif_entry_alloc (e, e->size);
 
1158
                if (!e->data) break;
1129
1159
                break;
1130
1160
 
1131
1161
        /* SHORT, 1 component, no default */
1138
1168
        case EXIF_TAG_FOCAL_LENGTH_IN_35MM_FILM:
1139
1169
        case EXIF_TAG_GAIN_CONTROL:
1140
1170
        case EXIF_TAG_SUBJECT_DISTANCE_RANGE:
 
1171
        case EXIF_TAG_COLOR_SPACE:
 
1172
        case EXIF_TAG_FLASH:
1141
1173
 
1142
1174
        /* SHORT, 1 component, default 0 */
1143
1175
        case EXIF_TAG_IMAGE_WIDTH:
1154
1186
                e->format = EXIF_FORMAT_SHORT;
1155
1187
                e->size = exif_format_get_size (e->format) * e->components;
1156
1188
                e->data = exif_entry_alloc (e, e->size);
 
1189
                if (!e->data) break;
1157
1190
                exif_set_short (e->data, o, 0);
1158
1191
                break;
1159
1192
 
1165
1198
                e->format = EXIF_FORMAT_SHORT;
1166
1199
                e->size = exif_format_get_size (e->format) * e->components;
1167
1200
                e->data = exif_entry_alloc (e, e->size);
 
1201
                if (!e->data) break;
1168
1202
                exif_set_short (e->data, o, 1);
1169
1203
                break;
1170
1204
 
1175
1209
                e->format = EXIF_FORMAT_SHORT;
1176
1210
                e->size = exif_format_get_size (e->format) * e->components;
1177
1211
                e->data = exif_entry_alloc (e, e->size);
 
1212
                if (!e->data) break;
1178
1213
                exif_set_short (e->data, o, 2);
1179
1214
                break;
1180
1215
 
1184
1219
                e->format = EXIF_FORMAT_SHORT;
1185
1220
                e->size = exif_format_get_size (e->format) * e->components;
1186
1221
                e->data = exif_entry_alloc (e, e->size);
 
1222
                if (!e->data) break;
1187
1223
                exif_set_short (e->data, o, 3);
1188
1224
                break;
1189
1225
 
1221
1257
                e->format = EXIF_FORMAT_SRATIONAL;
1222
1258
                e->size = exif_format_get_size (e->format) * e->components;
1223
1259
                e->data = exif_entry_alloc (e, e->size);
 
1260
                if (!e->data) break;
1224
1261
                break;
1225
1262
 
1226
1263
        /* RATIONAL, 1 component, no default */
1241
1278
                e->format = EXIF_FORMAT_RATIONAL;
1242
1279
                e->size = exif_format_get_size (e->format) * e->components;
1243
1280
                e->data = exif_entry_alloc (e, e->size);
 
1281
                if (!e->data) break;
1244
1282
                break;
1245
1283
 
1246
1284
        /* RATIONAL, 1 component, default 72/1 */
1250
1288
                e->format = EXIF_FORMAT_RATIONAL;
1251
1289
                e->size = exif_format_get_size (e->format) * e->components;
1252
1290
                e->data = exif_entry_alloc (e, e->size);
 
1291
                if (!e->data) break;
1253
1292
                r.numerator = 72;
1254
1293
                r.denominator = 1;
1255
1294
                exif_set_rational (e->data, o, r);
1261
1300
                e->format = EXIF_FORMAT_RATIONAL;
1262
1301
                e->size = exif_format_get_size (e->format) * e->components;
1263
1302
                e->data = exif_entry_alloc (e, e->size);
 
1303
                if (!e->data) break;
1264
1304
                break;
1265
1305
 
1266
1306
        /* RATIONAL, 6 components */
1339
1379
                break;
1340
1380
 
1341
1381
        /* UNDEFINED, no components, no default */
 
1382
        /* Use this if the tag is otherwise unsupported */
1342
1383
        case EXIF_TAG_MAKER_NOTE:
1343
1384
        case EXIF_TAG_USER_COMMENT:
 
1385
        default:
1344
1386
                e->components = 0;
1345
1387
                e->format = EXIF_FORMAT_UNDEFINED;
1346
1388
                e->size = 0;
1386
1428
                if (!e->data) break;
1387
1429
                memcpy (e->data, "0210", 4);
1388
1430
                break;
1389
 
 
1390
 
        default:
1391
 
                break;
1392
1431
        }
1393
1432
}