KImageFormats

microexif.cpp
1/*
2 This file is part of the KDE project
3 SPDX-FileCopyrightText: 2025 Mirco Miranda <mircomir@outlook.com>
4
5 SPDX-License-Identifier: LGPL-2.1-or-later
6*/
7
8#include "microexif_p.h"
9#include "util_p.h"
10
11#include <QBuffer>
12#include <QCoreApplication>
13#include <QDataStream>
14#include <QHash>
15#include <QTimeZone>
16
17// TIFF 6 specs
18#define TIFF_IMAGEWIDTH 0x100
19#define TIFF_IMAGEHEIGHT 0x101
20#define TIFF_BITSPERSAMPLE 0x102
21#define TIFF_IMAGEDESCRIPTION 0x10E
22#define TIFF_MAKE 0x10F
23#define TIFF_MODEL 0x110
24#define TIFF_ORIENT 0x0112
25#define TIFF_XRES 0x011A
26#define TIFF_YRES 0x011B
27#define TIFF_URES 0x0128
28#define TIFF_SOFTWARE 0x0131
29#define TIFF_ARTIST 0x013B
30#define TIFF_DATETIME 0x0132
31#define TIFF_COPYRIGHT 0x8298
32
33#define TIFF_VAL_URES_NOABSOLUTE 1
34#define TIFF_VAL_URES_INCH 2
35#define TIFF_VAL_URES_CENTIMETER 3
36
37// EXIF 3 specs
38#define EXIF_EXIFIFD 0x8769
39#define EXIF_GPSIFD 0x8825
40#define EXIF_EXIFVERSION 0x9000
41#define EXIF_DATETIMEORIGINAL 0x9003
42#define EXIF_DATETIMEDIGITIZED 0x9004
43#define EXIF_OFFSETTIME 0x9010
44#define EXIF_OFFSETTIMEORIGINAL 0x9011
45#define EXIF_OFFSETTIMEDIGITIZED 0x9012
46#define EXIF_COLORSPACE 0xA001
47#define EXIF_PIXELXDIM 0xA002
48#define EXIF_PIXELYDIM 0xA003
49#define EXIF_IMAGEUNIQUEID 0xA420
50#define EXIF_BODYSERIALNUMBER 0xA431
51#define EXIF_LENSMAKE 0xA433
52#define EXIF_LENSMODEL 0xA434
53#define EXIF_LENSSERIALNUMBER 0xA435
54#define EXIF_IMAGETITLE 0xA436
55
56#define EXIF_VAL_COLORSPACE_SRGB 1
57#define EXIF_VAL_COLORSPACE_UNCAL 0xFFFF
58
59#define GPS_GPSVERSION 0
60#define GPS_LATITUDEREF 1
61#define GPS_LATITUDE 2
62#define GPS_LONGITUDEREF 3
63#define GPS_LONGITUDE 4
64#define GPS_ALTITUDEREF 5
65#define GPS_ALTITUDE 6
66#define GPS_IMGDIRECTIONREF 16
67#define GPS_IMGDIRECTION 17
68#define EXIF_TAG_VALUE(n, byteSize) (((n) << 6) | ((byteSize) & 0x3F))
69#define EXIF_TAG_SIZEOF(dataType) (quint16(dataType) & 0x3F)
70#define EXIF_TAG_DATATYPE(dataType) (quint16(dataType) >> 6)
71
72enum class ExifTagType : quint16 {
73 // Base data types
74 Byte = EXIF_TAG_VALUE(1, 1),
75 Ascii = EXIF_TAG_VALUE(2, 1),
76 Short = EXIF_TAG_VALUE(3, 2),
77 Long = EXIF_TAG_VALUE(4, 4),
78 Rational = EXIF_TAG_VALUE(5, 8),
79
80 // Extended data types
81 SByte = EXIF_TAG_VALUE(6, 1),
82 Undefined = EXIF_TAG_VALUE(7, 1),
83 SShort = EXIF_TAG_VALUE(8, 2),
84 SLong = EXIF_TAG_VALUE(9, 4),
85 SRational = EXIF_TAG_VALUE(10, 8),
86
87 Float = EXIF_TAG_VALUE(11, 4), // not used in EXIF specs
88 Double = EXIF_TAG_VALUE(12, 8), // not used in EXIF specs
89 Ifd = EXIF_TAG_VALUE(13, 4), // not used in EXIF specs
90
91 // BigTiff data types (EXIF specs are 32-bits only)
92 Long8 = EXIF_TAG_VALUE(16, 8), // not used in EXIF specs
93 SLong8 = EXIF_TAG_VALUE(17, 8), // not used in EXIF specs
94 Ifd8 = EXIF_TAG_VALUE(18, 8), // not used in EXIF specs
95
96 // Exif 3.0 only
97 Utf8 = EXIF_TAG_VALUE(129, 1)
98};
99
100using TagPos = QHash<quint16, quint32>;
101using KnownTags = QHash<quint16, ExifTagType>;
102using TagInfo = std::pair<quint16, ExifTagType>;
103
104/*!
105 * \brief staticTagTypes
106 * The supported tags.
107 * \note EXIF tags are an extension of TIFF tags, so I'm writing them all together.
108 */
109// clang-format off
110static const KnownTags staticTagTypes = {
111 TagInfo(TIFF_IMAGEWIDTH, ExifTagType::Long),
112 TagInfo(TIFF_IMAGEHEIGHT, ExifTagType::Long),
113 TagInfo(TIFF_BITSPERSAMPLE, ExifTagType::Short),
114 TagInfo(TIFF_IMAGEDESCRIPTION, ExifTagType::Ascii),
115 TagInfo(TIFF_MAKE, ExifTagType::Ascii),
116 TagInfo(TIFF_MODEL, ExifTagType::Ascii),
117 TagInfo(TIFF_ORIENT, ExifTagType::Short),
118 TagInfo(TIFF_XRES, ExifTagType::Rational),
119 TagInfo(TIFF_YRES, ExifTagType::Rational),
120 TagInfo(TIFF_URES, ExifTagType::Short),
121 TagInfo(TIFF_SOFTWARE, ExifTagType::Ascii),
122 TagInfo(TIFF_ARTIST, ExifTagType::Ascii),
123 TagInfo(TIFF_DATETIME, ExifTagType::Ascii),
124 TagInfo(TIFF_COPYRIGHT, ExifTagType::Ascii),
125 TagInfo(EXIF_EXIFIFD, ExifTagType::Long),
126 TagInfo(EXIF_GPSIFD, ExifTagType::Long),
127 TagInfo(EXIF_DATETIMEORIGINAL, ExifTagType::Ascii),
128 TagInfo(EXIF_OFFSETTIMEDIGITIZED, ExifTagType::Ascii),
129 TagInfo(EXIF_OFFSETTIME, ExifTagType::Ascii),
130 TagInfo(EXIF_OFFSETTIMEORIGINAL, ExifTagType::Ascii),
131 TagInfo(EXIF_OFFSETTIMEDIGITIZED, ExifTagType::Ascii),
132 TagInfo(EXIF_COLORSPACE, ExifTagType::Short),
133 TagInfo(EXIF_PIXELXDIM, ExifTagType::Long),
134 TagInfo(EXIF_PIXELYDIM, ExifTagType::Long),
135 TagInfo(EXIF_IMAGEUNIQUEID, ExifTagType::Ascii),
136 TagInfo(EXIF_BODYSERIALNUMBER, ExifTagType::Ascii),
137 TagInfo(EXIF_LENSMAKE, ExifTagType::Ascii),
138 TagInfo(EXIF_LENSMODEL, ExifTagType::Ascii),
139 TagInfo(EXIF_LENSSERIALNUMBER, ExifTagType::Ascii),
140 TagInfo(EXIF_IMAGETITLE, ExifTagType::Ascii),
141 TagInfo(EXIF_EXIFVERSION, ExifTagType::Undefined)
142};
143// clang-format on
144
145/*!
146 * \brief staticGpsTagTypes
147 */
148// clang-format off
149static const KnownTags staticGpsTagTypes = {
150 TagInfo(GPS_GPSVERSION, ExifTagType::Byte),
151 TagInfo(GPS_LATITUDEREF, ExifTagType::Ascii),
152 TagInfo(GPS_LATITUDE, ExifTagType::Rational),
153 TagInfo(GPS_LONGITUDEREF, ExifTagType::Ascii),
154 TagInfo(GPS_LONGITUDE, ExifTagType::Rational),
155 TagInfo(GPS_ALTITUDEREF, ExifTagType::Byte),
156 TagInfo(GPS_ALTITUDE, ExifTagType::Rational),
157 TagInfo(GPS_IMGDIRECTIONREF, ExifTagType::Ascii),
158 TagInfo(GPS_IMGDIRECTION, ExifTagType::Rational)
159};
160// clang-format on
161
162/*!
163 * \brief tiffStrMap
164 * TIFF string <-> metadata
165 */
166// clang-format off
167static const QList<std::pair<quint16, QString>> tiffStrMap = {
168 std::pair<quint16, QString>(TIFF_IMAGEDESCRIPTION, QStringLiteral(META_KEY_DESCRIPTION)),
169 std::pair<quint16, QString>(TIFF_ARTIST, QStringLiteral(META_KEY_AUTHOR)),
170 std::pair<quint16, QString>(TIFF_SOFTWARE, QStringLiteral(META_KEY_SOFTWARE)),
171 std::pair<quint16, QString>(TIFF_COPYRIGHT, QStringLiteral(META_KEY_COPYRIGHT)),
172 std::pair<quint16, QString>(TIFF_MAKE, QStringLiteral(META_KEY_MANUFACTURER)),
173 std::pair<quint16, QString>(TIFF_MODEL, QStringLiteral(META_KEY_MODEL))
174};
175// clang-format on
176
177/*!
178 * \brief exifStrMap
179 * EXIF string <-> metadata
180 */
181// clang-format off
182static const QList<std::pair<quint16, QString>> exifStrMap = {
183 std::pair<quint16, QString>(EXIF_BODYSERIALNUMBER, QStringLiteral(META_KEY_SERIALNUMBER)),
184 std::pair<quint16, QString>(EXIF_LENSMAKE, QStringLiteral(META_KEY_LENS_MANUFACTURER)),
185 std::pair<quint16, QString>(EXIF_LENSMODEL, QStringLiteral(META_KEY_LENS_MODEL)),
186 std::pair<quint16, QString>(EXIF_LENSSERIALNUMBER, QStringLiteral(META_KEY_LENS_SERIALNUMBER)),
187 std::pair<quint16, QString>(EXIF_IMAGETITLE, QStringLiteral(META_KEY_TITLE)),
188};
189// clang-format on
190
191/*!
192 * \brief timeOffset
193 * \param offset The EXIF string of the offset from UTC.
194 * \return The offset in minutes.
195 */
196static qint16 timeOffset(const QString& offset)
197{
198 if (offset.size() != 6 || offset.at(3) != u':')
199 return 0;
200 auto ok = false;
201 auto hh = offset.left(3).toInt(&ok);
202 if (!ok)
203 return 0;
204 auto mm = offset.mid(4, 2).toInt(&ok) * (hh < 0 ? -1 : 1);
205 if (!ok)
206 return 0;
207 return qint16(hh * 60 + mm);
208}
209
210/*!
211 * \brief timeOffset
212 * \param offset Offset from UTC in minutes.
213 * \return The EXIF string of the offset.
214 */
215static QString timeOffset(qint16 offset)
216{
217 auto absOff = quint16(std::abs(offset));
218 return QStringLiteral("%1%2:%3")
219 .arg(offset < 0 ? QStringLiteral("-") : QStringLiteral("+"))
220 .arg(absOff / 60, 2, 10, QChar(u'0'))
221 .arg(absOff % 60, 2, 10, QChar(u'0'));
222}
223
224
225/*!
226 * \brief checkHeader
227 * \param ds The data stream
228 * \return True if header is a valid EXIF, otherwise false.
229 */
230static bool checkHeader(QDataStream &ds)
231{
232 quint16 order;
233 ds >> order;
234 if (order == 0x4949) {
235 ds.setByteOrder(QDataStream::LittleEndian);
236 } else if (order == 0x4d4d) {
237 ds.setByteOrder(QDataStream::BigEndian);
238 } else {
239 return false;
240 }
241
242 quint16 version;
243 ds >> version;
244 if (version != 0x002A && version != 0x01BC)
245 return false; // not TIFF or JXR
246
247 quint32 offset;
248 ds >> offset;
249 offset -= 8;
250 if (ds.skipRawData(offset) != offset)
251 return false;
252
253 return ds.status() == QDataStream::Ok;
254}
255
256/*!
257 * \brief updatePos
258 * Write the current stram position in \a pos position as uint32.
259 * \return True on success, otherwise false;
260 */
261static bool updatePos(QDataStream &ds, quint32 pos)
262{
263 auto dev = ds.device();
264 if (pos != 0) {
265 auto p = dev->pos();
266 if (!dev->seek(pos))
267 return false;
268 ds << quint32(p);
269 if (!dev->seek(p))
270 return false;
271 }
272 return ds.status() == QDataStream::Ok;
273}
274
275static qint32 countBytes(const ExifTagType &dataType, const QVariant &value)
276{
277 auto count = 1;
278 if (dataType == ExifTagType::Ascii) {
279 count = value.toString().toLatin1().size() + 1; // ASCIIZ
280 } else if (dataType == ExifTagType::Utf8) {
281 count = value.toString().toUtf8().size() + 1; // ASCIIZ
282 } else if (dataType == ExifTagType::Undefined) {
283 count = value.toByteArray().size();
284 } else if (dataType == ExifTagType::Byte) {
285 count = value.value<QList<quint8>>().size();
286 } else if (dataType == ExifTagType::Short) {
287 count = value.value<QList<quint16>>().size();
288 } else if (dataType == ExifTagType::Long || dataType == ExifTagType::Ifd) {
289 count = value.value<QList<quint32>>().size();
290 } else if (dataType == ExifTagType::SByte) {
291 count = value.value<QList<qint8>>().size();
292 } else if (dataType == ExifTagType::SShort) {
293 count = value.value<QList<qint16>>().size();
294 } else if (dataType == ExifTagType::SLong) {
295 count = value.value<QList<qint32>>().size();
296 } else if (dataType == ExifTagType::Rational || dataType == ExifTagType::SRational || dataType == ExifTagType::Double) {
297 count = value.value<QList<double>>().size();
298 } else if (dataType == ExifTagType::Float) {
299 count = value.value<QList<float>>().size();
300 }
301 return std::max(1, count);
302}
303
304template <class T>
305static void writeList(QDataStream &ds, const QVariant &value)
306{
307 auto l = value.value<QList<T>>();
308 if (l.isEmpty())
309 l.append(value.toInt());
310 for (;l.size() < qsizetype(4 / sizeof(T));)
311 l.append(T());
312 for (auto &&v : l)
313 ds << v;
314}
315
316inline qint32 rationalPrecision(double v)
317{
318 v = qAbs(v);
319 return 8 - qBound(0, v < 1 ? 8 : int(std::log10(v)), 8);
320}
321
322template<class T>
323static void writeRationalList(QDataStream &ds, const QVariant &value)
324{
325 auto l = value.value<QList<double>>();
326 if (l.isEmpty())
327 l.append(value.toDouble());
328 for (auto &&v : l) {
329 auto den = std::pow(10, rationalPrecision(v));
330 ds << T(qRound(v * den));
331 ds << T(den);
332 }
333}
334
335static void writeByteArray(QDataStream &ds, const QByteArray &ba)
336{
337 for (auto &&v : ba)
338 ds << v;
339 for (auto n = ba.size(); n < 4; ++n)
340 ds << char();
341}
342
343static void writeData(QDataStream &ds, const QVariant &value, const ExifTagType& dataType)
344{
345 if (dataType == ExifTagType::Ascii) {
346 writeByteArray(ds, value.toString().toLatin1().append(char()));
347 } else if (dataType == ExifTagType::Utf8) {
348 writeByteArray(ds, value.toString().toUtf8().append(char()));
349 } else if (dataType == ExifTagType::Undefined) {
350 writeByteArray(ds, value.toByteArray());
351 } else if (dataType == ExifTagType::Byte) {
352 writeList<quint8>(ds, value);
353 } else if (dataType == ExifTagType::SByte) {
354 writeList<qint8>(ds, value);
355 } else if (dataType == ExifTagType::Short) {
356 writeList<quint16>(ds, value);
357 } else if (dataType == ExifTagType::SShort) {
358 writeList<qint16>(ds, value);
359 } else if (dataType == ExifTagType::Long || dataType == ExifTagType::Ifd) {
360 writeList<quint32>(ds, value);
361 } else if (dataType == ExifTagType::SLong) {
362 writeList<qint32>(ds, value);
363 } else if (dataType == ExifTagType::Rational) {
364 writeRationalList<quint32>(ds, value);
365 } else if (dataType == ExifTagType::SRational) {
366 writeRationalList<qint32>(ds, value);
367 }
368}
369
370/*!
371 * \brief writeIfd
372 * \param ds The stream.
373 * \param tags The list of tags to write.
374 * \param pos The position of the TAG value to update with this IFD position.
375 * \param knownTags List of known and supported tags.
376 * \return True on success, otherwise false.
377 */
378static bool writeIfd(QDataStream &ds, const MicroExif::Tags &tags, TagPos &positions, quint32 pos = 0, const KnownTags &knownTags = staticTagTypes)
379{
380 if (tags.isEmpty())
381 return true;
382 if (!updatePos(ds, pos))
383 return false;
384
385 auto keys = tags.keys();
386 auto entries = quint16(keys.size());
387 ds << entries;
388 for (auto &&key : keys) {
389 if (!knownTags.contains(key)) {
390 continue;
391 }
392 auto value = tags.value(key);
393 auto dataType = knownTags.value(key);
394 auto count = countBytes(dataType, value);
395
396 ds << quint16(key);
397 ds << quint16(EXIF_TAG_DATATYPE(dataType));
398 ds << quint32(count);
399 positions.insert(key, quint32(ds.device()->pos()));
400 auto valueSize = count * EXIF_TAG_SIZEOF(dataType);
401 if (valueSize > 4) {
402 ds << quint32();
403 } else {
404 writeData(ds, value, dataType);
405 }
406 }
407 // no more IFDs
408 ds << quint32();
409
410 // write data larger than 4 bytes
411 for (auto &&key : keys) {
412 if (!knownTags.contains(key)) {
413 continue;
414 }
415
416 auto value = tags.value(key);
417 auto dataType = knownTags.value(key);
418 auto count = countBytes(dataType, value);
419 auto valueSize = count * EXIF_TAG_SIZEOF(dataType);
420 if (valueSize <= 4)
421 continue;
422 if (!updatePos(ds, positions.value(key)))
423 return false;
424 writeData(ds, value, dataType);
425 }
426
427 return ds.status() == QDataStream::Ok;
428}
429
430template<class T>
431static QList<T> readList(QDataStream &ds, quint32 count)
432{
433 QList<T> l;
434 T c;
435 for (quint32 i = 0; i < count; ++i) {
436 ds >> c;
437 l.append(c);
438 }
439 for (auto n = count; n < quint32(4 / sizeof(T)); ++n) {
440 ds >> c;
441 }
442 return l;
443}
444
445template<class T>
446static QList<double> readRationalList(QDataStream &ds, quint32 count)
447{
448 QList<double> l;
449 for (quint32 i = 0; i < count; ++i) {
450 T num;
451 ds >> num;
452 T den;
453 ds >> den;
454 l.append(den == 0 ? 0 : double(num) / double(den));
455 }
456 return l;
457}
458
459static QByteArray readBytes(QDataStream &ds, quint32 count, bool asciiz)
460{
461 QByteArray l;
462 if (count == 0) {
463 return l;
464 }
465 char c;
466 for (quint32 i = 0; i < count; ++i) {
467 ds >> c;
468 l.append(c);
469 }
470 if (asciiz && l.at(l.size() - 1) == 0) {
471 l.removeLast();
472 }
473 for (auto n = count; n < 4; ++n) {
474 ds >> c;
475 }
476 return l;
477}
478
479/*!
480 * \brief readIfd
481 * \param ds The stream.
482 * \param tags Where to sotro the read tags.
483 * \param pos The position of the IFD.
484 * \param knownTags List of known and supported tags.
485 * \param nextIfd The position of next IFD (0 if none).
486 * \return True on succes, otherwise false.
487 */
488static bool readIfd(QDataStream &ds, MicroExif::Tags &tags, quint32 pos = 0, const KnownTags &knownTags = staticTagTypes, quint32 *nextIfd = nullptr)
489{
490 auto localNextIfd = quint32();
491 if (nextIfd == nullptr)
492 nextIfd = &localNextIfd;
493 *nextIfd = 0;
494
495 auto device = ds.device();
496 if (pos && !device->seek(pos))
497 return false;
498
499 quint16 entries;
500 ds >> entries;
501 if (ds.status() != QDataStream::Ok)
502 return false;
503
504 for (quint16 i = 0; i < entries; ++i) {
505 quint16 tagId;
506 ds >> tagId;
507 quint16 dataType;
508 ds >> dataType;
509 quint32 count;
510 ds >> count;
511 if (ds.status() != QDataStream::Ok)
512 return false;
513
514 // search for supported values only
515 if (!knownTags.contains(tagId)) {
516 quint32 value;
517 ds >> value;
518 continue;
519 }
520
521 // read TAG data
522 auto toRead = qint64(count) * EXIF_TAG_SIZEOF(knownTags.value(tagId));
523 if (toRead > qint64(device->size()))
524 return false;
525
526 auto curPos = qint64();
527 if (toRead > 4) {
528 quint32 value;
529 ds >> value;
530 curPos = device->pos();
531 if (!device->seek(value))
532 return false;
533 }
534
535 if (dataType == EXIF_TAG_DATATYPE(ExifTagType::Ascii) || dataType == EXIF_TAG_DATATYPE(ExifTagType::Utf8)) {
536 auto l = readBytes(ds, count, true);
537 if (!l.isEmpty())
538 tags.insert(tagId, dataType == EXIF_TAG_DATATYPE(ExifTagType::Utf8) ? QString::fromUtf8(l) : QString::fromLatin1(l));
539 } else if (dataType == EXIF_TAG_DATATYPE(ExifTagType::Undefined)) {
540 auto l = readBytes(ds, count, false);
541 if (!l.isEmpty())
542 tags.insert(tagId, l);
543 } else if (dataType == EXIF_TAG_DATATYPE(ExifTagType::Byte)) {
544 auto l = readList<quint8>(ds, count);
545 tags.insert(tagId, l.size() == 1 ? QVariant(l.first()) : QVariant::fromValue(l));
546 } else if (dataType == EXIF_TAG_DATATYPE(ExifTagType::SByte)) {
547 auto l = readList<qint8>(ds, count);
548 tags.insert(tagId, l.size() == 1 ? QVariant(l.first()) : QVariant::fromValue(l));
549 } else if (dataType == EXIF_TAG_DATATYPE(ExifTagType::Short)) {
550 auto l = readList<quint16>(ds, count);
551 tags.insert(tagId, l.size() == 1 ? QVariant(l.first()) : QVariant::fromValue(l));
552 } else if (dataType == EXIF_TAG_DATATYPE(ExifTagType::SShort)) {
553 auto l = readList<qint16>(ds, count);
554 tags.insert(tagId, l.size() == 1 ? QVariant(l.first()) : QVariant::fromValue(l));
555 } else if (dataType == EXIF_TAG_DATATYPE(ExifTagType::Long) || dataType == EXIF_TAG_DATATYPE(ExifTagType::Ifd)) {
556 auto l = readList<quint32>(ds, count);
557 tags.insert(tagId, l.size() == 1 ? QVariant(l.first()) : QVariant::fromValue(l));
558 } else if (dataType == EXIF_TAG_DATATYPE(ExifTagType::SLong)) {
559 auto l = readList<qint32>(ds, count);
560 tags.insert(tagId, l.size() == 1 ? QVariant(l.first()) : QVariant::fromValue(l));
561 } else if (dataType == EXIF_TAG_DATATYPE(ExifTagType::Rational)) {
562 auto l = readRationalList<quint32>(ds, count);
563 tags.insert(tagId, l.size() == 1 ? QVariant(l.first()) : QVariant::fromValue(l));
564 } else if (dataType == EXIF_TAG_DATATYPE(ExifTagType::SRational)) {
565 auto l = readRationalList<qint32>(ds, count);
566 tags.insert(tagId, l.size() == 1 ? QVariant(l.first()) : QVariant::fromValue(l));
567 }
568
569 if (curPos > 0 && !device->seek(curPos))
570 return false;
571 }
572 ds >> *nextIfd;
573
574 return true;
575}
576
577MicroExif::MicroExif()
578{
579
580}
581
582void MicroExif::clear()
583{
584 m_tiffTags.clear();
585 m_exifTags.clear();
586 m_gpsTags.clear();
587}
588
589bool MicroExif::isEmpty() const
590{
591 return m_tiffTags.isEmpty() && m_exifTags.isEmpty() && m_gpsTags.isEmpty();
592}
593
594double MicroExif::horizontalResolution() const
595{
596 auto u = m_tiffTags.value(TIFF_URES).toUInt();
597 auto v = m_tiffTags.value(TIFF_XRES).toDouble();
598 if (u == TIFF_VAL_URES_CENTIMETER)
599 return v * 2.54;
600 return v;
601}
602
603void MicroExif::setHorizontalResolution(double hres)
604{
605 auto u = m_tiffTags.value(TIFF_URES).toUInt();
606 if (u == TIFF_VAL_URES_CENTIMETER) {
607 hres /= 2.54;
608 } else if (u < TIFF_VAL_URES_INCH) {
609 m_tiffTags.insert(TIFF_URES, TIFF_VAL_URES_INCH);
610 }
611 m_tiffTags.insert(TIFF_XRES, hres);
612}
613
614double MicroExif::verticalResolution() const
615{
616 auto u = m_tiffTags.value(TIFF_URES).toUInt();
617 auto v = m_tiffTags.value(TIFF_YRES).toDouble();
618 if (u == TIFF_VAL_URES_CENTIMETER)
619 return v * 2.54;
620 return v;
621}
622
623void MicroExif::setVerticalResolution(double vres)
624{
625 auto u = m_tiffTags.value(TIFF_URES).toUInt();
626 if (u == TIFF_VAL_URES_CENTIMETER) {
627 vres /= 2.54;
628 } else if (u < TIFF_VAL_URES_INCH) {
629 m_tiffTags.insert(TIFF_URES, TIFF_VAL_URES_INCH);
630 }
631 m_tiffTags.insert(TIFF_YRES, vres);
632}
633
634QColorSpace MicroExif::colosSpace() const
635{
636 if (m_exifTags.value(EXIF_COLORSPACE).toUInt() == EXIF_VAL_COLORSPACE_SRGB)
637 return QColorSpace(QColorSpace::SRgb);
638 return QColorSpace();
639}
640
641void MicroExif::setColorSpace(const QColorSpace &cs)
642{
643 auto srgb = cs.transferFunction() == QColorSpace::TransferFunction::SRgb && cs.primaries() == QColorSpace::Primaries::SRgb;
644 m_exifTags.insert(EXIF_COLORSPACE, srgb ? EXIF_VAL_COLORSPACE_SRGB : EXIF_VAL_COLORSPACE_UNCAL);
645}
646
647void MicroExif::setColorSpace(const QColorSpace::NamedColorSpace &csName)
648{
649 auto srgb = csName == QColorSpace::SRgb;
650 m_exifTags.insert(EXIF_COLORSPACE, srgb ? EXIF_VAL_COLORSPACE_SRGB : EXIF_VAL_COLORSPACE_UNCAL);
651}
652
653qint32 MicroExif::width() const
654{
655 return m_tiffTags.value(TIFF_IMAGEWIDTH).toUInt();
656}
657
658void MicroExif::setWidth(qint32 w)
659{
660 m_tiffTags.insert(TIFF_IMAGEWIDTH, w);
661 m_exifTags.insert(EXIF_PIXELXDIM, w);
662}
663
664qint32 MicroExif::height() const
665{
666 return m_tiffTags.value(TIFF_IMAGEHEIGHT).toUInt();
667}
668
669void MicroExif::setHeight(qint32 h)
670{
671 m_tiffTags.insert(TIFF_IMAGEHEIGHT, h);
672 m_exifTags.insert(EXIF_PIXELYDIM, h);
673}
674
675quint16 MicroExif::orientation() const
676{
677 return m_tiffTags.value(TIFF_ORIENT).toUInt();
678}
679
680void MicroExif::setOrientation(quint16 orient)
681{
682 if (orient < 1 || orient > 8)
683 m_tiffTags.remove(TIFF_ORIENT);
684 else
685 m_tiffTags.insert(TIFF_ORIENT, orient);
686}
687
688QImageIOHandler::Transformation MicroExif::transformation() const
689{
690 switch (orientation()) {
691 case 1:
692 return QImageIOHandler::TransformationNone;
693 case 2:
694 return QImageIOHandler::TransformationMirror;
695 case 3:
696 return QImageIOHandler::TransformationRotate180;
697 case 4:
698 return QImageIOHandler::TransformationFlip;
699 case 5:
700 return QImageIOHandler::TransformationFlipAndRotate90;
701 case 6:
702 return QImageIOHandler::TransformationRotate90;
703 case 7:
704 return QImageIOHandler::TransformationMirrorAndRotate90;
705 case 8:
706 return QImageIOHandler::TransformationRotate270;
707 default:
708 break;
709 };
710 return QImageIOHandler::TransformationNone;
711}
712
713void MicroExif::setTransformation(const QImageIOHandler::Transformation &t)
714{
715 switch (t) {
716 case QImageIOHandler::TransformationNone:
717 setOrientation(1);
718 break;
719 case QImageIOHandler::TransformationMirror:
720 setOrientation(2);
721 break;
722 case QImageIOHandler::TransformationRotate180:
723 setOrientation(3);
724 break;
725 case QImageIOHandler::TransformationFlip:
726 setOrientation(4);
727 break;
728 case QImageIOHandler::TransformationFlipAndRotate90:
729 setOrientation(5);
730 break;
731 case QImageIOHandler::TransformationRotate90:
732 setOrientation(6);
733 break;
734 case QImageIOHandler::TransformationMirrorAndRotate90:
735 setOrientation(7);
736 break;
737 case QImageIOHandler::TransformationRotate270:
738 setOrientation(8);
739 break;
740 default:
741 break;
742 }
743 setOrientation(0); // no orientation set
744}
745
746QString MicroExif::software() const
747{
748 return tiffString(TIFF_SOFTWARE);
749}
750
751void MicroExif::setSoftware(const QString &s)
752{
753 setTiffString(TIFF_SOFTWARE, s);
754}
755
756QString MicroExif::description() const
757{
758 return tiffString(TIFF_IMAGEDESCRIPTION);
759}
760
761void MicroExif::setDescription(const QString &s)
762{
763 setTiffString(TIFF_IMAGEDESCRIPTION, s);
764}
765
766QString MicroExif::artist() const
767{
768 return tiffString(TIFF_ARTIST);
769}
770
771void MicroExif::setArtist(const QString &s)
772{
773 setTiffString(TIFF_ARTIST, s);
774}
775
776QString MicroExif::copyright() const
777{
778 return tiffString(TIFF_COPYRIGHT);
779}
780
781void MicroExif::setCopyright(const QString &s)
782{
783 setTiffString(TIFF_COPYRIGHT, s);
784}
785
786QString MicroExif::make() const
787{
788 return tiffString(TIFF_MAKE);
789}
790
791void MicroExif::setMake(const QString &s)
792{
793 setTiffString(TIFF_MAKE, s);
794}
795
796QString MicroExif::model() const
797{
798 return tiffString(TIFF_MODEL);
799}
800
801void MicroExif::setModel(const QString &s)
802{
803 setTiffString(TIFF_MODEL, s);
804}
805
806QString MicroExif::serialNumber() const
807{
808 return tiffString(EXIF_BODYSERIALNUMBER);
809}
810
811void MicroExif::setSerialNumber(const QString &s)
812{
813 setTiffString(EXIF_BODYSERIALNUMBER, s);
814}
815
816QString MicroExif::lensMake() const
817{
818 return tiffString(EXIF_LENSMAKE);
819}
820
821void MicroExif::setLensMake(const QString &s)
822{
823 setTiffString(EXIF_LENSMAKE, s);
824}
825
826QString MicroExif::lensModel() const
827{
828 return tiffString(EXIF_LENSMODEL);
829}
830
831void MicroExif::setLensModel(const QString &s)
832{
833 setTiffString(EXIF_LENSMODEL, s);
834}
835
836QString MicroExif::lensSerialNumber() const
837{
838 return tiffString(EXIF_LENSSERIALNUMBER);
839}
840
841void MicroExif::setLensSerialNumber(const QString &s)
842{
843 setTiffString(EXIF_LENSSERIALNUMBER, s);
844}
845
846QDateTime MicroExif::dateTime() const
847{
848 auto dt = QDateTime::fromString(tiffString(TIFF_DATETIME), QStringLiteral("yyyy:MM:dd HH:mm:ss"));
849 auto ofTag = exifString(EXIF_OFFSETTIME);
850 if (dt.isValid() && !ofTag.isEmpty())
851 dt.setTimeZone(QTimeZone::fromSecondsAheadOfUtc(timeOffset(ofTag) * 60));
852 return(dt);
853}
854
855void MicroExif::setDateTime(const QDateTime &dt)
856{
857 if (!dt.isValid()) {
858 m_tiffTags.remove(TIFF_DATETIME);
859 m_exifTags.remove(EXIF_OFFSETTIME);
860 return;
861 }
862 setTiffString(TIFF_DATETIME, dt.toString(QStringLiteral("yyyy:MM:dd HH:mm:ss")));
863 setExifString(EXIF_OFFSETTIME, timeOffset(dt.offsetFromUtc() / 60));
864}
865
866QDateTime MicroExif::dateTimeOriginal() const
867{
868 auto dt = QDateTime::fromString(exifString(EXIF_DATETIMEORIGINAL), QStringLiteral("yyyy:MM:dd HH:mm:ss"));
869 auto ofTag = exifString(EXIF_OFFSETTIMEORIGINAL);
870 if (dt.isValid() && !ofTag.isEmpty())
871 dt.setTimeZone(QTimeZone::fromSecondsAheadOfUtc(timeOffset(ofTag) * 60));
872 return(dt);
873}
874
875void MicroExif::setDateTimeOriginal(const QDateTime &dt)
876{
877 if (!dt.isValid()) {
878 m_exifTags.remove(EXIF_DATETIMEORIGINAL);
879 m_exifTags.remove(EXIF_OFFSETTIMEORIGINAL);
880 return;
881 }
882 setExifString(EXIF_DATETIMEORIGINAL, dt.toString(QStringLiteral("yyyy:MM:dd HH:mm:ss")));
883 setExifString(EXIF_OFFSETTIMEORIGINAL, timeOffset(dt.offsetFromUtc() / 60));
884}
885
886QDateTime MicroExif::dateTimeDigitized() const
887{
888 auto dt = QDateTime::fromString(exifString(EXIF_DATETIMEDIGITIZED), QStringLiteral("yyyy:MM:dd HH:mm:ss"));
889 auto ofTag = exifString(EXIF_OFFSETTIMEDIGITIZED);
890 if (dt.isValid() && !ofTag.isEmpty())
891 dt.setTimeZone(QTimeZone::fromSecondsAheadOfUtc(timeOffset(ofTag) * 60));
892 return(dt);
893}
894
895void MicroExif::setDateTimeDigitized(const QDateTime &dt)
896{
897 if (!dt.isValid()) {
898 m_exifTags.remove(EXIF_DATETIMEDIGITIZED);
899 m_exifTags.remove(EXIF_OFFSETTIMEDIGITIZED);
900 return;
901 }
902 setExifString(EXIF_DATETIMEDIGITIZED, dt.toString(QStringLiteral("yyyy:MM:dd HH:mm:ss")));
903 setExifString(EXIF_OFFSETTIMEDIGITIZED, timeOffset(dt.offsetFromUtc() / 60));
904}
905
906QString MicroExif::title() const
907{
908 return exifString(EXIF_IMAGETITLE);
909}
910
911void MicroExif::setImageTitle(const QString &s)
912{
913 setExifString(EXIF_IMAGETITLE, s);
914}
915
916QUuid MicroExif::uniqueId() const
917{
918 auto s = exifString(EXIF_IMAGEUNIQUEID);
919 if (s.length() == 32) {
920 auto tmp = QStringLiteral("%1-%2-%3-%4-%5").arg(s.left(8), s.mid(8, 4), s.mid(12, 4), s.mid(16, 4), s.mid(20));
921 return QUuid(tmp);
922 }
923 return {};
924}
925
926void MicroExif::setUniqueId(const QUuid &uuid)
927{
928 if (uuid.isNull())
929 setExifString(EXIF_IMAGEUNIQUEID, QString());
930 else
931 setExifString(EXIF_IMAGEUNIQUEID, uuid.toString(QUuid::WithoutBraces).replace(QStringLiteral("-"), QString()));
932}
933
934double MicroExif::latitude() const
935{
936 auto ref = gpsString(GPS_LATITUDEREF).toUpper();
937 if (ref != QStringLiteral("N") && ref != QStringLiteral("S"))
938 return qQNaN();
939 auto lat = m_gpsTags.value(GPS_LATITUDE).value<QList<double>>();
940 if (lat.size() != 3)
941 return qQNaN();
942 auto degree = lat.at(0) + lat.at(1) / 60 + lat.at(2) / 3600;
943 if (degree < -90.0 || degree > 90.0)
944 return qQNaN();
945 return ref == QStringLiteral("N") ? degree : -degree;
946}
947
948void MicroExif::setLatitude(double degree)
949{
950 if (qIsNaN(degree)) {
951 m_gpsTags.remove(GPS_LATITUDEREF);
952 m_gpsTags.remove(GPS_LATITUDE);
953 }
954 if (degree < -90.0 || degree > 90.0)
955 return; // invalid latitude
956 auto adeg = qAbs(degree);
957 auto min = (adeg - int(adeg)) * 60;
958 auto sec = (min - int(min)) * 60;
959 m_gpsTags.insert(GPS_LATITUDEREF, degree < 0 ? QStringLiteral("S") : QStringLiteral("N"));
960 m_gpsTags.insert(GPS_LATITUDE, QVariant::fromValue(QList<double>() << int(adeg) << int(min) << sec));
961}
962
963double MicroExif::longitude() const
964{
965 auto ref = gpsString(GPS_LONGITUDEREF).toUpper();
966 if (ref != QStringLiteral("E") && ref != QStringLiteral("W"))
967 return qQNaN();
968 auto lon = m_gpsTags.value(GPS_LONGITUDE).value<QList<double>>();
969 if (lon.size() != 3)
970 return qQNaN();
971 auto degree = lon.at(0) + lon.at(1) / 60 + lon.at(2) / 3600;
972 if (degree < -180.0 || degree > 180.0)
973 return qQNaN();
974 return ref == QStringLiteral("E") ? degree : -degree;
975}
976
977void MicroExif::setLongitude(double degree)
978{
979 if (qIsNaN(degree)) {
980 m_gpsTags.remove(GPS_LONGITUDEREF);
981 m_gpsTags.remove(GPS_LONGITUDE);
982 }
983 if (degree < -180.0 || degree > 180.0)
984 return; // invalid longitude
985 auto adeg = qAbs(degree);
986 auto min = (adeg - int(adeg)) * 60;
987 auto sec = (min - int(min)) * 60;
988 m_gpsTags.insert(GPS_LONGITUDEREF, degree < 0 ? QStringLiteral("W") : QStringLiteral("E"));
989 m_gpsTags.insert(GPS_LONGITUDE, QVariant::fromValue(QList<double>() << int(adeg) << int(min) << sec));
990}
991
992double MicroExif::altitude() const
993{
994 auto ref = m_gpsTags.value(GPS_ALTITUDEREF);
995 if (ref.isNull())
996 return qQNaN();
997 if (!m_gpsTags.contains(GPS_ALTITUDE))
998 return qQNaN();
999 auto alt = m_gpsTags.value(GPS_ALTITUDE).toDouble();
1000 return (ref.toInt() == 0 || ref.toInt() == 2) ? alt : -alt;
1001}
1002
1003void MicroExif::setAltitude(double meters)
1004{
1005 if (qIsNaN(meters)) {
1006 m_gpsTags.remove(GPS_ALTITUDEREF);
1007 m_gpsTags.remove(GPS_ALTITUDE);
1008 }
1009 m_gpsTags.insert(GPS_ALTITUDEREF, quint8(meters < 0 ? 1 : 0));
1010 m_gpsTags.insert(GPS_ALTITUDE, meters);
1011}
1012
1013double MicroExif::imageDirection(bool *isMagnetic) const
1014{
1015 auto tmp = false;
1016 if (isMagnetic == nullptr)
1017 isMagnetic = &tmp;
1018 if (!m_gpsTags.contains(GPS_IMGDIRECTION))
1019 return qQNaN();
1020 auto ref = gpsString(GPS_IMGDIRECTIONREF).toUpper();
1021 *isMagnetic = (ref == QStringLiteral("M"));
1022 return m_gpsTags.value(GPS_IMGDIRECTION).toDouble();
1023}
1024
1025void MicroExif::setImageDirection(double degree, bool isMagnetic)
1026{
1027 if (qIsNaN(degree)) {
1028 m_gpsTags.remove(GPS_IMGDIRECTIONREF);
1029 m_gpsTags.remove(GPS_IMGDIRECTION);
1030 }
1031 m_gpsTags.insert(GPS_IMGDIRECTIONREF, isMagnetic ? QStringLiteral("M") : QStringLiteral("T"));
1032 m_gpsTags.insert(GPS_IMGDIRECTION, degree);
1033}
1034
1035QByteArray MicroExif::toByteArray(const QDataStream::ByteOrder &byteOrder) const
1036{
1037 QByteArray ba;
1038 {
1039 QBuffer buf(&ba);
1040 if (!write(&buf, byteOrder))
1041 return {};
1042 }
1043 return ba;
1044}
1045
1046QByteArray MicroExif::exifIfdByteArray(const QDataStream::ByteOrder &byteOrder) const
1047{
1048 QByteArray ba;
1049 {
1050 QDataStream ds(&ba, QIODevice::WriteOnly);
1051 ds.setByteOrder(byteOrder);
1052 auto exifTags = m_exifTags;
1053 exifTags.insert(EXIF_EXIFVERSION, QByteArray("0300"));
1054 TagPos positions;
1055 if (!writeIfd(ds, exifTags, positions))
1056 return {};
1057 }
1058 return ba;
1059}
1060
1061bool MicroExif::setExifIfdByteArray(const QByteArray &ba, const QDataStream::ByteOrder &byteOrder)
1062{
1063 QDataStream ds(ba);
1064 ds.setByteOrder(byteOrder);
1065 return readIfd(ds, m_exifTags, 0, staticTagTypes);
1066}
1067
1068QByteArray MicroExif::gpsIfdByteArray(const QDataStream::ByteOrder &byteOrder) const
1069{
1070 QByteArray ba;
1071 {
1072 QDataStream ds(&ba, QIODevice::WriteOnly);
1073 ds.setByteOrder(byteOrder);
1074 auto gpsTags = m_gpsTags;
1075 gpsTags.insert(GPS_GPSVERSION, QByteArray("2400"));
1076 TagPos positions;
1077 if (!writeIfd(ds, gpsTags, positions, 0, staticGpsTagTypes))
1078 return {};
1079 return ba;
1080 }
1081}
1082
1083bool MicroExif::setGpsIfdByteArray(const QByteArray &ba, const QDataStream::ByteOrder &byteOrder)
1084{
1085 QDataStream ds(ba);
1086 ds.setByteOrder(byteOrder);
1087 return readIfd(ds, m_gpsTags, 0, staticGpsTagTypes);
1088}
1089
1090bool MicroExif::write(QIODevice *device, const QDataStream::ByteOrder &byteOrder) const
1091{
1092 if (device == nullptr || device->isSequential() || isEmpty())
1093 return false;
1094 if (device->open(QBuffer::WriteOnly)) {
1095 QDataStream ds(device);
1096 ds.setByteOrder(byteOrder);
1097 if (!writeHeader(ds))
1098 return false;
1099 if (!writeIfds(ds))
1100 return false;
1101 }
1102 device->close();
1103 return true;
1104}
1105
1106void MicroExif::updateImageMetadata(QImage &targetImage, bool replaceExisting) const
1107{
1108 // set TIFF strings
1109 for (auto &&p : tiffStrMap) {
1110 if (!replaceExisting && !targetImage.text(p.second).isEmpty())
1111 continue;
1112 auto s = tiffString(p.first);
1113 if (!s.isEmpty())
1114 targetImage.setText(p.second, s);
1115 }
1116
1117 // set EXIF strings
1118 for (auto &&p : exifStrMap) {
1119 if (!replaceExisting && !targetImage.text(p.second).isEmpty())
1120 continue;
1121 auto s = exifString(p.first);
1122 if (!s.isEmpty())
1123 targetImage.setText(p.second, s);
1124 }
1125
1126 // set date and time
1127 if (replaceExisting || targetImage.text(QStringLiteral(META_KEY_MODIFICATIONDATE)).isEmpty()) {
1128 auto dt = dateTime();
1129 if (dt.isValid())
1130 targetImage.setText(QStringLiteral(META_KEY_MODIFICATIONDATE), dt.toString(Qt::ISODate));
1131 }
1132 if (replaceExisting || targetImage.text(QStringLiteral(META_KEY_CREATIONDATE)).isEmpty()) {
1133 auto dt = dateTimeOriginal();
1134 if (dt.isValid())
1135 targetImage.setText(QStringLiteral(META_KEY_CREATIONDATE), dt.toString(Qt::ISODate));
1136 }
1137
1138 // set GPS info
1139 if (replaceExisting || targetImage.text(QStringLiteral(META_KEY_ALTITUDE)).isEmpty()) {
1140 auto v = altitude();
1141 if (!qIsNaN(v))
1142 targetImage.setText(QStringLiteral(META_KEY_ALTITUDE), QStringLiteral("%1").arg(v, 0, 'g', 9));
1143 }
1144 if (replaceExisting || targetImage.text(QStringLiteral(META_KEY_LATITUDE)).isEmpty()) {
1145 auto v = latitude();
1146 if (!qIsNaN(v))
1147 targetImage.setText(QStringLiteral(META_KEY_LATITUDE), QStringLiteral("%1").arg(v, 0, 'g', 9));
1148 }
1149 if (replaceExisting || targetImage.text(QStringLiteral(META_KEY_LONGITUDE)).isEmpty()) {
1150 auto v = longitude();
1151 if (!qIsNaN(v))
1152 targetImage.setText(QStringLiteral(META_KEY_LONGITUDE), QStringLiteral("%1").arg(v, 0, 'g', 9));
1153 }
1154 if (replaceExisting || targetImage.text(QStringLiteral(META_KEY_DIRECTION)).isEmpty()) {
1155 auto v = imageDirection();
1156 if (!qIsNaN(v))
1157 targetImage.setText(QStringLiteral(META_KEY_DIRECTION), QStringLiteral("%1").arg(v, 0, 'g', 9));
1158 }
1159}
1160
1161void MicroExif::updateImageResolution(QImage &targetImage)
1162{
1163 if (horizontalResolution() > 0)
1164 targetImage.setDotsPerMeterX(qRound(horizontalResolution() / 25.4 * 1000));
1165 if (verticalResolution() > 0)
1166 targetImage.setDotsPerMeterY(qRound(verticalResolution() / 25.4 * 1000));
1167}
1168
1169MicroExif MicroExif::fromByteArray(const QByteArray &ba, bool searchHeader)
1170{
1171 auto ba0(ba);
1172 if (searchHeader) {
1173 auto idxLE = ba0.indexOf(QByteArray("II"));
1174 auto idxBE = ba0.indexOf(QByteArray("MM"));
1175 auto idx = -1;
1176 if (idxLE > -1 && idxBE > -1)
1177 idx = std::min(idxLE, idxBE);
1178 else
1179 idx = idxLE > -1 ? idxLE : idxBE;
1180 if(idx > 0)
1181 ba0 = ba0.mid(idx);
1182 }
1183 QBuffer buf;
1184 buf.setData(ba0);
1185 return fromDevice(&buf);
1186}
1187
1188MicroExif MicroExif::fromRawData(const char *data, size_t size, bool searchHeader)
1189{
1190 if (data == nullptr || size == 0)
1191 return {};
1192 return fromByteArray(QByteArray::fromRawData(data, size), searchHeader);
1193}
1194
1195MicroExif MicroExif::fromDevice(QIODevice *device)
1196{
1197 if (device == nullptr || device->isSequential())
1198 return {};
1199 if (!device->open(QBuffer::ReadOnly))
1200 return {};
1201
1202 QDataStream ds(device);
1203 if (!checkHeader(ds))
1204 return {};
1205
1206 MicroExif exif;
1207
1208 // read TIFF ifd
1209 if (!readIfd(ds, exif.m_tiffTags))
1210 return {};
1211
1212 // read EXIF ifd
1213 if (auto pos = exif.m_tiffTags.value(EXIF_EXIFIFD).toUInt()) {
1214 if (!readIfd(ds, exif.m_exifTags, pos))
1215 return {};
1216 }
1217
1218 // read GPS ifd
1219 if (auto pos = exif.m_tiffTags.value(EXIF_GPSIFD).toUInt()) {
1220 if (!readIfd(ds, exif.m_gpsTags, pos, staticGpsTagTypes))
1221 return {};
1222 }
1223
1224 return exif;
1225}
1226
1227MicroExif MicroExif::fromImage(const QImage &image)
1228{
1229 MicroExif exif;
1230 if (image.isNull())
1231 return exif;
1232
1233 // Image properties
1234 exif.setWidth(image.width());
1235 exif.setHeight(image.height());
1236 exif.setHorizontalResolution(image.dotsPerMeterX() * 25.4 / 1000);
1237 exif.setVerticalResolution(image.dotsPerMeterY() * 25.4 / 1000);
1238 exif.setColorSpace(image.colorSpace());
1239
1240 // TIFF strings
1241 for (auto &&p : tiffStrMap) {
1242 exif.setTiffString(p.first, image.text(p.second));
1243 }
1244
1245 // EXIF strings
1246 for (auto &&p : exifStrMap) {
1247 exif.setExifString(p.first, image.text(p.second));
1248 }
1249
1250 // TIFF Software
1251 if (exif.software().isEmpty()) {
1252 auto sw = QCoreApplication::applicationName();
1253 auto ver = sw = QCoreApplication::applicationVersion();
1254 if (!sw.isEmpty() && !ver.isEmpty())
1255 sw.append(QStringLiteral(" %1").arg(ver));
1256 exif.setSoftware(sw.trimmed());
1257 }
1258
1259 // TIFF date and time
1260 auto dt = QDateTime::fromString(image.text(QStringLiteral(META_KEY_MODIFICATIONDATE)), Qt::ISODate);
1261 if (!dt.isValid())
1262 dt = QDateTime::currentDateTime();
1263 exif.setDateTime(dt);
1264
1265 // EXIF original date and time
1266 dt = QDateTime::fromString(image.text(QStringLiteral(META_KEY_CREATIONDATE)), Qt::ISODate);
1267 if (!dt.isValid())
1268 dt = QDateTime::currentDateTime();
1269 exif.setDateTimeOriginal(dt);
1270
1271 // GPS Info
1272 auto ok = false;
1273 auto alt = image.text(QStringLiteral(META_KEY_ALTITUDE)).toDouble(&ok);
1274 if (ok)
1275 exif.setAltitude(alt);
1276 auto lat = image.text(QStringLiteral(META_KEY_LATITUDE)).toDouble(&ok);
1277 if (ok)
1278 exif.setLatitude(lat);
1279 auto lon = image.text(QStringLiteral(META_KEY_LONGITUDE)).toDouble(&ok);
1280 if (ok)
1281 exif.setLongitude(lon);
1282 auto dir = image.text(QStringLiteral(META_KEY_DIRECTION)).toDouble(&ok);
1283 if (ok)
1284 exif.setImageDirection(dir);
1285
1286 return exif;
1287}
1288
1289void MicroExif::setTiffString(quint16 tagId, const QString &s)
1290{
1291 MicroExif::setString(m_tiffTags, tagId, s);
1292}
1293
1294QString MicroExif::tiffString(quint16 tagId) const
1295{
1296 return MicroExif::string(m_tiffTags, tagId);
1297}
1298
1299void MicroExif::setExifString(quint16 tagId, const QString &s)
1300{
1301 MicroExif::setString(m_exifTags, tagId, s);
1302}
1303
1304QString MicroExif::exifString(quint16 tagId) const
1305{
1306 return MicroExif::string(m_exifTags, tagId);
1307}
1308
1309void MicroExif::setGpsString(quint16 tagId, const QString &s)
1310{
1311 MicroExif::setString(m_gpsTags, tagId, s);
1312}
1313
1314QString MicroExif::gpsString(quint16 tagId) const
1315{
1316 return MicroExif::string(m_gpsTags, tagId);
1317}
1318
1319bool MicroExif::writeHeader(QDataStream &ds) const
1320{
1321 if (ds.byteOrder() == QDataStream::LittleEndian)
1322 ds << quint16(0x4949); // II
1323 else
1324 ds << quint16(0x4d4d); // MM
1325 ds << quint16(0x002a); // Tiff V6
1326 ds << quint32(8); // IFD offset
1327 return ds.status() == QDataStream::Ok;
1328}
1329
1330bool MicroExif::writeIfds(QDataStream &ds) const
1331{
1332 auto tiffTags = m_tiffTags;
1333 auto exifTags = m_exifTags;
1334 auto gpsTags = m_gpsTags;
1335 updateTags(tiffTags, exifTags, gpsTags);
1336
1337 TagPos positions;
1338 if (!writeIfd(ds, tiffTags, positions))
1339 return false;
1340 if (!writeIfd(ds, exifTags, positions, positions.value(EXIF_EXIFIFD)))
1341 return false;
1342 if (!writeIfd(ds, gpsTags, positions, positions.value(EXIF_GPSIFD), staticGpsTagTypes))
1343 return false;
1344 return true;
1345}
1346
1347void MicroExif::updateTags(Tags &tiffTags, Tags &exifTags, Tags &gpsTags) const
1348{
1349 if (exifTags.isEmpty()) {
1350 tiffTags.remove(EXIF_EXIFIFD);
1351 } else {
1352 tiffTags.insert(EXIF_EXIFIFD, quint32());
1353 exifTags.insert(EXIF_EXIFVERSION, QByteArray("0300"));
1354 }
1355 if (gpsTags.isEmpty()) {
1356 tiffTags.remove(EXIF_GPSIFD);
1357 } else {
1358 tiffTags.insert(EXIF_GPSIFD, quint32());
1359 gpsTags.insert(GPS_GPSVERSION, QByteArray("2400"));
1360 }
1361}
1362
1363void MicroExif::setString(Tags &tags, quint16 tagId, const QString &s)
1364{
1365 if (s.isEmpty())
1366 tags.remove(tagId);
1367 else
1368 tags.insert(tagId, s);
1369}
1370
1371QString MicroExif::string(const Tags &tags, quint16 tagId)
1372{
1373 return tags.value(tagId).toString();
1374}
KDb::version
KDB_EXPORT KDbVersionInfo version()
KRecentDirs::dir
KIOCORE_EXPORT QString dir(const QString &fileClass)
QBuffer::setData
void setData(const QByteArray &data)
QByteArray::append
QByteArray & append(QByteArrayView data)
QByteArray::at
char at(qsizetype i) const const
QByteArray::first
QByteArray first(qsizetype n) const const
QByteArray::fromRawData
QByteArray fromRawData(const char *data, qsizetype size)
QByteArray::isEmpty
bool isEmpty() const const
QByteArray::removeLast
QByteArray & removeLast()
QByteArray::size
qsizetype size() const const
QColorSpace::primaries
Primaries primaries() const const
QColorSpace::transferFunction
TransferFunction transferFunction() const const
QDataStream::byteOrder
ByteOrder byteOrder() const const
QDataStream::device
QIODevice * device() const const
QDataStream::setByteOrder
void setByteOrder(ByteOrder bo)
QDataStream::skipRawData
int skipRawData(int len)
QDataStream::status
Status status() const const
QDateTime::currentDateTime
QDateTime currentDateTime()
QDateTime::fromString
QDateTime fromString(QStringView string, QStringView format, QCalendar cal)
QDateTime::isValid
bool isValid() const const
QDateTime::offsetFromUtc
int offsetFromUtc() const const
QDateTime::setTimeZone
void setTimeZone(const QTimeZone &toZone)
QDateTime::toString
QString toString(QStringView format, QCalendar cal) const const
QHash::insert
iterator insert(const Key &key, const T &value)
QHash::remove
bool remove(const Key &key)
QHash::value
T value(const Key &key) const const
QImage::colorSpace
QColorSpace colorSpace() const const
QImage::dotsPerMeterX
int dotsPerMeterX() const const
QImage::dotsPerMeterY
int dotsPerMeterY() const const
QImage::height
int height() const const
QImage::isNull
bool isNull() const const
QImage::setDotsPerMeterX
void setDotsPerMeterX(int x)
QImage::setDotsPerMeterY
void setDotsPerMeterY(int y)
QImage::setText
void setText(const QString &key, const QString &text)
QImage::text
QString text(const QString &key) const const
QImage::width
int width() const const
QIODevice::close
virtual void close()
QIODevice::isSequential
virtual bool isSequential() const const
QIODevice::open
virtual bool open(QIODeviceBase::OpenMode mode)
QIODevice::pos
virtual qint64 pos() const const
QList::append
void append(QList< T > &&value)
QString::at
const QChar at(qsizetype position) const const
QString::fromLatin1
QString fromLatin1(QByteArrayView str)
QString::fromUtf8
QString fromUtf8(QByteArrayView str)
QString::isEmpty
bool isEmpty() const const
QString::left
QString left(qsizetype n) const const
QString::mid
QString mid(qsizetype position, qsizetype n) const const
QString::replace
QString & replace(QChar before, QChar after, Qt::CaseSensitivity cs)
QString::size
qsizetype size() const const
QString::toDouble
double toDouble(bool *ok) const const
QString::toInt
int toInt(bool *ok, int base) const const
QString::toLatin1
QByteArray toLatin1() const const
QString::toUtf8
QByteArray toUtf8() const const
QTimeZone::fromSecondsAheadOfUtc
QTimeZone fromSecondsAheadOfUtc(int offset)
QUuid::isNull
bool isNull() const const
QUuid::toString
QString toString(StringFormat mode) const const
QVariant::fromValue
QVariant fromValue(T &&value)
QVariant::toByteArray
QByteArray toByteArray() const const
QVariant::toDouble
double toDouble(bool *ok) const const
QVariant::toInt
int toInt(bool *ok) const const
QVariant::toString
QString toString() const const
QVariant::value
T value() const const
This file is part of the KDE documentation.
Documentation copyright © 1996-2025 The KDE developers.
Generated on Fri Apr 4 2025 12:14:35 by doxygen 1.13.2 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.