src/exif-common.cc

   1 /*
   2  * Copyright (C) 2006 John Ellis
   3  * Copyright (C) 2008 - 2016 The Geeqie Team
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  */
  19
  20 #include <config.h>
  21
  22 #ifdef __linux__
  23 #define _XOPEN_SOURCE
  24 #endif
  25
  26 #include <cmath>
  27 #include <cstdlib>
  28 #include <cstring>
  29
  30 #ifdef HAVE_LCMS
  31 /*** color support enabled ***/
  32
  33 #ifdef HAVE_LCMS2
  34 #include <lcms2.h>
  35 #else
  36 #include <lcms.h>
  37 #endif
  38 #endif
  39
  40 #include "main.h"
  41 #include "exif.h"
  42
  43 #include "filecache.h"
  44 #include "glua.h"
  45 #include "ui-fileops.h"
  46 #include "cache.h"
  47 #include "jpeg-parser.h"
  48 #include "misc.h"
  49 #include "zonedetect.h"
  50
  51
  52 static gdouble exif_rational_to_double(ExifRational *r, gint sign)
  53 {
  54         if (!r || r->den == 0.0) return 0.0;
  55
  56         if (sign) return static_cast<gdouble>(static_cast<gint>(r->num)) / static_cast<gdouble>(static_cast<gint>(r->den));
  57         return static_cast<gdouble>(r->num) / r->den;
  58 }
  59
  60 static gdouble exif_get_rational_as_double(ExifData *exif, const gchar *key)
  61 {
  62         ExifRational *r;
  63         gint sign;
  64
  65         r = exif_get_rational(exif, key, &sign);
  66         return exif_rational_to_double(r, sign);
  67 }
  68
  69 static GString *append_comma_text(GString *string, const gchar *text)
  70 {
  71         string = g_string_append(string, ", ");
  72         string = g_string_append(string, text);
  73
  74         return string;
  75 }
  76
  77 static gchar *remove_common_prefix(gchar *s, gchar *t)
  78 {
  79         gint i;
  80
  81         if (!s || !t) return t;
  82
  83         for (i = 0; s[i] && t[i] && s[i] == t[i]; i++)
  84                 ;
  85         if (!i)
  86                 return t;
  87         if (s[i-1] == ' ' || !s[i])
  88                 {
  89                 while (t[i] == ' ')
  90                         i++;
  91                 return t + i;
  92                 }
  93         return s;
  94 }
  95
  96 static gdouble get_crop_factor(ExifData *exif)
  97 {
  98         gdouble res_unit_tbl[] = {0.0, 25.4, 25.4, 10.0, 1.0, 0.001 };
  99         gdouble xres = exif_get_rational_as_double(exif, "Exif.Photo.FocalPlaneXResolution");
 100         gdouble yres = exif_get_rational_as_double(exif, "Exif.Photo.FocalPlaneYResolution");
 101         gint res_unit;
 102         gint w;
 103         gint h;
 104         gdouble xsize;
 105         gdouble ysize;
 106         gdouble size;
 107         gdouble ratio;
 108
 109         if (xres == 0.0 || yres == 0.0) return 0.0;
 110
 111         if (!exif_get_integer(exif, "Exif.Photo.FocalPlaneResolutionUnit", &res_unit)) return 0.0;
 112         if (res_unit < 1 || res_unit > 5) return 0.0;
 113
 114         if (!exif_get_integer(exif, "Exif.Photo.PixelXDimension", &w)) return 0.0;
 115         if (!exif_get_integer(exif, "Exif.Photo.PixelYDimension", &h)) return 0.0;
 116
 117         xsize = w * res_unit_tbl[res_unit] / xres;
 118         ysize = h * res_unit_tbl[res_unit] / yres;
 119
 120         ratio = xsize / ysize;
 121
 122         if (ratio < 0.5 || ratio > 2.0) return 0.0; /* reasonable ratio */
 123
 124         size = hypot(xsize, ysize);
 125
 126         if (size < 1.0 || size > 100.0) return 0.0; /* reasonable sensor size in mm */
 127
 128         return hypot(36, 24) / size;
 129 }
 130
 131 static gboolean remove_suffix(gchar *str, const gchar *suffix, gint suffix_len)
 132 {
 133         gint str_len = strlen(str);
 134
 135         if (suffix_len < 0) suffix_len = strlen(suffix);
 136         if (str_len < suffix_len) return FALSE;
 137
 138         if (strcmp(str + str_len - suffix_len, suffix) != 0) return FALSE;
 139         str[str_len - suffix_len] = '\0';
 140
 141         return TRUE;
 142 }
 143
 144 static gchar *exif_build_formatted_Camera(ExifData *exif)
 145 {
 146         gchar *text;
 147         gchar *make = exif_get_data_as_text(exif, "Exif.Image.Make");
 148         gchar *model = exif_get_data_as_text(exif, "Exif.Image.Model");
 149         gchar *software = exif_get_data_as_text(exif, "Exif.Image.Software");
 150         gchar *model2;
 151         gchar *software2;
 152
 153         if (make)
 154                 {
 155                 g_strstrip(make);
 156
 157                 if (remove_suffix(make, " CORPORATION", 12)) { /* Nikon */ }
 158                 else if (remove_suffix(make, " Corporation", 12)) { /* Pentax */ }
 159                 else if (remove_suffix(make, " OPTICAL CO.,LTD", 16)) { /* OLYMPUS */ };
 160                 }
 161
 162         if (model)
 163                 g_strstrip(model);
 164
 165         if (software)
 166                 {
 167                 gint i;
 168                 gint j;
 169
 170                 g_strstrip(software);
 171
 172                 /* remove superfluous spaces (pentax K100D) */
 173                 for (i = 0, j = 0; software[i]; i++, j++)
 174                         {
 175                         if (software[i] == ' ' && software[i + 1] == ' ')
 176                                 i++;
 177                         if (i != j) software[j] = software[i];
 178                         }
 179                 software[j] = '\0';
 180                 }
 181
 182         model2 = remove_common_prefix(make, model);
 183         software2 = remove_common_prefix(model2, software);
 184
 185         text = g_strdup_printf("%s%s%s%s%s%s", (make) ? make : "", (make && model2) ? " " : "",
 186                                                (model2) ? model2 : "",
 187                                                (software2 && (make || model2)) ? " (" : "",
 188                                                (software2) ? software2 : "",
 189                                                (software2 && (make || model2)) ? ")" : "");
 190
 191         g_free(make);
 192         g_free(model);
 193         g_free(software);
 194         return text;
 195 }
 196
 197 static gchar *exif_build_formatted_DateTime(ExifData *exif)
 198 {
 199         gchar *text = exif_get_data_as_text(exif, "Exif.Photo.DateTimeOriginal");
 200         gchar *subsec = nullptr;
 201         gchar buf[128];
 202         gchar *tmp;
 203         gint buflen;
 204         struct tm tm;
 205         GError *error = nullptr;
 206
 207         if (text)
 208                 {
 209                 subsec = exif_get_data_as_text(exif, "Exif.Photo.SubSecTimeOriginal");
 210                 }
 211         else
 212                 {
 213                 text = exif_get_data_as_text(exif, "Exif.Image.DateTime");
 214                 if (text) subsec = exif_get_data_as_text(exif, "Exif.Photo.SubSecTime");
 215                 }
 216
 217         /* Convert the stuff into a tm struct */
 218         memset(&tm, 0, sizeof(tm)); /* Uh, strptime could let garbage in tm! */
 219         if (text && strptime(text, "%Y:%m:%d %H:%M:%S", &tm))
 220                 {
 221                 buflen = strftime(buf, sizeof(buf), "%x %X", &tm);
 222                 if (buflen > 0)
 223                         {
 224                         tmp = g_locale_to_utf8(buf, buflen, nullptr, nullptr, &error);
 225                         if (error)
 226                                 {
 227                                 log_printf("Error converting locale strftime to UTF-8: %s\n", error->message);
 228                                 g_error_free(error);
 229                                 }
 230                         else
 231                                 {
 232                                 g_free(text);
 233                                 text = g_strdup(tmp);
 234                                 }
 235                         }
 236                 }
 237
 238         if (subsec)
 239                 {
 240                 tmp = text;
 241                 text = g_strconcat(tmp, ".", subsec, NULL);
 242                 g_free(tmp);
 243                 g_free(subsec);
 244                 }
 245         return text;
 246 }
 247
 248 static gchar *exif_build_formatted_DateTimeDigitized(ExifData *exif)
 249 {
 250         gchar *text = exif_get_data_as_text(exif, "Exif.Photo.DateTimeDigitized");
 251         gchar *subsec = nullptr;
 252         gchar buf[128];
 253         gchar *tmp;
 254         gint buflen;
 255         struct tm tm;
 256         GError *error = nullptr;
 257
 258         if (text)
 259                 {
 260                 subsec = exif_get_data_as_text(exif, "Exif.Photo.SubSecTimeDigitized");
 261                 }
 262         else
 263                 {
 264                 text = exif_get_data_as_text(exif, "Exif.Image.DateTime");
 265                 if (text) subsec = exif_get_data_as_text(exif, "Exif.Photo.SubSecTime");
 266                 }
 267
 268         /* Convert the stuff into a tm struct */
 269         memset(&tm, 0, sizeof(tm)); /* Uh, strptime could let garbage in tm! */
 270         if (text && strptime(text, "%Y:%m:%d %H:%M:%S", &tm))
 271                 {
 272                 buflen = strftime(buf, sizeof(buf), "%x %X", &tm);
 273                 if (buflen > 0)
 274                         {
 275                         tmp = g_locale_to_utf8(buf, buflen, nullptr, nullptr, &error);
 276                         if (error)
 277                                 {
 278                                 log_printf("Error converting locale strftime to UTF-8: %s\n", error->message);
 279                                 g_error_free(error);
 280                                 }
 281                         else
 282                                 {
 283                                 g_free(text);
 284                                 text = g_strdup(tmp);
 285                                 }
 286                         }
 287                 }
 288
 289         if (subsec)
 290                 {
 291                 tmp = text;
 292                 text = g_strconcat(tmp, ".", subsec, NULL);
 293                 g_free(tmp);
 294                 g_free(subsec);
 295                 }
 296         return text;
 297 }
 298
 299 static gchar *exif_build_formatted_ShutterSpeed(ExifData *exif)
 300 {
 301         ExifRational *r;
 302
 303         r = exif_get_rational(exif, "Exif.Photo.ExposureTime", nullptr);
 304         if (r && r->num && r->den)
 305                 {
 306                 gdouble n = static_cast<gdouble>(r->den) / static_cast<gdouble>(r->num);
 307                 return g_strdup_printf("%s%.0fs", n > 1.0 ? "1/" : "",
 308                                                   n > 1.0 ? n : 1.0 / n);
 309                 }
 310         r = exif_get_rational(exif, "Exif.Photo.ShutterSpeedValue", nullptr);
 311         if (r && r->num  && r->den)
 312                 {
 313                 gdouble n = pow(2.0, exif_rational_to_double(r, TRUE));
 314
 315                 /* Correct exposure time to avoid values like 1/91s (seen on Minolta DImage 7) */
 316                 if (n > 1.0 && static_cast<gint>(n) - (static_cast<gint>(n/10))*10 == 1) n--;
 317
 318                 return g_strdup_printf("%s%.0fs", n > 1.0 ? "1/" : "",
 319                                                   n > 1.0 ? floor(n) : 1.0 / n);
 320                 }
 321         return nullptr;
 322 }
 323
 324 static gchar *exif_build_formatted_Aperture(ExifData *exif)
 325 {
 326         gdouble n;
 327
 328         n = exif_get_rational_as_double(exif, "Exif.Photo.FNumber");
 329         if (n == 0.0) n = exif_get_rational_as_double(exif, "Exif.Photo.ApertureValue");
 330         if (n == 0.0) return nullptr;
 331
 332         return g_strdup_printf("f/%.1f", n);
 333 }
 334
 335 static gchar *exif_build_formatted_ExposureBias(ExifData *exif)
 336 {
 337         ExifRational *r;
 338         gint sign;
 339         gdouble n;
 340
 341         r = exif_get_rational(exif, "Exif.Photo.ExposureBiasValue", &sign);
 342         if (!r) return nullptr;
 343
 344         n = exif_rational_to_double(r, sign);
 345         return g_strdup_printf("%+.1f", n);
 346 }
 347
 348 static gchar *exif_build_formatted_FocalLength(ExifData *exif)
 349 {
 350         gdouble n;
 351
 352         n = exif_get_rational_as_double(exif, "Exif.Photo.FocalLength");
 353         if (n == 0.0) return nullptr;
 354         return g_strdup_printf("%.0f mm", n);
 355 }
 356
 357 static gchar *exif_build_formatted_FocalLength35mmFilm(ExifData *exif)
 358 {
 359         gint n;
 360         gdouble f;
 361         gdouble c;
 362
 363         if (exif_get_integer(exif, "Exif.Photo.FocalLengthIn35mmFilm", &n) && n != 0)
 364                 {
 365                 return g_strdup_printf("%d mm", n);
 366                 }
 367
 368         f = exif_get_rational_as_double(exif, "Exif.Photo.FocalLength");
 369         if (f == 0.0) return nullptr;
 370
 371         c = get_crop_factor(exif);
 372         if (c == 0.0) return nullptr;
 373
 374         return g_strdup_printf("%.0f mm", f * c);
 375 }
 376
 377 static gchar *exif_build_formatted_ISOSpeedRating(ExifData *exif)
 378 {
 379         gchar *text;
 380
 381         text = exif_get_data_as_text(exif, "Exif.Photo.ISOSpeedRatings");
 382         /* old canon may set this instead */
 383         if (!text) text = exif_get_data_as_text(exif, "Exif.CanonSi.ISOSpeed");
 384         /* kodak may set this instead */
 385         if (!text) text = exif_get_data_as_text(exif, "Exif.Photo.ExposureIndex");
 386         return text;
 387 }
 388
 389 static gchar *exif_build_formatted_SubjectDistance(ExifData *exif)
 390 {
 391         ExifRational *r;
 392         gint sign;
 393         gdouble n;
 394
 395         r = exif_get_rational(exif, "Exif.Photo.SubjectDistance", &sign);
 396         if (!r) return nullptr;
 397
 398         if (static_cast<glong>(r->num) == static_cast<glong>(0xffffffff)) return g_strdup(_("infinity"));
 399         if (static_cast<glong>(r->num) == 0) return g_strdup(_("unknown"));
 400
 401         n = exif_rational_to_double(r, sign);
 402         if (n == 0.0) return _("unknown");
 403         return g_strdup_printf("%.3f m", n);
 404 }
 405
 406 static gchar *exif_build_formatted_Flash(ExifData *exif)
 407 {
 408         /* grr, flash is a bitmask... */
 409         GString *string;
 410         gint n;
 411         gint v;
 412
 413         if (!exif_get_integer(exif, "Exif.Photo.Flash", &n)) return nullptr;
 414
 415         /* Exif 2.1 only defines first 3 bits */
 416         if (n <= 0x07) return exif_get_data_as_text(exif, "Exif.Photo.Flash");
 417
 418         /* must be Exif 2.2 */
 419         string = g_string_new("");
 420
 421         /* flash fired (bit 0) */
 422         string = g_string_append(string, (n & 0x01) ? _("yes") : _("no"));
 423
 424         /* flash mode (bits 3, 4) */
 425         v = (n >> 3) & 0x03;
 426         if (v) string = append_comma_text(string, _("mode:"));
 427         switch (v)
 428                 {
 429                 case 1:
 430                         string = g_string_append(string, _("on"));
 431                         break;
 432                 case 2:
 433                         string = g_string_append(string, _("off"));
 434                         break;
 435                 case 3:
 436                         string = g_string_append(string, _("auto"));
 437                         break;
 438                 }
 439
 440         /* return light (bits 1, 2) */
 441         v = (n >> 1) & 0x03;
 442         if (v == 2) string = append_comma_text(string, _("not detected by strobe"));
 443         if (v == 3) string = append_comma_text(string, _("detected by strobe"));
 444
 445         /* we ignore flash function (bit 5) */
 446
 447         /* red-eye (bit 6) */
 448         if ((n >> 5) & 0x01) string = append_comma_text(string, _("red-eye reduction"));
 449
 450         return g_string_free(string, FALSE);
 451 }
 452
 453 static gchar *exif_build_formatted_Resolution(ExifData *exif)
 454 {
 455         ExifRational *rx;
 456         ExifRational *ry;
 457         gchar *units;
 458         gchar *text;
 459
 460         rx = exif_get_rational(exif, "Exif.Image.XResolution", nullptr);
 461         ry = exif_get_rational(exif, "Exif.Image.YResolution", nullptr);
 462         if (!rx || !ry) return nullptr;
 463
 464         units = exif_get_data_as_text(exif, "Exif.Image.ResolutionUnit");
 465         text = g_strdup_printf("%0.f x %0.f (%s/%s)", rx->den ? static_cast<gdouble>(rx->num) / rx->den : 1.0,
 466                                                       ry->den ? static_cast<gdouble>(ry->num) / ry->den : 1.0,
 467                                                       _("dot"), (units) ? units : _("unknown"));
 468
 469         g_free(units);
 470         return text;
 471 }
 472
 473 static gchar *exif_build_formatted_ColorProfile(ExifData *exif)
 474 {
 475 #ifdef HAVE_LCMS2
 476         cmsUInt8Number profileID[17];
 477 #endif
 478         const gchar *name = "";
 479         const gchar *source = "";
 480         guchar *profile_data;
 481         guint profile_len;
 482
 483         profile_data = exif_get_color_profile(exif, &profile_len);
 484         if (!profile_data)
 485                 {
 486                 gint cs;
 487                 gchar *interop_index;
 488
 489                 /* ColorSpace == 1 specifies sRGB per EXIF 2.2 */
 490                 if (!exif_get_integer(exif, "Exif.Photo.ColorSpace", &cs)) cs = 0;
 491                 interop_index = exif_get_data_as_text(exif, "Exif.Iop.InteroperabilityIndex");
 492
 493                 if (cs == 1)
 494                         {
 495                         name = _("sRGB");
 496                         source = "ColorSpace";
 497                         }
 498                 else if (cs == 2 || (interop_index && !strcmp(interop_index, "R03")))
 499                         {
 500                         name = _("AdobeRGB");
 501                         source = (cs == 2) ? "ColorSpace" : "Iop";
 502                         }
 503
 504                 g_free(interop_index);
 505                 }
 506         else
 507                 {
 508                 source = _("embedded");
 509 #ifdef HAVE_LCMS
 510
 511                         {
 512                         cmsHPROFILE profile;
 513
 514                         profile = cmsOpenProfileFromMem(profile_data, profile_len);
 515                         if (profile)
 516                                 {
 517 #ifdef HAVE_LCMS2
 518                                 profileID[16] = '\0';
 519                                 cmsGetHeaderProfileID(profile, profileID);
 520                                 name = reinterpret_cast<gchar *>(profileID);
 521 #else
 522                                 name = (gchar *) cmsTakeProductName(profile);
 523 #endif
 524                                 cmsCloseProfile(profile);
 525                                 }
 526                         g_free(profile_data);
 527                         }
 528 #endif
 529                 }
 530         if (name[0] == 0 && source[0] == 0) return nullptr;
 531         return g_strdup_printf("%s (%s)", name, source);
 532 }
 533
 534 static gchar *exif_build_formatted_GPSPosition(ExifData *exif)
 535 {
 536         GString *string;
 537         gchar *ref;
 538         ExifRational *value;
 539         ExifItem *item;
 540         guint i;
 541         gdouble p;
 542         gdouble p3;
 543         gulong p1;
 544         gulong p2;
 545
 546         string = g_string_new("");
 547
 548         item = exif_get_item(exif, "Exif.GPSInfo.GPSLatitude");
 549         ref = exif_get_data_as_text(exif, "Exif.GPSInfo.GPSLatitudeRef");
 550         if (item && ref)
 551                 {
 552                 p = 0;
 553                 for (i = 0; i < exif_item_get_elements(item); i++)
 554                         {
 555                         value = exif_item_get_rational(item, nullptr, i);
 556                         if (value && value->num && value->den)
 557                                 p += static_cast<gdouble>(value->num) / static_cast<gdouble>(value->den) / pow(60.0, static_cast<gdouble>(i));
 558                         }
 559                 p1 = static_cast<gint>(p);
 560                 p2 = static_cast<gint>((p - p1)*60);
 561                 p3 = ((p - p1)*60 - p2)*60;
 562
 563                 g_string_append_printf(string, "%0lu° %0lu' %0.2f\" %.1s", p1, p2, p3, ref);
 564                 } // if (item && ref)
 565
 566         item = exif_get_item(exif, "Exif.GPSInfo.GPSLongitude");
 567         ref = exif_get_data_as_text(exif, "Exif.GPSInfo.GPSLongitudeRef");
 568         if (item && ref)
 569                 {
 570                 p = 0;
 571                 for (i = 0; i < exif_item_get_elements(item); i++)
 572                         {
 573                         value = exif_item_get_rational(item, nullptr, i);
 574                         if (value && value->num && value->den)
 575                         p += static_cast<gdouble>(value->num) / static_cast<gdouble>(value->den) / pow(60.0, static_cast<gdouble>(i));
 576                         }
 577                 p1 = static_cast<gint>(p);
 578                 p2 = static_cast<gint>((p - p1)*60);
 579                 p3 = ((p - p1)*60 - p2)*60;
 580
 581                 g_string_append_printf(string, ", %0lu° %0lu' %0.2f\" %.1s", p1, p2, p3, ref);
 582                 } // if (item && ref)
 583
 584         return g_string_free(string, FALSE);
 585 } // static gchar *exif_build_forma...
 586
 587 static gchar *exif_build_formatted_GPSAltitude(ExifData *exif)
 588 {
 589         ExifRational *r;
 590         ExifItem *item;
 591         gdouble alt;
 592         gint ref;
 593
 594         item = exif_get_item(exif, "Exif.GPSInfo.GPSAltitudeRef");
 595         r = exif_get_rational(exif, "Exif.GPSInfo.GPSAltitude", nullptr);
 596
 597         if (!r || !item) return nullptr;
 598
 599         alt = exif_rational_to_double(r, 0);
 600         exif_item_get_integer(item, &ref);
 601
 602         return g_strdup_printf("%0.f m %s", alt, (ref==0)?_("Above Sea Level"):_("Below Sea Level"));
 603 }
 604
 605 /**
 606  * @brief Extracts timezone data from a ZoneDetect search structure
 607  * @param[in] results ZoneDetect search structure
 608  * @param[out] timezone in the form "Europe/London"
 609  * @param[out] countryname in the form "United Kingdom"
 610  * @param[out] countryalpha2 in the form "GB"
 611  *
 612  * Refer to https://github.com/BertoldVdb/ZoneDetect
 613  * for structure details
 614  */
 615 static void zd_tz(ZoneDetectResult *results, gchar **timezone, gchar **countryname, gchar **countryalpha2)
 616 {
 617         gchar *timezone_pre = nullptr;
 618         gchar *timezone_id = nullptr;
 619         unsigned int index = 0;
 620
 621         while(results[index].lookupResult != ZD_LOOKUP_END)
 622                 {
 623                 if(results[index].data)
 624                         {
 625                         for(unsigned int i=0; i<results[index].numFields; i++)
 626                                 {
 627                                 if (g_strstr_len(results[index].fieldNames[i], -1, "TimezoneIdPrefix"))
 628                                         {
 629                                         timezone_pre = g_strdup(results[index].data[i]);
 630                                         }
 631                                 if (g_strstr_len(results[index].fieldNames[i], -1, "TimezoneId"))
 632                                         {
 633                                         timezone_id = g_strdup(results[index].data[i]);
 634                                         }
 635                                 if (g_strstr_len(results[index].fieldNames[i], -1, "CountryName"))
 636                                         {
 637                                         *countryname = g_strdup(results[index].data[i]);
 638                                         }
 639                                 if (g_strstr_len(results[index].fieldNames[i], -1, "CountryAlpha2"))
 640                                         {
 641                                         *countryalpha2 = g_strdup(results[index].data[i]);
 642                                         }
 643                                 }
 644                         }
 645                 index++;
 646                 }
 647
 648         *timezone = g_strconcat(timezone_pre, timezone_id, NULL);
 649         g_free(timezone_pre);
 650         g_free(timezone_id);
 651 }
 652
 653 void ZoneDetect_onError(int errZD, int errNative)
 654 {
 655         log_printf("Error: ZoneDetect %s (0x%08X)\n", ZDGetErrorString(errZD), (unsigned)errNative);
 656 }
 657
 658 /**
 659  * @brief Gets timezone data from an exif structure
 660  * @param[in] exif
 661  * @returns TRUE if timezone data found AND GPS date and time found
 662  * @param[out] exif_date_time exif date/time in the form 2018:11:30:17:05:04
 663  * @param[out] timezone in the form "Europe/London"
 664  * @param[out] countryname in the form "United Kingdom"
 665  * @param[out] countryalpha2 in the form "GB"
 666  *
 667  *
 668  */
 669 static gboolean exif_build_tz_data(ExifData *exif, gchar **exif_date_time, gchar **timezone, gchar **countryname, gchar **countryalpha2)
 670 {
 671         gfloat latitude;
 672         gfloat longitude;
 673         gchar *text_latitude;
 674         gchar *text_longitude;
 675         gchar *text_latitude_ref;
 676         gchar *text_longitude_ref;
 677         gchar *text_date;
 678         gchar *text_time;
 679         gchar *lat_deg;
 680         gchar *lat_min;
 681         gchar *lon_deg;
 682         gchar *lon_min;
 683         gchar *timezone_path;
 684         ZoneDetect *cd;
 685         ZoneDetectResult *results;
 686         gboolean ret = FALSE;
 687
 688         text_latitude = exif_get_data_as_text(exif, "Exif.GPSInfo.GPSLatitude");
 689         text_longitude = exif_get_data_as_text(exif, "Exif.GPSInfo.GPSLongitude");
 690         text_latitude_ref = exif_get_data_as_text(exif, "Exif.GPSInfo.GPSLatitudeRef");
 691         text_longitude_ref = exif_get_data_as_text(exif, "Exif.GPSInfo.GPSLongitudeRef");
 692         text_date = exif_get_data_as_text(exif, "Exif.GPSInfo.GPSDateStamp");
 693         text_time = exif_get_data_as_text(exif, "Exif.GPSInfo.GPSTimeStamp");
 694
 695         if (text_latitude && text_longitude && text_latitude_ref && text_longitude_ref)
 696                 {
 697                 lat_deg = strtok(text_latitude, "deg'");
 698                 lat_min = strtok(nullptr, "deg'");
 699                 if (!lat_deg || !lat_min)
 700                         {
 701                         return FALSE;
 702                         }
 703                 latitude = atof(lat_deg) + atof(lat_min) / 60;
 704                 if (!g_strcmp0(text_latitude_ref, "South"))
 705                         {
 706                         latitude = -latitude;
 707                         }
 708                 lon_deg = strtok(text_longitude, "deg'");
 709                 lon_min = strtok(nullptr, "deg'");
 710                 if (!lon_deg || !lon_min)
 711                         {
 712                         return FALSE;
 713                         }
 714                 longitude = atof(lon_deg) + atof(lon_min) / 60;
 715                 if (!g_strcmp0(text_longitude_ref, "West"))
 716                         {
 717                         longitude = -longitude;
 718                         }
 719
 720                 timezone_path = g_build_filename(get_rc_dir(), TIMEZONE_DATABASE_FILE, NULL);
 721                 if (g_file_test(timezone_path, G_FILE_TEST_EXISTS))
 722                         {
 723                         ZDSetErrorHandler(ZoneDetect_onError);
 724                         cd = ZDOpenDatabase(timezone_path);
 725                         if (cd)
 726                                 {
 727                                 results = ZDLookup(cd, latitude, longitude, nullptr);
 728                                 if (results)
 729                                         {
 730                                         zd_tz(results, timezone, countryname, countryalpha2);
 731                                         ret = TRUE;
 732                                         }
 733                                 }
 734                         else
 735                                 {
 736                                 log_printf("Error: Init of timezone database %s failed\n", timezone_path);
 737                                 }
 738                         ZDCloseDatabase(cd);
 739                         }
 740                 g_free(timezone_path);
 741                 }
 742
 743         if (ret && text_date && text_time)
 744                 {
 745                 *exif_date_time = g_strconcat(text_date, ":", text_time, NULL);
 746                 }
 747         else
 748                 {
 749                 ret = FALSE;
 750                 }
 751         return ret;
 752 }
 753
 754 /**
 755  * @brief Creates local time from GPS lat/long
 756  * @param[in] exif
 757  * @returns Localised time and date
 758  *
 759  * GPS lat/long is translated to timezone using ZoneDetect.
 760  * GPS UTC is converted to Unix time stamp (seconds since 1970).
 761  * The TZ environment variable is set to the relevant timezone
 762  * and the Unix timestamp converted to local time using locale.
 763  * If the conversion fails, unformatted UTC is returned.
 764  */
 765 static gchar *exif_build_formatted_localtime(ExifData *exif)
 766 {
 767         gchar buf[128];
 768         gchar *tmp;
 769         gint buflen;
 770         GError *error = nullptr;
 771         gchar *time_zone_image;
 772         gchar *time_zone_org;
 773         struct tm *tm_local;
 774         struct tm tm_utc;
 775         time_t stamp;
 776         gchar *exif_date_time = nullptr;
 777         gchar *timezone = nullptr;
 778         gchar *countryname = nullptr;
 779         gchar *countryalpha2 = nullptr;
 780
 781         if (exif_build_tz_data(exif, &exif_date_time, &timezone, &countryname, &countryalpha2))
 782                 {
 783                 time_zone_image = g_strconcat("TZ=", timezone, NULL);
 784                 time_zone_org = g_strconcat("TZ=", getenv("TZ"), NULL);
 785                 setenv("TZ", "UTC", TRUE);
 786
 787                 memset(&tm_utc, 0, sizeof(tm_utc));
 788                 if (exif_date_time && strptime(exif_date_time, "%Y:%m:%d:%H:%M:%S", &tm_utc))
 789                         {
 790                         stamp = mktime(&tm_utc);        // Convert the struct to a Unix timestamp
 791                         putenv(time_zone_image);        // Switch to destination time zone
 792
 793                         tm_local = localtime(&stamp);
 794
 795                         /* Convert to localtime using locale */
 796                         buflen = strftime(buf, sizeof(buf), "%x %X", tm_local);
 797                         if (buflen > 0)
 798                                 {
 799                                 tmp = g_locale_to_utf8(buf, buflen, nullptr, nullptr, &error);
 800                                 if (error)
 801                                         {
 802                                         log_printf("Error converting locale strftime to UTF-8: %s\n", error->message);
 803                                         g_error_free(error);
 804                                         }
 805                                 else
 806                                         {
 807                                         g_free(exif_date_time);
 808                                         exif_date_time = tmp;
 809                                         }
 810                                 }
 811                         }
 812                 putenv(time_zone_org);
 813
 814                 g_free(time_zone_image);
 815                 g_free(time_zone_org);
 816                 }
 817
 818         g_free(timezone);
 819         g_free(countryname);
 820         g_free(countryalpha2);
 821
 822         return exif_date_time;
 823 }
 824
 825 /**
 826  * @brief Gets timezone from GPS lat/long
 827  * @param[in] exif
 828  * @returns Timezone string in the form "Europe/London"
 829  *
 830  *
 831  */
 832 static gchar *exif_build_formatted_timezone(ExifData *exif)
 833 {
 834         gchar *exif_date_time = nullptr;
 835         gchar *timezone = nullptr;
 836         gchar *countryname = nullptr;
 837         gchar *countryalpha2 = nullptr;
 838
 839         exif_build_tz_data(exif, &exif_date_time, &timezone, &countryname, &countryalpha2);
 840
 841         g_free(exif_date_time);
 842         g_free(countryname);
 843         g_free(countryalpha2);
 844
 845         return timezone;
 846 }
 847
 848 /**
 849  * @brief Gets countryname from GPS lat/long
 850  * @param[in] exif
 851  * @returns Countryname string
 852  *
 853  *
 854  */
 855 static gchar *exif_build_formatted_countryname(ExifData *exif)
 856 {
 857         gchar *exif_date_time = nullptr;
 858         gchar *timezone = nullptr;
 859         gchar *countryname = nullptr;
 860         gchar *countryalpha2 = nullptr;
 861
 862         exif_build_tz_data(exif, &exif_date_time, &timezone, &countryname, &countryalpha2);
 863
 864         g_free(exif_date_time);
 865         g_free(timezone);
 866         g_free(countryalpha2);
 867
 868         return countryname;
 869 }
 870
 871 /**
 872  * @brief Gets two-letter country code from GPS lat/long
 873  * @param[in] exif
 874  * @returns Countryalpha2 string
 875  *
 876  *
 877  */
 878 static gchar *exif_build_formatted_countrycode(ExifData *exif)
 879 {
 880         gchar *exif_date_time = nullptr;
 881         gchar *timezone = nullptr;
 882         gchar *countryname = nullptr;
 883         gchar *countryalpha2 = nullptr;
 884
 885         exif_build_tz_data(exif, &exif_date_time, &timezone, &countryname, &countryalpha2);
 886
 887         g_free(exif_date_time);
 888         g_free(timezone);
 889         g_free(countryname);
 890
 891         return countryalpha2;
 892 }
 893
 894 static gchar *exif_build_formatted_star_rating(ExifData *exif)
 895 {
 896         gint n = 0;
 897
 898         exif_get_integer(exif, "Xmp.xmp.Rating", &n);
 899
 900         return convert_rating_to_stars(n);
 901 }
 902
 903 /* List of custom formatted pseudo-exif tags */
 904 #define EXIF_FORMATTED_TAG(name, label) { EXIF_FORMATTED()#name, label, exif_build_formatted##_##name }
 905
 906 ExifFormattedText ExifFormattedList[] = {
 907         EXIF_FORMATTED_TAG(Camera,              N_("Camera")),
 908         EXIF_FORMATTED_TAG(DateTime,            N_("Date")),
 909         EXIF_FORMATTED_TAG(DateTimeDigitized,   N_("DateDigitized")),
 910         EXIF_FORMATTED_TAG(ShutterSpeed,        N_("Shutter speed")),
 911         EXIF_FORMATTED_TAG(Aperture,            N_("Aperture")),
 912         EXIF_FORMATTED_TAG(ExposureBias,        N_("Exposure bias")),
 913         EXIF_FORMATTED_TAG(ISOSpeedRating,      N_("ISO sensitivity")),
 914         EXIF_FORMATTED_TAG(FocalLength,         N_("Focal length")),
 915         EXIF_FORMATTED_TAG(FocalLength35mmFilm, N_("Focal length 35mm")),
 916         EXIF_FORMATTED_TAG(SubjectDistance,     N_("Subject distance")),
 917         EXIF_FORMATTED_TAG(Flash,               N_("Flash")),
 918         EXIF_FORMATTED_TAG(Resolution,          N_("Resolution")),
 919         EXIF_FORMATTED_TAG(ColorProfile,        N_("Color profile")),
 920         EXIF_FORMATTED_TAG(GPSPosition,         N_("GPS position")),
 921         EXIF_FORMATTED_TAG(GPSAltitude,         N_("GPS altitude")),
 922         EXIF_FORMATTED_TAG(localtime,           N_("Local time")),
 923         EXIF_FORMATTED_TAG(timezone,            N_("Time zone")),
 924         EXIF_FORMATTED_TAG(countryname,         N_("Country name")),
 925         EXIF_FORMATTED_TAG(countrycode,         N_("Country code")),
 926         EXIF_FORMATTED_TAG(star_rating,         N_("Star rating")),
 927         {"file.size",                           N_("File size"),        nullptr},
 928         {"file.date",                           N_("File date"),        nullptr},
 929         {"file.mode",                           N_("File mode"),        nullptr},
 930         {"file.ctime",                          N_("File ctime"),       nullptr},
 931         {"file.owner",                          N_("File owner"),       nullptr},
 932         {"file.group",                          N_("File group"),       nullptr},
 933         {"file.link",                           N_("File link"),        nullptr},
 934         {"file.class",                          N_("File class"),       nullptr},
 935         {"file.page_no",                        N_("Page no."),         nullptr},
 936         {"lua.lensID",                          N_("Lens"),             nullptr},
 937         { nullptr, nullptr, nullptr }
 938 };
 939
 940 gchar *exif_get_formatted_by_key(ExifData *exif, const gchar *key, gboolean *key_valid)
 941 {
 942         if (strncmp(key, EXIF_FORMATTED(), EXIF_FORMATTED_LEN) == 0)
 943                 {
 944                 gint i;
 945
 946                 if (key_valid) *key_valid = TRUE;
 947
 948                 key += EXIF_FORMATTED_LEN;
 949                 for (i = 0; ExifFormattedList[i].key; i++)
 950                         if (ExifFormattedList[i].build_func && strcmp(key, ExifFormattedList[i].key + EXIF_FORMATTED_LEN) == 0)
 951                                 return ExifFormattedList[i].build_func(exif);
 952                 }
 953
 954         if (key_valid) *key_valid = FALSE;
 955         return nullptr;
 956 }
 957
 958 gchar *exif_get_description_by_key(const gchar *key)
 959 {
 960         if (!key) return nullptr;
 961
 962         if (strncmp(key, EXIF_FORMATTED(), EXIF_FORMATTED_LEN) == 0 || strncmp(key, "file.", 5) == 0 || strncmp(key, "lua.", 4) == 0)
 963                 {
 964                 gint i;
 965
 966                 for (i = 0; ExifFormattedList[i].key; i++)
 967                         if (strcmp(key, ExifFormattedList[i].key) == 0)
 968                                 return g_strdup(_(ExifFormattedList[i].description));
 969                 }
 970
 971         return exif_get_tag_description_by_key(key);
 972 }
 973
 974 gint exif_get_integer(ExifData *exif, const gchar *key, gint *value)
 975 {
 976         ExifItem *item;
 977
 978         item = exif_get_item(exif, key);
 979         return exif_item_get_integer(item, value);
 980 }
 981
 982 ExifRational *exif_get_rational(ExifData *exif, const gchar *key, gint *sign)
 983 {
 984         ExifItem *item;
 985
 986         item = exif_get_item(exif, key);
 987         return exif_item_get_rational(item, sign, 0);
 988 }
 989
 990 gchar *exif_get_data_as_text(ExifData *exif, const gchar *key)
 991 {
 992         ExifItem *item;
 993         gchar *text;
 994         gboolean key_valid;
 995
 996         if (!key) return nullptr;
 997
 998         text = exif_get_formatted_by_key(exif, key, &key_valid);
 999         if (key_valid) return text;
1000
1001         item = exif_get_item(exif, key);
1002         if (item) return exif_item_get_data_as_text(item, exif);
1003
1004         return nullptr;
1005 }
1006
1007
1008 static FileCacheData *exif_cache;
1009
1010 void exif_release_cb(FileData *fd)
1011 {
1012         exif_free(fd->exif);
1013         fd->exif = nullptr;
1014 }
1015
1016 void exif_init_cache()
1017 {
1018         g_assert(!exif_cache);
1019         exif_cache = file_cache_new(exif_release_cb, 4);
1020 }
1021
1022 ExifData *exif_read_fd(FileData *fd)
1023 {
1024         gchar *sidecar_path;
1025
1026         if (!exif_cache) exif_init_cache();
1027
1028         if (!fd) return nullptr;
1029
1030         if (file_cache_get(exif_cache, fd)) return fd->exif;
1031         g_assert(fd->exif == nullptr);
1032
1033         /* CACHE_TYPE_XMP_METADATA file should exist only if the metadata are
1034          * not writable directly, thus it should contain the most up-to-date version */
1035         sidecar_path = nullptr;
1036
1037 #ifdef HAVE_EXIV2
1038         /* we are not able to handle XMP sidecars without exiv2 */
1039         sidecar_path = cache_find_location(CACHE_TYPE_XMP_METADATA, fd->path);
1040
1041         if (!sidecar_path) sidecar_path = file_data_get_sidecar_path(fd, TRUE);
1042 #endif
1043
1044         fd->exif = exif_read(fd->path, sidecar_path, fd->modified_xmp);
1045
1046         g_free(sidecar_path);
1047         file_cache_put(exif_cache, fd, 1);
1048         return fd->exif;
1049 }
1050
1051
1052 void exif_free_fd(FileData *fd, ExifData *exif)
1053 {
1054         if (!fd) return;
1055         g_assert(fd->exif == exif);
1056 }
1057
1058 /* embedded icc in jpeg */
1059
1060 gboolean exif_jpeg_parse_color(ExifData *exif, guchar *data, guint size)
1061 {
1062         guint seg_offset = 0;
1063         guint seg_length = 0;
1064         guint chunk_offset[255];
1065         guint chunk_length[255];
1066         guint chunk_count = 0;
1067
1068         /* For jpeg/jfif, ICC color profile data can be in more than one segment.
1069            the data is in APP2 data segments that start with "ICC_PROFILE\x00\xNN\xTT"
1070            NN = segment number for data
1071            TT = total number of ICC segments (TT in each ICC segment should match)
1072          */
1073
1074         while (jpeg_segment_find(data + seg_offset + seg_length,
1075                                       size - seg_offset - seg_length,
1076                                       JPEG_MARKER_APP2,
1077                                       "ICC_PROFILE\x00", 12,
1078                                       &seg_offset, &seg_length))
1079                 {
1080                 guchar chunk_num;
1081                 guchar chunk_tot;
1082
1083                 if (seg_length < 14) return FALSE;
1084
1085                 chunk_num = data[seg_offset + 12];
1086                 chunk_tot = data[seg_offset + 13];
1087
1088                 if (chunk_num == 0 || chunk_tot == 0) return FALSE;
1089
1090                 if (chunk_count == 0)
1091                         {
1092                         guint i;
1093
1094                         chunk_count = static_cast<guint>(chunk_tot);
1095                         for (i = 0; i < chunk_count; i++) chunk_offset[i] = 0;
1096                         for (i = 0; i < chunk_count; i++) chunk_length[i] = 0;
1097                         }
1098
1099                 if (chunk_tot != chunk_count ||
1100                     chunk_num > chunk_count) return FALSE;
1101
1102                 chunk_num--;
1103                 chunk_offset[chunk_num] = seg_offset + 14;
1104                 chunk_length[chunk_num] = seg_length - 14;
1105                 }
1106
1107         if (chunk_count > 0)
1108                 {
1109                 guchar *cp_data;
1110                 guint cp_length = 0;
1111                 guint i;
1112
1113                 for (i = 0; i < chunk_count; i++) cp_length += chunk_length[i];
1114                 cp_data = static_cast<guchar *>(g_malloc(cp_length));
1115
1116                 for (i = 0; i < chunk_count; i++)
1117                         {
1118                         if (chunk_offset[i] == 0)
1119                                 {
1120                                 /* error, we never saw this chunk */
1121                                 g_free(cp_data);
1122                                 return FALSE;
1123                                 }
1124                         memcpy(cp_data, data + chunk_offset[i], chunk_length[i]);
1125                         }
1126                 DEBUG_1("Found embedded icc profile in jpeg");
1127                 exif_add_jpeg_color_profile(exif, cp_data, cp_length);
1128
1129                 return TRUE;
1130                 }
1131
1132         return FALSE;
1133 }
1134
1135 /*
1136  *-------------------------------------------------------------------
1137  * file info
1138  * it is here because it shares tag neming infrastructure with exif
1139  * we should probably not invest too much effort into this because
1140  * new exiv2 will support the same functionality
1141  * https://dev.exiv2.org/issues/505
1142  *-------------------------------------------------------------------
1143  */
1144
1145 static gchar *mode_number(mode_t m)
1146 {
1147         gint mb;
1148         gint mu;
1149         gint mg;
1150         gint mo;
1151         gchar pbuf[12];
1152
1153         mb = mu = mg = mo = 0;
1154
1155         if (m & S_ISUID) mb |= 4;
1156         if (m & S_ISGID) mb |= 2;
1157         if (m & S_ISVTX) mb |= 1;
1158
1159         if (m & S_IRUSR) mu |= 4;
1160         if (m & S_IWUSR) mu |= 2;
1161         if (m & S_IXUSR) mu |= 1;
1162
1163         if (m & S_IRGRP) mg |= 4;
1164         if (m & S_IWGRP) mg |= 2;
1165         if (m & S_IXGRP) mg |= 1;
1166
1167         if (m & S_IROTH) mo |= 4;
1168         if (m & S_IWOTH) mo |= 2;
1169         if (m & S_IXOTH) mo |= 1;
1170
1171         pbuf[0] = (m & S_IRUSR) ? 'r' : '-';
1172         pbuf[1] = (m & S_IWUSR) ? 'w' : '-';
1173         pbuf[2] = (m & S_IXUSR) ? 'x' : '-';
1174         pbuf[3] = (m & S_IRGRP) ? 'r' : '-';
1175         pbuf[4] = (m & S_IWGRP) ? 'w' : '-';
1176         pbuf[5] = (m & S_IXGRP) ? 'x' : '-';
1177         pbuf[6] = (m & S_IROTH) ? 'r' : '-';
1178         pbuf[7] = (m & S_IWOTH) ? 'w' : '-';
1179         pbuf[8] = (m & S_IXOTH) ? 'x' : '-';
1180         pbuf[9] = '\0';
1181
1182         return g_strdup_printf("%s (%d%d%d%d)", pbuf, mb, mu, mg, mo);
1183 }
1184
1185 gchar *metadata_file_info(FileData *fd, const gchar *key, MetadataFormat)
1186 {
1187         gchar *page_n_of_m;
1188
1189         if (strcmp(key, "file.size") == 0)
1190                 {
1191                 return g_strdup_printf("%ld", static_cast<long>(fd->size));
1192                 }
1193         if (strcmp(key, "file.date") == 0)
1194                 {
1195                 return g_strdup(text_from_time(fd->date));
1196                 }
1197         if (strcmp(key, "file.mode") == 0)
1198                 {
1199                 return mode_number(fd->mode);
1200                 }
1201         if (strcmp(key, "file.ctime") == 0)
1202                 {
1203                 return g_strdup(text_from_time(fd->cdate));
1204                 }
1205         if (strcmp(key, "file.class") == 0)
1206                 {
1207                 return g_strdup(format_class_list[fd->format_class]);
1208                 }
1209         if (strcmp(key, "file.owner") == 0)
1210                 {
1211                 return g_strdup(fd->owner);
1212                 }
1213         if (strcmp(key, "file.group") == 0)
1214                 {
1215                 return g_strdup(fd->group);
1216                 }
1217         if (strcmp(key, "file.link") == 0)
1218                 {
1219                 return g_strdup(fd->sym_link);
1220                 }
1221         if (strcmp(key, "file.page_no") == 0)
1222                 {
1223                 if (fd->page_total > 1)
1224                         {
1225                         page_n_of_m = g_strdup_printf("[%d/%d]", fd->page_num + 1, fd->page_total);
1226                         return page_n_of_m;
1227                         }
1228
1229                 return nullptr;
1230                 }
1231         return g_strdup("");
1232 }
1233
1234 #ifdef HAVE_LUA
1235 gchar *metadata_lua_info(FileData *fd, const gchar *key, MetadataFormat)
1236 {
1237         gchar *script_name;
1238         gchar *script_name_utf8;
1239         gchar *data;
1240         gchar *raw_data;
1241         gchar *valid_data;
1242
1243         script_name_utf8 = g_strdup(key + 4);
1244         script_name = path_from_utf8(script_name_utf8);
1245
1246         raw_data = lua_callvalue(fd, script_name, nullptr);
1247         valid_data = g_utf8_make_valid(raw_data, -1);
1248         data = g_utf8_substring(valid_data, 0, 150);
1249
1250         g_free(script_name);
1251         g_free(script_name_utf8);
1252         g_free(raw_data);
1253         g_free(valid_data);
1254
1255         return data;
1256 }
1257 #endif
1258 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */