KExiv2

kexiv2exif.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// C++ includes
12
13#include <cctype>
14
15// Qt includes
16
17#include <QBuffer>
18
19// Local includes
20
21#include "rotationmatrix.h"
22#include "libkexiv2_debug.h"
23
24namespace KExiv2Iface
25{
26
27bool KExiv2::canWriteExif(const QString& filePath)
28{
29 try
30 {
31#if EXIV2_TEST_VERSION(0,28,0)
32 Exiv2::Image::UniquePtr image =
33#else
34 Exiv2::Image::AutoPtr image =
35#endif
36 Exiv2::ImageFactory::open((const char*)
37 (QFile::encodeName(filePath).constData()));
38
39 Exiv2::AccessMode mode = image->checkMode(Exiv2::mdExif);
40
41 return (mode == Exiv2::amWrite || mode == Exiv2::amReadWrite);
42 }
43 catch( Exiv2::Error& e )
44 {
45 std::string s(e.what());
46 qCCritical(LIBKEXIV2_LOG) << "Cannot check Exif access mode using Exiv2 (Error #"
47#if EXIV2_TEST_VERSION(0,28,0)
48 << Exiv2::Error(e.code()).what()
49#else
50 << e.code() << ": " << s.c_str()
51#endif
52 << ")";
53 }
54 catch(...)
55 {
56 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
57 }
58
59 return false;
60}
61
62bool KExiv2::hasExif() const
63{
64 return !d->exifMetadata().empty();
65}
66
67bool KExiv2::clearExif() const
68{
69 try
70 {
71 d->exifMetadata().clear();
72 return true;
73 }
74 catch( Exiv2::Error& e )
75 {
76 d->printExiv2ExceptionError(QString::fromLatin1("Cannot clear Exif data using Exiv2 "), e);
77 }
78 catch(...)
79 {
80 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
81 }
82
83 return false;
84}
85
86QByteArray KExiv2::getExifEncoded(bool addExifHeader) const
87{
88 try
89 {
90 if (!d->exifMetadata().empty())
91 {
92 QByteArray data;
93 Exiv2::ExifData& exif = d->exifMetadata();
94 Exiv2::Blob blob;
95 Exiv2::ExifParser::encode(blob, Exiv2::bigEndian, exif);
96 QByteArray ba((const char*)&blob[0], blob.size());
97
98 if (addExifHeader)
99 {
100 const uchar ExifHeader[] = {0x45, 0x78, 0x69, 0x66, 0x00, 0x00};
101 data.resize(ba.size() + sizeof(ExifHeader));
102 memcpy(data.data(), ExifHeader, sizeof(ExifHeader));
103 memcpy(data.data() + sizeof(ExifHeader), ba.data(), ba.size());
104 }
105 else
106 {
107 data = ba;
108 }
109 return data;
110 }
111 }
112 catch( Exiv2::Error& e )
113 {
114 if (!d->filePath.isEmpty())
115 qCDebug(LIBKEXIV2_LOG) << "From file " << d->filePath.toLatin1().constData();
116
117 d->printExiv2ExceptionError(QString::fromLatin1("Cannot get Exif data using Exiv2 "), e);
118 }
119 catch(...)
120 {
121 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
122 }
123
124 return QByteArray();
125}
126
127bool KExiv2::setExif(const QByteArray& data) const
128{
129 try
130 {
131 if (!data.isEmpty())
132 {
133 Exiv2::ExifParser::decode(d->exifMetadata(), (const Exiv2::byte*)data.data(), data.size());
134 return (!d->exifMetadata().empty());
135 }
136 }
137 catch( Exiv2::Error& e )
138 {
139 if (!d->filePath.isEmpty())
140 qCCritical(LIBKEXIV2_LOG) << "From file " << d->filePath.toLatin1().constData();
141
142 d->printExiv2ExceptionError(QString::fromLatin1("Cannot set Exif data using Exiv2 "), e);
143 }
144 catch(...)
145 {
146 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
147 }
148
149 return false;
150}
151
152KExiv2::MetaDataMap KExiv2::getExifTagsDataList(const QStringList& exifKeysFilter, bool invertSelection) const
153{
154 if (d->exifMetadata().empty())
155 return MetaDataMap();
156
157 try
158 {
159 Exiv2::ExifData exifData = d->exifMetadata();
160 exifData.sortByKey();
161
162 QString ifDItemName;
163 MetaDataMap metaDataMap;
164
165 for (Exiv2::ExifData::iterator md = exifData.begin(); md != exifData.end(); ++md)
166 {
167 QString key = QString::fromLatin1(md->key().c_str());
168
169 // Decode the tag value with a user friendly output.
170 QString tagValue;
171
172 if (key == QString::fromLatin1("Exif.Photo.UserComment"))
173 {
174 tagValue = d->convertCommentValue(*md);
175 }
176 else if (key == QString::fromLatin1("Exif.Image.0x935c"))
177 {
178 tagValue = QString::number(md->value().size());
179 }
180 else
181 {
182 std::ostringstream os;
183 os << *md;
184
185 // Exif tag contents can be an translated strings, no only simple ascii.
186 tagValue = QString::fromLocal8Bit(os.str().c_str());
187 }
188
189 tagValue.replace(QString::fromLatin1("\n"), QString::fromLatin1(" "));
190
191 // We apply a filter to get only the Exif tags that we need.
192
193 if (!exifKeysFilter.isEmpty())
194 {
195 if (!invertSelection)
196 {
197 if (exifKeysFilter.contains(key.section(QString::fromLatin1("."), 1, 1)))
198 metaDataMap.insert(key, tagValue);
199 }
200 else
201 {
202 if (!exifKeysFilter.contains(key.section(QString::fromLatin1("."), 1, 1)))
203 metaDataMap.insert(key, tagValue);
204 }
205 }
206 else // else no filter at all.
207 {
208 metaDataMap.insert(key, tagValue);
209 }
210 }
211
212 return metaDataMap;
213 }
214 catch (Exiv2::Error& e)
215 {
216 d->printExiv2ExceptionError(QString::fromLatin1("Cannot parse EXIF metadata using Exiv2 "), e);
217 }
218 catch(...)
219 {
220 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
221 }
222
223 return MetaDataMap();
224}
225
226QString KExiv2::getExifComment() const
227{
228 try
229 {
230 if (!d->exifMetadata().empty())
231 {
232 Exiv2::ExifData exifData(d->exifMetadata());
233 Exiv2::ExifKey key("Exif.Photo.UserComment");
234 Exiv2::ExifData::iterator it = exifData.findKey(key);
235
236 if (it != exifData.end())
237 {
238 QString exifComment = d->convertCommentValue(*it);
239
240 // some cameras fill the UserComment with whitespace
241 if (!exifComment.isEmpty() && !exifComment.trimmed().isEmpty())
242 return exifComment;
243 }
244
245 Exiv2::ExifKey key2("Exif.Image.ImageDescription");
246 Exiv2::ExifData::iterator it2 = exifData.findKey(key2);
247
248 if (it2 != exifData.end())
249 {
250 QString exifComment = d->convertCommentValue(*it2);
251
252 // Some cameras fill in nonsense default values
253 QStringList blackList;
254 blackList << QString::fromLatin1("SONY DSC"); // + whitespace
255 blackList << QString::fromLatin1("OLYMPUS DIGITAL CAMERA");
256 blackList << QString::fromLatin1("MINOLTA DIGITAL CAMERA");
257
258 QString trimmedComment = exifComment.trimmed();
259
260 // some cameras fill the UserComment with whitespace
261 if (!exifComment.isEmpty() && !trimmedComment.isEmpty() && !blackList.contains(trimmedComment))
262 return exifComment;
263 }
264 }
265 }
266 catch( Exiv2::Error& e )
267 {
268 d->printExiv2ExceptionError(QString::fromLatin1("Cannot find Exif User Comment using Exiv2 "), e);
269 }
270 catch(...)
271 {
272 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
273 }
274
275 return QString();
276}
277
278static bool is7BitAscii(const QString& s)
279{
280 return std::all_of(s.begin(), s.end(), [](QChar c) { return c.unicode() <= 0x7f; });
281}
282
283bool KExiv2::setExifComment(const QString& comment, bool setProgramName) const
284{
285 if (!setProgramId(setProgramName))
286 return false;
287
288 try
289 {
290 removeExifTag("Exif.Image.ImageDescription");
291 removeExifTag("Exif.Photo.UserComment");
292
293 if (!comment.isNull())
294 {
295 setExifTagString("Exif.Image.ImageDescription", comment, setProgramName);
296
297 // Write as Unicode only when necessary.
298 if (is7BitAscii(comment))
299 {
300 // write as ASCII
301 std::string exifComment("charset=\"Ascii\" ");
302 exifComment += comment.toLatin1().constData();
303 d->exifMetadata()["Exif.Photo.UserComment"] = exifComment;
304 return true;
305 }
306 // write as Unicode (UCS-2)
307 std::string exifComment("charset=\"Unicode\" ");
308 exifComment += comment.toUtf8().constData();
309 d->exifMetadata()["Exif.Photo.UserComment"] = exifComment;
310 }
311
312 return true;
313 }
314 catch( Exiv2::Error& e )
315 {
316 d->printExiv2ExceptionError(QString::fromLatin1("Cannot set Exif Comment using Exiv2 "), e);
317 }
318 catch(...)
319 {
320 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
321 }
322
323 return false;
324}
325
326QString KExiv2::getExifTagTitle(const char* exifTagName)
327{
328 try
329 {
330 std::string exifkey(exifTagName);
331 Exiv2::ExifKey ek(exifkey);
332
333 return QString::fromLocal8Bit( ek.tagLabel().c_str() );
334 }
335 catch (Exiv2::Error& e)
336 {
337 d->printExiv2ExceptionError(QString::fromLatin1("Cannot get metadata tag title using Exiv2 "), e);
338 }
339 catch(...)
340 {
341 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
342 }
343
344 return QString();
345}
346
347QString KExiv2::getExifTagDescription(const char* exifTagName)
348{
349 try
350 {
351 std::string exifkey(exifTagName);
352 Exiv2::ExifKey ek(exifkey);
353
354 return QString::fromLocal8Bit( ek.tagDesc().c_str() );
355 }
356 catch (Exiv2::Error& e)
357 {
358 d->printExiv2ExceptionError(QString::fromLatin1("Cannot get metadata tag description using Exiv2 "), e);
359 }
360 catch(...)
361 {
362 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
363 }
364
365 return QString();
366}
367
368bool KExiv2::removeExifTag(const char* exifTagName, bool setProgramName) const
369{
370 if (!setProgramId(setProgramName))
371 return false;
372
373 try
374 {
375 Exiv2::ExifKey exifKey(exifTagName);
376 Exiv2::ExifData::iterator it = d->exifMetadata().findKey(exifKey);
377
378 if (it != d->exifMetadata().end())
379 {
380 d->exifMetadata().erase(it);
381 return true;
382 }
383 }
384 catch( Exiv2::Error& e )
385 {
386 d->printExiv2ExceptionError(QString::fromLatin1("Cannot remove Exif tag using Exiv2 "), e);
387 }
388 catch(...)
389 {
390 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
391 }
392
393 return false;
394}
395
396bool KExiv2::getExifTagRational(const char* exifTagName, long int& num, long int& den, int component) const
397{
398 try
399 {
400 Exiv2::ExifKey exifKey(exifTagName);
401 Exiv2::ExifData exifData(d->exifMetadata());
402 Exiv2::ExifData::iterator it = exifData.findKey(exifKey);
403
404 if (it != exifData.end())
405 {
406 num = (*it).toRational(component).first;
407 den = (*it).toRational(component).second;
408
409 return true;
410 }
411 }
412 catch( Exiv2::Error& e )
413 {
414 d->printExiv2ExceptionError(QString::fromLatin1("Cannot find Exif Rational value from key '%1' into image using Exiv2 ").arg(QString::fromLatin1(exifTagName)), e);
415 }
416 catch(...)
417 {
418 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
419 }
420
421 return false;
422}
423
424bool KExiv2::setExifTagLong(const char* exifTagName, long val, bool setProgramName) const
425{
426 if (!setProgramId(setProgramName))
427 return false;
428
429 try
430 {
431 d->exifMetadata()[exifTagName] = static_cast<int32_t>(val);
432 return true;
433 }
434 catch( Exiv2::Error& e )
435 {
436 d->printExiv2ExceptionError(QString::fromLatin1("Cannot set Exif tag long value into image using Exiv2 "), e);
437 }
438 catch(...)
439 {
440 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
441 }
442
443 return false;
444}
445
446bool KExiv2::setExifTagRational(const char* exifTagName, long int num, long int den, bool setProgramName) const
447{
448 if (!setProgramId(setProgramName))
449 return false;
450
451 try
452 {
453 d->exifMetadata()[exifTagName] = Exiv2::Rational(num, den);
454 return true;
455 }
456 catch( Exiv2::Error& e )
457 {
458 d->printExiv2ExceptionError(QString::fromLatin1("Cannot set Exif tag rational value into image using Exiv2 "), e);
459 }
460 catch(...)
461 {
462 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
463 }
464
465 return false;
466}
467
468bool KExiv2::setExifTagData(const char* exifTagName, const QByteArray& data, bool setProgramName) const
469{
470 if (data.isEmpty())
471 return false;
472
473 if (!setProgramId(setProgramName))
474 return false;
475
476 try
477 {
478 Exiv2::DataValue val((Exiv2::byte*)data.data(), data.size());
479 d->exifMetadata()[exifTagName] = val;
480 return true;
481 }
482 catch( Exiv2::Error& e )
483 {
484 d->printExiv2ExceptionError(QString::fromLatin1("Cannot set Exif tag data into image using Exiv2 "), e);
485 }
486 catch(...)
487 {
488 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
489 }
490
491 return false;
492}
493
494bool KExiv2::setExifTagVariant(const char* exifTagName, const QVariant& val,
495 bool rationalWantSmallDenominator, bool setProgramName) const
496{
497#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
498 switch (val.metaType().id())
499#else
500 switch (val.type())
501#endif
502 {
503 case QMetaType::Int:
504 case QMetaType::UInt:
505 case QMetaType::Bool:
506 case QMetaType::LongLong:
507 case QMetaType::ULongLong:
508 return setExifTagLong(exifTagName, val.toInt(), setProgramName);
509
510 case QMetaType::Double:
511 {
512 long num, den;
513
514 if (rationalWantSmallDenominator)
515 convertToRationalSmallDenominator(val.toDouble(), &num, &den);
516 else
517 convertToRational(val.toDouble(), &num, &den, 4);
518
519 return setExifTagRational(exifTagName, num, den, setProgramName);
520 }
521 case QMetaType::QVariantList:
522 {
523 long num = 0, den = 1;
524 QList<QVariant> list = val.toList();
525
526 if (list.size() >= 1)
527 num = list[0].toInt();
528
529 if (list.size() >= 2)
530 den = list[1].toInt();
531
532 return setExifTagRational(exifTagName, num, den, setProgramName);
533 }
534
535 case QMetaType::QDate:
536 case QMetaType::QDateTime:
537 {
538 QDateTime dateTime = val.toDateTime();
539
540 if(!dateTime.isValid())
541 return false;
542
543 if (!setProgramId(setProgramName))
544 return false;
545
546 try
547 {
548 const std::string &exifdatetime(dateTime.toString(QString::fromLatin1("yyyy:MM:dd hh:mm:ss")).toLatin1().constData());
549 d->exifMetadata()[exifTagName] = exifdatetime;
550 }
551 catch( Exiv2::Error &e )
552 {
553 d->printExiv2ExceptionError(QString::fromLatin1("Cannot set Date & Time in image using Exiv2 "), e);
554 }
555 catch(...)
556 {
557 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
558 }
559
560 return false;
561 }
562
563 case QMetaType::QString:
564 case QMetaType::QChar:
565 return setExifTagString(exifTagName, val.toString(), setProgramName);
566
567 case QMetaType::QByteArray:
568 return setExifTagData(exifTagName, val.toByteArray(), setProgramName);
569 default:
570 break;
571 }
572 return false;
573}
574
575QString KExiv2::createExifUserStringFromValue(const char* exifTagName, const QVariant& val, bool escapeCR)
576{
577 try
578 {
579 Exiv2::ExifKey key(exifTagName);
580 Exiv2::Exifdatum datum(key);
581
582#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
583 switch (val.metaType().id())
584#else
585 switch (val.type())
586#endif
587 {
588 case QMetaType::Int:
589 case QMetaType::Bool:
590 case QMetaType::LongLong:
591 case QMetaType::ULongLong:
592 datum = (int32_t)val.toInt();
593 break;
594 case QMetaType::UInt:
595 datum = (uint32_t)val.toUInt();
596 break;
597
598 case QMetaType::Double:
599 {
600 long num, den;
601 convertToRationalSmallDenominator(val.toDouble(), &num, &den);
602 Exiv2::Rational rational;
603 rational.first = num;
604 rational.second = den;
605 datum = rational;
606 break;
607 }
608 case QMetaType::QVariantList:
609 {
610 long num = 0, den = 1;
611 QList<QVariant> list = val.toList();
612 if (list.size() >= 1)
613 num = list[0].toInt();
614 if (list.size() >= 2)
615 den = list[1].toInt();
616 Exiv2::Rational rational;
617 rational.first = num;
618 rational.second = den;
619 datum = rational;
620 break;
621 }
622
623 case QMetaType::QDate:
624 case QMetaType::QDateTime:
625 {
626 QDateTime dateTime = val.toDateTime();
627 if(!dateTime.isValid())
628 break;
629
630 const std::string &exifdatetime(dateTime.toString(QString::fromLatin1("yyyy:MM:dd hh:mm:ss")).toLatin1().constData());
631 datum = exifdatetime;
632 break;
633 }
634
635 case QMetaType::QString:
636 case QMetaType::QChar:
637 datum = (std::string)val.toString().toLatin1().constData();
638 break;
639 default:
640 break;
641 }
642
643 std::ostringstream os;
644 os << datum;
645 QString tagValue = QString::fromLocal8Bit(os.str().c_str());
646
647 if (escapeCR)
648 tagValue.replace(QString::fromLatin1("\n"), QString::fromLatin1(" "));
649
650 return tagValue;
651 }
652 catch( Exiv2::Error& e )
653 {
654 d->printExiv2ExceptionError(QString::fromLatin1("Cannot set Iptc tag string into image using Exiv2 "), e);
655 }
656 catch(...)
657 {
658 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
659 }
660
661 return QString();
662}
663
664bool KExiv2::getExifTagLong(const char* exifTagName, long& val) const
665{
666 return getExifTagLong(exifTagName, val, 0);
667}
668
669bool KExiv2::getExifTagLong(const char* exifTagName, long& val, int component) const
670{
671 try
672 {
673 Exiv2::ExifKey exifKey(exifTagName);
674 Exiv2::ExifData exifData(d->exifMetadata());
675 Exiv2::ExifData::iterator it = exifData.findKey(exifKey);
676
677 if (it != exifData.end() && it->count() > 0)
678 {
679#if EXIV2_TEST_VERSION(0,28,0)
680 val = it->toUint32(component);
681#else
682 val = it->toLong(component);
683#endif
684 return true;
685 }
686 }
687 catch( Exiv2::Error& e )
688 {
689 d->printExiv2ExceptionError(QString::fromLatin1("Cannot find Exif key '%1' into image using Exiv2 ").arg(QString::fromLatin1(exifTagName)), e);
690 }
691 catch(...)
692 {
693 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
694 }
695
696 return false;
697}
698
699QByteArray KExiv2::getExifTagData(const char* exifTagName) const
700{
701 try
702 {
703 Exiv2::ExifKey exifKey(exifTagName);
704 Exiv2::ExifData exifData(d->exifMetadata());
705 Exiv2::ExifData::iterator it = exifData.findKey(exifKey);
706
707 if (it != exifData.end())
708 {
709 char* const s = new char[(*it).size()];
710 (*it).copy((Exiv2::byte*)s, Exiv2::bigEndian);
711 QByteArray data(s, (*it).size());
712 delete[] s;
713
714 return data;
715 }
716 }
717 catch( Exiv2::Error& e )
718 {
719 d->printExiv2ExceptionError(QString::fromLatin1("Cannot find Exif key '%1' into image using Exiv2 ").arg(QString::fromLatin1(exifTagName)), e);
720 }
721 catch(...)
722 {
723 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
724 }
725
726 return QByteArray();
727}
728
729QVariant KExiv2::getExifTagVariant(const char* exifTagName, bool rationalAsListOfInts, bool stringEscapeCR, int component) const
730{
731 try
732 {
733 Exiv2::ExifKey exifKey(exifTagName);
734 Exiv2::ExifData exifData(d->exifMetadata());
735 Exiv2::ExifData::iterator it = exifData.findKey(exifKey);
736
737 if (it != exifData.end())
738 {
739 switch (it->typeId())
740 {
741 case Exiv2::unsignedByte:
742 case Exiv2::unsignedShort:
743 case Exiv2::unsignedLong:
744 case Exiv2::signedShort:
745 case Exiv2::signedLong:
746 if (it->count() > component)
747#if EXIV2_TEST_VERSION(0,28,0)
748 return QVariant((int)it->toUint32(component));
749#else
750 return QVariant((int)it->toLong(component));
751#endif
752 else
753#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
754 return QVariant(QMetaType(QMetaType::Int));
755#else
756 return QVariant(QVariant::Int);
757#endif
758 case Exiv2::unsignedRational:
759 case Exiv2::signedRational:
760
761 if (rationalAsListOfInts)
762 {
763 if (it->count() <= component)
764#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
765 return QVariant(QMetaType(QMetaType::QVariantList));
766#else
767 return QVariant(QVariant::List);
768#endif
769
770 QList<QVariant> list;
771 list << (*it).toRational(component).first;
772 list << (*it).toRational(component).second;
773
774 return QVariant(list);
775 }
776 else
777 {
778 if (it->count() <= component)
779#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
780 return QVariant(QMetaType(QMetaType::Double));
781#else
782 return QVariant(QVariant::Double);
783#endif
784
785 // prefer double precision
786 double num = (*it).toRational(component).first;
787 double den = (*it).toRational(component).second;
788
789 if (den == 0.0)
790#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
791 return QVariant(QMetaType(QMetaType::Double));
792#else
793 return QVariant(QVariant::Double);
794#endif
795
796 return QVariant(num / den);
797 }
798 case Exiv2::date:
799 case Exiv2::time:
800 {
801 QDateTime dateTime = QDateTime::fromString(QString::fromLatin1(it->toString().c_str()), Qt::ISODate);
802 return QVariant(dateTime);
803 }
804 case Exiv2::asciiString:
805 case Exiv2::comment:
806 case Exiv2::string:
807 {
808 std::ostringstream os;
809 os << *it;
810 QString tagValue = QString::fromLocal8Bit(os.str().c_str());
811
812 if (stringEscapeCR)
813 tagValue.replace(QString::fromLatin1("\n"), QString::fromLatin1(" "));
814
815 return QVariant(tagValue);
816 }
817 default:
818 break;
819 }
820 }
821 }
822 catch( Exiv2::Error& e )
823 {
824 d->printExiv2ExceptionError(QString::fromLatin1("Cannot find Exif key '%1' in the image using Exiv2 ").arg(QString::fromLatin1(exifTagName)), e);
825 }
826 catch(...)
827 {
828 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
829 }
830
831 return QVariant();
832}
833
834QString KExiv2::getExifTagString(const char* exifTagName, bool escapeCR) const
835{
836 try
837 {
838 Exiv2::ExifKey exifKey(exifTagName);
839 Exiv2::ExifData exifData(d->exifMetadata());
840 Exiv2::ExifData::iterator it = exifData.findKey(exifKey);
841
842 if (it != exifData.end())
843 {
844 // See B.K.O #184156 comment #13
845 std::string val = it->print(&exifData);
846 QString tagValue = QString::fromLocal8Bit(val.c_str());
847
848 if (escapeCR)
849 tagValue.replace(QString::fromLatin1("\n"), QString::fromLatin1(" "));
850
851 return tagValue;
852 }
853 }
854 catch( Exiv2::Error& e )
855 {
856 d->printExiv2ExceptionError(QString::fromLatin1("Cannot find Exif key '%1' into image using Exiv2 ").arg(QString::fromLatin1(exifTagName)), e);
857 }
858 catch(...)
859 {
860 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
861 }
862
863 return QString();
864}
865
866bool KExiv2::setExifTagString(const char* exifTagName, const QString& value, bool setProgramName) const
867{
868 if (!setProgramId(setProgramName))
869 return false;
870
871 try
872 {
873 d->exifMetadata()[exifTagName] = std::string(value.toLatin1().constData());
874 return true;
875 }
876 catch( Exiv2::Error& e )
877 {
878 d->printExiv2ExceptionError(QString::fromLatin1("Cannot set Exif tag string into image using Exiv2 "), e);
879 }
880 catch(...)
881 {
882 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
883 }
884
885 return false;
886}
887
888QImage KExiv2::getExifThumbnail(bool fixOrientation) const
889{
890 QImage thumbnail;
891
892 if (d->exifMetadata().empty())
893 return thumbnail;
894
895 try
896 {
897 Exiv2::ExifThumbC thumb(d->exifMetadata());
898 Exiv2::DataBuf const c1 = thumb.copy();
899#if EXIV2_TEST_VERSION(0,28,0)
900 thumbnail.loadFromData(c1.c_data(), c1.size());
901#else
902 thumbnail.loadFromData(c1.pData_, c1.size_);
903#endif
904
905 if (!thumbnail.isNull())
906 {
907 if (fixOrientation)
908 {
909 Exiv2::ExifKey key1("Exif.Thumbnail.Orientation");
910 Exiv2::ExifKey key2("Exif.Image.Orientation");
911 Exiv2::ExifData exifData(d->exifMetadata());
912 Exiv2::ExifData::iterator it = exifData.findKey(key1);
913
914 if (it == exifData.end())
915 it = exifData.findKey(key2);
916
917 if (it != exifData.end() && it->count())
918 {
919#if EXIV2_TEST_VERSION(0,28,0)
920 long orientation = it->toUint32();
921#else
922 long orientation = it->toLong();
923#endif
924 qCDebug(LIBKEXIV2_LOG) << "Exif Thumbnail Orientation: " << (int)orientation;
925 rotateExifQImage(thumbnail, (ImageOrientation)orientation);
926 }
927
928 return thumbnail;
929 }
930 }
931 }
932 catch( Exiv2::Error& e )
933 {
934 d->printExiv2ExceptionError(QString::fromLatin1("Cannot get Exif Thumbnail using Exiv2 "), e);
935 }
936 catch(...)
937 {
938 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
939 }
940
941 return thumbnail;
942}
943
944bool KExiv2::rotateExifQImage(QImage& image, ImageOrientation orientation) const
945{
946 QTransform matrix = RotationMatrix::toTransform(orientation);
947
948 if ((orientation != ORIENTATION_NORMAL) && (orientation != ORIENTATION_UNSPECIFIED))
949 {
950 image = image.transformed(matrix);
951 return true;
952 }
953
954 return false;
955}
956
957bool KExiv2::setExifThumbnail(const QImage& thumbImage, bool setProgramName) const
958{
959 if (!setProgramId(setProgramName))
960 return false;
961
962 if (thumbImage.isNull())
963 {
964 return removeExifThumbnail();
965 }
966
967 try
968 {
969 QByteArray data;
970 QBuffer buffer(&data);
971 buffer.open(QIODevice::WriteOnly);
972 thumbImage.save(&buffer, "JPEG");
973 Exiv2::ExifThumb thumb(d->exifMetadata());
974 thumb.setJpegThumbnail((Exiv2::byte *)data.data(), data.size());
975 return true;
976 }
977 catch( Exiv2::Error& e )
978 {
979 d->printExiv2ExceptionError(QString::fromLatin1("Cannot set Exif Thumbnail using Exiv2 "), e);
980 }
981 catch(...)
982 {
983 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
984 }
985
986 return false;
987}
988
989bool KExiv2::setTiffThumbnail(const QImage& thumbImage, bool setProgramName) const
990{
991 if (!setProgramId(setProgramName))
992 return false;
993
994 removeExifThumbnail();
995
996 try
997 {
998 // Make sure IFD0 is explicitly marked as a main image
999 Exiv2::ExifData::const_iterator pos = d->exifMetadata().findKey(Exiv2::ExifKey("Exif.Image.NewSubfileType"));
1000
1001#if EXIV2_TEST_VERSION(0,28,0)
1002 if (pos == d->exifMetadata().end() || pos->count() != 1 || pos->toUint32() != 0)
1003#else
1004 if (pos == d->exifMetadata().end() || pos->count() != 1 || pos->toLong() != 0)
1005#endif
1006 {
1007#if EXIV2_TEST_VERSION(0,28,0)
1008 throw Exiv2::Error(Exiv2::ErrorCode::kerErrorMessage, "Exif.Image.NewSubfileType missing or not set as main image");
1009#elif EXIV2_TEST_VERSION(0,27,0)
1010 throw Exiv2::Error(Exiv2::kerErrorMessage, "Exif.Image.NewSubfileType missing or not set as main image");
1011#else
1012 throw Exiv2::Error(1, "Exif.Image.NewSubfileType missing or not set as main image");
1013#endif
1014 }
1015
1016 // Remove sub-IFD tags
1017 std::string subImage1("SubImage1");
1018
1019 for (Exiv2::ExifData::iterator md = d->exifMetadata().begin(); md != d->exifMetadata().end();)
1020 {
1021 if (md->groupName() == subImage1)
1022 md = d->exifMetadata().erase(md);
1023 else
1024 ++md;
1025 }
1026
1027 if (!thumbImage.isNull())
1028 {
1029 // Set thumbnail tags
1030 QByteArray data;
1031 QBuffer buffer(&data);
1032 buffer.open(QIODevice::WriteOnly);
1033 thumbImage.save(&buffer, "JPEG");
1034
1035 Exiv2::DataBuf buf((Exiv2::byte *)data.data(), data.size());
1036 Exiv2::ULongValue val;
1037 val.read("0");
1038#if EXIV2_TEST_VERSION(0,28,0)
1039 val.setDataArea(buf.c_data(), buf.size());
1040#else
1041 val.setDataArea(buf.pData_, buf.size_);
1042#endif
1043 d->exifMetadata()["Exif.SubImage1.JPEGInterchangeFormat"] = val;
1044#if EXIV2_TEST_VERSION(0,28,0)
1045 d->exifMetadata()["Exif.SubImage1.JPEGInterchangeFormatLength"] = uint32_t(buf.size());
1046#else
1047 d->exifMetadata()["Exif.SubImage1.JPEGInterchangeFormatLength"] = uint32_t(buf.size_);
1048#endif
1049 d->exifMetadata()["Exif.SubImage1.Compression"] = uint16_t(6); // JPEG (old-style)
1050 d->exifMetadata()["Exif.SubImage1.NewSubfileType"] = uint32_t(1); // Thumbnail image
1051 return true;
1052 }
1053 }
1054 catch( Exiv2::Error& e )
1055 {
1056 d->printExiv2ExceptionError(QString::fromLatin1("Cannot set TIFF Thumbnail using Exiv2 "), e);
1057 }
1058 catch(...)
1059 {
1060 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
1061 }
1062
1063 return false;
1064}
1065
1066bool KExiv2::removeExifThumbnail() const
1067{
1068 try
1069 {
1070 // Remove all IFD0 subimages.
1071 Exiv2::ExifThumb thumb(d->exifMetadata());
1072 thumb.erase();
1073 return true;
1074 }
1075 catch( Exiv2::Error& e )
1076 {
1077 d->printExiv2ExceptionError(QString::fromLatin1("Cannot remove Exif Thumbnail using Exiv2 "), e);
1078 }
1079 catch(...)
1080 {
1081 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
1082 }
1083
1084 return false;
1085}
1086
1087KExiv2::TagsMap KExiv2::getStdExifTagsList() const
1088{
1089 try
1090 {
1091 QList<const Exiv2::TagInfo*> tags;
1092 TagsMap tagsMap;
1093
1094 const Exiv2::GroupInfo* gi = Exiv2::ExifTags::groupList();
1095
1096 while (gi->tagList_ != nullptr)
1097 {
1098 if (QString::fromLatin1(gi->ifdName_) != QString::fromLatin1("Makernote"))
1099 {
1100 Exiv2::TagListFct tl = gi->tagList_;
1101 const Exiv2::TagInfo* ti = tl();
1102
1103 while (ti->tag_ != 0xFFFF)
1104 {
1105 tags << ti;
1106 ++ti;
1107 }
1108 }
1109 ++gi;
1110 }
1111
1112 for (QList<const Exiv2::TagInfo*>::iterator it = tags.begin(); it != tags.end(); ++it)
1113 {
1114 do
1115 {
1116 const Exiv2::TagInfo* const ti = *it;
1117 QString key = QLatin1String(Exiv2::ExifKey(*ti).key().c_str());
1118 QStringList values;
1119 values << QString::fromLatin1(ti->name_) << QString::fromLatin1(ti->title_) << QString::fromLatin1(ti->desc_);
1120 tagsMap.insert(key, values);
1121 ++(*it);
1122 }
1123 while((*it)->tag_ != 0xffff);
1124 }
1125 return tagsMap;
1126 }
1127 catch( Exiv2::Error& e )
1128 {
1129 d->printExiv2ExceptionError(QString::fromLatin1("Cannot get Exif Tags list using Exiv2 "), e);
1130 }
1131 catch(...)
1132 {
1133 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
1134 }
1135
1136 return TagsMap();
1137}
1138
1139KExiv2::TagsMap KExiv2::getMakernoteTagsList() const
1140{
1141 try
1142 {
1143 QList<const Exiv2::TagInfo*> tags;
1144 TagsMap tagsMap;
1145
1146 const Exiv2::GroupInfo* gi = Exiv2::ExifTags::groupList();
1147
1148 while (gi->tagList_ != nullptr)
1149 {
1150 if (QString::fromLatin1(gi->ifdName_) == QString::fromLatin1("Makernote"))
1151 {
1152 Exiv2::TagListFct tl = gi->tagList_;
1153 const Exiv2::TagInfo* ti = tl();
1154
1155 while (ti->tag_ != 0xFFFF)
1156 {
1157 tags << ti;
1158 ++ti;
1159 }
1160 }
1161 ++gi;
1162 }
1163
1164 for (QList<const Exiv2::TagInfo*>::iterator it = tags.begin(); it != tags.end(); ++it)
1165 {
1166 do
1167 {
1168 const Exiv2::TagInfo* const ti = *it;
1169 QString key = QLatin1String(Exiv2::ExifKey(*ti).key().c_str());
1170 QStringList values;
1171 values << QString::fromLatin1(ti->name_) << QString::fromLatin1(ti->title_) << QString::fromLatin1(ti->desc_);
1172 tagsMap.insert(key, values);
1173 ++(*it);
1174 }
1175 while((*it)->tag_ != 0xffff);
1176 }
1177
1178 return tagsMap;
1179 }
1180 catch( Exiv2::Error& e )
1181 {
1182 d->printExiv2ExceptionError(QString::fromLatin1("Cannot get Makernote Tags list using Exiv2 "), e);
1183 }
1184 catch(...)
1185 {
1186 qCCritical(LIBKEXIV2_LOG) << "Default exception from Exiv2";
1187 }
1188
1189 return TagsMap();
1190}
1191
1192} // NameSpace KExiv2Iface
KExiv2Iface::KExiv2::TagsMap
QMap< QString, QStringList > TagsMap
A map used to store Tags Key and a list of Tags properties :
Definition kexiv2.h:125
KExiv2Iface::KExiv2::rotateExifQImage
bool rotateExifQImage(QImage &image, ImageOrientation orientation) const
Fix orientation of a QImage image accordingly with Exif orientation tag.
Definition kexiv2exif.cpp:944
KExiv2Iface::KExiv2::removeExifTag
bool removeExifTag(const char *exifTagName, bool setProgramName=true) const
Remove the Exif tag 'exifTagName' from Exif metadata.
Definition kexiv2exif.cpp:368
KExiv2Iface::KExiv2::getMakernoteTagsList
TagsMap getMakernoteTagsList() const
Return a map of all non-standard Exif tags (makernotes) supported by Exiv2.
Definition kexiv2exif.cpp:1139
KExiv2Iface::KExiv2::convertToRationalSmallDenominator
static void convertToRationalSmallDenominator(const double number, long int *const numerator, long int *const denominator)
This method convert a 'number' to a rational value, returned in 'numerator' and 'denominator' paramet...
Definition kexiv2gps.cpp:643
KExiv2Iface::KExiv2::setExifTagString
bool setExifTagString(const char *exifTagName, const QString &value, bool setProgramName=true) const
Set an Exif tag content using a string.
Definition kexiv2exif.cpp:866
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::MetaDataMap
QMap< QString, QString > MetaDataMap
A map used to store Tags Key and Tags Value.
Definition kexiv2.h:112
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::getExifTagsDataList
KExiv2::MetaDataMap getExifTagsDataList(const QStringList &exifKeysFilter=QStringList(), bool invertSelection=false) const
Return a map of Exif tags name/value found in metadata sorted by Exif keys given by 'exifKeysFilter'.
Definition kexiv2exif.cpp:152
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::canWriteExif
static bool canWriteExif(const QString &filePath)
Return 'true' if Exif can be written in file.
Definition kexiv2exif.cpp:27
KExiv2Iface::KExiv2::convertToRational
static void convertToRational(const double number, long int *const numerator, long int *const denominator, const int rounding)
This method converts 'number' to a rational value, returned in the 'numerator' and 'denominator' para...
Definition kexiv2gps.cpp:583
KExiv2Iface::KExiv2::setExifTagVariant
bool setExifTagVariant(const char *exifTagName, const QVariant &data, bool rationalWantSmallDenominator=true, bool setProgramName=true) const
Set an Exif tag content using a QVariant.
Definition kexiv2exif.cpp:494
KExiv2Iface::KExiv2::ImageOrientation
ImageOrientation
The image orientation values given by Exif metadata.
Definition kexiv2.h:86
KExiv2Iface::KExiv2::setTiffThumbnail
bool setTiffThumbnail(const QImage &thumb, bool setProgramName=true) const
Adds a JPEG thumbnail to a TIFF images.
Definition kexiv2exif.cpp:989
KExiv2Iface::KExiv2::getExifEncoded
QByteArray getExifEncoded(bool addExifHeader=false) const
Returns the exif data encoded to a QByteArray in a form suitable for storage in a JPEG image.
Definition kexiv2exif.cpp:86
KExiv2Iface::KExiv2::getStdExifTagsList
TagsMap getStdExifTagsList() const
Return a map of all standard Exif tags supported by Exiv2.
Definition kexiv2exif.cpp:1087
KExiv2Iface::KExiv2::getExifTagDescription
QString getExifTagDescription(const char *exifTagName)
Return the Exif Tag description or a null string.
Definition kexiv2exif.cpp:347
KExiv2Iface::KExiv2::setExifThumbnail
bool setExifThumbnail(const QImage &thumb, bool setProgramName=true) const
Set the Exif Thumbnail image.
Definition kexiv2exif.cpp:957
KExiv2Iface::KExiv2::getExifComment
QString getExifComment() const
Return a QString copy of Exif user comments.
Definition kexiv2exif.cpp:226
KExiv2Iface::KExiv2::getExifThumbnail
QImage getExifThumbnail(bool fixOrientation) const
Return a QImage copy of Exif thumbnail image.
Definition kexiv2exif.cpp:888
KExiv2Iface::KExiv2::clearExif
bool clearExif() const
Clear the Exif metadata container in memory.
Definition kexiv2exif.cpp:67
KExiv2Iface::KExiv2::getExifTagData
QByteArray getExifTagData(const char *exifTagName) const
Get an Exif tag content like a bytes array.
Definition kexiv2exif.cpp:699
KExiv2Iface::KExiv2::setExifTagRational
bool setExifTagRational(const char *exifTagName, long int num, long int den, bool setProgramName=true) const
Set an Exif tag content using a rational value.
Definition kexiv2exif.cpp:446
KExiv2Iface::KExiv2::createExifUserStringFromValue
QString createExifUserStringFromValue(const char *exifTagName, const QVariant &val, bool escapeCR=true)
Takes a QVariant value as it could have been retrieved by getExifTagVariant with the given exifTagNam...
Definition kexiv2exif.cpp:575
KExiv2Iface::KExiv2::setExifComment
bool setExifComment(const QString &comment, bool setProgramName=true) const
Set the Exif user comments from image.
Definition kexiv2exif.cpp:283
KExiv2Iface::KExiv2::setExifTagData
bool setExifTagData(const char *exifTagName, const QByteArray &data, bool setProgramName=true) const
Set an Exif tag content using a bytes array.
Definition kexiv2exif.cpp:468
KExiv2Iface::KExiv2::removeExifThumbnail
bool removeExifThumbnail() const
Remove the Exif Thumbnail from the image.
Definition kexiv2exif.cpp:1066
KExiv2Iface::KExiv2::getExifTagVariant
QVariant getExifTagVariant(const char *exifTagName, bool rationalAsListOfInts=true, bool escapeCR=true, int component=0) const
Get an Exif tags content as a QVariant.
Definition kexiv2exif.cpp:729
KExiv2Iface::KExiv2::setExifTagLong
bool setExifTagLong(const char *exifTagName, long val, bool setProgramName=true) const
Set an Exif tag content using a long value.
Definition kexiv2exif.cpp:424
KExiv2Iface::KExiv2::hasExif
bool hasExif() const
Return 'true' if metadata container in memory as Exif.
Definition kexiv2exif.cpp:62
KExiv2Iface::KExiv2::getExifTagRational
bool getExifTagRational(const char *exifTagName, long int &num, long int &den, int component=0) const
Get the 'component' index of an Exif tags content like a rational value.
Definition kexiv2exif.cpp:396
KExiv2Iface::KExiv2::getExifTagTitle
QString getExifTagTitle(const char *exifTagName)
Return the Exif Tag title or a null string.
Definition kexiv2exif.cpp:326
KExiv2Iface::KExiv2::setExif
bool setExif(const QByteArray &data) const
Set the Exif data using a Qt byte array.
Definition kexiv2exif.cpp:127
KExiv2Iface::RotationMatrix::toTransform
QTransform toTransform() const
Returns a QTransform representing this matrix.
Definition rotationmatrix.cpp:270
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::isEmpty
bool isEmpty() const const
QByteArray::replace
QByteArray & replace(QByteArrayView before, QByteArrayView after)
QByteArray::resize
void resize(qsizetype newSize, char c)
QByteArray::size
qsizetype size() const const
QDateTime::fromString
QDateTime fromString(QStringView string, QStringView format, QCalendar cal)
QDateTime::isValid
bool isValid() const const
QDateTime::toString
QString toString(QStringView format, QCalendar cal) const const
QFile::encodeName
QByteArray encodeName(const QString &fileName)
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::transformed
QImage transformed(const QTransform &matrix, Qt::TransformationMode mode) const const
QList::begin
iterator begin()
QList::end
iterator end()
QList::first
T & first()
QList::isEmpty
bool isEmpty() const const
QList::size
qsizetype size() const const
QMap::insert
iterator insert(const Key &key, const T &value)
QMetaType::id
int id() const const
QString::begin
iterator begin()
QString::end
iterator end()
QString::fromLatin1
QString fromLatin1(QByteArrayView str)
QString::fromLocal8Bit
QString fromLocal8Bit(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::section
QString section(QChar sep, qsizetype start, qsizetype end, SectionFlags flags) const const
QString::toLatin1
QByteArray toLatin1() const const
QString::toUtf8
QByteArray toUtf8() const const
QString::trimmed
QString trimmed() const const
QStringList::contains
bool contains(QLatin1StringView str, Qt::CaseSensitivity cs) const const
QVariant::type
Type type() const const
QVariant::metaType
QMetaType metaType() const const
QVariant::toByteArray
QByteArray toByteArray() const const
QVariant::toDateTime
QDateTime toDateTime() const const
QVariant::toDouble
double toDouble(bool *ok) const const
QVariant::toInt
int toInt(bool *ok) const const
QVariant::toList
QList< QVariant > toList() const const
QVariant::toString
QString toString() const const
QVariant::toUInt
uint toUInt(bool *ok) const const
This file is part of the KDE documentation.
Documentation copyright © 1996-2024 The KDE developers.
Generated on Sat Apr 27 2024 22:09:48 by doxygen 1.10.0 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.