Merge lp:~aacid/thumbnailer/asyncprovider into lp:thumbnailer

[Albert Astals Cid]

Implement an Async image provider

This is a skeleton needs work and also unreleased https://codereview.qt-project.org/#/c/108540/ for now

Decisions that need to be taken:
 * How to organize the thread pools, i'm using 2 thread pools with two threads each, one for slow and one for fast jobs. But one can organize them as wanted

Questions that need answering:
 * Why the artist/album providers use dbus but not the thumbnailer one?

Work that needs to be done:
 * Add a dbus query to see if art/artist is cached (or don't use the dbus api for those two either) to make them use the fast/slow pool acoordingly
 * Make the dbus based providers cancellable when waiting for dbus

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:124
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~aacid/thumbnailer/asyncprovider/+merge/253188/+edit-commit-message

http://jenkins.qa.ubuntu.com/job/thumbnailer-ci/142/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/thumbnailer-vivid-amd64-ci/36/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/thumbnailer-vivid-armhf-ci/34/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/thumbnailer-vivid-i386-ci/31/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/thumbnailer-ci/142/rebuild

review: Needs Fixing (continuous-integration)

[Jussi Pakkanen (jpakkane)]

> Why the artist/album providers use dbus but not the thumbnailer one?

Because artist and album art deal with public data that is downloaded from the net. Thus they are cached in one global location.

Thumbnails are app-specific and for security reasons are stored in an app-specific directory. Otherwise apps could snoop on each others' thumbnails which would be a security violation.

Because of this the former uses dbus and the latter hits the file system directly.

[Albert Astals Cid (aacid)]

Setting as WiP for the moment until upstream Qt change is landed

Unmerged revisions

125. By Albert Astals Cid on 2015-03-27

New API

124. By Albert Astals Cid on 2015-03-17

Implement an Async image provider

This is a skeleton needs work and also needs an unreleased Qt for now

Just so people can comment on it

=== modified file 'include/thumbnailer.h'
--- include/thumbnailer.h	2014-08-01 13:22:43 +0000
+++ include/thumbnailer.h	2015-03-27 14:56:52 +0000
@@ -76,6 +76,8 @@
     std::string get_artist_art(const std::string &artist, const std::string &album,
             ThumbnailSize desiredSize, ThumbnailPolicy policy);
 
+    bool has_cached_thumbnail(const std::string &filename, ThumbnailSize desired_size) const;
+
 private:
     Thumbnailer(const Thumbnailer &t);
     Thumbnailer & operator=(const Thumbnailer &t);

=== modified file 'plugins/Ubuntu/Thumbnailer/albumartgenerator.cpp'
--- plugins/Ubuntu/Thumbnailer/albumartgenerator.cpp	2015-03-05 08:47:32 +0000
+++ plugins/Ubuntu/Thumbnailer/albumartgenerator.cpp	2015-03-27 14:56:52 +0000
@@ -25,6 +25,7 @@
 #include <QUrlQuery>
 #include <QDBusUnixFileDescriptor>
 #include <QDBusReply>
+#include <QThreadPool>
 
 static const char DEFAULT_ALBUM_ART[] = "/usr/share/thumbnailer/icons/album_missing.png";
 
@@ -33,52 +34,97 @@
 static const char THUMBNAILER_IFACE[] = "com.canonical.Thumbnailer";
 static const char GET_ALBUM_ART[] = "GetAlbumArt";
 
-AlbumArtGenerator::AlbumArtGenerator()
-    : QQuickImageProvider(QQuickImageProvider::Image, QQmlImageProviderBase::ForceAsynchronousImageLoading)
+AlbumArtGenerator::AlbumArtGenerator(QThreadPool *fastPool, QThreadPool *slowPool)
+    : m_fastPool(fastPool)
+    , m_slowPool(slowPool)
 {
 }
 
-static QImage fallbackImage(QSize *realSize) {
+static QImage fallbackImage() {
     QImage fallback;
     fallback.load(DEFAULT_ALBUM_ART);
-    *realSize = fallback.size();
     return fallback;
 }
 
-QImage AlbumArtGenerator::requestImage(const QString &id, QSize *realSize,
-        const QSize &requestedSize) {
-    QUrlQuery query(id);
-    if (!query.hasQueryItem("artist") || !query.hasQueryItem("album")) {
-        qWarning() << "Invalid albumart uri:" << id;
-        return fallbackImage(realSize);
-    }
-
-    if (!connection) {
-        // Create them here and not them on the constrcutor so they belong to the proper thread
-        connection.reset(new QDBusConnection(QDBusConnection::connectToBus(QDBusConnection::SessionBus, "album_art_generator_dbus_connection")));
-        iface.reset(new QDBusInterface(BUS_NAME, BUS_PATH, THUMBNAILER_IFACE, *connection));
-    }
-
-    const QString artist = query.queryItemValue("artist", QUrl::FullyDecoded);
-    const QString album = query.queryItemValue("album", QUrl::FullyDecoded);
-
-    QString desiredSize = sizeToDesiredSizeString(requestedSize);
-
-    // perform dbus call
-    QDBusReply<QDBusUnixFileDescriptor> reply = iface->call(
-        GET_ALBUM_ART, artist, album, desiredSize);
-    if (!reply.isValid()) {
-        qWarning() << "D-Bus error: " << reply.error().message();
-        return fallbackImage(realSize);
-    }
-
-    try {
-        return imageFromFd(reply.value().fileDescriptor(), realSize);
-    } catch (const std::exception &e) {
-        qDebug() << "Album art loader failed: " << e.what();
-    } catch (...) {
-        qDebug() << "Unknown error when generating image.";
-    }
-
-    return fallbackImage(realSize);
+class AlbumArtGeneratorImageResponse : public QQuickImageResponse, public QRunnable
+{
+public:
+    AlbumArtGeneratorImageResponse(const QString &id, const QSize &requestedSize)
+        : m_id(id), m_requestedSize(requestedSize), m_texture(nullptr), m_cancelled(false)
+    {
+        setAutoDelete(false);
+    }
+
+    QQuickTextureFactory *textureFactory() const  override
+    {
+        return m_texture;
+    }
+
+    void run()  override
+    {
+        if (m_cancelled) {
+            qDebug() << "RUNNING CANCELLED ALBUM ART" << m_id;
+            emit finished();
+            return;
+        }
+
+        qDebug() << "RUNNING ALBUM ART" << m_id;
+
+        QImage image;
+        const QUrlQuery query(m_id);
+        if (query.hasQueryItem("artist") && query.hasQueryItem("album")) {
+            QDBusConnection connection = QDBusConnection::connectToBus(QDBusConnection::SessionBus, "album_art_generator_dbus_connection");
+            QDBusInterface iface(BUS_NAME, BUS_PATH, THUMBNAILER_IFACE, connection);
+
+            const QString artist = query.queryItemValue("artist", QUrl::FullyDecoded);
+            const QString album = query.queryItemValue("album", QUrl::FullyDecoded);
+            const QString desiredSize = sizeToDesiredSizeString(m_requestedSize);
+
+            // perform dbus call
+            // TODO make this async so we can actually cancel at this point too
+            QDBusReply<QDBusUnixFileDescriptor> reply = iface.call(
+                GET_ALBUM_ART, artist, album, desiredSize);
+            if (reply.isValid()) {
+                try {
+                    image = imageFromFd(reply.value().fileDescriptor());
+                } catch (const std::exception &e) {
+                    qDebug() << "Album art loader failed: " << e.what();
+                } catch (...) {
+                    qDebug() << "Unknown error when generating image.";
+                }
+            } else {
+                qWarning() << "D-Bus error: " << reply.error().message();
+            }
+        } else {
+            qWarning() << "Invalid albumart uri:" << m_id;
+        }
+
+        if (image.isNull())
+            image = fallbackImage();
+
+        m_texture = QQuickTextureFactory::textureFactoryForImage(image);
+        emit finished();
+    }
+
+    void cancel() override
+    {
+        m_cancelled = true;
+        qDebug() << "CANCEL ALBUM ART" << m_id;
+    }
+
+private:
+    QString m_id;
+    QSize m_requestedSize;
+    QQuickTextureFactory *m_texture;
+    bool m_cancelled;
+};
+
+QQuickImageResponse *AlbumArtGenerator::requestImageResponse(const QString &id, const QSize &requestedSize)
+{
+    qDebug() << "ALBUM ART" << id;
+    AlbumArtGeneratorImageResponse *response = new AlbumArtGeneratorImageResponse(id, requestedSize);
+    // TODO we need a dbus call in the thumbnailer to know if to queue on the fast or in the slow one
+    // TODO Why are we using a thumbnailer object in thumbnail generator but a dbus service here?
+    m_fastPool->start(response);
+    return response;
 }

=== modified file 'plugins/Ubuntu/Thumbnailer/albumartgenerator.h'
--- plugins/Ubuntu/Thumbnailer/albumartgenerator.h	2015-03-05 08:43:59 +0000
+++ plugins/Ubuntu/Thumbnailer/albumartgenerator.h	2015-03-27 14:56:52 +0000
@@ -25,15 +25,17 @@
 
 #include <memory>
 
-class AlbumArtGenerator: public QQuickImageProvider
+class QThreadPool;
+
+class AlbumArtGenerator: public QQuickAsyncImageProvider
 {
 private:
-    std::unique_ptr<QDBusConnection> connection;
-    std::unique_ptr<QDBusInterface> iface;
+    QThreadPool *m_fastPool;
+    QThreadPool *m_slowPool;
 
 public:
-    AlbumArtGenerator();
-    QImage requestImage(const QString &id, QSize *size, const QSize &requestedSize);
+    AlbumArtGenerator(QThreadPool *fastPool, QThreadPool *slowPool);
+    QQuickImageResponse *requestImageResponse(const QString &id, const QSize &requestedSize) override;
 };
 
 #endif

=== modified file 'plugins/Ubuntu/Thumbnailer/artgeneratorcommon.cpp'
--- plugins/Ubuntu/Thumbnailer/artgeneratorcommon.cpp	2014-08-01 11:02:12 +0000
+++ plugins/Ubuntu/Thumbnailer/artgeneratorcommon.cpp	2015-03-27 14:56:52 +0000
@@ -35,12 +35,11 @@
     return desiredSize;
 }
 
-QImage imageFromFd(int fd, QSize *realSize)
+QImage imageFromFd(int fd)
 {
     QFile file;
     file.open(fd, QIODevice::ReadOnly);
     QImage image;
     image.load(&file, NULL);
-    *realSize = image.size();
     return image;
 }

=== modified file 'plugins/Ubuntu/Thumbnailer/artgeneratorcommon.h'
--- plugins/Ubuntu/Thumbnailer/artgeneratorcommon.h	2014-08-01 11:02:12 +0000
+++ plugins/Ubuntu/Thumbnailer/artgeneratorcommon.h	2015-03-27 14:56:52 +0000
@@ -23,6 +23,6 @@
 #include <QImage>
 
 QString sizeToDesiredSizeString(const QSize& requestedSize);
-QImage imageFromFd(int fd, QSize *realSize);
+QImage imageFromFd(int fd);
 
 #endif

=== modified file 'plugins/Ubuntu/Thumbnailer/artistartgenerator.cpp'
--- plugins/Ubuntu/Thumbnailer/artistartgenerator.cpp	2015-03-05 08:47:32 +0000
+++ plugins/Ubuntu/Thumbnailer/artistartgenerator.cpp	2015-03-27 14:56:52 +0000
@@ -26,6 +26,7 @@
 #include <QUrlQuery>
 #include <QDBusUnixFileDescriptor>
 #include <QDBusReply>
+#include <QThreadPool>
 
 static const char DEFAULT_ARTIST_ART[] = "/usr/share/thumbnailer/icons/album_missing.png";
 
@@ -34,52 +35,98 @@
 static const char THUMBNAILER_IFACE[] = "com.canonical.Thumbnailer";
 static const char GET_ARTIST_ART[] = "GetArtistArt";
 
-ArtistArtGenerator::ArtistArtGenerator()
-    : QQuickImageProvider(QQuickImageProvider::Image, QQmlImageProviderBase::ForceAsynchronousImageLoading)
+ArtistArtGenerator::ArtistArtGenerator(QThreadPool *fastPool, QThreadPool *slowPool)
+    : m_fastPool(fastPool)
+    , m_slowPool(slowPool)
 {
 }
 
-static QImage fallbackImage(QSize *realSize) {
+static QImage fallbackImage() {
     QImage fallback;
     fallback.load(DEFAULT_ARTIST_ART);
-    *realSize = fallback.size();
     return fallback;
 }
 
-QImage ArtistArtGenerator::requestImage(const QString &id, QSize *realSize,
-        const QSize &requestedSize) {
-    QUrlQuery query(id);
-    if (!query.hasQueryItem("artist") || !query.hasQueryItem("album")) {
-        qWarning() << "Invalid artistart uri:" << id;
-        return fallbackImage(realSize);
-    }
-
-    if (!connection) {
-        // Create them here and not them on the constrcutor so they belong to the proper thread
-        connection.reset(new QDBusConnection(QDBusConnection::connectToBus(QDBusConnection::SessionBus, "artist_art_generator_dbus_connection")));
-        iface.reset(new QDBusInterface(BUS_NAME, BUS_PATH, THUMBNAILER_IFACE, *connection));
-    }
-
-    const QString artist = query.queryItemValue("artist", QUrl::FullyDecoded);
-    const QString album = query.queryItemValue("album", QUrl::FullyDecoded);
-
-    QString desiredSize = sizeToDesiredSizeString(requestedSize);
-
-    // perform dbus call
-    QDBusReply<QDBusUnixFileDescriptor> reply = iface->call(
-        GET_ARTIST_ART, artist, album, desiredSize);
-    if (!reply.isValid()) {
-        qWarning() << "D-Bus error: " << reply.error().message();
-        return fallbackImage(realSize);
-    }
-
-    try {
-        return imageFromFd(reply.value().fileDescriptor(), realSize);
-    } catch (const std::exception &e) {
-        qDebug() << "Artist art loader failed: " << e.what();
-    } catch (...) {
-        qDebug() << "Unknown error when generating image.";
-    }
-
-    return fallbackImage(realSize);
+class ArtistArtGeneratorImageResponse : public QQuickImageResponse, public QRunnable
+{
+public:
+    ArtistArtGeneratorImageResponse(const QString &id, const QSize &requestedSize)
+        : m_id(id), m_requestedSize(requestedSize), m_texture(nullptr), m_cancelled(false)
+    {
+        setAutoDelete(false);
+    }
+
+    QQuickTextureFactory *textureFactory() const override
+    {
+        return m_texture;
+    }
+
+    void run() override
+    {
+        if (m_cancelled) {
+            qDebug() << "RUNNING CANCELLED ARTIST ART" << m_id;
+            emit finished();
+            return;
+        }
+
+        qDebug() << "RUNNING ARTIST ART" << m_id;
+        QImage image;
+        const QUrlQuery query(m_id);
+        if (query.hasQueryItem("artist") && query.hasQueryItem("album")) {
+            QDBusConnection connection = QDBusConnection::connectToBus(QDBusConnection::SessionBus, "artist_art_generator_dbus_connection");
+            QDBusInterface iface(BUS_NAME, BUS_PATH, THUMBNAILER_IFACE, connection);
+
+            const QString artist = query.queryItemValue("artist", QUrl::FullyDecoded);
+            const QString album = query.queryItemValue("album", QUrl::FullyDecoded);
+            const QString desiredSize = sizeToDesiredSizeString(m_requestedSize);
+
+            // perform dbus call
+            // TODO make this async so we can actually cancel at this point too
+            QDBusReply<QDBusUnixFileDescriptor> reply = iface.call(
+                GET_ARTIST_ART, artist, album, desiredSize);
+            if (reply.isValid()) {
+                try {
+                    image = imageFromFd(reply.value().fileDescriptor());
+                } catch (const std::exception &e) {
+                    qDebug() << "Artist art loader failed: " << e.what();
+                } catch (...) {
+                    qDebug() << "Unknown error when generating image.";
+                }
+            } else {
+                qWarning() << "D-Bus error: " << reply.error().message();
+            }
+        } else {
+            qWarning() << "Invalid artistart uri:" << m_id;
+        }
+
+        if (image.isNull())
+            image = fallbackImage();
+
+        m_texture = QQuickTextureFactory::textureFactoryForImage(image);
+        qDebug() << "DONE RUNNING ARTIST ART" << m_id;
+        emit finished();
+    }
+
+    void cancel() override
+    {
+        m_cancelled = true;
+        qDebug() << "CANCEL ARTIST ART" << m_id;
+    }
+
+private:
+    QString m_id;
+    QSize m_requestedSize;
+    QQuickTextureFactory *m_texture;
+    bool m_cancelled;
+};
+
+QQuickImageResponse *ArtistArtGenerator::requestImageResponse(const QString &id, const QSize &requestedSize)
+{
+    qDebug() << "REQUEST ARTIST ART" << id;
+    ArtistArtGeneratorImageResponse *response = new ArtistArtGeneratorImageResponse(id, requestedSize);
+    // TODO we need a dbus call in the thumbnailer to know if to queue on the fast or in the slow one
+    // TODO Why are we using a thumbnailer object in thumbnail generator but a dbus service here?
+    m_fastPool->start(response);
+    return response;
 }
+

=== modified file 'plugins/Ubuntu/Thumbnailer/artistartgenerator.h'
--- plugins/Ubuntu/Thumbnailer/artistartgenerator.h	2015-03-05 08:43:59 +0000
+++ plugins/Ubuntu/Thumbnailer/artistartgenerator.h	2015-03-27 14:56:52 +0000
@@ -24,15 +24,20 @@
 
 #include <memory>
 
-class ArtistArtGenerator: public QQuickImageProvider
+class QThreadPool;
+
+class ArtistArtGenerator: public QQuickAsyncImageProvider
 {
 private:
     std::unique_ptr<QDBusConnection> connection;
     std::unique_ptr<QDBusInterface> iface;
 
+    QThreadPool *m_fastPool;
+    QThreadPool *m_slowPool;
+
 public:
-    ArtistArtGenerator();
-    QImage requestImage(const QString &id, QSize *size, const QSize &requestedSize);
+    ArtistArtGenerator(QThreadPool *fastPool, QThreadPool *slowPool);
+    QQuickImageResponse *requestImageResponse(const QString &id, const QSize &requestedSize) override;
 };
 
 #endif

=== modified file 'plugins/Ubuntu/Thumbnailer/plugin.cpp'
--- plugins/Ubuntu/Thumbnailer/plugin.cpp	2014-08-01 10:21:31 +0000
+++ plugins/Ubuntu/Thumbnailer/plugin.cpp	2015-03-27 14:56:52 +0000
@@ -30,8 +30,12 @@
 void ThumbnailerPlugin::initializeEngine(QQmlEngine *engine, const char *uri) {
     QQmlExtensionPlugin::initializeEngine(engine, uri);
 
+    // TODO decide if this is the threading strategy we want
+    fastPool.setMaxThreadCount(2);
+    slowPool.setMaxThreadCount(2);
+
     try {
-        engine->addImageProvider("albumart", new AlbumArtGenerator());
+        engine->addImageProvider("albumart", new AlbumArtGenerator(&fastPool, &slowPool));
     } catch (const std::exception &e) {
         qWarning() << "Failed to register albumart image provider:" << e.what();
     } catch (...) {
@@ -39,7 +43,7 @@
     }
 
     try {
-        engine->addImageProvider("artistart", new ArtistArtGenerator());
+        engine->addImageProvider("artistart", new ArtistArtGenerator(&fastPool, &slowPool));
     } catch (const std::exception &e) {
         qWarning() << "Failed to register artistart image provider:" << e.what();
     } catch (...) {
@@ -47,7 +51,7 @@
     }
 
     try {
-        engine->addImageProvider("thumbnailer", new ThumbnailGenerator());
+        engine->addImageProvider("thumbnailer", new ThumbnailGenerator(&fastPool, &slowPool));
     } catch (const std::exception &e) {
         qWarning() << "Failed to register thumbnailer image provider:" << e.what();
     } catch (...) {

=== modified file 'plugins/Ubuntu/Thumbnailer/plugin.h'
--- plugins/Ubuntu/Thumbnailer/plugin.h	2014-03-28 10:11:44 +0000
+++ plugins/Ubuntu/Thumbnailer/plugin.h	2015-03-27 14:56:52 +0000
@@ -29,6 +29,9 @@
 public:
     virtual void registerTypes(const char *uri) override;
     virtual void initializeEngine(QQmlEngine *engine, const char *uri) override;
+
+    QThreadPool fastPool;
+    QThreadPool slowPool;
 };
 
 #endif

=== modified file 'plugins/Ubuntu/Thumbnailer/thumbnailgenerator.cpp'
--- plugins/Ubuntu/Thumbnailer/thumbnailgenerator.cpp	2015-01-12 17:11:04 +0000
+++ plugins/Ubuntu/Thumbnailer/thumbnailgenerator.cpp	2015-03-27 14:56:52 +0000
@@ -22,75 +22,12 @@
 #include <QMimeDatabase>
 #include <QUrl>
 #include <QImageReader>
+#include <QThreadPool>
 
 static const char *DEFAULT_VIDEO_ART = "/usr/share/thumbnailer/icons/video_missing.png";
 static const char *DEFAULT_ALBUM_ART = "/usr/share/thumbnailer/icons/album_missing.png";
 
-ThumbnailGenerator::ThumbnailGenerator() : QQuickImageProvider(QQuickImageProvider::Image,
-        QQmlImageProviderBase::ForceAsynchronousImageLoading) {
-
-}
-
-QImage ThumbnailGenerator::requestImage(const QString &id, QSize *realSize,
-        const QSize &requestedSize) {
-    /* Allow appending a query string (e.g. ?something=timestamp)
-     * to the id and then ignore it.
-     * This is workaround to force reloading a thumbnail when it has
-     * the same file name on disk but we know the content has changed.
-     * It is necessary because in such a situation the QML image cache
-     * will kick in and this ImageProvider will never get called.
-     * The only "solution" is setting Image.cache = false, but in some
-     * cases we don't want to do that for performance reasons, so this
-     * is the only way around the issue for now. */
-    std::string src_path(QUrl(id).path().toUtf8().data());
-    std::string tgt_path;
-    try {
-        ThumbnailSize desiredSize;
-        const int xlarge_cutoff = 512;
-        const int large_cutoff = 256;
-        const int small_cutoff = 128;
-        if(requestedSize.width() > xlarge_cutoff || requestedSize.height() > xlarge_cutoff) {
-            desiredSize = TN_SIZE_ORIGINAL;
-        } else if(requestedSize.width() > large_cutoff || requestedSize.height() > large_cutoff) {
-            desiredSize = TN_SIZE_XLARGE;
-        } else if(requestedSize.width() > small_cutoff || requestedSize.height() > small_cutoff) {
-            desiredSize = TN_SIZE_LARGE;
-        } else {
-            desiredSize = TN_SIZE_SMALL;
-        }
-        tgt_path = tn.get_thumbnail(src_path, desiredSize);
-        if(!tgt_path.empty()) {
-            QString tgt(tgt_path.c_str());
-            QImage image;
-            QImageReader reader;
-            reader.setFileName(tgt);
-            QSize imageSize = reader.size();
-            if (!requestedSize.isNull() &&
-                (imageSize.width() > requestedSize.width() ||
-                 imageSize.height() > requestedSize.height())) {
-                QSize validRequestedSize = requestedSize;
-                if (validRequestedSize.width() == 0) {
-                    validRequestedSize.setWidth(imageSize.width());
-                }
-                if (validRequestedSize.height() == 0) {
-                    validRequestedSize.setHeight(imageSize.height());
-                }
-                imageSize.scale(validRequestedSize, Qt::KeepAspectRatio);
-                reader.setScaledSize(imageSize);
-            }
-            image = reader.read();
-            *realSize = image.size();
-            return image;
-        }
-    } catch(std::runtime_error &e) {
-        qDebug() << "Thumbnail generator failed: " << e.what();
-    }
-    return getFallbackImage(id, realSize, requestedSize);
-}
-
-QImage ThumbnailGenerator::getFallbackImage(const QString &id, QSize *size,
-        const QSize &requestedSize) {
-    Q_UNUSED(requestedSize);
+static QImage getFallbackImage(const QString &id) {
     QMimeDatabase db;
     QMimeType mime = db.mimeTypeForFile(id);
     QImage result;
@@ -99,6 +36,113 @@
     } else if(mime.name().contains("video")) {
         result.load(DEFAULT_VIDEO_ART);
     }
-    *size = result.size();
     return result;
 }
+
+static ThumbnailSize thumbnailSizeFromQSize(const QSize &requestedSize) {
+    const int xlarge_cutoff = 512;
+    const int large_cutoff = 256;
+    const int small_cutoff = 128;
+
+    if(requestedSize.width() > xlarge_cutoff || requestedSize.height() > xlarge_cutoff) {
+        return TN_SIZE_ORIGINAL;
+    } else if(requestedSize.width() > large_cutoff || requestedSize.height() > large_cutoff) {
+        return TN_SIZE_XLARGE;
+    } else if(requestedSize.width() > small_cutoff || requestedSize.height() > small_cutoff) {
+        return TN_SIZE_LARGE;
+    } else {
+        return TN_SIZE_SMALL;
+    }
+}
+
+class ThumbnailGeneratorImageResponse : public QQuickImageResponse, public QRunnable
+{
+public:
+    ThumbnailGeneratorImageResponse(const QString &id, const QSize &requestedSize, Thumbnailer *tn)
+        : m_id(id), m_requestedSize(requestedSize), m_tn(tn), m_texture(nullptr), m_cancelled(false)
+    {
+        setAutoDelete(false);
+    }
+
+    QQuickTextureFactory *textureFactory() const
+    {
+        return m_texture;
+    }
+
+    void run()
+    {
+        if (m_cancelled) {
+            emit finished();
+            return;
+        }
+
+        /* Allow appending a query string (e.g. ?something=timestamp)
+        * to the id and then ignore it.
+        * This is workaround to force reloading a thumbnail when it has
+        * the same file name on disk but we know the content has changed.
+        * It is necessary because in such a situation the QML image cache
+        * will kick in and this ImageProvider will never get called.
+        * The only "solution" is setting Image.cache = false, but in some
+        * cases we don't want to do that for performance reasons, so this
+        * is the only way around the issue for now. */
+        QImage image;
+        try {
+            const std::string src_path(QUrl(m_id).path().toUtf8().data());
+            const std::string tgt_path = m_tn->get_thumbnail(src_path, thumbnailSizeFromQSize(m_requestedSize));
+            if(!tgt_path.empty()) {
+                QString tgt(tgt_path.c_str());
+                QImageReader reader;
+                reader.setFileName(tgt);
+                QSize imageSize = reader.size();
+                if (!m_requestedSize.isNull() &&
+                    (imageSize.width() > m_requestedSize.width() ||
+                    imageSize.height() > m_requestedSize.height())) {
+                    QSize validRequestedSize = m_requestedSize;
+                    if (validRequestedSize.width() == 0) {
+                        validRequestedSize.setWidth(imageSize.width());
+                    }
+                    if (validRequestedSize.height() == 0) {
+                        validRequestedSize.setHeight(imageSize.height());
+                    }
+                    imageSize.scale(validRequestedSize, Qt::KeepAspectRatio);
+                    reader.setScaledSize(imageSize);
+                }
+                image = reader.read();
+            }
+        } catch(std::runtime_error &e) {
+            qDebug() << "Thumbnail generator failed: " << e.what();
+        }
+        if (image.isNull()) {
+            image = getFallbackImage(m_id);
+        }
+
+        m_texture = QQuickTextureFactory::textureFactoryForImage(image);
+        emit finished();
+    }
+
+private:
+    QString m_id;
+    QSize m_requestedSize;
+    Thumbnailer *m_tn;
+    QQuickTextureFactory *m_texture;
+    bool m_cancelled;
+};
+
+
+ThumbnailGenerator::ThumbnailGenerator(QThreadPool *fastPool, QThreadPool *slowPool)
+ : m_fastPool(fastPool)
+ , m_slowPool(slowPool)
+{
+}
+
+QQuickImageResponse *ThumbnailGenerator::requestImageResponse(const QString &id, const QSize &requestedSize) {
+    qDebug() << "THUMBNAIL" << id;
+    ThumbnailGeneratorImageResponse *response = new ThumbnailGeneratorImageResponse(id, requestedSize, &m_thumbnailer);
+    const std::string src_path(QUrl(id).path().toUtf8().data());
+    if (m_thumbnailer.has_cached_thumbnail(src_path, thumbnailSizeFromQSize(requestedSize))) {
+        m_fastPool->start(response);
+    } else {
+        m_slowPool->start(response);
+    }
+    return response;
+}

=== modified file 'plugins/Ubuntu/Thumbnailer/thumbnailgenerator.h'
--- plugins/Ubuntu/Thumbnailer/thumbnailgenerator.h	2014-09-15 08:13:32 +0000
+++ plugins/Ubuntu/Thumbnailer/thumbnailgenerator.h	2015-03-27 14:56:52 +0000
@@ -22,20 +22,23 @@
 #include <QQuickImageProvider>
 #include <thumbnailer.h>
 
-class ThumbnailGenerator: public QQuickImageProvider
+class QThreadPool;
+
+class ThumbnailGenerator: public QQuickAsyncImageProvider
 {
-private:
-    Thumbnailer tn;
-
 public:
-    ThumbnailGenerator();
+    ThumbnailGenerator(QThreadPool *fastPool, QThreadPool *slowPool);
     ThumbnailGenerator(const ThumbnailGenerator &other) = delete;
     const ThumbnailGenerator & operator=(const ThumbnailGenerator &other) = delete;
     ThumbnailGenerator(ThumbnailGenerator &&other) = delete;
     const ThumbnailGenerator & operator=(ThumbnailGenerator &&other) = delete;
 
-    QImage requestImage(const QString &id, QSize *size, const QSize &requestedSize);
-    QImage getFallbackImage(const QString &id, QSize *size, const QSize &requestedSize);
+    QQuickImageResponse *requestImageResponse(const QString &id, const QSize &requestedSize) override;
+
+private:
+    Thumbnailer m_thumbnailer;
+    QThreadPool *m_fastPool;
+    QThreadPool *m_slowPool;
 };
 
 #endif

=== modified file 'src/libthumbnailer.map'
--- src/libthumbnailer.map	2014-08-01 13:22:43 +0000
+++ src/libthumbnailer.map	2015-03-27 14:56:52 +0000
@@ -7,6 +7,7 @@
         "Thumbnailer::get_thumbnail(std::string const&, ThumbnailSize, ThumbnailPolicy)";
         "Thumbnailer::get_album_art(std::string const&, std::string const&, ThumbnailSize, ThumbnailPolicy)";
         "Thumbnailer::get_artist_art(std::string const&, std::string const&, ThumbnailSize, ThumbnailPolicy)";
+        "Thumbnailer::has_cached_thumbnail(std::string const&, ThumbnailSize) const";
     };
 local:
     extern "C++" {

=== modified file 'src/thumbnailer.cpp'
--- src/thumbnailer.cpp	2015-01-20 15:29:10 +0000
+++ src/thumbnailer.cpp	2015-03-27 14:56:52 +0000
@@ -212,6 +212,25 @@
 Thumbnailer::~Thumbnailer() {
     delete p;
 }
+
+bool Thumbnailer::has_cached_thumbnail(const std::string &filename, ThumbnailSize desired_size) const
+{
+    string abspath;
+    if(filename.empty()) {
+        return "";
+    }
+    if(filename[0] != '/') {
+        auto cwd = getcwd(nullptr, 0);
+        abspath += cwd;
+        free(cwd);
+        abspath += "/" + filename;
+    } else {
+        abspath = filename;
+    }
+    std::string estimate = p->cache.get_if_exists(abspath, desired_size);
+    return !estimate.empty();
+}
+
 std::string Thumbnailer::get_thumbnail(const std::string &filename, ThumbnailSize desired_size,
         ThumbnailPolicy policy) {
     string abspath;