From a9f9ec7b4568e949775c98a80334ac7b6b2bd978 Mon Sep 17 00:00:00 2001 From: GM Date: Wed, 11 Nov 2026 00:45:58 -0400 Subject: [PATCH 01/15] Check a cached thumbnail belongs to its file A cache entry or failure marker was trusted on its modified time alone, so one made for another file with the same time was shown as this file's. It now has to carry this file's Thumb::URI as well, as the thumbnail spec asks a reader to check. --- src/thumbnails.cpp | 10 ++++++---- src/thumbnails.h | 2 +- tests/folio_tests.cpp | 42 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 49 insertions(+), 5 deletions(-) diff --git a/src/thumbnails.cpp b/src/thumbnails.cpp index 35fcf1ed..47004cf5 100644 --- a/src/thumbnails.cpp +++ b/src/thumbnails.cpp @@ -157,7 +157,7 @@ QImage Thumbnails::load(const QString &path, const QString &mime, int size) cons return {}; const QDateTime modified = info.lastModified(); - if (const QImage image(cachePath(path, size)); madeFor(image, modified)) + if (const QImage image(cachePath(path, size)); madeFor(image, path, modified)) return image; if (failedBefore(path, modified)) return {}; @@ -317,7 +317,7 @@ void Thumbnails::rememberFailure(const QString &path, const QDateTime &modified) } bool Thumbnails::failedBefore(const QString &path, const QDateTime &modified) const { - return madeFor(QImage(failPath(path)), modified); + return madeFor(QImage(failPath(path)), path, modified); } // Whether a cached thumbnail (or failure marker) was made from the file as it @@ -326,9 +326,11 @@ bool Thumbnails::failedBefore(const QString &path, const QDateTime &modified) co // the milliseconds. One another app made goes by the seconds alone. // QImageReader::text() splits keys at ':', so these are only readable from // the decoded image. -bool Thumbnails::madeFor(const QImage &image, const QDateTime &modified) { +bool Thumbnails::madeFor(const QImage &image, const QString &path, const QDateTime &modified) { const QString exact = image.text("X-Folio::MTime"); - return !image.isNull() && image.text("Thumb::MTime") == QString::number(modified.toSecsSinceEpoch()) + // The spec asks a reader to check that Thumb::URI names the file too. + return !image.isNull() && image.text("Thumb::URI") == fileUri(path) + && image.text("Thumb::MTime") == QString::number(modified.toSecsSinceEpoch()) && (exact.isEmpty() || exact == QString::number(modified.toMSecsSinceEpoch())); } diff --git a/src/thumbnails.h b/src/thumbnails.h index 919cc2da..935ac586 100644 --- a/src/thumbnails.h +++ b/src/thumbnails.h @@ -41,7 +41,7 @@ class Thumbnails { void rememberFailure(const QString &path, const QDateTime &modified) const; bool failedBefore(const QString &path, const QDateTime &modified) const; void save(QImage image, const QString &target, const QString &path, const QDateTime &modified) const; - static bool madeFor(const QImage &image, const QDateTime &modified); + static bool madeFor(const QImage &image, const QString &path, const QDateTime &modified); QString m_cache; QHash m_thumbnailers; diff --git a/tests/folio_tests.cpp b/tests/folio_tests.cpp index c26edf31..3cd065f1 100644 --- a/tests/folio_tests.cpp +++ b/tests/folio_tests.cpp @@ -5038,6 +5038,48 @@ private slots: QCOMPARE(Thumbnails::bucketFor(512), QString("x-large")); } + void thumbnailsRejectACacheEntryForAnotherFile() + { + QTemporaryDir dir; + QImage picture(800, 400, QImage::Format_RGB32); + picture.fill(Qt::red); + const QString file = dir.filePath("wide.png"); + QVERIFY(picture.save(file)); + + Thumbnails thumbnails(dir.filePath("cache"), {dir.filePath("none")}); + thumbnails.load(file, "image/png", 256); + const QString cached = dir.filePath("cache/large/" + Thumbnails::cacheKey(file)); + + // A fresh entry tagged for another file, or for none, is made again. + for (const QString &uri : {QString("file:///elsewhere/wide.png"), QString()}) { + QImage foreign(cached); + foreign.fill(Qt::blue); + foreign.setText("Thumb::URI", uri); + QVERIFY(foreign.save(cached)); + QCOMPARE(thumbnails.load(file, "image/png", 256).pixelColor(0, 0), QColor(Qt::red)); + QCOMPARE(QImage(cached).text("Thumb::URI"), QUrl::fromLocalFile(file).toString(QUrl::FullyEncoded)); + } + } + + void thumbnailsRejectAFailureMarkerForAnotherFile() + { + QTemporaryDir dir; + Thumbnails thumbnails(dir.filePath("cache"), {dir.filePath("none")}); + + // A marker with the file's time but another file's URI, or none, doesn't stop its thumbnail. + for (const QString &uri : {QString("file:///elsewhere/photo.png"), QString()}) { + const QString file = dir.filePath(uri.isEmpty() ? "unnamed.png" : "named.png"); + QVERIFY(QImage(64, 32, QImage::Format_RGB32).save(file)); + const QString marker = dir.filePath("cache/fail/folio/" + Thumbnails::cacheKey(file)); + QVERIFY(QDir().mkpath(QFileInfo(marker).absolutePath())); + QImage foreign(1, 1, QImage::Format_ARGB32); + foreign.setText("Thumb::URI", uri); + foreign.setText("Thumb::MTime", QString::number(QFileInfo(file).lastModified().toSecsSinceEpoch())); + QVERIFY(foreign.save(marker)); + QVERIFY(!thumbnails.load(file, "image/png", 128).isNull()); + } + } + void thumbnailsFollowAPictureSavedOver() { // Qt keeps the images it has shown by their URL, and a re-read makes From bb07ecaf41a8a78eb4ecdc0d1b82698214a0726d Mon Sep 17 00:00:00 2001 From: GM Date: Wed, 11 Nov 2026 00:45:58 -0400 Subject: [PATCH 02/15] Try again what an older Folio couldn't thumbnail Failure markers went to fail/folio, so a file Folio could not thumbnail stayed blank after it learned to, as it does for camera RAW here. They now go to the spec's fail/-, as fail/folio-2: the number is raised whenever Folio learns to draw more. --- src/thumbnails.cpp | 2 +- src/thumbnails.h | 2 ++ tests/folio_tests.cpp | 36 +++++++++++++++++++++++++++++++++--- 3 files changed, 36 insertions(+), 4 deletions(-) diff --git a/src/thumbnails.cpp b/src/thumbnails.cpp index 47004cf5..db665591 100644 --- a/src/thumbnails.cpp +++ b/src/thumbnails.cpp @@ -144,7 +144,7 @@ QString Thumbnails::cachePath(const QString &path, int size) const { } QString Thumbnails::failPath(const QString &path) const { - return m_cache + "/fail/folio/" + cacheKey(path); + return m_cache + "/" + failures + "/" + cacheKey(path); } QImage Thumbnails::load(const QString &path, const QString &mime, int size) const { diff --git a/src/thumbnails.h b/src/thumbnails.h index 935ac586..819cb585 100644 --- a/src/thumbnails.h +++ b/src/thumbnails.h @@ -24,6 +24,8 @@ class Thumbnails { QImage load(const QString &path, const QString &mime, int size) const; static QString cacheKey(const QString &path); + // The spec's fail/-: the number is raised when Folio learns to draw more, so old failures are tried again. + static inline const QString failures = QStringLiteral("fail/folio-2"); static QString bucketFor(int size); // A text file's first lines set on a page in the given colors. Made // fresh each time rather than cached, since the colors follow the theme. diff --git a/tests/folio_tests.cpp b/tests/folio_tests.cpp index 3cd065f1..3555573e 100644 --- a/tests/folio_tests.cpp +++ b/tests/folio_tests.cpp @@ -5070,7 +5070,7 @@ private slots: for (const QString &uri : {QString("file:///elsewhere/photo.png"), QString()}) { const QString file = dir.filePath(uri.isEmpty() ? "unnamed.png" : "named.png"); QVERIFY(QImage(64, 32, QImage::Format_RGB32).save(file)); - const QString marker = dir.filePath("cache/fail/folio/" + Thumbnails::cacheKey(file)); + const QString marker = dir.filePath("cache/" + Thumbnails::failures + "/" + Thumbnails::cacheKey(file)); QVERIFY(QDir().mkpath(QFileInfo(marker).absolutePath())); QImage foreign(1, 1, QImage::Format_ARGB32); foreign.setText("Thumb::URI", uri); @@ -5132,7 +5132,37 @@ private slots: // A thumbnailer that fails leaves a failure marker, so it isn't retried. write(dir.filePath("clip.mp4"), "not a video"); QVERIFY(thumbnails.load(dir.filePath("clip.mp4"), "video/mp4", 128).isNull()); - QVERIFY(QFile::exists(dir.filePath("cache/fail/folio/" + Thumbnails::cacheKey(dir.filePath("clip.mp4"))))); + QVERIFY(QFile::exists(dir.filePath("cache/" + Thumbnails::failures + "/" + Thumbnails::cacheKey(dir.filePath("clip.mp4"))))); + } + + void thumbnailsTryAgainWhatAnOlderVersionCouldnt() + { + QTemporaryDir dir; + // The thumbnailer is a script that notes each run beside itself and fails. + const QString script = dir.filePath("fail.sh"), runs = script + ".runs"; + write(script, "echo run >> \"$0.runs\"\nexit 1\n"); + write(dir.filePath("demo.thumbnailer"), + "[Thumbnailer Entry]\nExec=/bin/sh \"" + script.toUtf8() + "\" %i %o %s\nMimeType=video/mp4;\n"); + Thumbnails thumbnails(dir.filePath("cache"), {dir.path()}); + const QString clip = dir.filePath("clip.mp4"), older = dir.filePath("older.mp4"); + write(clip, "not a video"); + write(older, "not a video"); + + // A marker of this Folio's holds the file back, so the thumbnailer runs once; each run notes four bytes. + QVERIFY(thumbnails.load(clip, "video/mp4", 128).isNull()); + QVERIFY(thumbnails.load(clip, "video/mp4", 128).isNull()); + QVERIFY(QFile::exists(dir.filePath("cache/" + Thumbnails::failures + "/" + Thumbnails::cacheKey(clip)))); + QCOMPARE(QFileInfo(runs).size(), 4); + + // A marker from 0.2.0, which kept them in fail/folio, holds nothing back: the file is tried once more. + const QString marker = dir.filePath("cache/fail/folio/" + Thumbnails::cacheKey(older)); + QVERIFY(QDir().mkpath(QFileInfo(marker).absolutePath())); + QImage stale(1, 1, QImage::Format_ARGB32); + stale.setText("Thumb::URI", QUrl::fromLocalFile(older).toString(QUrl::FullyEncoded)); + stale.setText("Thumb::MTime", QString::number(QFileInfo(older).lastModified().toSecsSinceEpoch())); + QVERIFY(stale.save(marker)); + QVERIFY(thumbnails.load(older, "video/mp4", 128).isNull()); + QCOMPARE(QFileInfo(runs).size(), 8); } void thumbnailsRememberOnlyWhatFailed() @@ -5149,7 +5179,7 @@ private slots: // later still gets its turn. write(dir.filePath("bundle.zip"), "not a zip"); QVERIFY(thumbnails.load(dir.filePath("bundle.zip"), "application/zip", 128).isNull()); - QVERIFY(!QFile::exists(dir.filePath("cache/fail/folio/" + Thumbnails::cacheKey(dir.filePath("bundle.zip"))))); + QVERIFY(!QFile::exists(dir.filePath("cache/" + Thumbnails::failures + "/" + Thumbnails::cacheKey(dir.filePath("bundle.zip"))))); // A folder's peek asks for any picture, and gets the thumbnailer for // the one it names. From c3ddaa3028592359c8e82ca0394fc84937fb9810 Mon Sep 17 00:00:00 2001 From: GM Date: Wed, 11 Nov 2026 00:45:58 -0400 Subject: [PATCH 03/15] Find a thumbnailer through its type's aliases A thumbnailer that names a type only by an alias never matched the canonical name Folio asks with, so glycin's image/x-dds left a DDS file blank. The declared types are resolved to canonical names once, when the thumbnailers are read. --- src/thumbnails.cpp | 14 ++++++++++++-- tests/folio_tests.cpp | 31 +++++++++++++++++++++++++++++++ 2 files changed, 43 insertions(+), 2 deletions(-) diff --git a/src/thumbnails.cpp b/src/thumbnails.cpp index db665591..3d51199e 100644 --- a/src/thumbnails.cpp +++ b/src/thumbnails.cpp @@ -94,7 +94,10 @@ Thumbnails::Thumbnails(const QString &cacheDirectory, const QStringList &thumbna for (const QString &base : data) directories << base + "/thumbnailers"; } + QMimeDatabase mimes; for (const QString &directory : directories) { + // A spec may name a type by an alias, as glycin names DDS pictures image/x-dds. + QHash named, aliased; QDirIterator it(directory, {"*.thumbnailer"}, QDir::Files); while (it.hasNext()) { // A tiny desktop-entry reader: QSettings would treat the @@ -115,9 +118,16 @@ Thumbnails::Thumbnails(const QString &cacheDirectory, const QStringList &thumbna const QString tryExec = fields.value("TryExec"); if (exec.isEmpty() || (!tryExec.isEmpty() && QStandardPaths::findExecutable(tryExec).isEmpty())) continue; - for (const QString &mime : fields.value("MimeType").split(';', Qt::SkipEmptyParts)) - m_thumbnailers.insert(mime.trimmed(), exec); + for (const QString &declared : fields.value("MimeType").split(';', Qt::SkipEmptyParts)) { + const QString mime = declared.trimmed(); + named.insert(mime, exec); + if (const QString type = mimes.mimeTypeForName(mime).name(); !type.isEmpty()) + aliased.insert(type, exec); + } } + // Within one directory the spec that names a type itself wins over one that names an alias of it. + m_thumbnailers.insert(aliased); + m_thumbnailers.insert(named); } } diff --git a/tests/folio_tests.cpp b/tests/folio_tests.cpp index 3555573e..e5b8f5b8 100644 --- a/tests/folio_tests.cpp +++ b/tests/folio_tests.cpp @@ -14,6 +14,7 @@ #include #include #include +#include #include #include #include @@ -5231,6 +5232,36 @@ private slots: QVERIFY(qGray(page.pixel(page.width() - 3, page.height() - 3)) > 200); } + void thumbnailsMatchATypeNamedByItsAlias() + { + QTemporaryDir dir; + QImage page(64, 96, QImage::Format_RGB32); + page.fill(Qt::green); + QVERIFY(page.save(dir.filePath("page.png"))); + QVERIFY(QDir(dir.path()).mkdir("system") && QDir(dir.path()).mkdir("user")); + // Like evince, the user's spec names comic books and icons only by an alias. + write(dir.filePath("user/comics.thumbnailer"), + "[Thumbnailer Entry]\nExec=/bin/cp \"" + dir.filePath("page.png").toUtf8() + "\" %o\n" + "MimeType=application/x-cbz;image/x-icon;application/x-nothing-here;video/x-matroska;audio/vnd.wave;\n"); + write(dir.filePath("user/media.thumbnailer"), "[Thumbnailer Entry]\nExec=/bin/true %i\nMimeType=video/matroska;audio/x-wav;\n"); + write(dir.filePath("system/icons.thumbnailer"), "[Thumbnailer Entry]\nExec=/bin/false %i\nMimeType=image/vnd.microsoft.icon;\n"); + Thumbnails thumbnails(dir.filePath("cache"), {dir.filePath("system"), dir.filePath("user")}); + + write(dir.filePath("issue.cbz"), "not really a zip"); + const QImage thumb = thumbnails.load(dir.filePath("issue.cbz"), "application/vnd.comicbook+zip", 128); + QCOMPARE(thumb.pixelColor(0, 0), QColor(Qt::green)); + // The later directory still wins when its spec names the type by an alias. + QVERIFY(thumbnails.thumbnailerFor("image/vnd.microsoft.icon").startsWith("/bin/cp")); + // Within one directory the spec that names the type itself wins, whichever file is read first. + QCOMPARE(QMimeDatabase().mimeTypeForName("video/x-matroska").name(), QString("video/matroska")); + QCOMPARE(QMimeDatabase().mimeTypeForName("audio/x-wav").name(), QString("audio/vnd.wave")); + QVERIFY(thumbnails.thumbnailerFor("video/matroska").startsWith("/bin/true")); + QVERIFY(thumbnails.thumbnailerFor("audio/vnd.wave").startsWith("/bin/cp")); + // A type the MIME database doesn't know is matched by the name the spec gives, and by no other. + QVERIFY(thumbnails.thumbnailerFor("application/x-nothing-here").startsWith("/bin/cp")); + QVERIFY(thumbnails.thumbnailerFor("").isEmpty()); + } + void previewerPicksAViewerForEachType() { QCOMPARE(Previewer::viewerFor("image/png", false), QString("image")); From 3621993da7ab8c5ee2b96a0ee69fbf3c669a29df Mon Sep 17 00:00:00 2001 From: GM Date: Wed, 11 Nov 2026 00:45:58 -0400 Subject: [PATCH 04/15] Thumbnail camera RAW from its embedded JPEG A CR2, NEF, NRW, ARW, SR2, DNG or PEF showed a blank tile unless a RAW thumbnailer was installed. The camera stores a finished JPEG in each, and a bounded reader of the TIFF directories now finds the largest one. An installed thumbnailer still answers first. --- src/rawembed.cpp | 322 ++++++++++++++++++++++++++++++++++++++++++ src/rawembed.h | 14 ++ src/thumbnails.cpp | 7 + tests/folio_tests.cpp | 193 +++++++++++++++++++++++++ 4 files changed, 536 insertions(+) create mode 100644 src/rawembed.cpp create mode 100644 src/rawembed.h diff --git a/src/rawembed.cpp b/src/rawembed.cpp new file mode 100644 index 00000000..5ba6d702 --- /dev/null +++ b/src/rawembed.cpp @@ -0,0 +1,322 @@ +#include "rawembed.h" + +#include +#include +#include +#include +#include +#include +#include + +namespace { + +// Header and directory bytes read per file in total. +constexpr quint64 kHeaderBudget = 1048576; +// Frame-header bytes read per file across all candidates; then validation stops. +constexpr qint64 kSofBudget = 1048576; +// One candidate's frame-header walk never reads past this. +constexpr qint64 kJpegPrefix = 262144; +// Frame-header walks read through a window this big, so a byte costs no system call. +constexpr qint64 kWindow = 8192; +// More candidates than this are never validated; a real file holds a handful. +constexpr int kMaxCandidates = 16; +// More directories than this, or deeper nesting, is a corrupt chain; the limit also bounds the recursion. +constexpr int kMaxIfds = 64; +constexpr int kMaxDepth = 4; +constexpr quint16 kMaxEntries = 1024; +constexpr quint64 kEntryLength = 12; +// A value longer than this is image data or a corrupt count. +constexpr quint64 kMaxValue = 65536; +// SubIFD fan-out is capped, so one count cannot queue unbounded work. +constexpr quint32 kMaxPointers = 64; +// The largest embedded JPEG read into memory; a real one is a few MiB. +constexpr quint64 kMaxJpeg = 64 * 1048576; +// SOI plus one frame header: anything shorter is no picture. +constexpr qint64 kMinJpeg = 20; +constexpr quint16 kTiffMagic = 42; +// A TIFF header is 8 bytes; a value of 4 bytes or fewer rides inline in its entry. +constexpr quint64 kTiffHeaderLength = 8, kInlineBytes = 4; + +// TIFF and EXIF tags, JPEG compression values, field types and JPEG markers. +constexpr quint16 kCompression = 0x0103, kStripOffsets = 0x0111, kOrientation = 0x0112, kStripByteCounts = 0x0117; +constexpr quint16 kSubIfds = 0x014A, kJpegOffset = 0x0201, kJpegLength = 0x0202; +// EXIF Orientation 1 is upright; 2 to 8 flip or turn the picture. +constexpr quint64 kFirstTurn = 2, kLastTurn = 8; +constexpr quint64 kOldJpeg = 6, kJpeg = 7; +constexpr quint16 kShort = 3, kLong = 4, kIfdType = 13; +constexpr quint8 kMarker = 0xFF, kSoi = 0xD8, kStuffed = 0x00, kTem = 0x01, kRst0 = 0xD0; +constexpr quint8 kSos = 0xDA, kEoi = 0xD9, kApp1 = 0xE1; +// A frame header opens with precision(1) height(2) width(2); SOF0 to SOF2 are the Huffman frames a preview uses. +constexpr quint8 kFirstFrame = 0xC0, kLastFrame = 0xCF, kLastHuffmanFrame = 0xC2, kDht = 0xC4, kJpg = 0xC8, kDac = 0xCC; +constexpr qsizetype kFrameHeadLength = 5; + +// Marker, length 34, "Exif\0\0", "II" 42 and IFD0 at 8, one entry: Orientation, SHORT, count 1, no next IFD. +constexpr unsigned char kExifOrientation[36] = {0xFF, 0xE1, 0x00, 0x22, 'E', 'x', 'i', 'f', 0, 0, 'I', 'I', 0x2A, 0, + 8, 0, 0, 0, 1, 0, 0x12, 0x01, 3, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; +constexpr int kExifOrientationAt = 28; + +quint16 rd16(const char *p, bool le) { return le ? qFromLittleEndian(p) : qFromBigEndian(p); } +quint32 rd32(const char *p, bool le) { return le ? qFromLittleEndian(p) : qFromBigEndian(p); } + +// Bytes of one value of each TIFF type 0 to 13 (TIFF 6.0 section 2, 13 is an IFD offset); 0 is unknown. +quint64 typeSize(quint16 type) { + static const quint8 sizes[] = {0, 1, 1, 2, 4, 8, 1, 1, 2, 4, 8, 4, 8, 4}; + return type < sizeof sizes ? sizes[type] : 0; +} + +bool isLong(quint16 type) { return type == kLong || type == kIfdType; } + +// A JPEG frame header; DHT, JPG and DAC share the marker range but are not frames. +bool isFrame(quint8 m) { return m >= kFirstFrame && m <= kLastFrame && m != kDht && m != kJpg && m != kDac; } + +// The file through the header budget, or a slice in hand that is read at most its own length. +struct Source { + QFile *file; + QByteArray slice; + quint64 size; + quint64 left; + + bool get(quint64 offset, quint64 length, QByteArray &out) { + if (length > left || offset > size || length > size - offset) + return false; + left -= length; + if (!file) + out = slice.mid(qsizetype(offset), qsizetype(length)); + else + out = file->seek(qint64(offset)) ? file->read(qint64(length)) : QByteArray(); + return quint64(out.size()) == length; + } +}; + +// 49 49 2A 00 and the first IFD's offset, or 4D 4D 00 2A big-endian; BigTIFF (43) is refused, not misread. +bool tiffHeader(Source &src, quint64 at, bool &le, quint64 &ifd) { + QByteArray b; + if (!src.get(at, kTiffHeaderLength, b) || (!b.startsWith("II") && !b.startsWith("MM"))) + return false; + le = b.startsWith("II"); + ifd = rd32(b.constData() + 4, le); + return rd16(b.constData() + 2, le) == kTiffMagic; +} + +struct Walker { + explicit Walker(Source &source) : src(source) {} + Source &src; + QVector> candidates; + // Each directory is read once, so a cycle neither loops nor uses up the limit. + QVector seen; + std::optional orientation; + + // A value's bytes: the entry's last four when they fit, else that many bytes at the offset those four name. + bool value(bool le, quint16 type, quint32 count, const char *val, QByteArray &out) { + const quint64 total = typeSize(type) * count; + if (typeSize(type) == 0 || total > kMaxValue) + return false; + if (total <= kInlineBytes) + out = QByteArray(val, int(total)); + return total <= kInlineBytes || src.get(rd32(val, le), total, out); + } + + // The first value of a SHORT or LONG field. + std::optional one(bool le, quint16 type, quint32 count, const char *val) { + QByteArray b; + if (count == 0 || (type != kShort && !isLong(type)) || !value(le, type, count, val, b)) + return {}; + return type == kShort ? rd16(b.constData(), le) : rd32(b.constData(), le); + } + + // An IFD is count(2), then 12-byte entries tag(2) type(2) count(4) value-or-offset(4), then the next IFD(4). + void walk(bool le, int depth, quint64 at) { + QByteArray b, entries; + if (depth > kMaxDepth || seen.size() >= kMaxIfds || seen.contains(at) || !src.get(at, 2, b)) + return; + const quint16 count = rd16(b.constData(), le); + // A 0xFFFF count is the hostile case: this directory is skipped, never read or looped. + if (count > kMaxEntries || !src.get(at + 2, count * kEntryLength, entries)) + return; + seen.append(at); + std::optional jpegOffset, jpegLength, stripOffset, stripLength, compression; + QVector children; + for (int i = 0; i < count; ++i) { + const char *e = entries.constData() + i * kEntryLength; + const quint16 tag = rd16(e, le), type = rd16(e + 2, le); + const quint32 n = rd32(e + 4, le); + if (tag == kOrientation && !orientation) orientation = one(le, type, n, e + 8); + else if (tag == kJpegOffset) jpegOffset = one(le, type, n, e + 8); + else if (tag == kJpegLength) jpegLength = one(le, type, n, e + 8); + // Many strips are raw sensor data, never one preview. + else if (tag == kStripOffsets) stripOffset = n == 1 ? one(le, type, n, e + 8) : std::nullopt; + else if (tag == kStripByteCounts) stripLength = one(le, type, n, e + 8); + else if (tag == kCompression) compression = one(le, type, n, e + 8); + else if (tag == kSubIfds && n > 0 && (type == kShort || isLong(type)) + && value(le, type, qMin(n, kMaxPointers), e + 8, b)) + for (quint32 k = 0; k < qMin(n, kMaxPointers); ++k) + children.append(type == kShort ? rd16(b.constData() + k * 2, le) : rd32(b.constData() + k * 4, le)); + } + if (jpegOffset && jpegLength && *jpegLength > 0) + candidates.append({*jpegOffset, *jpegLength}); + // Any lone JPEG-compressed strip is a preview (a CR2 keeps its big one in IFD0); the frame rule keeps raw data out. + if (stripOffset && stripLength && compression && (*compression == kOldJpeg || *compression == kJpeg) + && *stripLength > 0) + candidates.append({*stripOffset, *stripLength}); + for (const quint64 child : children) + walk(le, depth + 1, child); + // A next pointer that cannot be read ends the chain and keeps what it collected. + if (src.get(at + 2 + count * kEntryLength, 4, b) && rd32(b.constData(), le) != 0) + walk(le, depth, rd32(b.constData(), le)); + } +}; + +// The first frame header's marker and size (FF C0 00 11 08 height width), reading at most `left` file bytes through a window. +bool firstFrame(QFile &file, qint64 &left, quint8 &marker, quint32 &width, quint32 &height) { + QByteArray window, b; + qsizetype used = 0; + const auto take = [&](qsizetype n) { + b.clear(); + while (b.size() < n) { + if (used == window.size()) { + window = left > 0 ? file.read(qMin(kWindow, left)) : QByteArray(); + left -= window.size(); + used = 0; + if (window.isEmpty()) + return false; + } + const qsizetype part = qMin(n - b.size(), window.size() - used); + b += window.mid(used, part); + used += part; + } + return true; + }; + if (!take(2) || quint8(b[0]) != kMarker || quint8(b[1]) != kSoi) + return false; + for (;;) { + do { if (!take(1)) return false; } while (quint8(b[0]) != kMarker); + do { if (!take(1)) return false; } while (quint8(b[0]) == kMarker); + const quint8 m = quint8(b[0]); + if (m == kStuffed || m == kSos || m == kEoi) + return false; + // TEM, the restart markers and SOI carry no length. + if (m == kTem || (m >= kRst0 && m <= kSoi)) + continue; + if (!take(2) || qFromBigEndian(b.constData()) < 2) + return false; + // A segment is skipped by reading past it, so the window still bounds the total. + if (!isFrame(m)) { + if (!take(qFromBigEndian(b.constData()) - 2)) + return false; + continue; + } + if (!take(kFrameHeadLength)) + return false; + marker = m; + height = qFromBigEndian(b.constData() + 1); + width = qFromBigEndian(b.constData() + 3); + return true; + } +} + +// The orientation the JPEG's own first Exif segment (FF E1, length, "Exif\0\0", a TIFF) names, if any. +std::optional ownOrientation(const QByteArray &jpeg) { + for (qsizetype at = 2; at + 4 <= jpeg.size() && quint8(jpeg[at]) == kMarker;) { + const quint8 marker = quint8(jpeg[at + 1]); + const qsizetype length = qFromBigEndian(jpeg.constData() + at + 2); + if (marker == kSos || marker == kEoi || isFrame(marker) || length < 2 || at + 2 + length > jpeg.size()) + return {}; + if (marker == kApp1 && length >= 8 && jpeg.mid(at + 4, 6) == QByteArray("Exif\0\0", 6)) { + const QByteArray tiff = jpeg.mid(at + 10, length - 8); + Source slice{nullptr, tiff, quint64(tiff.size()), quint64(tiff.size())}; + Walker walker(slice); + bool le = true; + quint64 ifd = 0; + if (tiffHeader(slice, 0, le, ifd)) + walker.walk(le, 0, ifd); + return walker.orientation; + } + at += 2 + length; + } + return {}; +} + +struct Preview { + quint64 offset = 0, length = 0, pixels = 0; +}; + +// Most pixels first, the longer of two equals ahead; only Huffman frames (SOF0 to SOF2) count, SOF3 is raw data. +QVector ranked(QFile &file, const QVector> &candidates) { + qint64 sofLeft = kSofBudget; + QVector previews; + for (int i = 0; i < qMin(int(candidates.size()), kMaxCandidates); ++i) { + const quint64 offset = candidates[i].first, length = candidates[i].second; + // A span running past the end of the file is a cut file, not a preview. + if (length < quint64(kMinJpeg) || sofLeft == 0 || offset > quint64(file.size()) + || length > quint64(file.size()) - offset) + continue; + const qint64 span = qMin(qint64(qMin(length, quint64(kJpegPrefix))), sofLeft); + qint64 left = span; + quint8 marker = 0; + quint32 width = 0, height = 0; + const bool found = span >= kMinJpeg && file.seek(qint64(offset)) && firstFrame(file, left, marker, width, height); + sofLeft -= span - left; + if (found && marker <= kLastHuffmanFrame) + previews.append({offset, length, quint64(width) * height}); + } + std::stable_sort(previews.begin(), previews.end(), [](const Preview &a, const Preview &b) { + return a.pixels != b.pixels ? a.pixels > b.pixels : a.length > b.length; + }); + return previews; +} + +// One preview read and scaled to fit `pixels`, turned by the directory's `turn` when it names none of its own. +QImage decoded(QFile &file, const Preview &preview, quint64 turn, int pixels) { + if (!file.seek(qint64(preview.offset))) + return {}; + QByteArray jpeg = file.read(qint64(preview.length)); + if (quint64(jpeg.size()) != preview.length) + return {}; + if (turn >= kFirstTurn && turn <= kLastTurn && !ownOrientation(jpeg.left(kJpegPrefix))) { + QByteArray segment(reinterpret_cast(kExifOrientation), sizeof kExifOrientation); + qToLittleEndian(quint16(turn), segment.data() + kExifOrientationAt); + jpeg.insert(2, segment); + } + QBuffer buffer(&jpeg); + QImageReader reader(&buffer, "jpeg"); + reader.setAutoTransform(true); + const QSize full = reader.size(); + if (full.width() > pixels || full.height() > pixels) + reader.setScaledSize(full.scaled(pixels, pixels, Qt::KeepAspectRatio)); + return reader.read(); +} + +} // namespace + +bool RawEmbed::handles(const QString &mime) { + // shared-mime-info's names for .cr2 .nef .nrw .arw .sr2 .dng .pef. + static const QStringList types = {"image/x-canon-cr2", "image/x-nikon-nef", "image/x-nikon-nrw", "image/x-sony-arw", + "image/x-sony-sr2", "image/x-adobe-dng", "image/x-pentax-pef"}; + return types.contains(mime); +} + +QImage RawEmbed::thumbnail(const QString &path, int pixels) { + // Unbuffered, so a small directory read costs its own bytes and no read-ahead. + QFile file(path); + if (!file.open(QIODevice::ReadOnly | QIODevice::Unbuffered)) + return {}; + Source src{&file, {}, quint64(file.size()), kHeaderBudget}; + Walker walker(src); + bool le = true; + quint64 ifd = 0; + if (!tiffHeader(src, 0, le, ifd)) + return {}; + walker.walk(le, 0, ifd); + + // A preview that doesn't decode is passed over for the next largest that fits what is left of one limit of bytes. + quint64 left = kMaxJpeg; + for (const Preview &preview : ranked(file, walker.candidates)) { + if (preview.length > left) + continue; + left -= preview.length; + const QImage image = decoded(file, preview, walker.orientation.value_or(0), pixels); + if (!image.isNull()) + return image; + } + return {}; +} diff --git a/src/rawembed.h b/src/rawembed.h new file mode 100644 index 00000000..cbdec325 --- /dev/null +++ b/src/rawembed.h @@ -0,0 +1,14 @@ +#pragma once + +#include +#include + +// Camera RAW thumbnails from the embedded JPEG, found in the TIFF directories of CR2 NEF NRW ARW SR2 DNG PEF. +namespace RawEmbed { + +bool handles(const QString &mime); + +// The largest valid embedded JPEG, upright and at most `pixels` on its longer side; null when the file holds none. +QImage thumbnail(const QString &path, int pixels); + +} // namespace RawEmbed diff --git a/src/thumbnails.cpp b/src/thumbnails.cpp index 3d51199e..69de6c69 100644 --- a/src/thumbnails.cpp +++ b/src/thumbnails.cpp @@ -1,4 +1,5 @@ #include "thumbnails.h" +#include "rawembed.h" #include #include @@ -194,6 +195,12 @@ QImage Thumbnails::load(const QString &path, const QString &mime, int size) cons } QImage Thumbnails::generate(const QString &path, const QString &mime, int pixels, bool &attempted) const { + // A camera RAW with no installed thumbnailer, the desktop's own answer, shows the JPEG the camera embedded. + if (RawEmbed::handles(mime) && !m_thumbnailers.contains(mime)) { + attempted = true; + if (const QImage image = RawEmbed::thumbnail(path, pixels); !image.isNull()) + return image; + } // Common photo formats decode fastest in-process; anything Qt can't read // (HEIC, JPEG XL) falls through to the installed thumbnailers. if (mime.startsWith("image/")) { diff --git a/tests/folio_tests.cpp b/tests/folio_tests.cpp index e5b8f5b8..99b32403 100644 --- a/tests/folio_tests.cpp +++ b/tests/folio_tests.cpp @@ -5262,6 +5262,116 @@ private slots: QVERIFY(thumbnails.thumbnailerFor("").isEmpty()); } + void thumbnailsShowACameraRawsEmbeddedJpeg() + { + // IFD0's quarter turn applies to the stored 400 by 300 picture unless the JPEG names its own, which then rules. + QCOMPARE(rawThumbnail(rawWithJpeg(jpeg(400, 300), kQuarterTurn)), QSize(300, 400)); + QCOMPARE(rawThumbnail(rawWithJpeg(jpeg(400, 300, kUpright), kQuarterTurn)), QSize(400, 300)); + QCOMPARE(rawThumbnail(rawWithJpeg(jpeg(400, 300, kQuarterTurn), kUpright)), QSize(300, 400)); + } + + void thumbnailsPickTheLargestEmbeddedJpeg() + { + // Big-endian like a NEF: IFD0 names a small JPEG, its SubIFDs lossless raw data (SOF3) and the preview. + const QByteArray small = jpeg(160, 120), big = jpeg(640, 480); + const QByteArray sof3("\xFF\xD8\xFF\xC3\x00\x0B\x08\x0B\xB8\x0F\xA0\x01\x01\x22\x00\xFF\xD9\0\0\0\0\0\0\0\0", 25); + Raw nef(false); + const quint32 smallAt = nef.add(small), bigAt = nef.add(big), sof3At = nef.add(sof3); + const quint32 raw = nef.ifd(strip(sof3At, sof3.size())), preview = nef.ifd(pair(bigAt, big.size())); + const quint32 subs = nef.add(nef.word(raw, 4) + nef.word(preview, 4)); + nef.setFirst(nef.ifd(pair(smallAt, small.size()) + Entries{{kSubIfds, kLong, 2, subs}})); + QCOMPARE(rawThumbnail(nef.bytes), QSize(640, 480)); + // Like a CR2: the preview is IFD0's JPEG-compressed strip and IFD1 holds a thumbnail. + Raw cr2(true); + const quint32 stripAt = cr2.add(big), thumbAt = cr2.add(small); + cr2.setFirst(cr2.ifd(strip(stripAt, big.size()), cr2.ifd(pair(thumbAt, small.size())))); + QCOMPARE(rawThumbnail(cr2.bytes), QSize(640, 480)); + } + + void thumbnailsFallBackToASmallerEmbeddedJpeg() + { + // The larger preview's frame header reads but its picture data is gone, so the thumbnail IFD0 names is shown. + const QByteArray small = jpeg(160, 120), big = jpeg(640, 480); + const qsizetype scan = big.indexOf(QByteArray("\xFF\xDA", 2)); + QVERIFY(scan > 0); + const QByteArray damaged = big.left(scan) + QByteArray(big.size() - scan, '\0'); + Raw raw(true); + const quint32 smallAt = raw.add(small), damagedAt = raw.add(damaged); + raw.setFirst(raw.ifd(pair(smallAt, small.size()), raw.ifd(pair(damagedAt, damaged.size())))); + QCOMPARE(rawThumbnail(raw.bytes), QSize(160, 120)); + // A preview one byte over what the reader holds in memory is never picked ahead of one it can show. + Raw huge(true); + const quint32 thumbAt = huge.add(small), hugeAt = huge.add(big); + huge.setFirst(huge.ifd(pair(thumbAt, small.size()), huge.ifd(pair(hugeAt, kMostJpegBytes + 1)))); + QCOMPARE(rawThumbnail(huge.bytes, hugeAt + kMostJpegBytes + 1), QSize(160, 120)); + // All the previews tried share that limit: a damaged one that leaves a byte too few for the next sends it past that one. + const QByteArray wide = jpeg(800, 600), gone = wide.left(wide.indexOf(QByteArray("\xFF\xDA", 2))); + const auto after = [&](qint64 damagedLength) { + Raw spent(true); + const quint32 firstAt = spent.add(small), nextAt = spent.add(big), goneAt = spent.add(gone); + spent.setFirst(spent.ifd(pair(firstAt, small.size()), + spent.ifd(pair(nextAt, big.size()), spent.ifd(pair(goneAt, damagedLength))))); + return rawThumbnail(spent.bytes, goneAt + damagedLength); + }; + QCOMPARE(after(kMostJpegBytes - big.size()), QSize(640, 480)); + QCOMPARE(after(kMostJpegBytes - big.size() + 1), QSize(160, 120)); + } + + void thumbnailsRefuseABrokenCameraRaw() + { + QCOMPARE(rawThumbnail(rawWithJpeg(jpeg(400, 300), kUpright)), QSize(400, 300)); + // A preview that runs past the end of the file is passed over for the whole thumbnail IFD0 names. + const QByteArray small = jpeg(160, 120), big = jpeg(640, 480); + Raw cut(true); + const quint32 smallAt = cut.add(small), bigAt = quint32(cut.bytes.size()) + 2 * kTwoEntryIfd; + cut.setFirst(cut.ifd(pair(smallAt, small.size()), cut.ifd(pair(bigAt, big.size())))); + cut.add(big); + QCOMPARE(rawThumbnail(cut.bytes), QSize(640, 480)); + QCOMPARE(rawThumbnail(cut.bytes.left(cut.bytes.size() - 16)), QSize(160, 120)); + // A SubIFD that names itself as its next directory is walked once, so the preview in IFD1 is still reached. + Raw loop(true); + const quint32 previewAt = loop.add(big), self = quint32(loop.bytes.size()); + loop.ifd({}, self); + loop.setFirst(loop.ifd({{kSubIfds, kLong, 1, self}}, loop.ifd(pair(previewAt, big.size())))); + QCOMPARE(rawThumbnail(loop.bytes), QSize(640, 480)); + // The picture the 64th directory of a chain names is reached; with one more directory ahead of it, it is not. + Raw chain(true); + const quint32 lastAt = chain.add(small); + quint32 next = chain.ifd(pair(lastAt, small.size())); + for (int i = 1; i < kDirectoryLimit; ++i) + next = chain.ifd({}, next); + chain.setFirst(next); + QCOMPARE(rawThumbnail(chain.bytes), QSize(160, 120)); + chain.setFirst(chain.ifd({}, next)); + QVERIFY(rawThumbnail(chain.bytes).isEmpty()); + // An IFD0 whose first two entries name the JPEG and whose other entries, all held by the file, name nothing. + const auto wide = [&small](int entries) { + Raw raw(true); + const quint32 at = raw.add(small); + raw.setFirst(raw.ifd(pair(at, small.size()) + Entries(entries - 2, std::array{}))); + return rawThumbnail(raw.bytes); + }; + QCOMPARE(wide(kEntryLimit), QSize(160, 120)); + QVERIFY(wide(kEntryLimit + 1).isEmpty()); + QVERIFY(wide(kMostEntries).isEmpty()); + } + + void thumbnailsKeepOtherPathsForCameraRaws() + { + QTemporaryDir dir; + const QByteArray raw = rawWithJpeg(jpeg(400, 300), kUpright); + QCOMPARE(rawThumbnail(raw), QSize(400, 300)); + // An installed thumbnailer stays the desktop's answer, and a plain TIFF never takes the RAW reader. + QVERIFY(QImage(10, 20, QImage::Format_RGB32).save(dir.filePath("mark.png"))); + write(dir.filePath("raw.thumbnailer"), "[Thumbnailer Entry]\nTryExec=/bin/cp\nExec=/bin/cp \"" + + dir.filePath("mark.png").toUtf8() + "\" %o\nMimeType=image/x-adobe-dng;\n"); + Thumbnails thumbnails(dir.filePath("cache"), {dir.path()}); + write(dir.filePath("photo.dng"), raw); + QCOMPARE(thumbnails.load(dir.filePath("photo.dng"), "image/x-adobe-dng", 1024).size(), QSize(10, 20)); + write(dir.filePath("photo.tif"), raw); + QVERIFY(thumbnails.load(dir.filePath("photo.tif"), "image/tiff", 1024).isNull()); + } + void previewerPicksAViewerForEachType() { QCOMPARE(Previewer::viewerFor("image/png", false), QString("image")); @@ -5801,6 +5911,89 @@ private slots: return file.open(QIODevice::ReadOnly) ? file.readAll() : QByteArray(); } + using Entries = QList>; + // The TIFF 6.0 tags, field types and values a camera RAW names its embedded JPEG and its turn with. + static constexpr quint32 kCompression = 0x0103, kStripOffsets = 0x0111, kOrientation = 0x0112, kStripByteCounts = 0x0117; + static constexpr quint32 kSubIfds = 0x014A, kJpegOffset = 0x0201, kJpegLength = 0x0202; + static constexpr quint32 kShort = 3, kLong = 4, kJpegCompression = 7, kUpright = 1, kQuarterTurn = 6; + // An IFD of two entries: count(2), two 12-byte entries, next(4). + static constexpr quint32 kTwoEntryIfd = 2 + 2 * 12 + 4; + // The reader walks this many directories of one file and no more. + static constexpr int kDirectoryLimit = 64; + // The reader takes a directory of this many entries and none longer; a 16-bit count can claim the second. + static constexpr int kEntryLimit = 1024, kMostEntries = 0xFFFF; + // The reader holds an embedded JPEG of this many bytes in memory and none longer. + static constexpr qint64 kMebibyte = 1048576, kMostJpegBytes = 64 * kMebibyte; + // A camera RAW in either byte order; blobs and IFDs are appended, so every offset is known before it is named. + struct Raw { + explicit Raw(bool littleEndian) + : le(littleEndian), bytes(QByteArray(le ? "II*\0" : "MM\0*", 4) + QByteArray(4, '\0')) {} + QByteArray word(quint32 value, int size) const + { + QByteArray out(4, '\0'); + le ? qToLittleEndian(value, out.data()) : qToBigEndian(value, out.data()); + return le ? out.left(size) : out.right(size); + } + // Entries are (tag, type, count, value) and a SHORT value fills its field's first two bytes. + QByteArray dir(const Entries &entries, quint32 next = 0) const + { + QByteArray out = word(entries.size(), 2); + for (const auto &[tag, type, count, value] : entries) + out += word(tag, 2) + word(type, 2) + word(count, 4) + + (type == kShort ? word(value, 2) + QByteArray(2, '\0') : word(value, 4)); + return out + word(next, 4); + } + quint32 add(const QByteArray &data) { bytes += data; return quint32(bytes.size() - data.size()); } + quint32 ifd(const Entries &entries, quint32 next = 0) { return add(dir(entries, next)); } + void setFirst(quint32 ifd) { bytes.replace(4, 4, word(ifd, 4)); } + bool le; + QByteArray bytes; + }; + // JPEGInterchangeFormat and its length, or one JPEG-compressed strip as DNG and CR2 store a preview. + static Entries pair(quint32 at, qsizetype length) + { + return {{kJpegOffset, kLong, 1, at}, {kJpegLength, kLong, 1, quint32(length)}}; + } + static Entries strip(quint32 at, qsizetype length) + { + return {{kStripOffsets, kLong, 1, at}, {kStripByteCounts, kLong, 1, quint32(length)}, + {kCompression, kShort, 1, kJpegCompression}}; + } + // A green JPEG; `own`, when not 0, is the Orientation its own Exif segment (FF E1, length, "Exif\0\0", a TIFF) names. + static QByteArray jpeg(int width, int height, quint32 own = 0) + { + QImage picture(width, height, QImage::Format_RGB32); + picture.fill(Qt::green); + QByteArray data; + QBuffer buffer(&data); + if (!buffer.open(QIODevice::WriteOnly) || !picture.save(&buffer, "JPEG")) + return {}; + Raw tiff(true); + tiff.setFirst(tiff.ifd({{kOrientation, kShort, 1, own}})); + const QByteArray exif = QByteArray("Exif\0\0", 6) + tiff.bytes; + return own ? data.insert(2, QByteArray("\xFF\xE1", 2) + Raw(false).word(2 + exif.size(), 2) + exif) : data; + } + + // A little-endian RAW whose IFD0 names one JPEG and an orientation. + static QByteArray rawWithJpeg(const QByteArray &picture, quint32 orientation) + { + Raw raw(true); + const quint32 at = raw.add(picture); + raw.setFirst(raw.ifd(pair(at, picture.size()) + Entries{{kOrientation, kShort, 1, orientation}})); + return raw.bytes; + } + + // What Folio shows for these bytes as a DNG with no thumbnailer installed, unscaled; `grownTo` lengthens the file with a hole. + static QSize rawThumbnail(const QByteArray &raw, qint64 grownTo = 0) + { + QTemporaryDir dir; + write(dir.filePath("photo.dng"), raw); + if (grownTo > 0 && !QFile::resize(dir.filePath("photo.dng"), grownTo)) + return {}; + const Thumbnails thumbnails(dir.filePath("cache"), {dir.filePath("none")}); + return thumbnails.load(dir.filePath("photo.dng"), "image/x-adobe-dng", 1024).size(); + } + static void write(const QString &path, const QByteArray &contents) { QFile file(path); From a6c33d8e8f45773913b0088273ff001f88f08c50 Mon Sep 17 00:00:00 2001 From: GM Date: Wed, 11 Nov 2026 00:45:58 -0400 Subject: [PATCH 05/15] Name the package that would draw a missing thumbnail A type with no installed thumbnailer showed a blank tile and nothing else. The details pane now says which optional package draws it, from the types ffmpegthumbnailer, papers, glycin and libgsf declare. --- src/PreviewPane.qml | 10 ++++++ src/i18n/en.json | 1 + src/main.cpp | 1 + src/thumbnails.cpp | 73 +++++++++++++++++++++++++++++++++++++++++++ src/thumbnails.h | 7 ++++- tests/folio_tests.cpp | 15 +++++++++ 6 files changed, 106 insertions(+), 1 deletion(-) diff --git a/src/PreviewPane.qml b/src/PreviewPane.qml index bc93b1b6..3d7fe2bd 100644 --- a/src/PreviewPane.qml +++ b/src/PreviewPane.qml @@ -129,6 +129,16 @@ Rectangle { font.pixelSize: 12 elide: Text.ElideRight } + // A type nothing installed can draw: which package would. + Text { + readonly property string missing: big.status === Image.Error ? thumbnails.missingPackage(pane.item.mime) : "" + visible: missing.length > 0 + Layout.fillWidth: true + text: qsTr("Thumbnails of this type need the %1 package.").arg(missing) + color: theme.secondaryForeground + font.pixelSize: 12 + wrapMode: Text.Wrap + } } GridLayout { diff --git a/src/i18n/en.json b/src/i18n/en.json index 369dbda5..fa546b3e 100644 --- a/src/i18n/en.json +++ b/src/i18n/en.json @@ -393,6 +393,7 @@ "This computer can't make %1 drives.": "This computer can't make %1 drives.", "This folder is empty": "This folder is empty", "This folder no longer exists.": "This folder no longer exists.", + "Thumbnails of this type need the %1 package.": "Thumbnails of this type need the %1 package.", "Trash": "Trash", "Try again once the work under way is done.": "Try again once the work under way is done.", "Type a path, or a server's address like sftp://host/ (Tab completes)": "Type a path, or a server's address like sftp://host/ (Tab completes)", diff --git a/src/main.cpp b/src/main.cpp index 9228dca5..813d21c1 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -148,6 +148,7 @@ int main(int argc, char *argv[]) { engine.rootContext()->setContextProperty("theme", &theme); engine.rootContext()->setContextProperty("places", &places); engine.rootContext()->setContextProperty("plugins", &plugins); + engine.rootContext()->setContextProperty("thumbnails", &thumbnails); Windows windows(&engine, &plugins); if (!windows.open(start, select)) diff --git a/src/thumbnails.cpp b/src/thumbnails.cpp index 69de6c69..46d7b92e 100644 --- a/src/thumbnails.cpp +++ b/src/thumbnails.cpp @@ -80,6 +80,71 @@ QStringList expandCommand(const QString &command, const QString &input, const QS return args; } +// Each optional package's thumbnailers and the MimeType= lines they ship, as "video/mp4;video/webm;". +struct PackageTypes { + const char *package; + const char *types; +}; +const PackageTypes packageTypes[] = { + {"ffmpegthumbnailer", + "video/3gpp;video/3gpp2;video/annodex;video/dv;video/isivideo;video/matroska;video/matroska-3d;" + "video/mj2;video/mp2t;video/mp4;video/mpeg;video/ogg;video/quicktime;video/vnd.avi;" + "video/vnd.mpegurl;video/vnd.radgamettools.bink;video/vnd.radgamettools.smacker;" + "video/vnd.rn-realvideo;video/vnd.vivo;video/vnd.youtube.yt;video/wavelet;video/webm;" + "video/x-anim;video/x-flic;video/x-flv;video/x-javafx;video/x-matroska;video/x-matroska-3d;" + "video/x-mjpeg;video/x-mng;video/x-ms-wmv;video/x-nsv;video/x-ogm+ogg;video/x-sgi-movie;" + "video/x-theora+ogg;application/mxf;application/vnd.ms-asf;application/vnd.rn-realmedia;" + "application/matroska;application/x-matroska;application/ogg;"}, + {"glycin", + "image/avif;image/heif;image/apng;image/bmp;image/gif;image/jp2;image/jpeg;image/png;image/qoi;" + "image/tiff;image/vnd.microsoft.icon;image/webp;image/x-dds;image/x-exr;image/x-jp2-codestream;" + "image/x-portable-anymap;image/x-portable-bitmap;image/x-portable-graymap;" + "image/x-portable-pixmap;image/x-tga;image/x-win-bitmap;image/x-xbitmap;image/x-xpixmap;" + "image/jxl;image/svg+xml;image/svg+xml-compressed;"}, + {"papers", + "application/vnd.comicbook-rar;application/vnd.comicbook+zip;application/x-cb7;application/x-cbr;" + "application/x-cbt;application/x-cbz;application/x-ext-cb7;application/x-ext-cbr;" + "application/x-ext-cbt;application/x-ext-cbz;application/x-ext-djv;application/x-ext-djvu;" + "image/vnd.djvu;image/vnd.djvu+multipage;application/pdf;application/x-bzpdf;" + "application/x-ext-pdf;application/x-gzpdf;application/x-xzpdf;application/illustrator;" + "image/tiff;"}, + {"libgsf", + "application/msword;application/vnd.ms-excel;application/vnd.ms-powerpoint;" + "application/vnd.oasis.opendocument.chart;application/vnd.oasis.opendocument.formula;" + "application/vnd.oasis.opendocument.graphics;" + "application/vnd.oasis.opendocument.graphics-template;application/vnd.oasis.opendocument.image;" + "application/vnd.oasis.opendocument.presentation;" + "application/vnd.oasis.opendocument.presentation-template;" + "application/vnd.oasis.opendocument.spreadsheet;" + "application/vnd.oasis.opendocument.spreadsheet-template;application/vnd.oasis.opendocument.text;" + "application/vnd.oasis.opendocument.text-master;application/vnd.oasis.opendocument.text-template;" + "application/vnd.openxmlformats-officedocument.presentationml.presentation;" + "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;" + "application/vnd.openxmlformats-officedocument.wordprocessingml.document;" + "application/vnd.sun.xml.calc;application/vnd.sun.xml.calc.template;application/vnd.sun.xml.draw;" + "application/vnd.sun.xml.draw.template;application/vnd.sun.xml.impress;" + "application/vnd.sun.xml.impress.template;application/vnd.sun.xml.math;" + "application/vnd.sun.xml.writer;application/vnd.sun.xml.writer.global;" + "application/vnd.sun.xml.writer.template;"}, +}; + +// The package for each type by its own name, read once; the first package listed wins, so glycin draws TIFF before papers. +const QHash &packageFor() { + static const QHash table = [] { + QMimeDatabase mimes; + QHash byType; + for (const PackageTypes &entry : packageTypes) { + for (const QString &declared : QString::fromLatin1(entry.types).split(';', Qt::SkipEmptyParts)) { + const QString type = mimes.mimeTypeForName(declared).name(); + if (const QString key = type.isEmpty() ? declared : type; !byType.contains(key)) + byType.insert(key, QString::fromLatin1(entry.package)); + } + } + return byType; + }(); + return table; +} + } // namespace Thumbnails::Thumbnails(const QString &cacheDirectory, const QStringList &thumbnailerDirectories) @@ -132,6 +197,14 @@ Thumbnails::Thumbnails(const QString &cacheDirectory, const QStringList &thumbna } } +QString Thumbnails::missingPackage(const QString &mime) const { + // Qt draws its own pictures in-process, and an installed thumbnailer needs nothing more. + if ((mime.startsWith("image/") && QImageReader::supportedMimeTypes().contains(mime.toLatin1())) + || m_thumbnailers.contains(mime)) + return {}; + return packageFor().value(mime); +} + QString Thumbnails::cacheKey(const QString &path) { return QCryptographicHash::hash(fileUri(path).toUtf8(), QCryptographicHash::Md5).toHex() + ".png"; } diff --git a/src/thumbnails.h b/src/thumbnails.h index 819cb585..bedf77f1 100644 --- a/src/thumbnails.h +++ b/src/thumbnails.h @@ -3,6 +3,7 @@ #include #include #include +#include #include #include #include @@ -15,7 +16,9 @@ // /usr/share/thumbnailers (videos via ffmpegthumbnailer, and so on), with // Poppler's pdftoppm drawing PDFs when no thumbnailer does. Nothing is generated until a // tile asks for it: there is no background crawl. -class Thumbnails { +class Thumbnails : public QObject { + Q_OBJECT + public: explicit Thumbnails(const QString &cacheDirectory = {}, const QStringList &thumbnailerDirectories = {}); @@ -31,6 +34,8 @@ class Thumbnails { // fresh each time rather than cached, since the colors follow the theme. static QImage textPage(const QString &path, int pixels, const QColor &paper, const QColor &ink); QString thumbnailerFor(const QString &mime) const { return m_thumbnailers.value(mime); } + // The package that would draw `mime` when neither Qt nor an installed thumbnailer does, or nothing. + Q_INVOKABLE QString missingPackage(const QString &mime) const; private: QString cachePath(const QString &path, int size) const; diff --git a/tests/folio_tests.cpp b/tests/folio_tests.cpp index 99b32403..be50af26 100644 --- a/tests/folio_tests.cpp +++ b/tests/folio_tests.cpp @@ -5372,6 +5372,21 @@ private slots: QVERIFY(thumbnails.load(dir.filePath("photo.tif"), "image/tiff", 1024).isNull()); } + void thumbnailsNameThePackageThatWouldDrawAType() + { + QTemporaryDir dir; + write(dir.filePath("webm.thumbnailer"), + "[Thumbnailer Entry]\nTryExec=/bin/sh\nExec=/bin/sh -c \"exit 1\" %i %o\nMimeType=video/webm;\n"); + const Thumbnails thumbnails(dir.filePath("cache"), {dir.path()}); + QCOMPARE(thumbnails.missingPackage("video/mp4"), QString("ffmpegthumbnailer")); + QCOMPARE(thumbnails.missingPackage("application/pdf"), QString("papers")); + QCOMPARE(thumbnails.missingPackage("application/vnd.oasis.opendocument.text"), QString("libgsf")); + // Installed already, drawn by Qt itself, or no package known: nothing to name. + QVERIFY(thumbnails.missingPackage("video/webm").isEmpty()); + QVERIFY(thumbnails.missingPackage("image/png").isEmpty()); + QVERIFY(thumbnails.missingPackage("model/step").isEmpty()); + } + void previewerPicksAViewerForEachType() { QCOMPARE(Previewer::viewerFor("image/png", false), QString("image")); From 691c01b239e6b4cc8e8c6a7fb57ae6fe7723ab2d Mon Sep 17 00:00:00 2001 From: GM Date: Wed, 11 Nov 2026 03:38:19 -0400 Subject: [PATCH 06/15] Let a thumbnailer installed later draw what failed A file nothing installed could draw kept its failure marker, so a thumbnailer installed afterwards never ran for it. The marker now records the thumbnailer the type had, none included, and holds the file back only while that is unchanged. --- src/thumbnails.cpp | 18 ++++++++++++------ src/thumbnails.h | 5 +++-- tests/folio_tests.cpp | 20 ++++++++++++++++++++ 3 files changed, 35 insertions(+), 8 deletions(-) diff --git a/src/thumbnails.cpp b/src/thumbnails.cpp index 46d7b92e..46fc461a 100644 --- a/src/thumbnails.cpp +++ b/src/thumbnails.cpp @@ -231,6 +231,9 @@ QString Thumbnails::failPath(const QString &path) const { return m_cache + "/" + failures + "/" + cacheKey(path); } +// The marker's own key for the thumbnailer command the type had when it failed, empty for none. +static const QString kFailedWith = QStringLiteral("X-Folio::Thumbnailer"); + QImage Thumbnails::load(const QString &path, const QString &mime, int size) const { const QFileInfo info(path); if (!info.isFile()) @@ -243,14 +246,15 @@ QImage Thumbnails::load(const QString &path, const QString &mime, int size) cons const QDateTime modified = info.lastModified(); if (const QImage image(cachePath(path, size)); madeFor(image, path, modified)) return image; - if (failedBefore(path, modified)) - return {}; // A folder's peek asks for any picture ("image/*"); named by extension, // as the grid names it, it goes to the same thumbnailer as its tile. const QString type = mime.endsWith("/*") ? QMimeDatabase().mimeTypeForFile(path, QMimeDatabase::MatchExtension).name() : mime; + const QString thumbnailer = m_thumbnailers.value(type); + if (failedBefore(path, modified, thumbnailer)) + return {}; const int pixels = bucketPixels(bucketFor(size)); bool attempted = false; QImage image = generate(path, type, pixels, attempted); @@ -258,7 +262,7 @@ QImage Thumbnails::load(const QString &path, const QString &mime, int size) cons // Only a reader or thumbnailer that ran and failed is remembered, so // one installed later still gets its turn. if (attempted) - rememberFailure(path, modified); + rememberFailure(path, modified, thumbnailer); return {}; } if (image.width() > pixels || image.height() > pixels) @@ -400,14 +404,16 @@ void Thumbnails::remember(QImage image, const QString &path, int size, const QDa save(std::move(image), cachePath(path, size), path, modified); } -void Thumbnails::rememberFailure(const QString &path, const QDateTime &modified) const { +void Thumbnails::rememberFailure(const QString &path, const QDateTime &modified, const QString &thumbnailer) const { QImage marker(1, 1, QImage::Format_ARGB32); marker.fill(Qt::transparent); + marker.setText(kFailedWith, thumbnailer); save(std::move(marker), failPath(path), path, modified); } -bool Thumbnails::failedBefore(const QString &path, const QDateTime &modified) const { - return madeFor(QImage(failPath(path)), path, modified); +bool Thumbnails::failedBefore(const QString &path, const QDateTime &modified, const QString &thumbnailer) const { + const QImage marker(failPath(path)); + return madeFor(marker, path, modified) && marker.text(kFailedWith) == thumbnailer; } // Whether a cached thumbnail (or failure marker) was made from the file as it diff --git a/src/thumbnails.h b/src/thumbnails.h index bedf77f1..cad3ba10 100644 --- a/src/thumbnails.h +++ b/src/thumbnails.h @@ -45,8 +45,9 @@ class Thumbnails : public QObject { QImage runThumbnailer(const QString &command, const QString &path, int pixels) const; static QImage pdfPage(const QString &path, int pixels); void remember(QImage image, const QString &path, int size, const QDateTime &modified) const; - void rememberFailure(const QString &path, const QDateTime &modified) const; - bool failedBefore(const QString &path, const QDateTime &modified) const; + // A failure goes with the type's thumbnailer as it was then, none included: one installed since gets its turn. + void rememberFailure(const QString &path, const QDateTime &modified, const QString &thumbnailer) const; + bool failedBefore(const QString &path, const QDateTime &modified, const QString &thumbnailer) const; void save(QImage image, const QString &target, const QString &path, const QDateTime &modified) const; static bool madeFor(const QImage &image, const QString &path, const QDateTime &modified); diff --git a/tests/folio_tests.cpp b/tests/folio_tests.cpp index be50af26..3f539971 100644 --- a/tests/folio_tests.cpp +++ b/tests/folio_tests.cpp @@ -5161,11 +5161,31 @@ private slots: QImage stale(1, 1, QImage::Format_ARGB32); stale.setText("Thumb::URI", QUrl::fromLocalFile(older).toString(QUrl::FullyEncoded)); stale.setText("Thumb::MTime", QString::number(QFileInfo(older).lastModified().toSecsSinceEpoch())); + // It names the thumbnailer this Folio's marker names, so only its folder sets it apart. + const QImage current(dir.filePath("cache/" + Thumbnails::failures + "/" + Thumbnails::cacheKey(clip))); + QVERIFY(!current.text("X-Folio::Thumbnailer").isEmpty()); + stale.setText("X-Folio::Thumbnailer", current.text("X-Folio::Thumbnailer")); QVERIFY(stale.save(marker)); QVERIFY(thumbnails.load(older, "video/mp4", 128).isNull()); QCOMPARE(QFileInfo(runs).size(), 8); } + void thumbnailsLetAThumbnailerInstalledLaterDraw() + { + QTemporaryDir dir; + // A camera RAW with no picture inside and nothing installed to draw it fails, and that is remembered. + const QString raw = dir.filePath("bare.cr2"); + write(raw, "no picture inside"); + QVERIFY(Thumbnails(dir.filePath("cache"), {dir.filePath("none")}).load(raw, "image/x-canon-cr2", 128).isNull()); + QVERIFY(QFile::exists(dir.filePath("cache/" + Thumbnails::failures + "/" + Thumbnails::cacheKey(raw)))); + + // The failure was the built-in reader's, so a thumbnailer installed since still draws the file. + QVERIFY(QImage(10, 20, QImage::Format_RGB32).save(dir.filePath("mark.png"))); + write(dir.filePath("raw.thumbnailer"), "[Thumbnailer Entry]\nTryExec=/bin/cp\nExec=/bin/cp \"" + + dir.filePath("mark.png").toUtf8() + "\" %o\nMimeType=image/x-canon-cr2;\n"); + QCOMPARE(Thumbnails(dir.filePath("cache"), {dir.path()}).load(raw, "image/x-canon-cr2", 128).size(), QSize(10, 20)); + } + void thumbnailsRememberOnlyWhatFailed() { QTemporaryDir dir; From 18b61c5ed93d2f1a240a53db003b5bd293ab2be0 Mon Sep 17 00:00:00 2001 From: GM Date: Wed, 11 Nov 2026 10:52:35 -0400 Subject: [PATCH 07/15] Turn a RAW preview by its own directory's orientation One orientation was kept for the whole file, so a preview whose directory names a turn of its own was turned by IFD0's instead. Each embedded JPEG now carries its directory's orientation, and takes the file's only when its directory names none. --- src/rawembed.cpp | 30 ++++++++++++++++++++---------- tests/folio_tests.cpp | 21 +++++++++++++++++++++ 2 files changed, 41 insertions(+), 10 deletions(-) diff --git a/src/rawembed.cpp b/src/rawembed.cpp index 5ba6d702..8edc7c98 100644 --- a/src/rawembed.cpp +++ b/src/rawembed.cpp @@ -98,10 +98,16 @@ bool tiffHeader(Source &src, quint64 at, bool &le, quint64 &ifd) { return rd16(b.constData() + 2, le) == kTiffMagic; } +// A JPEG a directory names, with the turn that directory gives its picture, if any. +struct Candidate { + quint64 offset = 0, length = 0; + std::optional turn; +}; + struct Walker { explicit Walker(Source &source) : src(source) {} Source &src; - QVector> candidates; + QVector candidates; // Each directory is read once, so a cycle neither loops nor uses up the limit. QVector seen; std::optional orientation; @@ -134,13 +140,13 @@ struct Walker { if (count > kMaxEntries || !src.get(at + 2, count * kEntryLength, entries)) return; seen.append(at); - std::optional jpegOffset, jpegLength, stripOffset, stripLength, compression; + std::optional jpegOffset, jpegLength, stripOffset, stripLength, compression, turn; QVector children; for (int i = 0; i < count; ++i) { const char *e = entries.constData() + i * kEntryLength; const quint16 tag = rd16(e, le), type = rd16(e + 2, le); const quint32 n = rd32(e + 4, le); - if (tag == kOrientation && !orientation) orientation = one(le, type, n, e + 8); + if (tag == kOrientation) turn = one(le, type, n, e + 8); else if (tag == kJpegOffset) jpegOffset = one(le, type, n, e + 8); else if (tag == kJpegLength) jpegLength = one(le, type, n, e + 8); // Many strips are raw sensor data, never one preview. @@ -152,12 +158,14 @@ struct Walker { for (quint32 k = 0; k < qMin(n, kMaxPointers); ++k) children.append(type == kShort ? rd16(b.constData() + k * 2, le) : rd32(b.constData() + k * 4, le)); } + // The first directory to name a turn speaks for the file, as IFD0 does in a camera's own. + if (!orientation) orientation = turn; if (jpegOffset && jpegLength && *jpegLength > 0) - candidates.append({*jpegOffset, *jpegLength}); + candidates.append({*jpegOffset, *jpegLength, turn}); // Any lone JPEG-compressed strip is a preview (a CR2 keeps its big one in IFD0); the frame rule keeps raw data out. if (stripOffset && stripLength && compression && (*compression == kOldJpeg || *compression == kJpeg) && *stripLength > 0) - candidates.append({*stripOffset, *stripLength}); + candidates.append({*stripOffset, *stripLength, turn}); for (const quint64 child : children) walk(le, depth + 1, child); // A next pointer that cannot be read ends the chain and keeps what it collected. @@ -238,14 +246,15 @@ std::optional ownOrientation(const QByteArray &jpeg) { struct Preview { quint64 offset = 0, length = 0, pixels = 0; + std::optional turn; }; // Most pixels first, the longer of two equals ahead; only Huffman frames (SOF0 to SOF2) count, SOF3 is raw data. -QVector ranked(QFile &file, const QVector> &candidates) { +QVector ranked(QFile &file, const QVector &candidates) { qint64 sofLeft = kSofBudget; QVector previews; for (int i = 0; i < qMin(int(candidates.size()), kMaxCandidates); ++i) { - const quint64 offset = candidates[i].first, length = candidates[i].second; + const quint64 offset = candidates[i].offset, length = candidates[i].length; // A span running past the end of the file is a cut file, not a preview. if (length < quint64(kMinJpeg) || sofLeft == 0 || offset > quint64(file.size()) || length > quint64(file.size()) - offset) @@ -257,7 +266,7 @@ QVector ranked(QFile &file, const QVector> &can const bool found = span >= kMinJpeg && file.seek(qint64(offset)) && firstFrame(file, left, marker, width, height); sofLeft -= span - left; if (found && marker <= kLastHuffmanFrame) - previews.append({offset, length, quint64(width) * height}); + previews.append({offset, length, quint64(width) * height, candidates[i].turn}); } std::stable_sort(previews.begin(), previews.end(), [](const Preview &a, const Preview &b) { return a.pixels != b.pixels ? a.pixels > b.pixels : a.length > b.length; @@ -265,7 +274,7 @@ QVector ranked(QFile &file, const QVector> &can return previews; } -// One preview read and scaled to fit `pixels`, turned by the directory's `turn` when it names none of its own. +// One preview read and scaled to fit `pixels`, turned by `turn` when it names no orientation of its own. QImage decoded(QFile &file, const Preview &preview, quint64 turn, int pixels) { if (!file.seek(qint64(preview.offset))) return {}; @@ -314,7 +323,8 @@ QImage RawEmbed::thumbnail(const QString &path, int pixels) { if (preview.length > left) continue; left -= preview.length; - const QImage image = decoded(file, preview, walker.orientation.value_or(0), pixels); + // A directory's own turn rules its picture; one that names none takes the file's. + const QImage image = decoded(file, preview, preview.turn.value_or(walker.orientation.value_or(0)), pixels); if (!image.isNull()) return image; } diff --git a/tests/folio_tests.cpp b/tests/folio_tests.cpp index 3f539971..89389dd8 100644 --- a/tests/folio_tests.cpp +++ b/tests/folio_tests.cpp @@ -5288,6 +5288,27 @@ private slots: QCOMPARE(rawThumbnail(rawWithJpeg(jpeg(400, 300), kQuarterTurn)), QSize(300, 400)); QCOMPARE(rawThumbnail(rawWithJpeg(jpeg(400, 300, kUpright), kQuarterTurn)), QSize(400, 300)); QCOMPARE(rawThumbnail(rawWithJpeg(jpeg(400, 300, kQuarterTurn), kUpright)), QSize(300, 400)); + + // A later directory that names a turn of its own rules its picture; one that names none takes IFD0's. + const QByteArray picture = jpeg(400, 300); + const auto turned = [&](quint32 first, const Entries &own) { + Raw raw(true); + const quint32 at = raw.add(picture); + raw.setFirst(raw.ifd({{kOrientation, kShort, 1, first}}, raw.ifd(pair(at, picture.size()) + own))); + return rawThumbnail(raw.bytes); + }; + QCOMPARE(turned(kUpright, {{kOrientation, kShort, 1, kQuarterTurn}}), QSize(300, 400)); + QCOMPARE(turned(kQuarterTurn, {{kOrientation, kShort, 1, kUpright}}), QSize(400, 300)); + QCOMPARE(turned(kQuarterTurn, {}), QSize(300, 400)); + + // Of two directories that name a turn the first speaks for the file, so a third that names none takes that one. + Raw three(true); + const QByteArray small = jpeg(160, 120); + const quint32 bigAt = three.add(picture), smallAt = three.add(small); + three.setFirst(three.ifd({{kOrientation, kShort, 1, kQuarterTurn}}, + three.ifd(pair(smallAt, small.size()) + Entries{{kOrientation, kShort, 1, kUpright}}, + three.ifd(pair(bigAt, picture.size()))))); + QCOMPARE(rawThumbnail(three.bytes), QSize(300, 400)); } void thumbnailsPickTheLargestEmbeddedJpeg() From bb0f83c763e10c2ae22a5355cf6cd7f45b7a81c2 Mon Sep 17 00:00:00 2001 From: GM Date: Wed, 11 Nov 2026 10:52:35 -0400 Subject: [PATCH 08/15] Name no package for a PDF that pdftoppm draws With Poppler installed and no PDF thumbnailer, a PDF that failed to draw (damaged, or locked with a password) had the details pane name papers as missing. A PDF's package is now named only when pdftoppm is not there either. --- src/thumbnails.cpp | 5 +++-- tests/folio_tests.cpp | 13 ++++++++++++- 2 files changed, 15 insertions(+), 3 deletions(-) diff --git a/src/thumbnails.cpp b/src/thumbnails.cpp index 46fc461a..a2294686 100644 --- a/src/thumbnails.cpp +++ b/src/thumbnails.cpp @@ -198,9 +198,10 @@ Thumbnails::Thumbnails(const QString &cacheDirectory, const QStringList &thumbna } QString Thumbnails::missingPackage(const QString &mime) const { - // Qt draws its own pictures in-process, and an installed thumbnailer needs nothing more. + // Qt draws its own pictures in-process, an installed thumbnailer needs nothing more, and pdftoppm draws a PDF without one. if ((mime.startsWith("image/") && QImageReader::supportedMimeTypes().contains(mime.toLatin1())) - || m_thumbnailers.contains(mime)) + || m_thumbnailers.contains(mime) + || (mime == "application/pdf" && !QStandardPaths::findExecutable("pdftoppm").isEmpty())) return {}; return packageFor().value(mime); } diff --git a/tests/folio_tests.cpp b/tests/folio_tests.cpp index 89389dd8..79f7b7d7 100644 --- a/tests/folio_tests.cpp +++ b/tests/folio_tests.cpp @@ -5420,12 +5420,23 @@ private slots: "[Thumbnailer Entry]\nTryExec=/bin/sh\nExec=/bin/sh -c \"exit 1\" %i %o\nMimeType=video/webm;\n"); const Thumbnails thumbnails(dir.filePath("cache"), {dir.path()}); QCOMPARE(thumbnails.missingPackage("video/mp4"), QString("ffmpegthumbnailer")); - QCOMPARE(thumbnails.missingPackage("application/pdf"), QString("papers")); QCOMPARE(thumbnails.missingPackage("application/vnd.oasis.opendocument.text"), QString("libgsf")); // Installed already, drawn by Qt itself, or no package known: nothing to name. QVERIFY(thumbnails.missingPackage("video/webm").isEmpty()); QVERIFY(thumbnails.missingPackage("image/png").isEmpty()); QVERIFY(thumbnails.missingPackage("model/step").isEmpty()); + + // A PDF has its package named only where pdftoppm is not there to draw it. + const QByteArray programs = qgetenv("PATH"); + QVERIFY(QDir(dir.path()).mkpath("bin")); + qputenv("PATH", dir.filePath("bin").toUtf8()); + const QString without = thumbnails.missingPackage("application/pdf"); + write(dir.filePath("bin/pdftoppm"), "#!/bin/sh\n"); + QFile::setPermissions(dir.filePath("bin/pdftoppm"), QFile::ReadOwner | QFile::ExeOwner); + const QString with = thumbnails.missingPackage("application/pdf"); + qputenv("PATH", programs); + QCOMPARE(without, QString("papers")); + QVERIFY(with.isEmpty()); } void previewerPicksAViewerForEachType() From 2cda48cca590e7c33c0e714a94b09776bb760ba1 Mon Sep 17 00:00:00 2001 From: David Heinemeier Hansson Date: Wed, 11 Nov 2026 18:14:39 +0100 Subject: [PATCH 09/15] Read an embedded JPEG's own turn from IFD0, past any fill bytes A JPEG may put 0xFF fill bytes ahead of a marker, and the Exif segment of one that did was missed, so an upright preview got the RAW's turn. And the walk followed IFD0's next pointer into IFD1, the Exif thumbnail's directory, whose orientation then passed for the picture's. Only IFD0's own Orientation is read now. Co-Authored-By: Claude Opus 5.5 --- src/rawembed.cpp | 41 ++++++++++++++++++++++++++++++++--------- tests/folio_tests.cpp | 19 ++++++++++++++++++- 2 files changed, 50 insertions(+), 10 deletions(-) diff --git a/src/rawembed.cpp b/src/rawembed.cpp index 8edc7c98..f45dc029 100644 --- a/src/rawembed.cpp +++ b/src/rawembed.cpp @@ -131,13 +131,33 @@ struct Walker { } // An IFD is count(2), then 12-byte entries tag(2) type(2) count(4) value-or-offset(4), then the next IFD(4). + bool directory(bool le, quint64 at, quint16 &count, QByteArray &entries) { + QByteArray b; + if (!src.get(at, 2, b)) + return false; + count = rd16(b.constData(), le); + // A 0xFFFF count is the hostile case: this directory is skipped, never read or looped. + return count <= kMaxEntries && src.get(at + 2, count * kEntryLength, entries); + } + + // The Orientation one directory names itself, its next and child directories left unread. + std::optional turnAt(bool le, quint64 at) { + quint16 count = 0; + QByteArray entries; + if (!directory(le, at, count, entries)) + return {}; + for (int i = 0; i < count; ++i) { + const char *e = entries.constData() + i * kEntryLength; + if (rd16(e, le) == kOrientation) + return one(le, rd16(e + 2, le), rd32(e + 4, le), e + 8); + } + return {}; + } + void walk(bool le, int depth, quint64 at) { QByteArray b, entries; - if (depth > kMaxDepth || seen.size() >= kMaxIfds || seen.contains(at) || !src.get(at, 2, b)) - return; - const quint16 count = rd16(b.constData(), le); - // A 0xFFFF count is the hostile case: this directory is skipped, never read or looped. - if (count > kMaxEntries || !src.get(at + 2, count * kEntryLength, entries)) + quint16 count = 0; + if (depth > kMaxDepth || seen.size() >= kMaxIfds || seen.contains(at) || !directory(le, at, count, entries)) return; seen.append(at); std::optional jpegOffset, jpegLength, stripOffset, stripLength, compression, turn; @@ -226,18 +246,21 @@ bool firstFrame(QFile &file, qint64 &left, quint8 &marker, quint32 &width, quint std::optional ownOrientation(const QByteArray &jpeg) { for (qsizetype at = 2; at + 4 <= jpeg.size() && quint8(jpeg[at]) == kMarker;) { const quint8 marker = quint8(jpeg[at + 1]); + // Any number of 0xFF fill bytes may stand ahead of a marker. + if (marker == kMarker) { + ++at; + continue; + } const qsizetype length = qFromBigEndian(jpeg.constData() + at + 2); if (marker == kSos || marker == kEoi || isFrame(marker) || length < 2 || at + 2 + length > jpeg.size()) return {}; if (marker == kApp1 && length >= 8 && jpeg.mid(at + 4, 6) == QByteArray("Exif\0\0", 6)) { const QByteArray tiff = jpeg.mid(at + 10, length - 8); Source slice{nullptr, tiff, quint64(tiff.size()), quint64(tiff.size())}; - Walker walker(slice); bool le = true; quint64 ifd = 0; - if (tiffHeader(slice, 0, le, ifd)) - walker.walk(le, 0, ifd); - return walker.orientation; + // Only IFD0 describes the picture; the IFD1 it leads to is the Exif thumbnail's. + return tiffHeader(slice, 0, le, ifd) ? Walker(slice).turnAt(le, ifd) : std::nullopt; } at += 2 + length; } diff --git a/tests/folio_tests.cpp b/tests/folio_tests.cpp index a023729d..08196d3a 100644 --- a/tests/folio_tests.cpp +++ b/tests/folio_tests.cpp @@ -5631,6 +5631,18 @@ private slots: QCOMPARE(rawThumbnail(three.bytes), QSize(300, 400)); } + void thumbnailsReadAnEmbeddedJpegsOwnTurnFromItsFirstDirectory() + { + // 0xFF fill bytes may stand ahead of any JPEG marker, so the upright the Exif segment after them names still rules. + const QByteArray padded = jpeg(400, 300, kUpright).insert(2, QByteArray("\xFF\xFF", 2)); + QCOMPARE(rawThumbnail(rawWithJpeg(padded, kQuarterTurn)), QSize(400, 300)); + // IFD1 is the Exif thumbnail's directory: the upright it names says nothing of the picture, so the RAW's turn applies. + Raw tiff(true); + tiff.setFirst(tiff.ifd({}, tiff.ifd({{kOrientation, kShort, 1, kUpright}}))); + const QByteArray unnamed = jpeg(400, 300).insert(2, exifSegment(tiff)); + QCOMPARE(rawThumbnail(rawWithJpeg(unnamed, kQuarterTurn)), QSize(300, 400)); + } + void thumbnailsPickTheLargestEmbeddedJpeg() { // Big-endian like a NEF: IFD0 names a small JPEG, its SubIFDs lossless raw data (SOF3) and the preview. @@ -6357,8 +6369,13 @@ private slots: return {}; Raw tiff(true); tiff.setFirst(tiff.ifd({{kOrientation, kShort, 1, own}})); + return own ? data.insert(2, exifSegment(tiff)) : data; + } + // An Exif segment holding `tiff`: FF E1, its big-endian length, "Exif\0\0" and the TIFF. + static QByteArray exifSegment(const Raw &tiff) + { const QByteArray exif = QByteArray("Exif\0\0", 6) + tiff.bytes; - return own ? data.insert(2, QByteArray("\xFF\xE1", 2) + Raw(false).word(2 + exif.size(), 2) + exif) : data; + return QByteArray("\xFF\xE1", 2) + Raw(false).word(2 + exif.size(), 2) + exif; } // A little-endian RAW whose IFD0 names one JPEG and an orientation. From 99935cde76482c9df41487153246a912f593a89b Mon Sep 17 00:00:00 2001 From: David Heinemeier Hansson Date: Wed, 11 Nov 2026 18:18:46 +0100 Subject: [PATCH 10/15] Clear away the failure markers an older Folio left Markers moved from fail/folio to fail/folio-2, and nothing reads the old folder again. It is removed on a worker thread at start, as is any fail/folio- a later bump leaves behind. Co-Authored-By: Claude Opus 5.5 --- src/thumbnails.cpp | 7 +++++++ tests/folio_tests.cpp | 16 ++++++++++++++++ 2 files changed, 23 insertions(+) diff --git a/src/thumbnails.cpp b/src/thumbnails.cpp index a2294686..42c7502a 100644 --- a/src/thumbnails.cpp +++ b/src/thumbnails.cpp @@ -195,6 +195,13 @@ Thumbnails::Thumbnails(const QString &cacheDirectory, const QStringList &thumbna m_thumbnailers.insert(aliased); m_thumbnailers.insert(named); } + // Another Folio's failure markers (fail/folio, or a fail/folio- with another number) are never read here, so they + // are cleared away, on a worker since there may be thousands. + QThreadPool::globalInstance()->start([fail = m_cache + "/fail"] { + for (const QString &name : QDir(fail).entryList({"folio", "folio-*"}, QDir::Dirs | QDir::NoDotAndDotDot)) + if ("fail/" + name != failures) + QDir(fail + "/" + name).removeRecursively(); + }); } QString Thumbnails::missingPackage(const QString &mime) const { diff --git a/tests/folio_tests.cpp b/tests/folio_tests.cpp index 08196d3a..7d542dcc 100644 --- a/tests/folio_tests.cpp +++ b/tests/folio_tests.cpp @@ -5490,6 +5490,22 @@ private slots: QCOMPARE(QFileInfo(runs).size(), 8); } + void thumbnailsClearAwayAnOlderFoliosFailures() + { + QTemporaryDir dir; + const QStringList kept = {Thumbnails::failures, "fail/gnome-thumbnail-factory"}, gone = {"fail/folio", "fail/folio-1"}; + for (const QString &folder : kept + gone) { + QVERIFY(QDir().mkpath(dir.filePath("cache/" + folder))); + write(dir.filePath("cache/" + folder + "/marker.png"), "marker"); + } + const Thumbnails thumbnails(dir.filePath("cache"), {dir.filePath("none")}); + QThreadPool::globalInstance()->waitForDone(); + for (const QString &folder : kept) + QVERIFY(QFile::exists(dir.filePath("cache/" + folder + "/marker.png"))); + for (const QString &folder : gone) + QVERIFY(!QFileInfo::exists(dir.filePath("cache/" + folder))); + } + void thumbnailsLetAThumbnailerInstalledLaterDraw() { QTemporaryDir dir; From 9f0c26c81c5a9f519a2a6e3a7b002180043faf7c Mon Sep 17 00:00:00 2001 From: David Heinemeier Hansson Date: Wed, 11 Nov 2026 18:18:46 +0100 Subject: [PATCH 11/15] Say where the table of packages' types was copied from Co-Authored-By: Claude Opus 5.5 --- src/thumbnails.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/thumbnails.cpp b/src/thumbnails.cpp index 42c7502a..0fb11e43 100644 --- a/src/thumbnails.cpp +++ b/src/thumbnails.cpp @@ -80,7 +80,9 @@ QStringList expandCommand(const QString &command, const QString &input, const QS return args; } -// Each optional package's thumbnailers and the MimeType= lines they ship, as "video/mp4;video/webm;". +// Each optional package's thumbnailers and the MimeType= lines they ship, as "video/mp4;video/webm;". Copied from the +// .thumbnailer files of Arch's ffmpegthumbnailer 2.3.1 (the video one only: the audio one draws just cover art, which +// most files lack), glycin 2.2.6, papers 51.1 and libgsf's gsf-office; refresh them from there when a package adds types. struct PackageTypes { const char *package; const char *types; From 3b3d7ed2e381794a0000d690b1ef7e7f9ac45f47 Mon Sep 17 00:00:00 2001 From: David Heinemeier Hansson Date: Wed, 11 Nov 2026 18:31:13 +0100 Subject: [PATCH 12/15] Leave a newer Folio's failures, and never follow a link out of the cache The start-up sweep listed fail/folio and fail/folio-* with QDir::Dirs, which includes symlinks to folders, and removeRecursively() deletes through a link: a fail/folio that pointed elsewhere had everything it pointed at deleted. Symlinks are now skipped. It also removed every fail/folio- but the current one, so an installed Folio and a newer build run side by side cleared each other's markers on every start. Only plain fail/folio and lower numbers are removed now. Co-Authored-By: Claude Opus 5.5 --- src/thumbnails.cpp | 15 +++++++++++---- tests/folio_tests.cpp | 9 ++++++++- 2 files changed, 19 insertions(+), 5 deletions(-) diff --git a/src/thumbnails.cpp b/src/thumbnails.cpp index 0fb11e43..20644023 100644 --- a/src/thumbnails.cpp +++ b/src/thumbnails.cpp @@ -197,12 +197,19 @@ Thumbnails::Thumbnails(const QString &cacheDirectory, const QStringList &thumbna m_thumbnailers.insert(aliased); m_thumbnailers.insert(named); } - // Another Folio's failure markers (fail/folio, or a fail/folio- with another number) are never read here, so they - // are cleared away, on a worker since there may be thousands. + // An older Folio's failure markers (fail/folio, or a fail/folio- with a lower number) are never read again, so + // they are cleared away, on a worker since there may be thousands. A newer Folio's are left for it, so an installed + // Folio and a newer build side by side don't clear each other's on every start. A symlink is never followed: removing + // through one would delete files outside the cache. QThreadPool::globalInstance()->start([fail = m_cache + "/fail"] { - for (const QString &name : QDir(fail).entryList({"folio", "folio-*"}, QDir::Dirs | QDir::NoDotAndDotDot)) - if ("fail/" + name != failures) + const int current = failures.section('-', -1).toInt(); + for (const QString &name : + QDir(fail).entryList({"folio", "folio-*"}, QDir::Dirs | QDir::NoDotAndDotDot | QDir::NoSymLinks)) { + bool numbered = true; + const int version = name == "folio" ? 0 : name.mid(6).toInt(&numbered); + if (numbered && version < current) QDir(fail + "/" + name).removeRecursively(); + } }); } diff --git a/tests/folio_tests.cpp b/tests/folio_tests.cpp index 7d542dcc..d461fbf3 100644 --- a/tests/folio_tests.cpp +++ b/tests/folio_tests.cpp @@ -5493,17 +5493,24 @@ private slots: void thumbnailsClearAwayAnOlderFoliosFailures() { QTemporaryDir dir; - const QStringList kept = {Thumbnails::failures, "fail/gnome-thumbnail-factory"}, gone = {"fail/folio", "fail/folio-1"}; + // A newer Folio's markers are its own to keep, as are another program's. + const QString newer = "fail/folio-" + QString::number(Thumbnails::failures.section('-', -1).toInt() + 1); + const QStringList kept = {Thumbnails::failures, newer, "fail/gnome-thumbnail-factory"}, gone = {"fail/folio", "fail/folio-1"}; for (const QString &folder : kept + gone) { QVERIFY(QDir().mkpath(dir.filePath("cache/" + folder))); write(dir.filePath("cache/" + folder + "/marker.png"), "marker"); } + // An old marker folder that links out of the cache is never followed. + QVERIFY(QDir().mkpath(dir.filePath("photos"))); + write(dir.filePath("photos/beach.jpg"), "picture"); + QVERIFY(QFile::link(dir.filePath("photos"), dir.filePath("cache/fail/folio-0"))); const Thumbnails thumbnails(dir.filePath("cache"), {dir.filePath("none")}); QThreadPool::globalInstance()->waitForDone(); for (const QString &folder : kept) QVERIFY(QFile::exists(dir.filePath("cache/" + folder + "/marker.png"))); for (const QString &folder : gone) QVERIFY(!QFileInfo::exists(dir.filePath("cache/" + folder))); + QVERIFY(QFile::exists(dir.filePath("photos/beach.jpg"))); } void thumbnailsLetAThumbnailerInstalledLaterDraw() From b94340b91bb48c005d6fdea86f9cb1fc25b2c8a0 Mon Sep 17 00:00:00 2001 From: David Heinemeier Hansson Date: Wed, 11 Nov 2026 18:31:13 +0100 Subject: [PATCH 13/15] Bound what a hostile RAW can cost the reader A preview is no longer ranked when its frame header claims more than 250 million pixels, more than any camera's; a few KiB claiming 57000 by 56000 otherwise ranked first and cost a 270 MB decode that failed, up to sixteen times per file. The header budget now caps the number of reads as well as their bytes: each read is its own system call, a round trip on a network mount, and crafted directories reached some 60,000 tiny reads within the byte budget. The embedded JPEG is read into a buffer with room for the Exif segment, so putting the segment in front no longer copies up to 64 MiB. Co-Authored-By: Claude Opus 5.5 --- src/rawembed.cpp | 19 ++++++++++++++----- tests/folio_tests.cpp | 9 +++++++++ 2 files changed, 23 insertions(+), 5 deletions(-) diff --git a/src/rawembed.cpp b/src/rawembed.cpp index f45dc029..5f192187 100644 --- a/src/rawembed.cpp +++ b/src/rawembed.cpp @@ -10,8 +10,10 @@ namespace { -// Header and directory bytes read per file in total. +// Header and directory bytes read per file in total, and the reads they take: each one is its own system call, and a +// round trip on a network mount, so many tiny reads cost far more than their bytes. constexpr quint64 kHeaderBudget = 1048576; +constexpr int kMaxReads = 4096; // Frame-header bytes read per file across all candidates; then validation stops. constexpr qint64 kSofBudget = 1048576; // One candidate's frame-header walk never reads past this. @@ -29,6 +31,8 @@ constexpr quint64 kEntryLength = 12; constexpr quint64 kMaxValue = 65536; // SubIFD fan-out is capped, so one count cannot queue unbounded work. constexpr quint32 kMaxPointers = 64; +// No camera's preview holds more pixels than this; a frame header that claims more would cost a vast decode for nothing. +constexpr quint64 kMaxPixels = 250000000; // The largest embedded JPEG read into memory; a real one is a few MiB. constexpr quint64 kMaxJpeg = 64 * 1048576; // SOI plus one frame header: anything shorter is no picture. @@ -75,10 +79,12 @@ struct Source { QByteArray slice; quint64 size; quint64 left; + int reads = kMaxReads; bool get(quint64 offset, quint64 length, QByteArray &out) { - if (length > left || offset > size || length > size - offset) + if (reads == 0 || length > left || offset > size || length > size - offset) return false; + --reads; left -= length; if (!file) out = slice.mid(qsizetype(offset), qsizetype(length)); @@ -288,7 +294,7 @@ QVector ranked(QFile &file, const QVector &candidates) { quint32 width = 0, height = 0; const bool found = span >= kMinJpeg && file.seek(qint64(offset)) && firstFrame(file, left, marker, width, height); sofLeft -= span - left; - if (found && marker <= kLastHuffmanFrame) + if (found && marker <= kLastHuffmanFrame && quint64(width) * height <= kMaxPixels) previews.append({offset, length, quint64(width) * height, candidates[i].turn}); } std::stable_sort(previews.begin(), previews.end(), [](const Preview &a, const Preview &b) { @@ -301,8 +307,11 @@ QVector ranked(QFile &file, const QVector &candidates) { QImage decoded(QFile &file, const Preview &preview, quint64 turn, int pixels) { if (!file.seek(qint64(preview.offset))) return {}; - QByteArray jpeg = file.read(qint64(preview.length)); - if (quint64(jpeg.size()) != preview.length) + // Room for the Exif segment is kept, so putting it in moves the bytes in place instead of copying them all. + QByteArray jpeg; + jpeg.reserve(qsizetype(preview.length + sizeof kExifOrientation)); + jpeg.resize(qsizetype(preview.length)); + if (file.read(jpeg.data(), jpeg.size()) != jpeg.size()) return {}; if (turn >= kFirstTurn && turn <= kLastTurn && !ownOrientation(jpeg.left(kJpegPrefix))) { QByteArray segment(reinterpret_cast(kExifOrientation), sizeof kExifOrientation); diff --git a/tests/folio_tests.cpp b/tests/folio_tests.cpp index d461fbf3..9dde07ba 100644 --- a/tests/folio_tests.cpp +++ b/tests/folio_tests.cpp @@ -5750,6 +5750,15 @@ private slots: QCOMPARE(wide(kEntryLimit), QSize(160, 120)); QVERIFY(wide(kEntryLimit + 1).isEmpty()); QVERIFY(wide(kMostEntries).isEmpty()); + // A frame header that claims more pixels than any camera's preview, 20000 by 20000, is passed over undecoded. + QByteArray vast = big; + const qsizetype frame = vast.indexOf(QByteArray("\xFF\xC0", 2)); + QVERIFY(frame > 0); + vast.replace(frame + 5, 4, QByteArray("\x4E\x20\x4E\x20", 4)); + Raw claimed(true); + const quint32 thumbAt = claimed.add(small), vastAt = claimed.add(vast); + claimed.setFirst(claimed.ifd(pair(thumbAt, small.size()), claimed.ifd(pair(vastAt, vast.size())))); + QCOMPARE(rawThumbnail(claimed.bytes), QSize(160, 120)); } void thumbnailsKeepOtherPathsForCameraRaws() From 6b4f84c966e110730fef4ae5c5cd687fe20e52f0 Mon Sep 17 00:00:00 2001 From: David Heinemeier Hansson Date: Wed, 11 Nov 2026 18:31:13 +0100 Subject: [PATCH 14/15] Say a .thumbnailer file names the alias, not the spec Elsewhere in this file "the spec" is the freedesktop thumbnail spec. Co-Authored-By: Claude Opus 5.5 --- src/thumbnails.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/thumbnails.cpp b/src/thumbnails.cpp index 20644023..e4ed2b3b 100644 --- a/src/thumbnails.cpp +++ b/src/thumbnails.cpp @@ -164,7 +164,7 @@ Thumbnails::Thumbnails(const QString &cacheDirectory, const QStringList &thumbna } QMimeDatabase mimes; for (const QString &directory : directories) { - // A spec may name a type by an alias, as glycin names DDS pictures image/x-dds. + // A .thumbnailer file may name a type by an alias, as glycin names DDS pictures image/x-dds. QHash named, aliased; QDirIterator it(directory, {"*.thumbnailer"}, QDir::Files); while (it.hasNext()) { @@ -193,7 +193,7 @@ Thumbnails::Thumbnails(const QString &cacheDirectory, const QStringList &thumbna aliased.insert(type, exec); } } - // Within one directory the spec that names a type itself wins over one that names an alias of it. + // Within one directory the file that names a type itself wins over one that names an alias of it. m_thumbnailers.insert(aliased); m_thumbnailers.insert(named); } From 7fdbc27e3cacabbfb78886acf15a564b279ef838 Mon Sep 17 00:00:00 2001 From: David Heinemeier Hansson Date: Wed, 11 Nov 2026 19:20:36 +0100 Subject: [PATCH 15/15] Never clear failure markers through a fail folder that is a link Co-Authored-By: Claude Opus 5.5 --- src/thumbnails.cpp | 6 ++++-- tests/folio_tests.cpp | 11 +++++++++++ 2 files changed, 15 insertions(+), 2 deletions(-) diff --git a/src/thumbnails.cpp b/src/thumbnails.cpp index e4ed2b3b..97552113 100644 --- a/src/thumbnails.cpp +++ b/src/thumbnails.cpp @@ -199,9 +199,11 @@ Thumbnails::Thumbnails(const QString &cacheDirectory, const QStringList &thumbna } // An older Folio's failure markers (fail/folio, or a fail/folio- with a lower number) are never read again, so // they are cleared away, on a worker since there may be thousands. A newer Folio's are left for it, so an installed - // Folio and a newer build side by side don't clear each other's on every start. A symlink is never followed: removing - // through one would delete files outside the cache. + // Folio and a newer build side by side don't clear each other's on every start. A symlink is never followed, the fail + // folder itself included: removing through one would delete files outside the cache. QThreadPool::globalInstance()->start([fail = m_cache + "/fail"] { + if (QFileInfo(fail).isSymLink()) + return; const int current = failures.section('-', -1).toInt(); for (const QString &name : QDir(fail).entryList({"folio", "folio-*"}, QDir::Dirs | QDir::NoDotAndDotDot | QDir::NoSymLinks)) { diff --git a/tests/folio_tests.cpp b/tests/folio_tests.cpp index 9dde07ba..e769a7f2 100644 --- a/tests/folio_tests.cpp +++ b/tests/folio_tests.cpp @@ -5511,6 +5511,17 @@ private slots: for (const QString &folder : gone) QVERIFY(!QFileInfo::exists(dir.filePath("cache/" + folder))); QVERIFY(QFile::exists(dir.filePath("photos/beach.jpg"))); + + // Nor is a fail folder that is itself a link: what it leads to isn't + // the cache's. + QTemporaryDir linked; + QVERIFY(QDir().mkpath(linked.filePath("elsewhere/folio-1"))); + write(linked.filePath("elsewhere/folio-1/keep.txt"), "mine"); + QVERIFY(QDir().mkpath(linked.filePath("cache"))); + QVERIFY(QFile::link(linked.filePath("elsewhere"), linked.filePath("cache/fail"))); + const Thumbnails throughLink(linked.filePath("cache"), {linked.filePath("none")}); + QThreadPool::globalInstance()->waitForDone(); + QVERIFY(QFile::exists(linked.filePath("elsewhere/folio-1/keep.txt"))); } void thumbnailsLetAThumbnailerInstalledLaterDraw()