KExiv2

kexiv2image.cpp
1/*
2 SPDX-FileCopyrightText: 2006-2015 Gilles Caulier <caulier dot gilles at gmail dot com>
3 SPDX-FileCopyrightText: 2006-2012 Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
4
5 SPDX-License-Identifier: GPL-2.0-or-later
6*/
7
8#include "kexiv2.h"
9#include "kexiv2_p.h"
10
11// Qt includes
12
13#include <QBuffer>
14
15// Local includes
16
17#include "rotationmatrix.h"
18#include "libkexiv2_debug.h"
19
20namespace KExiv2Iface
21{
22
23bool KExiv2::setImageProgramId(const QString& program, const QString& version) const
24{
25 try
26 {
27 QString software(program);
28 software.append(QString::fromLatin1("-"));
29 software.append(version);
30
31 // Set program info into Exif.Image.ProcessingSoftware tag (only available with Exiv2 >= 0.14.0).
32
33 d->exifMetadata()["Exif.Image.ProcessingSoftware"] = std::string(software.toLatin1().constData());
34
35 // See B.K.O #142564: Check if Exif.Image.Software already exist. If yes, do not touch this tag.
36
37 if (!d->exifMetadata().empty())
38 {
39 Exiv2::ExifData exifData(d->exifMetadata());
40 Exiv2::ExifKey key("Exif.Image.Software");
41 Exiv2::ExifData::iterator it = exifData.findKey(key);
42
43 if (it == exifData.end())
44 d->exifMetadata()["Exif.Image.Software"] = std::string(software.toLatin1().constData());
45 }
46
47 // set program info into XMP tags.
48
49#ifdef _XMP_SUPPORT_
50
51 if (!d->xmpMetadata().empty())
52 {
53 // Only create Xmp.xmp.CreatorTool if it do not exist.
54 Exiv2::XmpData xmpData(d->xmpMetadata());
55 Exiv2::XmpKey key("Xmp.xmp.CreatorTool");
56 Exiv2::XmpData::iterator it = xmpData.findKey(key);
57
58 if (it == xmpData.end())
59 setXmpTagString("Xmp.xmp.CreatorTool", software, false);
60 }
61
62 setXmpTagString("Xmp.tiff.Software", software, false);
63
64#endif // _XMP_SUPPORT_
65
66 // Set program info into IPTC tags.
67
68 d->iptcMetadata()["Iptc.Application2.Program"] = std::string(program.toLatin1().constData());
69 d->iptcMetadata()["Iptc.Application2.ProgramVersion"] = std::string(version.toLatin1().constData());
70 return true;
71 }
72 catch( Exiv2::Error& e )
73 {
74 d->printExiv2ExceptionError(QString::fromLatin1("Cannot set Program identity into image using Exiv2 "), e);
75 }
76 catch(...)
77 {
78 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
79 }
80
81 return false;
82}
83
84QSize KExiv2::getImageDimensions() const
85{
86 try
87 {
88 long width=-1, height=-1;
89
90 // Try to get Exif.Photo tags
91
92 Exiv2::ExifData exifData(d->exifMetadata());
93 Exiv2::ExifKey key("Exif.Photo.PixelXDimension");
94 Exiv2::ExifData::iterator it = exifData.findKey(key);
95
96 if (it != exifData.end() && it->count())
97#if EXIV2_TEST_VERSION(0,28,0)
98 width = it->toUint32();
99#else
100 width = it->toLong();
101#endif
102
103 Exiv2::ExifKey key2("Exif.Photo.PixelYDimension");
104 Exiv2::ExifData::iterator it2 = exifData.findKey(key2);
105
106 if (it2 != exifData.end() && it2->count())
107#if EXIV2_TEST_VERSION(0,28,0)
108 height = it2->toUint32();
109#else
110 height = it2->toLong();
111#endif
112
113 if (width != -1 && height != -1)
114 return QSize(width, height);
115
116 // Try to get Exif.Image tags
117
118 width = -1;
119 height = -1;
120
121 Exiv2::ExifKey key3("Exif.Image.ImageWidth");
122 Exiv2::ExifData::iterator it3 = exifData.findKey(key3);
123
124 if (it3 != exifData.end() && it3->count())
125#if EXIV2_TEST_VERSION(0,28,0)
126 width = it3->toUint32();
127#else
128 width = it3->toLong();
129#endif
130
131 Exiv2::ExifKey key4("Exif.Image.ImageLength");
132 Exiv2::ExifData::iterator it4 = exifData.findKey(key4);
133
134 if (it4 != exifData.end() && it4->count())
135#if EXIV2_TEST_VERSION(0,28,0)
136 height = it4->toUint32();
137#else
138 height = it4->toLong();
139#endif
140
141 if (width != -1 && height != -1)
142 return QSize(width, height);
143
144#ifdef _XMP_SUPPORT_
145
146 // Try to get Xmp.tiff tags
147
148 width = -1;
149 height = -1;
150 bool wOk = false;
151 bool hOk = false;
152
153 QString str = getXmpTagString("Xmp.tiff.ImageWidth");
154
155 if (!str.isEmpty())
156 width = str.toInt(&wOk);
157
158 str = getXmpTagString("Xmp.tiff.ImageLength");
159
160 if (!str.isEmpty())
161 height = str.toInt(&hOk);
162
163 if (wOk && hOk)
164 return QSize(width, height);
165
166 // Try to get Xmp.exif tags
167
168 width = -1;
169 height = -1;
170 wOk = false;
171 hOk = false;
172
173 str = getXmpTagString("Xmp.exif.PixelXDimension");
174
175 if (!str.isEmpty())
176 width = str.toInt(&wOk);
177
178 str = getXmpTagString("Xmp.exif.PixelYDimension");
179
180 if (!str.isEmpty())
181 height = str.toInt(&hOk);
182
183 if (wOk && hOk)
184 return QSize(width, height);
185
186#endif // _XMP_SUPPORT_
187
188 }
189 catch( Exiv2::Error& e )
190 {
191 d->printExiv2ExceptionError(QString::fromLatin1("Cannot parse image dimensions tag using Exiv2 "), e);
192 }
193 catch(...)
194 {
195 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
196 }
197
198 return QSize();
199}
200
201bool KExiv2::setImageDimensions(const QSize& size, bool setProgramName) const
202{
203 if (!setProgramId(setProgramName))
204 return false;
205
206 try
207 {
208 // Set Exif values.
209
210 // NOTE: see B.K.O #144604: need to cast to record an unsigned integer value.
211 d->exifMetadata()["Exif.Image.ImageWidth"] = static_cast<uint32_t>(size.width());
212 d->exifMetadata()["Exif.Image.ImageLength"] = static_cast<uint32_t>(size.height());
213 d->exifMetadata()["Exif.Photo.PixelXDimension"] = static_cast<uint32_t>(size.width());
214 d->exifMetadata()["Exif.Photo.PixelYDimension"] = static_cast<uint32_t>(size.height());
215
216 // Set Xmp values.
217
218#ifdef _XMP_SUPPORT_
219
220 setXmpTagString("Xmp.tiff.ImageWidth", QString::number(size.width()), false);
221 setXmpTagString("Xmp.tiff.ImageLength", QString::number(size.height()), false);
222 setXmpTagString("Xmp.exif.PixelXDimension", QString::number(size.width()), false);
223 setXmpTagString("Xmp.exif.PixelYDimension", QString::number(size.height()), false);
224
225#endif // _XMP_SUPPORT_
226
227 return true;
228 }
229 catch( Exiv2::Error& e )
230 {
231 d->printExiv2ExceptionError(QString::fromLatin1("Cannot set image dimensions using Exiv2 "), e);
232 }
233 catch(...)
234 {
235 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
236 }
237
238 return false;
239}
240
241KExiv2::ImageOrientation KExiv2::getImageOrientation() const
242{
243 try
244 {
245 Exiv2::ExifData exifData(d->exifMetadata());
246 Exiv2::ExifData::iterator it;
247 long orientation;
248 ImageOrientation imageOrient = ORIENTATION_NORMAL;
249
250 // -- Standard Xmp tag --------------------------------
251
252#ifdef _XMP_SUPPORT_
253
254 bool ok = false;
255 QString str = getXmpTagString("Xmp.tiff.Orientation");
256
257 if (!str.isEmpty())
258 {
259 orientation = str.toLong(&ok);
260
261 if (ok)
262 {
263 qCDebug(LIBKEXIV2_LOG) << "Orientation => Xmp.tiff.Orientation => " << (int)orientation;
264 return (ImageOrientation)orientation;
265 }
266 }
267
268#endif // _XMP_SUPPORT_
269
270 // Because some camera set a wrong standard exif orientation tag,
271 // We need to check makernote tags in first!
272
273 // -- Minolta Cameras ----------------------------------
274
275 Exiv2::ExifKey minoltaKey1("Exif.MinoltaCs7D.Rotation");
276 it = exifData.findKey(minoltaKey1);
277
278 if (it != exifData.end() && it->count())
279 {
280#if EXIV2_TEST_VERSION(0,28,0)
281 orientation = it->toUint32();
282#else
283 orientation = it->toLong();
284#endif
285 qCDebug(LIBKEXIV2_LOG) << "Orientation => Exif.MinoltaCs7D.Rotation => " << (int)orientation;
286
287 switch(orientation)
288 {
289 case 76:
290 imageOrient = ORIENTATION_ROT_90;
291 break;
292 case 82:
293 imageOrient = ORIENTATION_ROT_270;
294 break;
295 }
296
297 return imageOrient;
298 }
299
300 Exiv2::ExifKey minoltaKey2("Exif.MinoltaCs5D.Rotation");
301 it = exifData.findKey(minoltaKey2);
302
303 if (it != exifData.end() && it->count())
304 {
305#if EXIV2_TEST_VERSION(0,28,0)
306 orientation = it->toUint32();
307#else
308 orientation = it->toLong();
309#endif
310 qCDebug(LIBKEXIV2_LOG) << "Orientation => Exif.MinoltaCs5D.Rotation => " << (int)orientation;
311
312 switch(orientation)
313 {
314 case 76:
315 imageOrient = ORIENTATION_ROT_90;
316 break;
317 case 82:
318 imageOrient = ORIENTATION_ROT_270;
319 break;
320 }
321
322 return imageOrient;
323 }
324
325 // -- Standard Exif tag --------------------------------
326
327 Exiv2::ExifKey keyStd("Exif.Image.Orientation");
328 it = exifData.findKey(keyStd);
329
330 if (it != exifData.end() && it->count())
331 {
332#if EXIV2_TEST_VERSION(0,28,0)
333 orientation = it->toUint32();
334#else
335 orientation = it->toLong();
336#endif
337 qCDebug(LIBKEXIV2_LOG) << "Orientation => Exif.Image.Orientation => " << (int)orientation;
338 return (ImageOrientation)orientation;
339 }
340
341 }
342 catch( Exiv2::Error& e )
343 {
344 d->printExiv2ExceptionError(QString::fromLatin1("Cannot parse Exif Orientation tag using Exiv2 "), e);
345 }
346 catch(...)
347 {
348 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
349 }
350
351 return ORIENTATION_UNSPECIFIED;
352}
353
354bool KExiv2::setImageOrientation(ImageOrientation orientation, bool setProgramName) const
355{
356 if (!setProgramId(setProgramName))
357 return false;
358
359 try
360 {
361 if (orientation < ORIENTATION_UNSPECIFIED || orientation > ORIENTATION_ROT_270)
362 {
363 qCDebug(LIBKEXIV2_LOG) << "Image orientation value is not correct!";
364 return false;
365 }
366
367 // Set Exif values.
368
369 d->exifMetadata()["Exif.Image.Orientation"] = static_cast<uint16_t>(orientation);
370 qCDebug(LIBKEXIV2_LOG) << "Exif.Image.Orientation tag set to: " << (int)orientation;
371
372 // Set Xmp values.
373
374#ifdef _XMP_SUPPORT_
375
376 setXmpTagString("Xmp.tiff.Orientation", QString::number((int)orientation), false);
377
378#endif // _XMP_SUPPORT_
379
380 // -- Minolta/Sony Cameras ----------------------------------
381
382 // Minolta and Sony camera store image rotation in Makernote.
383 // We remove these information to prevent duplicate values.
384
385 Exiv2::ExifData::iterator it;
386
387 Exiv2::ExifKey minoltaKey1("Exif.MinoltaCs7D.Rotation");
388 it = d->exifMetadata().findKey(minoltaKey1);
389
390 if (it != d->exifMetadata().end())
391 {
392 d->exifMetadata().erase(it);
393 qCDebug(LIBKEXIV2_LOG) << "Removing Exif.MinoltaCs7D.Rotation tag";
394 }
395
396 Exiv2::ExifKey minoltaKey2("Exif.MinoltaCs5D.Rotation");
397 it = d->exifMetadata().findKey(minoltaKey2);
398
399 if (it != d->exifMetadata().end())
400 {
401 d->exifMetadata().erase(it);
402 qCDebug(LIBKEXIV2_LOG) << "Removing Exif.MinoltaCs5D.Rotation tag";
403 }
404
405 // -- Exif embedded thumbnail ----------------------------------
406
407 Exiv2::ExifKey thumbKey("Exif.Thumbnail.Orientation");
408 it = d->exifMetadata().findKey(thumbKey);
409
410 if (it != d->exifMetadata().end() && it->count())
411 {
412#if EXIV2_TEST_VERSION(0,28,0)
413 RotationMatrix operation((KExiv2Iface::KExiv2::ImageOrientation)it->toUint32());
414#else
415 RotationMatrix operation((KExiv2Iface::KExiv2::ImageOrientation)it->toLong());
416#endif
417 operation *= orientation;
418 (*it) = static_cast<uint16_t>(operation.exifOrientation());
419 }
420
421 return true;
422 }
423 catch( Exiv2::Error& e )
424 {
425 d->printExiv2ExceptionError(QString::fromLatin1("Cannot set Exif Orientation tag using Exiv2 "), e);
426 }
427 catch(...)
428 {
429 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
430 }
431
432 return false;
433}
434
435KExiv2::ImageColorWorkSpace KExiv2::getImageColorWorkSpace() const
436{
437 // Check Exif values.
438
439 long exifColorSpace = -1;
440
441 if (!getExifTagLong("Exif.Photo.ColorSpace", exifColorSpace))
442 {
443#ifdef _XMP_SUPPORT_
444 QVariant var = getXmpTagVariant("Xmp.exif.ColorSpace");
445 if (!var.isNull())
446 exifColorSpace = var.toInt();
447#endif // _XMP_SUPPORT_
448 }
449
450 if (exifColorSpace == 1)
451 {
452 return WORKSPACE_SRGB; // as specified by standard
453 }
454 else if (exifColorSpace == 2)
455 {
456 return WORKSPACE_ADOBERGB; // not in the standard!
457 }
458 else
459 {
460 if (exifColorSpace == 65535)
461 {
462 // A lot of cameras set the Exif.Iop.InteroperabilityIndex,
463 // as documented for ExifTool
464 QString interopIndex = getExifTagString("Exif.Iop.InteroperabilityIndex");
465
466 if (!interopIndex.isNull())
467 {
468 if (interopIndex == QString::fromLatin1("R03"))
469 return WORKSPACE_ADOBERGB;
470 else if (interopIndex == QString::fromLatin1("R98"))
471 return WORKSPACE_SRGB;
472 }
473 }
474
475 // Note: Text EXIF ColorSpace tag may just not be present (NEF files)
476
477 // Nikon camera set Exif.Photo.ColorSpace to uncalibrated or just skip this field,
478 // then add additional information into the makernotes.
479 // Exif.Nikon3.ColorSpace: 1 => sRGB, 2 => AdobeRGB
480 long nikonColorSpace;
481
482 if (getExifTagLong("Exif.Nikon3.ColorSpace", nikonColorSpace))
483 {
484 if (nikonColorSpace == 1)
485 return WORKSPACE_SRGB;
486 else if (nikonColorSpace == 2)
487 return WORKSPACE_ADOBERGB;
488 }
489 // Exif.Nikon3.ColorMode is set to "MODE2" for AdobeRGB, but there are sometimes two ColorMode fields
490 // in a NEF, with the first one "COLOR" and the second one "MODE2"; but in this case, ColorSpace (above) was set.
491 if (getExifTagString("Exif.Nikon3.ColorMode").contains(QString::fromLatin1("MODE2")))
492 return WORKSPACE_ADOBERGB;
493
494 //TODO: This makernote tag (0x00b4) must be added to libexiv2
495 /*
496 long canonColorSpace;
497 if (getExifTagLong("Exif.Canon.ColorSpace", canonColorSpace))
498 {
499 if (canonColorSpace == 1)
500 return WORKSPACE_SRGB;
501 else if (canonColorSpace == 2)
502 return WORKSPACE_ADOBERGB;
503 }
504 */
505
506 // TODO : add more Makernote parsing here ...
507
508 if (exifColorSpace == 65535)
509 return WORKSPACE_UNCALIBRATED;
510 }
511
512 return WORKSPACE_UNSPECIFIED;
513}
514
515bool KExiv2::setImageColorWorkSpace(ImageColorWorkSpace workspace, bool setProgramName) const
516{
517 if (!setProgramId(setProgramName))
518 return false;
519
520 try
521 {
522 // Set Exif value.
523
524 d->exifMetadata()["Exif.Photo.ColorSpace"] = static_cast<uint16_t>(workspace);
525
526 // Set Xmp value.
527
528#ifdef _XMP_SUPPORT_
529
530 setXmpTagString("Xmp.exif.ColorSpace", QString::number((int)workspace), false);
531
532#endif // _XMP_SUPPORT_
533
534 return true;
535 }
536 catch( Exiv2::Error& e )
537 {
538 d->printExiv2ExceptionError(QString::fromLatin1("Cannot set Exif color workspace tag using Exiv2 "), e);
539 }
540 catch(...)
541 {
542 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
543 }
544
545 return false;
546}
547
548QDateTime KExiv2::getImageDateTime() const
549{
550 try
551 {
552 // In first, trying to get Date & time from Exif tags.
553
554 if (!d->exifMetadata().empty())
555 {
556 Exiv2::ExifData exifData(d->exifMetadata());
557 {
558 Exiv2::ExifKey key("Exif.Photo.DateTimeOriginal");
559 Exiv2::ExifData::iterator it = exifData.findKey(key);
560
561 if (it != exifData.end())
562 {
563 QDateTime dateTime = QDateTime::fromString(QString::fromLatin1(it->toString().c_str()), Qt::ISODate);
564
565 if (dateTime.isValid())
566 {
567 qCDebug(LIBKEXIV2_LOG) << "DateTime => Exif.Photo.DateTimeOriginal => " << dateTime;
568 return dateTime;
569 }
570 }
571 }
572 {
573 Exiv2::ExifKey key("Exif.Photo.DateTimeDigitized");
574 Exiv2::ExifData::iterator it = exifData.findKey(key);
575
576 if (it != exifData.end())
577 {
578 QDateTime dateTime = QDateTime::fromString(QString::fromLatin1(it->toString().c_str()), Qt::ISODate);
579
580 if (dateTime.isValid())
581 {
582 qCDebug(LIBKEXIV2_LOG) << "DateTime => Exif.Photo.DateTimeDigitized => " << dateTime;
583 return dateTime;
584 }
585 }
586 }
587 {
588 Exiv2::ExifKey key("Exif.Image.DateTime");
589 Exiv2::ExifData::iterator it = exifData.findKey(key);
590
591 if (it != exifData.end())
592 {
593 QDateTime dateTime = QDateTime::fromString(QString::fromLatin1(it->toString().c_str()), Qt::ISODate);
594
595 if (dateTime.isValid())
596 {
597 qCDebug(LIBKEXIV2_LOG) << "DateTime => Exif.Image.DateTime => " << dateTime;
598 return dateTime;
599 }
600 }
601 }
602 }
603
604 // In second, trying to get Date & time from Xmp tags.
605
606#ifdef _XMP_SUPPORT_
607
608 if (!d->xmpMetadata().empty())
609 {
610 Exiv2::XmpData xmpData(d->xmpMetadata());
611 {
612 Exiv2::XmpKey key("Xmp.exif.DateTimeOriginal");
613 Exiv2::XmpData::iterator it = xmpData.findKey(key);
614
615 if (it != xmpData.end())
616 {
617 QDateTime dateTime = QDateTime::fromString(QString::fromLatin1(it->toString().c_str()), Qt::ISODate);
618
619 if (dateTime.isValid())
620 {
621 qCDebug(LIBKEXIV2_LOG) << "DateTime => Xmp.exif.DateTimeOriginal => " << dateTime;
622 return dateTime;
623 }
624 }
625 }
626 {
627 Exiv2::XmpKey key("Xmp.exif.DateTimeDigitized");
628 Exiv2::XmpData::iterator it = xmpData.findKey(key);
629
630 if (it != xmpData.end())
631 {
632 QDateTime dateTime = QDateTime::fromString(QString::fromLatin1(it->toString().c_str()), Qt::ISODate);
633
634 if (dateTime.isValid())
635 {
636 qCDebug(LIBKEXIV2_LOG) << "DateTime => Xmp.exif.DateTimeDigitized => " << dateTime;
637 return dateTime;
638 }
639 }
640 }
641 {
642 Exiv2::XmpKey key("Xmp.photoshop.DateCreated");
643 Exiv2::XmpData::iterator it = xmpData.findKey(key);
644
645 if (it != xmpData.end())
646 {
647 QDateTime dateTime = QDateTime::fromString(QString::fromLatin1(it->toString().c_str()), Qt::ISODate);
648
649 if (dateTime.isValid())
650 {
651 qCDebug(LIBKEXIV2_LOG) << "DateTime => Xmp.photoshop.DateCreated => " << dateTime;
652 return dateTime;
653 }
654 }
655 }
656 {
657 Exiv2::XmpKey key("Xmp.xmp.CreateDate");
658 Exiv2::XmpData::iterator it = xmpData.findKey(key);
659
660 if (it != xmpData.end())
661 {
662 QDateTime dateTime = QDateTime::fromString(QString::fromLatin1(it->toString().c_str()), Qt::ISODate);
663
664 if (dateTime.isValid())
665 {
666 qCDebug(LIBKEXIV2_LOG) << "DateTime => Xmp.xmp.CreateDate => " << dateTime;
667 return dateTime;
668 }
669 }
670 }
671 {
672 Exiv2::XmpKey key("Xmp.tiff.DateTime");
673 Exiv2::XmpData::iterator it = xmpData.findKey(key);
674
675 if (it != xmpData.end())
676 {
677 QDateTime dateTime = QDateTime::fromString(QString::fromLatin1(it->toString().c_str()), Qt::ISODate);
678
679 if (dateTime.isValid())
680 {
681 qCDebug(LIBKEXIV2_LOG) << "DateTime => Xmp.tiff.DateTime => " << dateTime;
682 return dateTime;
683 }
684 }
685 }
686 {
687 Exiv2::XmpKey key("Xmp.xmp.ModifyDate");
688 Exiv2::XmpData::iterator it = xmpData.findKey(key);
689
690 if (it != xmpData.end())
691 {
692 QDateTime dateTime = QDateTime::fromString(QString::fromLatin1(it->toString().c_str()), Qt::ISODate);
693
694 if (dateTime.isValid())
695 {
696 qCDebug(LIBKEXIV2_LOG) << "DateTime => Xmp.xmp.ModifyDate => " << dateTime;
697 return dateTime;
698 }
699 }
700 }
701 {
702 Exiv2::XmpKey key("Xmp.xmp.MetadataDate");
703 Exiv2::XmpData::iterator it = xmpData.findKey(key);
704
705 if (it != xmpData.end())
706 {
707 QDateTime dateTime = QDateTime::fromString(QString::fromLatin1(it->toString().c_str()), Qt::ISODate);
708
709 if (dateTime.isValid())
710 {
711 qCDebug(LIBKEXIV2_LOG) << "DateTime => Xmp.xmp.MetadataDate => " << dateTime;
712 return dateTime;
713 }
714 }
715 }
716
717 // Video files support
718
719 {
720 Exiv2::XmpKey key("Xmp.video.DateTimeOriginal");
721 Exiv2::XmpData::iterator it = xmpData.findKey(key);
722
723 if (it != xmpData.end())
724 {
725 QDateTime dateTime = QDateTime::fromString(QString::fromLatin1(it->toString().c_str()), Qt::ISODate);
726
727 if (dateTime.isValid())
728 {
729 qCDebug(LIBKEXIV2_LOG) << "DateTime => Xmp.video.DateTimeOriginal => " << dateTime;
730 return dateTime;
731 }
732 }
733 }
734 {
735 Exiv2::XmpKey key("Xmp.video.DateUTC");
736 Exiv2::XmpData::iterator it = xmpData.findKey(key);
737
738 if (it != xmpData.end())
739 {
740 QDateTime dateTime = QDateTime::fromString(QString::fromLatin1(it->toString().c_str()), Qt::ISODate);
741
742 if (dateTime.isValid())
743 {
744 qCDebug(LIBKEXIV2_LOG) << "DateTime => Xmp.video.DateUTC => " << dateTime;
745 return dateTime;
746 }
747 }
748 }
749 {
750 Exiv2::XmpKey key("Xmp.video.ModificationDate");
751 Exiv2::XmpData::iterator it = xmpData.findKey(key);
752
753 if (it != xmpData.end())
754 {
755 QDateTime dateTime = QDateTime::fromString(QString::fromLatin1(it->toString().c_str()), Qt::ISODate);
756
757 if (dateTime.isValid())
758 {
759 qCDebug(LIBKEXIV2_LOG) << "DateTime => Xmp.video.ModificationDate => " << dateTime;
760 return dateTime;
761 }
762 }
763 }
764 {
765 Exiv2::XmpKey key("Xmp.video.DateTimeDigitized");
766 Exiv2::XmpData::iterator it = xmpData.findKey(key);
767
768 if (it != xmpData.end())
769 {
770 QDateTime dateTime = QDateTime::fromString(QString::fromLatin1(it->toString().c_str()), Qt::ISODate);
771
772 if (dateTime.isValid())
773 {
774 qCDebug(LIBKEXIV2_LOG) << "DateTime => Xmp.video.DateTimeDigitized => " << dateTime;
775 return dateTime;
776 }
777 }
778 }
779 }
780
781#endif // _XMP_SUPPORT_
782
783 // In third, trying to get Date & time from Iptc tags.
784
785 if (!d->iptcMetadata().empty())
786 {
787 Exiv2::IptcData iptcData(d->iptcMetadata());
788
789 // Try creation Iptc date & time entries.
790
791 Exiv2::IptcKey keyDateCreated("Iptc.Application2.DateCreated");
792 Exiv2::IptcData::iterator it = iptcData.findKey(keyDateCreated);
793
794 if (it != iptcData.end())
795 {
796 QString IptcDateCreated(QString::fromLatin1(it->toString().c_str()));
797 Exiv2::IptcKey keyTimeCreated("Iptc.Application2.TimeCreated");
798 Exiv2::IptcData::iterator it2 = iptcData.findKey(keyTimeCreated);
799
800 if (it2 != iptcData.end())
801 {
802 QString IptcTimeCreated(QString::fromLatin1(it2->toString().c_str()));
803 QDate date = QDate::fromString(IptcDateCreated, Qt::ISODate);
804 QTime time = QTime::fromString(IptcTimeCreated, Qt::ISODate);
805 QDateTime dateTime = QDateTime(date, time);
806
807 if (dateTime.isValid())
808 {
809 qCDebug(LIBKEXIV2_LOG) << "DateTime => Iptc.Application2.DateCreated => " << dateTime;
810 return dateTime;
811 }
812 }
813 }
814
815 // Try digitization Iptc date & time entries.
816
817 Exiv2::IptcKey keyDigitizationDate("Iptc.Application2.DigitizationDate");
818 Exiv2::IptcData::iterator it3 = iptcData.findKey(keyDigitizationDate);
819
820 if (it3 != iptcData.end())
821 {
822 QString IptcDateDigitization(QString::fromLatin1(it3->toString().c_str()));
823 Exiv2::IptcKey keyDigitizationTime("Iptc.Application2.DigitizationTime");
824 Exiv2::IptcData::iterator it4 = iptcData.findKey(keyDigitizationTime);
825
826 if (it4 != iptcData.end())
827 {
828 QString IptcTimeDigitization(QString::fromLatin1(it4->toString().c_str()));
829 QDate date = QDate::fromString(IptcDateDigitization, Qt::ISODate);
830 QTime time = QTime::fromString(IptcTimeDigitization, Qt::ISODate);
831 QDateTime dateTime = QDateTime(date, time);
832
833 if (dateTime.isValid())
834 {
835 qCDebug(LIBKEXIV2_LOG) << "DateTime => Iptc.Application2.DigitizationDate => " << dateTime;
836 return dateTime;
837 }
838 }
839 }
840 }
841 }
842 catch( Exiv2::Error& e )
843 {
844 d->printExiv2ExceptionError(QString::fromLatin1("Cannot parse Exif date & time tag using Exiv2 "), e);
845 }
846 catch(...)
847 {
848 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
849 }
850
851 return QDateTime();
852}
853
854bool KExiv2::setImageDateTime(const QDateTime& dateTime, bool setDateTimeDigitized, bool setProgramName) const
855{
856 if(!dateTime.isValid())
857 return false;
858
859 if (!setProgramId(setProgramName))
860 return false;
861
862 try
863 {
864 // In first we write date & time into Exif.
865
866 // DateTimeDigitized is set by slide scanners etc. when a picture is digitized.
867 // DateTimeOriginal specifies the date/time when the picture was taken.
868 // For digital cameras, these dates should be both set, and identical.
869 // Reference: https://www.exif.org/Exif2-2.PDF, chapter 4.6.5, table 4, section F.
870
871 const std::string &exifdatetime(dateTime.toString(QString::fromLatin1("yyyy:MM:dd hh:mm:ss")).toLatin1().constData());
872 d->exifMetadata()["Exif.Image.DateTime"] = exifdatetime;
873 d->exifMetadata()["Exif.Photo.DateTimeOriginal"] = exifdatetime;
874
875 if(setDateTimeDigitized)
876 d->exifMetadata()["Exif.Photo.DateTimeDigitized"] = exifdatetime;
877
878#ifdef _XMP_SUPPORT_
879
880 // In second we write date & time into Xmp.
881
882 const std::string &xmpdatetime(dateTime.toString(Qt::ISODate).toLatin1().constData());
883
884#if EXIV2_TEST_VERSION(0,28,0)
885 Exiv2::Value::UniquePtr xmpTxtVal = Exiv2::Value::create(Exiv2::xmpText);
886#else
887 Exiv2::Value::AutoPtr xmpTxtVal = Exiv2::Value::create(Exiv2::xmpText);
888#endif
889 xmpTxtVal->read(xmpdatetime);
890 d->xmpMetadata().add(Exiv2::XmpKey("Xmp.exif.DateTimeOriginal"), xmpTxtVal.get());
891 d->xmpMetadata().add(Exiv2::XmpKey("Xmp.photoshop.DateCreated"), xmpTxtVal.get());
892 d->xmpMetadata().add(Exiv2::XmpKey("Xmp.tiff.DateTime"), xmpTxtVal.get());
893 d->xmpMetadata().add(Exiv2::XmpKey("Xmp.xmp.CreateDate"), xmpTxtVal.get());
894 d->xmpMetadata().add(Exiv2::XmpKey("Xmp.xmp.MetadataDate"), xmpTxtVal.get());
895 d->xmpMetadata().add(Exiv2::XmpKey("Xmp.xmp.ModifyDate"), xmpTxtVal.get());
896 d->xmpMetadata().add(Exiv2::XmpKey("Xmp.video.DateTimeOriginal"), xmpTxtVal.get());
897 d->xmpMetadata().add(Exiv2::XmpKey("Xmp.video.DateUTC"), xmpTxtVal.get());
898 d->xmpMetadata().add(Exiv2::XmpKey("Xmp.video.ModificationDate"), xmpTxtVal.get());
899
900 if(setDateTimeDigitized)
901 {
902 d->xmpMetadata().add(Exiv2::XmpKey("Xmp.exif.DateTimeDigitized"), xmpTxtVal.get());
903 d->xmpMetadata().add(Exiv2::XmpKey("Xmp.video.DateTimeDigitized"), xmpTxtVal.get());
904 }
905
906 // Tag not updated:
907 // "Xmp.dc.DateTime" is a sequence of date relevant of dublin core change.
908 // This is not the picture date as well
909
910#endif // _XMP_SUPPORT_
911
912 // In third we write date & time into Iptc.
913
914 const std::string &iptcdate(dateTime.date().toString(Qt::ISODate).toLatin1().constData());
915 const std::string &iptctime(dateTime.time().toString(Qt::ISODate).toLatin1().constData());
916 d->iptcMetadata()["Iptc.Application2.DateCreated"] = iptcdate;
917 d->iptcMetadata()["Iptc.Application2.TimeCreated"] = iptctime;
918
919 if(setDateTimeDigitized)
920 {
921 d->iptcMetadata()["Iptc.Application2.DigitizationDate"] = iptcdate;
922 d->iptcMetadata()["Iptc.Application2.DigitizationTime"] = iptctime;
923 }
924
925 return true;
926 }
927 catch( Exiv2::Error& e )
928 {
929 d->printExiv2ExceptionError(QString::fromLatin1("Cannot set Date & Time into image using Exiv2 "), e);
930 }
931 catch(...)
932 {
933 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
934 }
935
936 return false;
937}
938
939QDateTime KExiv2::getDigitizationDateTime(bool fallbackToCreationTime) const
940{
941 try
942 {
943 // In first, trying to get Date & time from Exif tags.
944
945 if (!d->exifMetadata().empty())
946 {
947 // Try Exif date time digitized.
948
949 Exiv2::ExifData exifData(d->exifMetadata());
950 Exiv2::ExifKey key("Exif.Photo.DateTimeDigitized");
951 Exiv2::ExifData::iterator it = exifData.findKey(key);
952
953 if (it != exifData.end())
954 {
955 QDateTime dateTime = QDateTime::fromString(QString::fromLatin1(it->toString().c_str()), Qt::ISODate);
956
957 if (dateTime.isValid())
958 {
959 qCDebug(LIBKEXIV2_LOG) << "DateTime (Exif digitalized): " << dateTime.toString().toLatin1().constData();
960 return dateTime;
961 }
962 }
963 }
964
965 // In second, we trying XMP
966
967#ifdef _XMP_SUPPORT_
968
969 if (!d->xmpMetadata().empty())
970 {
971 Exiv2::XmpData xmpData(d->xmpMetadata());
972 {
973 Exiv2::XmpKey key("Xmp.exif.DateTimeDigitized");
974 Exiv2::XmpData::iterator it = xmpData.findKey(key);
975
976 if (it != xmpData.end())
977 {
978 QDateTime dateTime = QDateTime::fromString(QString::fromLatin1(it->toString().c_str()), Qt::ISODate);
979
980 if (dateTime.isValid())
981 {
982 qCDebug(LIBKEXIV2_LOG) << "DateTime (XMP-Exif digitalized): " << dateTime.toString().toLatin1().constData();
983 return dateTime;
984 }
985 }
986 }
987 {
988 Exiv2::XmpKey key("Xmp.video.DateTimeDigitized");
989 Exiv2::XmpData::iterator it = xmpData.findKey(key);
990
991 if (it != xmpData.end())
992 {
993 QDateTime dateTime = QDateTime::fromString(QString::fromLatin1(it->toString().c_str()), Qt::ISODate);
994
995 if (dateTime.isValid())
996 {
997 qCDebug(LIBKEXIV2_LOG) << "DateTime (XMP-Video digitalized): " << dateTime.toString().toLatin1().constData();
998 return dateTime;
999 }
1000 }
1001 }
1002 }
1003
1004#endif // _XMP_SUPPORT_
1005
1006 // In third, trying to get Date & time from Iptc tags.
1007
1008 if (!d->iptcMetadata().empty())
1009 {
1010 // Try digitization Iptc date time entries.
1011
1012 Exiv2::IptcData iptcData(d->iptcMetadata());
1013 Exiv2::IptcKey keyDigitizationDate("Iptc.Application2.DigitizationDate");
1014 Exiv2::IptcData::iterator it = iptcData.findKey(keyDigitizationDate);
1015
1016 if (it != iptcData.end())
1017 {
1018 QString IptcDateDigitization(QString::fromLatin1(it->toString().c_str()));
1019
1020 Exiv2::IptcKey keyDigitizationTime("Iptc.Application2.DigitizationTime");
1021 Exiv2::IptcData::iterator it2 = iptcData.findKey(keyDigitizationTime);
1022
1023 if (it2 != iptcData.end())
1024 {
1025 QString IptcTimeDigitization(QString::fromLatin1(it2->toString().c_str()));
1026
1027 QDate date = QDate::fromString(IptcDateDigitization, Qt::ISODate);
1028 QTime time = QTime::fromString(IptcTimeDigitization, Qt::ISODate);
1029 QDateTime dateTime = QDateTime(date, time);
1030
1031 if (dateTime.isValid())
1032 {
1033 qCDebug(LIBKEXIV2_LOG) << "Date (IPTC digitalized): " << dateTime.toString().toLatin1().constData();
1034 return dateTime;
1035 }
1036 }
1037 }
1038 }
1039 }
1040 catch( Exiv2::Error& e )
1041 {
1042 d->printExiv2ExceptionError(QString::fromLatin1("Cannot parse Exif digitization date & time tag using Exiv2 "), e);
1043 }
1044 catch(...)
1045 {
1046 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
1047 }
1048
1049 if (fallbackToCreationTime)
1050 return getImageDateTime();
1051 else
1052 return QDateTime();
1053}
1054
1055bool KExiv2::getImagePreview(QImage& preview) const
1056{
1057 try
1058 {
1059 // In first we trying to get from Iptc preview tag.
1060 if (preview.loadFromData(getIptcTagData("Iptc.Application2.Preview")) )
1061 return true;
1062
1063 // TODO : Added here Makernotes preview extraction when Exiv2 will be fixed for that.
1064 }
1065 catch( Exiv2::Error& e )
1066 {
1067 d->printExiv2ExceptionError(QString::fromLatin1("Cannot get image preview using Exiv2 "), e);
1068 }
1069 catch(...)
1070 {
1071 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
1072 }
1073
1074 return false;
1075}
1076
1077bool KExiv2::setImagePreview(const QImage& preview, bool setProgramName) const
1078{
1079 if (!setProgramId(setProgramName))
1080 return false;
1081
1082 if (preview.isNull())
1083 {
1084 removeIptcTag("Iptc.Application2.Preview");
1085 removeIptcTag("Iptc.Application2.PreviewFormat");
1086 removeIptcTag("Iptc.Application2.PreviewVersion");
1087 return true;
1088 }
1089
1090 try
1091 {
1092 QByteArray data;
1093 QBuffer buffer(&data);
1094 buffer.open(QIODevice::WriteOnly);
1095
1096 // A little bit compressed preview jpeg image to limit IPTC size.
1097 preview.save(&buffer, "JPEG");
1098 qCDebug(LIBKEXIV2_LOG) << "JPEG image preview size: (" << preview.width() << " x "
1099 << preview.height() << ") pixels - " << data.size() << " bytes";
1100
1101 Exiv2::DataValue val;
1102 val.read((Exiv2::byte *)data.data(), data.size());
1103 d->iptcMetadata()["Iptc.Application2.Preview"] = val;
1104
1105 // See https://www.iptc.org/std/IIM/4.1/specification/IIMV4.1.pdf Appendix A for details.
1106 d->iptcMetadata()["Iptc.Application2.PreviewFormat"] = 11; // JPEG
1107 d->iptcMetadata()["Iptc.Application2.PreviewVersion"] = 1;
1108
1109 return true;
1110 }
1111 catch( Exiv2::Error& e )
1112 {
1113 d->printExiv2ExceptionError(QString::fromLatin1("Cannot get image preview using Exiv2 "), e);
1114 }
1115 catch(...)
1116 {
1117 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
1118 }
1119
1120 return false;
1121}
1122
1123} // NameSpace KExiv2Iface
KExiv2Iface::KExiv2::getXmpTagString
QString getXmpTagString(const char *xmpTagName, bool escapeCR=true) const
Get a Xmp tag content like a string.
Definition kexiv2xmp.cpp:336
KExiv2Iface::KExiv2::getExifTagLong
bool getExifTagLong(const char *exifTagName, long &val) const
Get an Exif tag content like a long value.
Definition kexiv2exif.cpp:664
KExiv2Iface::KExiv2::getImageOrientation
KExiv2::ImageOrientation getImageOrientation() const
Return the image orientation set in Exif metadata.
Definition kexiv2image.cpp:241
KExiv2Iface::KExiv2::setProgramId
virtual bool setProgramId(bool on=true) const
Re-implement this method to set automatically the Program Name and Program Version information in Exi...
Definition kexiv2.cpp:526
KExiv2Iface::KExiv2::getImageColorWorkSpace
KExiv2::ImageColorWorkSpace getImageColorWorkSpace() const
Return the image color-space set in Exif metadata.
Definition kexiv2image.cpp:435
KExiv2Iface::KExiv2::setImagePreview
virtual bool setImagePreview(const QImage &preview, bool setProgramName=true) const
Set the Iptc preview image.
Definition kexiv2image.cpp:1077
KExiv2Iface::KExiv2::setImageColorWorkSpace
bool setImageColorWorkSpace(ImageColorWorkSpace workspace, bool setProgramName=true) const
Set the Exif color-space tag of image.
Definition kexiv2image.cpp:515
KExiv2Iface::KExiv2::getExifTagString
QString getExifTagString(const char *exifTagName, bool escapeCR=true) const
Get an Exif tags content like a string.
Definition kexiv2exif.cpp:834
KExiv2Iface::KExiv2::ImageOrientation
ImageOrientation
The image orientation values given by Exif metadata.
Definition kexiv2.h:86
KExiv2Iface::KExiv2::getImagePreview
bool getImagePreview(QImage &preview) const
Return a QImage copy of Iptc preview image.
Definition kexiv2image.cpp:1055
KExiv2Iface::KExiv2::getDigitizationDateTime
QDateTime getDigitizationDateTime(bool fallbackToCreationTime=false) const
Return the digitization time stamp of the image.
Definition kexiv2image.cpp:939
KExiv2Iface::KExiv2::ImageColorWorkSpace
ImageColorWorkSpace
The image color workspace values given by Exif metadata.
Definition kexiv2.h:76
KExiv2Iface::KExiv2::setImageDimensions
bool setImageDimensions(const QSize &size, bool setProgramName=true) const
Set the size of image in pixels in Exif tags.
Definition kexiv2image.cpp:201
KExiv2Iface::KExiv2::version
static QString version()
Return a string version of libkexiv2 release.
Definition kexiv2.cpp:140
KExiv2Iface::KExiv2::getImageDimensions
QSize getImageDimensions() const
Return the size of image in pixels using Exif tags.
Definition kexiv2image.cpp:84
KExiv2Iface::KExiv2::getXmpTagVariant
QVariant getXmpTagVariant(const char *xmpTagName, bool rationalAsListOfInts=true, bool stringEscapeCR=true) const
Get an Xmp tag content as a QVariant.
Definition kexiv2xmp.cpp:944
KExiv2Iface::KExiv2::getImageDateTime
QDateTime getImageDateTime() const
Return the time stamp of image.
Definition kexiv2image.cpp:548
KExiv2Iface::KExiv2::removeIptcTag
bool removeIptcTag(const char *iptcTagName, bool setProgramName=true) const
Remove the all instance of Iptc tags 'iptcTagName' from Iptc metadata.
Definition kexiv2iptc.cpp:294
KExiv2Iface::KExiv2::getIptcTagData
QByteArray getIptcTagData(const char *iptcTagName) const
Get an Iptc tag content as a bytes array.
Definition kexiv2iptc.cpp:360
KExiv2Iface::KExiv2::setImageOrientation
bool setImageOrientation(ImageOrientation orientation, bool setProgramName=true) const
Set the Exif orientation tag of image.
Definition kexiv2image.cpp:354
KExiv2Iface::KExiv2::setImageProgramId
bool setImageProgramId(const QString &program, const QString &version) const
Set Program name and program version in Exif and Iptc Metadata.
Definition kexiv2image.cpp:23
KExiv2Iface::KExiv2::setXmpTagString
bool setXmpTagString(const char *xmpTagName, const QString &value, bool setProgramName=true) const
Set a Xmp tag content using a string.
Definition kexiv2xmp.cpp:377
KExiv2Iface::KExiv2::setImageDateTime
bool setImageDateTime(const QDateTime &dateTime, bool setDateTimeDigitized=false, bool setProgramName=true) const
Set the Exif and Iptc time stamp.
Definition kexiv2image.cpp:854
KExiv2Iface::RotationMatrix::exifOrientation
KExiv2::ImageOrientation exifOrientation() const
Returns the Exif orienation flag describing this matrix.
Definition rotationmatrix.cpp:231
KExiv2Iface
KExiv2Iface - Exiv2 library interface.
Definition kexiv2.cpp:17
QBuffer::open
virtual bool open(OpenMode flags) override
QByteArray::constData
const char * constData() const const
QByteArray::data
char * data()
QByteArray::size
qsizetype size() const const
QDate::fromString
QDate fromString(QStringView string, QStringView format, QCalendar cal)
QDate::toString
QString toString(QStringView format, QCalendar cal) const const
QDateTime::date
QDate date() const const
QDateTime::fromString
QDateTime fromString(QStringView string, QStringView format, QCalendar cal)
QDateTime::isValid
bool isValid() const const
QDateTime::time
QTime time() const const
QDateTime::toString
QString toString(QStringView format, QCalendar cal) const const
QImage::height
int height() const const
QImage::isNull
bool isNull() const const
QImage::loadFromData
bool loadFromData(QByteArrayView data, const char *format)
QImage::save
bool save(QIODevice *device, const char *format, int quality) const const
QImage::width
int width() const const
QSize::height
int height() const const
QSize::width
int width() const const
QString::append
QString & append(QChar ch)
QString::fromLatin1
QString fromLatin1(QByteArrayView str)
QString::isEmpty
bool isEmpty() const const
QString::isNull
bool isNull() const const
QString::number
QString number(double n, char format, int precision)
QString::toInt
int toInt(bool *ok, int base) const const
QString::toLatin1
QByteArray toLatin1() const const
QString::toLong
long toLong(bool *ok, int base) const const
QTime::fromString
QTime fromString(QStringView string, QStringView format)
QTime::toString
QString toString(QStringView format) const const
QVariant::isNull
bool isNull() const const
QVariant::toInt
int toInt(bool *ok) const const
This file is part of the KDE documentation.
Documentation copyright © 1996-2024 The KDE developers.
Generated on Tue Mar 26 2024 11:16:02 by doxygen 1.10.0 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.