1// Copyright (C) 2016 The Qt Company Ltd.
2// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
3
4#include <QtQuick/private/qquickpixmapcache_p.h>
5#include <QtQuick/private/qquickimageprovider_p.h>
6#include <QtQuick/private/qquickprofiler_p.h>
7#include <QtQuick/private/qsgcontext_p.h>
8#include <QtQuick/private/qsgrenderer_p.h>
9#include <QtQuick/private/qsgtexturereader_p.h>
10#include <QtQuick/qquickwindow.h>
11
12#include <QtGui/private/qguiapplication_p.h>
13#include <QtGui/private/qimage_p.h>
14#include <QtGui/qpa/qplatformintegration.h>
15#include <QtGui/qimagereader.h>
16#include <QtGui/qpixmapcache.h>
17
18#include <QtQml/private/qqmlglobal_p.h>
19#include <QtQml/private/qqmlengine_p.h>
20#include <QtQml/qqmlfile.h>
21
22#include <QtCore/private/qobject_p.h>
23#include <QtCore/qcoreapplication.h>
24#include <QtCore/qhash.h>
25#include <QtCore/qfile.h>
26#include <QtCore/qthread.h>
27#include <QtCore/qmutex.h>
28#include <QtCore/qbuffer.h>
29#include <QtCore/qdebug.h>
30#include <QtCore/qmetaobject.h>
31#include <QtCore/qscopeguard.h>
32
33#if QT_CONFIG(qml_network)
34#include <QtQml/qqmlnetworkaccessmanagerfactory.h>
35#include <QtNetwork/qnetworkreply.h>
36#include <QtNetwork/qsslerror.h>
37#endif
38
39#include <private/qdebug_p.h>
40
41#define IMAGEREQUEST_MAX_NETWORK_REQUEST_COUNT 8
42
43// After QQuickPixmapCache::unreferencePixmap() it may get deleted via a timer in 30 seconds
44#define CACHE_EXPIRE_TIME 30
45
46// How many (1/4) of the unreferenced pixmaps to delete in QQuickPixmapCache::timerEvent()
47#define CACHE_REMOVAL_FRACTION 4
48
49#define PIXMAP_PROFILE(Code) Q_QUICK_PROFILE(QQuickProfiler::ProfilePixmapCache, Code)
50
51#if QT_CONFIG(thread) && !defined(Q_OS_WASM)
52# define USE_THREADED_DOWNLOAD 1
53#else
54# define USE_THREADED_DOWNLOAD 0
55#endif
56
57QT_BEGIN_NAMESPACE
58
59using namespace Qt::Literals::StringLiterals;
60
61Q_DECLARE_LOGGING_CATEGORY(lcQsgLeak)
62
63#if defined(QT_DEBUG) && QT_CONFIG(thread)
64class ThreadAffinityMarker
65{
66public:
67 ThreadAffinityMarker() { attachToCurrentThread(); }
68
69 void assertOnAssignedThread()
70 {
71 QMutexLocker locker(&m_mutex);
72 if (!m_assignedThread)
73 attachToCurrentThread();
74 Q_ASSERT_X(m_assignedThread == QThread::currentThreadId(), Q_FUNC_INFO,
75 "Running on a wrong thread!");
76 }
77
78 void detachFromCurrentThread()
79 {
80 QMutexLocker locker(&m_mutex);
81 m_assignedThread = nullptr;
82 }
83
84 void attachToCurrentThread() { m_assignedThread = QThread::currentThreadId(); }
85
86private:
87 Qt::HANDLE m_assignedThread;
88 QMutex m_mutex;
89};
90# define Q_THREAD_AFFINITY_MARKER(x) ThreadAffinityMarker x
91# define Q_ASSERT_CALLED_ON_VALID_THREAD(x) x.assertOnAssignedThread()
92# define Q_DETACH_THREAD_AFFINITY_MARKER(x) x.detachFromCurrentThread()
93#else
94# define Q_THREAD_AFFINITY_MARKER(x)
95# define Q_ASSERT_CALLED_ON_VALID_THREAD(x)
96# define Q_DETACH_THREAD_AFFINITY_MARKER(x)
97#endif
98
99const QLatin1String QQuickPixmap::itemGrabberScheme = QLatin1String("itemgrabber");
100
101Q_LOGGING_CATEGORY(lcImg, "qt.quick.image")
102
103/*! \internal
104 The maximum currently-unused image data that can be stored for potential
105 later reuse, in bytes. See QQuickPixmapCache::shrinkCache()
106*/
107static int cache_limit = 2048 * 1024;
108
109static inline QString imageProviderId(const QUrl &url)
110{
111 return url.host();
112}
113
114static inline QString imageId(const QUrl &url)
115{
116 return url.toString(options: QUrl::RemoveScheme | QUrl::RemoveAuthority).mid(position: 1);
117}
118
119QQuickDefaultTextureFactory::QQuickDefaultTextureFactory(const QImage &image)
120{
121 if (image.format() == QImage::Format_ARGB32_Premultiplied
122 || image.format() == QImage::Format_RGB32) {
123 im = image;
124 } else {
125 im = image.convertToFormat(f: QImage::Format_ARGB32_Premultiplied);
126 }
127 size = im.size();
128}
129
130
131QSGTexture *QQuickDefaultTextureFactory::createTexture(QQuickWindow *window) const
132{
133 QSGTexture *t = window->createTextureFromImage(image: im, options: QQuickWindow::TextureCanUseAtlas);
134 static bool transient = qEnvironmentVariableIsSet(varName: "QSG_TRANSIENT_IMAGES");
135 if (transient)
136 const_cast<QQuickDefaultTextureFactory *>(this)->im = QImage();
137 return t;
138}
139
140class QQuickPixmapReader;
141class QQuickPixmapData;
142class QQuickPixmapReply : public QObject
143{
144 Q_OBJECT
145public:
146 enum ReadError { NoError, Loading, Decoding };
147
148 QQuickPixmapReply(QQuickPixmapData *);
149 ~QQuickPixmapReply();
150
151 QQuickPixmapData *data;
152 QQmlEngine *engineForReader; // always access reader inside readerMutex
153 QRect requestRegion;
154 QSize requestSize;
155 QUrl url;
156
157 bool loading;
158 QQuickImageProviderOptions providerOptions;
159
160 class Event : public QEvent {
161 Q_EVENT_DISABLE_COPY(Event);
162 public:
163 Event(ReadError, const QString &, const QSize &, QQuickTextureFactory *factory);
164 ~Event();
165
166 ReadError error;
167 QString errorString;
168 QSize implicitSize;
169 QQuickTextureFactory *textureFactory;
170 };
171 void postReply(ReadError, const QString &, const QSize &, QQuickTextureFactory *factory);
172
173
174Q_SIGNALS:
175 void finished();
176 void downloadProgress(qint64, qint64);
177
178protected:
179 bool event(QEvent *event) override;
180
181private:
182 Q_DISABLE_COPY(QQuickPixmapReply)
183
184public:
185 static int finishedMethodIndex;
186 static int downloadProgressMethodIndex;
187};
188
189/*! \internal
190 Serves as an endpoint for notifications on the connected reader's thread, thus enforcing
191 execution of their continuation on the thread. */
192class ReaderThreadExecutionEnforcer : public QObject
193{
194 Q_OBJECT
195public:
196 enum Event {
197 ProcessJobs = QEvent::User,
198 };
199
200 ReaderThreadExecutionEnforcer(QQuickPixmapReader *reader);
201
202 /*! \internal
203 Forces the execution of processJobs() on the original reader on the thread it's running on.
204 */
205 void processJobsOnReaderThreadLater();
206
207public slots:
208 void asyncResponseFinished(QQuickImageResponse *response);
209 void asyncResponseFinished();
210private slots:
211 void networkRequestDone();
212private:
213 Q_DISABLE_COPY(ReaderThreadExecutionEnforcer)
214 bool event(QEvent *e) override;
215
216 QQuickPixmapReader *reader;
217};
218
219class QQuickPixmapData;
220class QQuickPixmapReader : public QThread
221{
222 Q_OBJECT
223public:
224 QQuickPixmapReader(QQmlEngine *eng);
225 ~QQuickPixmapReader();
226
227 QQuickPixmapReply *getImage(QQuickPixmapData *);
228 void cancel(QQuickPixmapReply *rep);
229
230 static QQuickPixmapReader *instance(QQmlEngine *engine);
231 static QQuickPixmapReader *existingInstance(QQmlEngine *engine);
232 void startJob(QQuickPixmapReply *job);
233
234protected:
235 void run() override;
236
237private:
238 Q_DISABLE_COPY(QQuickPixmapReader)
239 friend class ReaderThreadExecutionEnforcer;
240 void processJobs();
241 void processJob(QQuickPixmapReply *, const QUrl &, const QString &, QQuickImageProvider::ImageType, const QSharedPointer<QQuickImageProvider> &);
242#if QT_CONFIG(qml_network)
243 void networkRequestDone(QNetworkReply *);
244#endif
245 void asyncResponseFinished(QQuickImageResponse *);
246
247 QList<QQuickPixmapReply*> jobs;
248 QList<QQuickPixmapReply *> cancelledJobs;
249 QQmlEngine *engine;
250
251#if QT_CONFIG(quick_pixmap_cache_threaded_download)
252 /*! \internal
253 Returns a pointer to the thread object owned by the run loop in QQuickPixmapReader::run.
254 */
255 ReaderThreadExecutionEnforcer *readerThreadExecutionEnforcer()
256 {
257 return runLoopReaderThreadExecutionEnforcer;
258 }
259 QObject *eventLoopQuitHack;
260 QMutex mutex;
261 ReaderThreadExecutionEnforcer *runLoopReaderThreadExecutionEnforcer = nullptr;
262#else
263 /*! \internal
264 Returns a pointer to the thread object owned by this instance.
265 */
266 ReaderThreadExecutionEnforcer *readerThreadExecutionEnforcer()
267 {
268 return ownedReaderThreadExecutionEnforcer.get();
269 }
270 std::unique_ptr<ReaderThreadExecutionEnforcer> ownedReaderThreadExecutionEnforcer;
271#endif
272
273#if QT_CONFIG(qml_network)
274 QNetworkAccessManager *networkAccessManager();
275 QNetworkAccessManager *accessManager;
276 QHash<QNetworkReply*,QQuickPixmapReply*> networkJobs;
277#endif
278 QHash<QQuickImageResponse*,QQuickPixmapReply*> asyncResponses;
279
280 Q_THREAD_AFFINITY_MARKER(m_creatorThreadAffinityMarker);
281 Q_THREAD_AFFINITY_MARKER(m_readerThreadAffinityMarker);
282
283 static int replyDownloadProgressMethodIndex;
284 static int replyFinishedMethodIndex;
285 static int downloadProgressMethodIndex;
286 static int threadNetworkRequestDoneMethodIndex;
287 static QHash<QQmlEngine *,QQuickPixmapReader*> readers;
288public:
289 static QMutex readerMutex;
290};
291
292#if QT_CONFIG(quick_pixmap_cache_threaded_download)
293# define PIXMAP_READER_LOCK() QMutexLocker locker(&mutex)
294#else
295# define PIXMAP_READER_LOCK()
296#endif
297
298class QQuickPixmapCache;
299
300/*! \internal
301 The private storage for QQuickPixmap.
302*/
303class QQuickPixmapData
304{
305public:
306 QQuickPixmapData(const QUrl &u, const QRect &r, const QSize &rs,
307 const QQuickImageProviderOptions &po, const QString &e)
308 : refCount(1), frameCount(1), frame(0), inCache(false), fromSpecialDevice(false), pixmapStatus(QQuickPixmap::Error),
309 url(u), errorString(e), requestRegion(r), requestSize(rs),
310 providerOptions(po), appliedTransform(QQuickImageProviderOptions::UsePluginDefaultTransform),
311 textureFactory(nullptr), reply(nullptr), prevUnreferenced(nullptr),
312 prevUnreferencedPtr(nullptr), nextUnreferenced(nullptr)
313#ifdef Q_OS_WEBOS
314 , storeToCache(true)
315#endif
316 {
317 }
318
319 QQuickPixmapData(const QUrl &u, const QRect &r, const QSize &s, const QQuickImageProviderOptions &po,
320 QQuickImageProviderOptions::AutoTransform aTransform, int frame=0, int frameCount=1)
321 : refCount(1), frameCount(frameCount), frame(frame), inCache(false), fromSpecialDevice(false), pixmapStatus(QQuickPixmap::Loading),
322 url(u), requestRegion(r), requestSize(s),
323 providerOptions(po), appliedTransform(aTransform),
324 textureFactory(nullptr), reply(nullptr), prevUnreferenced(nullptr), prevUnreferencedPtr(nullptr),
325 nextUnreferenced(nullptr)
326#ifdef Q_OS_WEBOS
327 , storeToCache(true)
328#endif
329 {
330 }
331
332 QQuickPixmapData(const QUrl &u, QQuickTextureFactory *texture,
333 const QSize &s, const QRect &r, const QSize &rs, const QQuickImageProviderOptions &po,
334 QQuickImageProviderOptions::AutoTransform aTransform, int frame=0, int frameCount=1)
335 : refCount(1), frameCount(frameCount), frame(frame), inCache(false), fromSpecialDevice(false), pixmapStatus(QQuickPixmap::Ready),
336 url(u), implicitSize(s), requestRegion(r), requestSize(rs),
337 providerOptions(po), appliedTransform(aTransform),
338 textureFactory(texture), reply(nullptr), prevUnreferenced(nullptr),
339 prevUnreferencedPtr(nullptr), nextUnreferenced(nullptr)
340#ifdef Q_OS_WEBOS
341 , storeToCache(true)
342#endif
343 {
344 }
345
346 QQuickPixmapData(QQuickTextureFactory *texture)
347 : refCount(1), frameCount(1), frame(0), inCache(false), fromSpecialDevice(false), pixmapStatus(QQuickPixmap::Ready),
348 appliedTransform(QQuickImageProviderOptions::UsePluginDefaultTransform),
349 textureFactory(texture), reply(nullptr), prevUnreferenced(nullptr),
350 prevUnreferencedPtr(nullptr), nextUnreferenced(nullptr)
351#ifdef Q_OS_WEBOS
352 , storeToCache(true)
353#endif
354 {
355 if (texture)
356 requestSize = implicitSize = texture->textureSize();
357 }
358
359 ~QQuickPixmapData()
360 {
361 delete textureFactory;
362 }
363
364 int cost() const;
365 void addref();
366 void release(QQuickPixmapCache *store = nullptr);
367 void addToCache();
368 void removeFromCache(QQuickPixmapCache *store = nullptr);
369
370 uint refCount;
371 int frameCount;
372 int frame;
373
374 bool inCache:1;
375 bool fromSpecialDevice:1;
376
377 QQuickPixmap::Status pixmapStatus;
378 QUrl url;
379 QString errorString;
380 QSize implicitSize;
381 QRect requestRegion;
382 QSize requestSize;
383 QQuickImageProviderOptions providerOptions;
384 QQuickImageProviderOptions::AutoTransform appliedTransform;
385 QColorSpace targetColorSpace;
386
387 QPointer<QIODevice> specialDevice;
388
389 // actual image data, after loading
390 QQuickTextureFactory *textureFactory;
391
392 QQuickPixmapReply *reply;
393
394 // prev/next pointers to form a linked list for dereferencing pixmaps that are currently unused
395 // (those get lazily deleted in QQuickPixmapCache::shrinkCache())
396 QQuickPixmapData *prevUnreferenced;
397 QQuickPixmapData**prevUnreferencedPtr;
398 QQuickPixmapData *nextUnreferenced;
399
400#ifdef Q_OS_WEBOS
401 bool storeToCache;
402#endif
403
404private:
405 Q_DISABLE_COPY(QQuickPixmapData)
406};
407
408int QQuickPixmapReply::finishedMethodIndex = -1;
409int QQuickPixmapReply::downloadProgressMethodIndex = -1;
410
411// XXX
412QHash<QQmlEngine *,QQuickPixmapReader*> QQuickPixmapReader::readers;
413QMutex QQuickPixmapReader::readerMutex;
414
415int QQuickPixmapReader::replyDownloadProgressMethodIndex = -1;
416int QQuickPixmapReader::replyFinishedMethodIndex = -1;
417int QQuickPixmapReader::downloadProgressMethodIndex = -1;
418int QQuickPixmapReader::threadNetworkRequestDoneMethodIndex = -1;
419
420void QQuickPixmapReply::postReply(ReadError error, const QString &errorString,
421 const QSize &implicitSize, QQuickTextureFactory *factory)
422{
423 loading = false;
424 QCoreApplication::postEvent(receiver: this, event: new Event(error, errorString, implicitSize, factory));
425}
426
427QQuickPixmapReply::Event::Event(ReadError e, const QString &s, const QSize &iSize, QQuickTextureFactory *factory)
428 : QEvent(QEvent::User), error(e), errorString(s), implicitSize(iSize), textureFactory(factory)
429{
430}
431
432QQuickPixmapReply::Event::~Event()
433{
434 delete textureFactory;
435}
436
437#if QT_CONFIG(qml_network)
438QNetworkAccessManager *QQuickPixmapReader::networkAccessManager()
439{
440 if (!accessManager) {
441 Q_ASSERT(readerThreadExecutionEnforcer());
442 accessManager = QQmlEnginePrivate::get(e: engine)->createNetworkAccessManager(
443 parent: readerThreadExecutionEnforcer());
444 }
445 return accessManager;
446}
447#endif
448
449static void maybeRemoveAlpha(QImage *image)
450{
451 // If the image
452 if (image->hasAlphaChannel() && image->data_ptr()
453 && !image->data_ptr()->checkForAlphaPixels()) {
454 switch (image->format()) {
455 case QImage::Format_RGBA8888:
456 case QImage::Format_RGBA8888_Premultiplied:
457 if (image->data_ptr()->convertInPlace(newFormat: QImage::Format_RGBX8888, Qt::AutoColor))
458 break;
459
460 *image = image->convertToFormat(f: QImage::Format_RGBX8888);
461 break;
462 case QImage::Format_A2BGR30_Premultiplied:
463 if (image->data_ptr()->convertInPlace(newFormat: QImage::Format_BGR30, Qt::AutoColor))
464 break;
465
466 *image = image->convertToFormat(f: QImage::Format_BGR30);
467 break;
468 case QImage::Format_A2RGB30_Premultiplied:
469 if (image->data_ptr()->convertInPlace(newFormat: QImage::Format_RGB30, Qt::AutoColor))
470 break;
471
472 *image = image->convertToFormat(f: QImage::Format_RGB30);
473 break;
474 default:
475 if (image->data_ptr()->convertInPlace(newFormat: QImage::Format_RGB32, Qt::AutoColor))
476 break;
477
478 *image = image->convertToFormat(f: QImage::Format_RGB32);
479 break;
480 }
481 }
482}
483
484static bool readImage(const QUrl& url, QIODevice *dev, QImage *image, QString *errorString, QSize *impsize, int *frameCount,
485 const QRect &requestRegion, const QSize &requestSize, const QQuickImageProviderOptions &providerOptions,
486 QQuickImageProviderOptions::AutoTransform *appliedTransform = nullptr, int frame = 0,
487 qreal devicePixelRatio = 1.0)
488{
489 QImageReader imgio(dev);
490 if (providerOptions.autoTransform() != QQuickImageProviderOptions::UsePluginDefaultTransform)
491 imgio.setAutoTransform(providerOptions.autoTransform() == QQuickImageProviderOptions::ApplyTransform);
492 else if (appliedTransform)
493 *appliedTransform = imgio.autoTransform() ? QQuickImageProviderOptions::ApplyTransform : QQuickImageProviderOptions::DoNotApplyTransform;
494
495 if (frame < imgio.imageCount())
496 imgio.jumpToImage(imageNumber: frame);
497
498 if (frameCount)
499 *frameCount = imgio.imageCount();
500
501 QSize scSize = QQuickImageProviderWithOptions::loadSize(originalSize: imgio.size(), requestedSize: requestSize, format: imgio.format(), options: providerOptions, devicePixelRatio);
502 if (scSize.isValid())
503 imgio.setScaledSize(scSize);
504 if (!requestRegion.isNull())
505 imgio.setScaledClipRect(requestRegion);
506 const QSize originalSize = imgio.size();
507 qCDebug(lcImg) << url << "frame" << frame << "of" << imgio.imageCount()
508 << "requestRegion" << requestRegion << "QImageReader size" << originalSize << "-> scSize" << scSize;
509
510 if (impsize)
511 *impsize = originalSize;
512
513 if (imgio.read(image)) {
514 maybeRemoveAlpha(image);
515 if (impsize && impsize->width() < 0)
516 *impsize = image->size();
517 if (providerOptions.targetColorSpace().isValid()) {
518 if (image->colorSpace().isValid())
519 image->convertToColorSpace(colorSpace: providerOptions.targetColorSpace());
520 else
521 image->setColorSpace(providerOptions.targetColorSpace());
522 }
523 return true;
524 } else {
525 if (errorString)
526 *errorString = QQuickPixmap::tr(sourceText: "Error decoding: %1: %2").arg(a: url.toString())
527 .arg(a: imgio.errorString());
528 return false;
529 }
530}
531
532static QStringList fromLatin1List(const QList<QByteArray> &list)
533{
534 QStringList res;
535 res.reserve(asize: list.size());
536 for (const QByteArray &item : list)
537 res.append(t: QString::fromLatin1(ba: item));
538 return res;
539}
540
541class BackendSupport
542{
543public:
544 BackendSupport()
545 {
546 delete QSGContext::createTextureFactoryFromImage(image: QImage()); // Force init of backend data
547 hasOpenGL = QQuickWindow::sceneGraphBackend().isEmpty(); // i.e. default
548 QList<QByteArray> list;
549 if (hasOpenGL)
550 list.append(other: QSGTextureReader::supportedFileFormats());
551 list.append(other: QImageReader::supportedImageFormats());
552 fileSuffixes = fromLatin1List(list);
553 }
554 bool hasOpenGL;
555 QStringList fileSuffixes;
556private:
557 Q_DISABLE_COPY(BackendSupport)
558};
559Q_GLOBAL_STATIC(BackendSupport, backendSupport);
560
561static QString existingImageFileForPath(const QString &localFile)
562{
563 // Do nothing if given filepath exists or already has a suffix
564 QFileInfo fi(localFile);
565 if (!fi.suffix().isEmpty() || fi.exists())
566 return localFile;
567
568 QString tryFile = localFile + QStringLiteral(".xxxx");
569 const int suffixIdx = localFile.size() + 1;
570 for (const QString &suffix : backendSupport()->fileSuffixes) {
571 tryFile.replace(i: suffixIdx, len: 10, after: suffix);
572 if (QFileInfo::exists(file: tryFile))
573 return tryFile;
574 }
575 return localFile;
576}
577
578QQuickPixmapReader::QQuickPixmapReader(QQmlEngine *eng)
579: QThread(eng), engine(eng)
580#if QT_CONFIG(qml_network)
581, accessManager(nullptr)
582#endif
583{
584 Q_DETACH_THREAD_AFFINITY_MARKER(m_readerThreadAffinityMarker);
585#if QT_CONFIG(quick_pixmap_cache_threaded_download)
586 eventLoopQuitHack = new QObject;
587 eventLoopQuitHack->moveToThread(thread: this);
588 QObject::connect(sender: eventLoopQuitHack, signal: &QObject::destroyed, context: this, slot: &QThread::quit, type: Qt::DirectConnection);
589 start(QThread::LowestPriority);
590#else
591 run(); // Call nonblocking run for ourselves.
592#endif
593}
594
595QQuickPixmapReader::~QQuickPixmapReader()
596{
597 Q_ASSERT_CALLED_ON_VALID_THREAD(m_creatorThreadAffinityMarker);
598
599 readerMutex.lock();
600 readers.remove(key: engine);
601 readerMutex.unlock();
602
603 {
604 PIXMAP_READER_LOCK();
605 // manually cancel all outstanding jobs.
606 for (QQuickPixmapReply *reply : std::as_const(t&: jobs)) {
607 if (reply->data && reply->data->reply == reply)
608 reply->data->reply = nullptr;
609 delete reply;
610 }
611 jobs.clear();
612 const auto cancelJob = [this](QQuickPixmapReply *reply) {
613 if (reply->loading) {
614 cancelledJobs.append(t: reply);
615 reply->data = nullptr;
616 }
617 };
618#if QT_CONFIG(qml_network)
619 for (auto *reply : std::as_const(t&: networkJobs))
620 cancelJob(reply);
621#endif
622 for (auto *reply : std::as_const(t&: asyncResponses))
623 cancelJob(reply);
624#if !QT_CONFIG(quick_pixmap_cache_threaded_download)
625 // In this case we won't be waiting, but we are on the correct thread already, so we can
626 // perform housekeeping synchronously now.
627 processJobs();
628#else // QT_CONFIG(quick_pixmap_cache_threaded_download) is true
629 // Perform housekeeping on all the jobs cancelled above soon...
630 if (readerThreadExecutionEnforcer())
631 readerThreadExecutionEnforcer()->processJobsOnReaderThreadLater();
632#endif
633 }
634
635#if QT_CONFIG(quick_pixmap_cache_threaded_download)
636 // ... schedule stopping of this thread via the eventLoopQuitHack (processJobs scheduled above
637 // will run first) ...
638 eventLoopQuitHack->deleteLater();
639 // ... and wait() for it all to finish, as the thread will only quit after eventLoopQuitHack
640 // has been deleted.
641 wait();
642#endif
643
644 // While we've been waiting, the other thread may have added
645 // more replies. No one will care about them anymore.
646
647 auto deleteReply = [](QQuickPixmapReply *reply) {
648 if (reply->data && reply->data->reply == reply)
649 reply->data->reply = nullptr;
650 delete reply;
651 };
652#if QT_CONFIG(qml_network)
653 for (QQuickPixmapReply *reply : std::as_const(t&: networkJobs))
654 deleteReply(reply);
655#endif
656 for (QQuickPixmapReply *reply : std::as_const(t&: asyncResponses))
657 deleteReply(reply);
658
659#if QT_CONFIG(qml_network)
660 networkJobs.clear();
661#endif
662 asyncResponses.clear();
663}
664
665#if QT_CONFIG(qml_network)
666void QQuickPixmapReader::networkRequestDone(QNetworkReply *reply)
667{
668 Q_ASSERT_CALLED_ON_VALID_THREAD(m_readerThreadAffinityMarker);
669
670 QQuickPixmapReply *job = networkJobs.take(key: reply);
671
672 if (job) {
673 QImage image;
674 QQuickPixmapReply::ReadError error = QQuickPixmapReply::NoError;
675 QString errorString;
676 QSize readSize;
677 QQuickTextureFactory *factory = nullptr;
678 if (reply->error()) {
679 error = QQuickPixmapReply::Loading;
680 errorString = reply->errorString();
681 } else {
682 QByteArray all = reply->readAll();
683 QBuffer buff(&all);
684 buff.open(openMode: QIODevice::ReadOnly);
685 QSGTextureReader texReader(&buff, reply->url().fileName());
686 if (backendSupport()->hasOpenGL && texReader.isTexture()) {
687 factory = texReader.read();
688 if (factory) {
689 readSize = factory->textureSize();
690 } else {
691 error = QQuickPixmapReply::Decoding;
692 errorString = QQuickPixmap::tr(sourceText: "Error decoding: %1").arg(a: reply->url().toString());
693 }
694 } else {
695 int frameCount;
696 int const frame = job->data ? job->data->frame : 0;
697 if (!readImage(url: reply->url(), dev: &buff, image: &image, errorString: &errorString, impsize: &readSize, frameCount: &frameCount,
698 requestRegion: job->requestRegion, requestSize: job->requestSize, providerOptions: job->providerOptions, appliedTransform: nullptr, frame))
699 error = QQuickPixmapReply::Decoding;
700 else if (job->data)
701 job->data->frameCount = frameCount;
702 }
703 }
704 // send completion event to the QQuickPixmapReply
705 if (!factory)
706 factory = QQuickTextureFactory::textureFactoryForImage(image);
707
708 PIXMAP_READER_LOCK();
709 if (!cancelledJobs.contains(t: job))
710 job->postReply(error, errorString, implicitSize: readSize, factory);
711 }
712 reply->deleteLater();
713
714 // kick off event loop again in case we have dropped below max request count
715 readerThreadExecutionEnforcer()->processJobsOnReaderThreadLater();
716}
717#endif // qml_network
718
719void QQuickPixmapReader::asyncResponseFinished(QQuickImageResponse *response)
720{
721 Q_ASSERT_CALLED_ON_VALID_THREAD(m_readerThreadAffinityMarker);
722
723 QQuickPixmapReply *job = asyncResponses.take(key: response);
724
725 if (job) {
726 QQuickTextureFactory *t = nullptr;
727 QQuickPixmapReply::ReadError error = QQuickPixmapReply::NoError;
728 QString errorString;
729 if (!response->errorString().isEmpty()) {
730 error = QQuickPixmapReply::Loading;
731 errorString = response->errorString();
732 } else {
733 t = response->textureFactory();
734 }
735
736 PIXMAP_READER_LOCK();
737 if (!cancelledJobs.contains(t: job))
738 job->postReply(error, errorString, implicitSize: t ? t->textureSize() : QSize(), factory: t);
739 else
740 delete t;
741 }
742 response->deleteLater();
743
744 // kick off event loop again in case we have dropped below max request count
745 readerThreadExecutionEnforcer()->processJobsOnReaderThreadLater();
746}
747
748ReaderThreadExecutionEnforcer::ReaderThreadExecutionEnforcer(QQuickPixmapReader *i) : reader(i) { }
749
750void ReaderThreadExecutionEnforcer::processJobsOnReaderThreadLater()
751{
752 QCoreApplication::postEvent(
753 receiver: this, event: new QEvent(QEvent::Type(ReaderThreadExecutionEnforcer::ProcessJobs)));
754}
755
756bool ReaderThreadExecutionEnforcer::event(QEvent *e)
757{
758 switch (e->type()) {
759 case QEvent::Type(ReaderThreadExecutionEnforcer::ProcessJobs):
760 reader->processJobs();
761 return true;
762 default:
763 return QObject::event(event: e);
764 }
765}
766
767void ReaderThreadExecutionEnforcer::networkRequestDone()
768{
769#if QT_CONFIG(qml_network)
770 QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
771 reader->networkRequestDone(reply);
772#endif
773}
774
775void ReaderThreadExecutionEnforcer::asyncResponseFinished(QQuickImageResponse *response)
776{
777 reader->asyncResponseFinished(response);
778}
779
780void ReaderThreadExecutionEnforcer::asyncResponseFinished()
781{
782 QQuickImageResponse *response = static_cast<QQuickImageResponse *>(sender());
783 asyncResponseFinished(response);
784}
785
786void QQuickPixmapReader::processJobs()
787{
788 Q_ASSERT_CALLED_ON_VALID_THREAD(m_readerThreadAffinityMarker);
789
790 PIXMAP_READER_LOCK();
791 while (true) {
792 if (cancelledJobs.isEmpty() && jobs.isEmpty())
793 return; // Nothing else to do
794
795 // Clean cancelled jobs
796 if (!cancelledJobs.isEmpty()) {
797 for (int i = 0; i < cancelledJobs.size(); ++i) {
798 QQuickPixmapReply *job = cancelledJobs.at(i);
799#if QT_CONFIG(qml_network)
800 QNetworkReply *reply = networkJobs.key(value: job, defaultKey: 0);
801 if (reply) {
802 networkJobs.remove(key: reply);
803 if (reply->isRunning()) {
804 // cancel any jobs already started
805 reply->close();
806 }
807 } else
808#endif
809 {
810 QQuickImageResponse *asyncResponse = asyncResponses.key(value: job);
811 if (asyncResponse) {
812 asyncResponses.remove(key: asyncResponse);
813 asyncResponse->cancel();
814 }
815 }
816 PIXMAP_PROFILE(pixmapStateChanged<QQuickProfiler::PixmapLoadingError>(job->url));
817 // deleteLater, since not owned by this thread
818 job->deleteLater();
819 }
820 cancelledJobs.clear();
821 }
822
823 if (!jobs.isEmpty()) {
824 // Find a job we can use
825 bool usableJob = false;
826 for (int i = jobs.size() - 1; !usableJob && i >= 0; i--) {
827 QQuickPixmapReply *job = jobs.at(i);
828 const QUrl url = job->url;
829 QString localFile;
830 QQuickImageProvider::ImageType imageType = QQuickImageProvider::Invalid;
831 QSharedPointer<QQuickImageProvider> provider;
832
833 if (url.scheme() == QLatin1String("image")) {
834 QQmlEnginePrivate *enginePrivate = QQmlEnginePrivate::get(e: engine);
835 provider = enginePrivate->imageProvider(providerId: imageProviderId(url)).staticCast<QQuickImageProvider>();
836 if (provider)
837 imageType = provider->imageType();
838
839 usableJob = true;
840 } else {
841 localFile = QQmlFile::urlToLocalFileOrQrc(url);
842 usableJob = !localFile.isEmpty()
843#if QT_CONFIG(qml_network)
844 || networkJobs.size() < IMAGEREQUEST_MAX_NETWORK_REQUEST_COUNT
845#endif
846 ;
847 }
848
849 if (usableJob) {
850 jobs.removeAt(i);
851
852 job->loading = true;
853
854 PIXMAP_PROFILE(pixmapStateChanged<QQuickProfiler::PixmapLoadingStarted>(url));
855
856#if QT_CONFIG(quick_pixmap_cache_threaded_download)
857 locker.unlock();
858 auto relockMutexGuard = qScopeGuard(f: ([&locker]() {
859 locker.relock();
860 }));
861#endif
862 processJob(job, url, localFile, imageType, provider);
863 }
864 }
865
866 if (!usableJob)
867 return;
868 }
869 }
870}
871
872void QQuickPixmapReader::processJob(QQuickPixmapReply *runningJob, const QUrl &url, const QString &localFile,
873 QQuickImageProvider::ImageType imageType, const QSharedPointer<QQuickImageProvider> &provider)
874{
875 Q_ASSERT_CALLED_ON_VALID_THREAD(m_readerThreadAffinityMarker);
876
877 // fetch
878 if (url.scheme() == QLatin1String("image")) {
879 // Use QQuickImageProvider
880 QSize readSize;
881
882 if (imageType == QQuickImageProvider::Invalid) {
883 QString errorStr = QQuickPixmap::tr(sourceText: "Invalid image provider: %1").arg(a: url.toString());
884 PIXMAP_READER_LOCK();
885 if (!cancelledJobs.contains(t: runningJob))
886 runningJob->postReply(error: QQuickPixmapReply::Loading, errorString: errorStr, implicitSize: readSize, factory: nullptr);
887 return;
888 }
889
890 // This is safe because we ensure that provider does outlive providerV2 and it does not escape the function
891 QQuickImageProviderWithOptions *providerV2 = QQuickImageProviderWithOptions::checkedCast(provider: provider.get());
892
893 switch (imageType) {
894 case QQuickImageProvider::Invalid:
895 {
896 // Already handled
897 break;
898 }
899
900 case QQuickImageProvider::Image:
901 {
902 QImage image;
903 if (providerV2) {
904 image = providerV2->requestImage(id: imageId(url), size: &readSize, requestedSize: runningJob->requestSize, options: runningJob->providerOptions);
905 } else {
906 image = provider->requestImage(id: imageId(url), size: &readSize, requestedSize: runningJob->requestSize);
907 }
908 QQuickPixmapReply::ReadError errorCode = QQuickPixmapReply::NoError;
909 QString errorStr;
910 if (image.isNull()) {
911 errorCode = QQuickPixmapReply::Loading;
912 errorStr = QQuickPixmap::tr(sourceText: "Failed to get image from provider: %1").arg(a: url.toString());
913 }
914 PIXMAP_READER_LOCK();
915 if (!cancelledJobs.contains(t: runningJob)) {
916 runningJob->postReply(error: errorCode, errorString: errorStr, implicitSize: readSize,
917 factory: QQuickTextureFactory::textureFactoryForImage(image));
918 }
919 break;
920 }
921
922 case QQuickImageProvider::Pixmap:
923 {
924 QPixmap pixmap;
925 if (providerV2) {
926 pixmap = providerV2->requestPixmap(id: imageId(url), size: &readSize, requestedSize: runningJob->requestSize, options: runningJob->providerOptions);
927 } else {
928 pixmap = provider->requestPixmap(id: imageId(url), size: &readSize, requestedSize: runningJob->requestSize);
929 }
930 QQuickPixmapReply::ReadError errorCode = QQuickPixmapReply::NoError;
931 QString errorStr;
932 if (pixmap.isNull()) {
933 errorCode = QQuickPixmapReply::Loading;
934 errorStr = QQuickPixmap::tr(sourceText: "Failed to get image from provider: %1").arg(a: url.toString());
935 }
936
937 PIXMAP_READER_LOCK();
938 if (!cancelledJobs.contains(t: runningJob)) {
939 runningJob->postReply(
940 error: errorCode, errorString: errorStr, implicitSize: readSize,
941 factory: QQuickTextureFactory::textureFactoryForImage(image: pixmap.toImage()));
942 }
943 break;
944 }
945
946 case QQuickImageProvider::Texture:
947 {
948 QQuickTextureFactory *t;
949 if (providerV2) {
950 t = providerV2->requestTexture(id: imageId(url), size: &readSize, requestedSize: runningJob->requestSize, options: runningJob->providerOptions);
951 } else {
952 t = provider->requestTexture(id: imageId(url), size: &readSize, requestedSize: runningJob->requestSize);
953 }
954 QQuickPixmapReply::ReadError errorCode = QQuickPixmapReply::NoError;
955 QString errorStr;
956 if (!t) {
957 errorCode = QQuickPixmapReply::Loading;
958 errorStr = QQuickPixmap::tr(sourceText: "Failed to get texture from provider: %1").arg(a: url.toString());
959 }
960 PIXMAP_READER_LOCK();
961 if (!cancelledJobs.contains(t: runningJob))
962 runningJob->postReply(error: errorCode, errorString: errorStr, implicitSize: readSize, factory: t);
963 else
964 delete t;
965 break;
966 }
967
968 case QQuickImageProvider::ImageResponse:
969 {
970 QQuickImageResponse *response;
971 if (providerV2) {
972 response = providerV2->requestImageResponse(id: imageId(url), requestedSize: runningJob->requestSize, options: runningJob->providerOptions);
973 } else {
974 QQuickAsyncImageProvider *asyncProvider = static_cast<QQuickAsyncImageProvider*>(provider.get());
975 response = asyncProvider->requestImageResponse(id: imageId(url), requestedSize: runningJob->requestSize);
976 }
977
978 {
979 QObject::connect(sender: response, signal: &QQuickImageResponse::finished, context: readerThreadExecutionEnforcer(),
980 slot: qOverload<>(&ReaderThreadExecutionEnforcer::asyncResponseFinished));
981 // as the response object can outlive the provider QSharedPointer, we have to extend the pointee's lifetime by that of the response
982 // we do this by capturing a copy of the QSharedPointer in a lambda, and dropping it once the lambda has been called
983 auto provider_copy = provider; // capturing provider would capture it as a const reference, and copy capture with initializer is only available in C++14
984 QObject::connect(sender: response, signal: &QQuickImageResponse::destroyed, context: response, slot: [provider_copy]() {
985 // provider_copy will be deleted when the connection gets deleted
986 });
987 }
988 // Might be that the async provider was so quick it emitted the signal before we
989 // could connect to it.
990 //
991 // loadAcquire() synchronizes-with storeRelease() in QQuickImageResponsePrivate::_q_finished():
992 if (static_cast<QQuickImageResponsePrivate*>(QObjectPrivate::get(o: response))->finished.loadAcquire()) {
993 QMetaObject::invokeMethod(obj: readerThreadExecutionEnforcer(), member: "asyncResponseFinished",
994 c: Qt::QueuedConnection,
995 Q_ARG(QQuickImageResponse *, response));
996 }
997
998 asyncResponses.insert(key: response, value: runningJob);
999 break;
1000 }
1001 }
1002
1003 } else {
1004 if (!localFile.isEmpty()) {
1005 // Image is local - load/decode immediately
1006 QImage image;
1007 QQuickPixmapReply::ReadError errorCode = QQuickPixmapReply::NoError;
1008 QString errorStr;
1009 QSize readSize;
1010
1011 if (runningJob->data && runningJob->data->fromSpecialDevice) {
1012 auto specialDevice = runningJob->data->specialDevice;
1013 if (specialDevice.isNull() || QObjectPrivate::get(o: specialDevice.data())->deleteLaterCalled) {
1014 qCDebug(lcImg) << "readImage job aborted" << url;
1015 return;
1016 }
1017 int frameCount;
1018 // Ensure that specialDevice's thread affinity is _this_ thread, to avoid deleteLater()
1019 // deleting prematurely, before readImage() is done. But this is only possible if it has already
1020 // relinquished its initial thread affinity.
1021 if (!specialDevice->thread()) {
1022 qCDebug(lcQsgLeak) << specialDevice.data() << ": changing thread affinity so that"
1023 << QThread::currentThread() << "will handle any deleteLater() calls";
1024 specialDevice->moveToThread(thread: QThread::currentThread());
1025 }
1026 if (!readImage(url, dev: specialDevice.data(), image: &image, errorString: &errorStr, impsize: &readSize, frameCount: &frameCount,
1027 requestRegion: runningJob->requestRegion, requestSize: runningJob->requestSize,
1028 providerOptions: runningJob->providerOptions, appliedTransform: nullptr, frame: runningJob->data->frame)) {
1029 errorCode = QQuickPixmapReply::Loading;
1030 } else if (runningJob->data) {
1031 runningJob->data->frameCount = frameCount;
1032 }
1033 } else {
1034 QFile f(existingImageFileForPath(localFile));
1035 if (f.open(flags: QIODevice::ReadOnly)) {
1036 QSGTextureReader texReader(&f, localFile);
1037 if (backendSupport()->hasOpenGL && texReader.isTexture()) {
1038 QQuickTextureFactory *factory = texReader.read();
1039 if (factory) {
1040 readSize = factory->textureSize();
1041 } else {
1042 errorStr = QQuickPixmap::tr(sourceText: "Error decoding: %1").arg(a: url.toString());
1043 if (f.fileName() != localFile)
1044 errorStr += QString::fromLatin1(ba: " (%1)").arg(a: f.fileName());
1045 errorCode = QQuickPixmapReply::Decoding;
1046 }
1047 PIXMAP_READER_LOCK();
1048 if (!cancelledJobs.contains(t: runningJob))
1049 runningJob->postReply(error: errorCode, errorString: errorStr, implicitSize: readSize, factory);
1050 return;
1051 } else {
1052 int frameCount;
1053 int const frame = runningJob->data ? runningJob->data->frame : 0;
1054 if (!readImage(url, dev: &f, image: &image, errorString: &errorStr, impsize: &readSize, frameCount: &frameCount,
1055 requestRegion: runningJob->requestRegion, requestSize: runningJob->requestSize,
1056 providerOptions: runningJob->providerOptions, appliedTransform: nullptr, frame)) {
1057 errorCode = QQuickPixmapReply::Loading;
1058 if (f.fileName() != localFile)
1059 errorStr += QString::fromLatin1(ba: " (%1)").arg(a: f.fileName());
1060 } else if (runningJob->data) {
1061 runningJob->data->frameCount = frameCount;
1062 }
1063 }
1064 } else {
1065 errorStr = QQuickPixmap::tr(sourceText: "Cannot open: %1").arg(a: url.toString());
1066 errorCode = QQuickPixmapReply::Loading;
1067 }
1068 }
1069 PIXMAP_READER_LOCK();
1070 if (!cancelledJobs.contains(t: runningJob)) {
1071 runningJob->postReply(error: errorCode, errorString: errorStr, implicitSize: readSize,
1072 factory: QQuickTextureFactory::textureFactoryForImage(image));
1073 }
1074 } else {
1075#if QT_CONFIG(qml_network)
1076 // Network resource
1077 QNetworkRequest req(url);
1078 req.setAttribute(code: QNetworkRequest::HttpPipeliningAllowedAttribute, value: true);
1079 QNetworkReply *reply = networkAccessManager()->get(request: req);
1080
1081 QMetaObject::connect(sender: reply, signal_index: replyDownloadProgressMethodIndex, receiver: runningJob,
1082 method_index: downloadProgressMethodIndex);
1083 QMetaObject::connect(sender: reply, signal_index: replyFinishedMethodIndex, receiver: readerThreadExecutionEnforcer(),
1084 method_index: threadNetworkRequestDoneMethodIndex);
1085
1086 networkJobs.insert(key: reply, value: runningJob);
1087#else
1088// Silently fail if compiled with no_network
1089#endif
1090 }
1091 }
1092}
1093
1094QQuickPixmapReader *QQuickPixmapReader::instance(QQmlEngine *engine)
1095{
1096 // XXX NOTE: must be called within readerMutex locking.
1097 QQuickPixmapReader *reader = readers.value(key: engine);
1098 if (!reader) {
1099 reader = new QQuickPixmapReader(engine);
1100 readers.insert(key: engine, value: reader);
1101 }
1102
1103 return reader;
1104}
1105
1106QQuickPixmapReader *QQuickPixmapReader::existingInstance(QQmlEngine *engine)
1107{
1108 // XXX NOTE: must be called within readerMutex locking.
1109 return readers.value(key: engine, defaultValue: 0);
1110}
1111
1112QQuickPixmapReply *QQuickPixmapReader::getImage(QQuickPixmapData *data)
1113{
1114 QQuickPixmapReply *reply = new QQuickPixmapReply(data);
1115 reply->engineForReader = engine;
1116 return reply;
1117}
1118
1119void QQuickPixmapReader::startJob(QQuickPixmapReply *job)
1120{
1121 PIXMAP_READER_LOCK();
1122 jobs.append(t: job);
1123 if (readerThreadExecutionEnforcer())
1124 readerThreadExecutionEnforcer()->processJobsOnReaderThreadLater();
1125}
1126
1127void QQuickPixmapReader::cancel(QQuickPixmapReply *reply)
1128{
1129 PIXMAP_READER_LOCK();
1130 if (reply->loading) {
1131 cancelledJobs.append(t: reply);
1132 reply->data = nullptr;
1133 // XXX
1134 if (readerThreadExecutionEnforcer())
1135 readerThreadExecutionEnforcer()->processJobsOnReaderThreadLater();
1136 } else {
1137 // If loading was started (reply removed from jobs) but the reply was never processed
1138 // (otherwise it would have deleted itself) we need to profile an error.
1139 if (jobs.removeAll(t: reply) == 0) {
1140 PIXMAP_PROFILE(pixmapStateChanged<QQuickProfiler::PixmapLoadingError>(reply->url));
1141 }
1142 delete reply;
1143 }
1144}
1145
1146void QQuickPixmapReader::run()
1147{
1148 Q_ASSERT_CALLED_ON_VALID_THREAD(m_readerThreadAffinityMarker);
1149
1150 if (replyDownloadProgressMethodIndex == -1) {
1151#if QT_CONFIG(qml_network)
1152 replyDownloadProgressMethodIndex =
1153 QMetaMethod::fromSignal(signal: &QNetworkReply::downloadProgress).methodIndex();
1154 replyFinishedMethodIndex = QMetaMethod::fromSignal(signal: &QNetworkReply::finished).methodIndex();
1155 const QMetaObject *ir = &ReaderThreadExecutionEnforcer::staticMetaObject;
1156 threadNetworkRequestDoneMethodIndex = ir->indexOfSlot(slot: "networkRequestDone()");
1157#endif
1158 downloadProgressMethodIndex =
1159 QMetaMethod::fromSignal(signal: &QQuickPixmapReply::downloadProgress).methodIndex();
1160 }
1161
1162#if QT_CONFIG(quick_pixmap_cache_threaded_download)
1163 const auto guard = qScopeGuard(f: [this]() {
1164 // We need to delete the runLoopReaderThreadExecutionEnforcer from the same thread.
1165 PIXMAP_READER_LOCK();
1166 delete runLoopReaderThreadExecutionEnforcer;
1167 runLoopReaderThreadExecutionEnforcer = nullptr;
1168 });
1169
1170 {
1171 PIXMAP_READER_LOCK();
1172 Q_ASSERT(!runLoopReaderThreadExecutionEnforcer);
1173 runLoopReaderThreadExecutionEnforcer = new ReaderThreadExecutionEnforcer(this);
1174 }
1175
1176 processJobs();
1177 exec();
1178#else
1179 ownedReaderThreadExecutionEnforcer = std::make_unique<ReaderThreadExecutionEnforcer>(this);
1180 processJobs();
1181#endif
1182}
1183
1184inline bool operator==(const QQuickPixmapKey &lhs, const QQuickPixmapKey &rhs)
1185{
1186 return *lhs.url == *rhs.url &&
1187 *lhs.region == *rhs.region &&
1188 *lhs.size == *rhs.size &&
1189 lhs.frame == rhs.frame &&
1190 lhs.options == rhs.options;
1191}
1192
1193inline size_t qHash(const QQuickPixmapKey &key, size_t seed) noexcept
1194{
1195 return qHashMulti(seed, args: *key.url, args: *key.region, args: *key.size, args: key.frame, args: key.options.autoTransform());
1196}
1197
1198#ifndef QT_NO_DEBUG_STREAM
1199inline QDebug operator<<(QDebug debug, const QQuickPixmapKey &key)
1200{
1201 QDebugStateSaver saver(debug);
1202 debug.nospace();
1203 if (!key.url) {
1204 debug << "QQuickPixmapKey(0)";
1205 return debug;
1206 }
1207
1208 debug << "QQuickPixmapKey(" << key.url->toString() << " frame=" << key.frame;
1209 if (!key.region->isEmpty()) {
1210 debug << " region=";
1211 QtDebugUtils::formatQRect(debug, rect: *key.region);
1212 }
1213 if (!key.size->isEmpty()) {
1214 debug << " size=";
1215 QtDebugUtils::formatQSize(debug, size: *key.size);
1216 }
1217 debug << ')';
1218 return debug;
1219}
1220#endif
1221
1222QQuickPixmapCache *QQuickPixmapCache::instance()
1223{
1224 static QQuickPixmapCache self;
1225 return &self;
1226}
1227
1228QQuickPixmapCache::~QQuickPixmapCache()
1229{
1230 destroyCache();
1231}
1232
1233/*! \internal
1234 Empty the cache completely, to prevent leaks. Returns the number of
1235 leaked pixmaps (should always be \c 0).
1236
1237 This is work the destructor needs to do, but we put it into a function
1238 only to make it testable in autotests, because the static instance()
1239 cannot be destroyed before shutdown.
1240*/
1241int QQuickPixmapCache::destroyCache()
1242{
1243 if (m_destroying)
1244 return -1;
1245
1246 m_destroying = true;
1247
1248 // Prevent unreferencePixmap() from assuming it needs to kick
1249 // off the cache expiry timer, as we're shrinking the cache
1250 // manually below after releasing all the pixmaps.
1251 m_timerId = -2;
1252
1253 // unreference all (leaked) pixmaps
1254 int leakedPixmaps = 0;
1255 const auto cache = m_cache; // NOTE: intentional copy (QTBUG-65077); releasing items from the cache modifies m_cache.
1256 for (auto *pixmap : cache) {
1257 auto currRefCount = pixmap->refCount;
1258 if (currRefCount) {
1259 leakedPixmaps++;
1260 qCDebug(lcQsgLeak) << "leaked pixmap: refCount" << pixmap->refCount << pixmap->url << "frame" << pixmap->frame
1261 << "size" << pixmap->requestSize << "region" << pixmap->requestRegion;
1262 while (currRefCount > 0) {
1263 pixmap->release(store: this);
1264 currRefCount--;
1265 }
1266 }
1267 }
1268
1269 // free all unreferenced pixmaps
1270 while (m_lastUnreferencedPixmap)
1271 shrinkCache(remove: 20);
1272
1273 qCDebug(lcQsgLeak, "Number of leaked pixmaps: %i", leakedPixmaps);
1274 return leakedPixmaps;
1275}
1276
1277qsizetype QQuickPixmapCache::referencedCost() const
1278{
1279 qsizetype ret = 0;
1280 QMutexLocker locker(&m_cacheMutex);
1281 for (const auto *pixmap : std::as_const(t: m_cache)) {
1282 if (pixmap->refCount)
1283 ret += pixmap->cost();
1284 }
1285 return ret;
1286}
1287
1288/*! \internal
1289 Declare that \a data is currently unused so that shrinkCache() can lazily
1290 delete it later.
1291*/
1292void QQuickPixmapCache::unreferencePixmap(QQuickPixmapData *data)
1293{
1294 Q_ASSERT(data->prevUnreferenced == nullptr);
1295 Q_ASSERT(data->prevUnreferencedPtr == nullptr);
1296 Q_ASSERT(data->nextUnreferenced == nullptr);
1297
1298 data->nextUnreferenced = m_unreferencedPixmaps;
1299 data->prevUnreferencedPtr = &m_unreferencedPixmaps;
1300 if (!m_destroying) { // the texture factories may have been cleaned up already.
1301 m_unreferencedCost += data->cost();
1302 qCDebug(lcImg) << data->url << "had cost" << data->cost() << "of total unreferenced" << m_unreferencedCost;
1303 }
1304
1305 m_unreferencedPixmaps = data;
1306 if (m_unreferencedPixmaps->nextUnreferenced) {
1307 m_unreferencedPixmaps->nextUnreferenced->prevUnreferenced = m_unreferencedPixmaps;
1308 m_unreferencedPixmaps->nextUnreferenced->prevUnreferencedPtr = &m_unreferencedPixmaps->nextUnreferenced;
1309 }
1310
1311 if (!m_lastUnreferencedPixmap)
1312 m_lastUnreferencedPixmap = data;
1313
1314 shrinkCache(remove: -1); // Shrink the cache in case it has become larger than cache_limit
1315
1316 if (m_timerId == -1 && m_unreferencedPixmaps
1317 && !m_destroying && !QCoreApplication::closingDown()) {
1318 m_timerId = startTimer(CACHE_EXPIRE_TIME * 1000);
1319 }
1320}
1321
1322/*! \internal
1323 Declare that \a data is being used (by a QQuickPixmap) so that
1324 shrinkCache() won't delete it. (This is not reference counting though.)
1325*/
1326void QQuickPixmapCache::referencePixmap(QQuickPixmapData *data)
1327{
1328 Q_ASSERT(data->prevUnreferencedPtr);
1329
1330 *data->prevUnreferencedPtr = data->nextUnreferenced;
1331 if (data->nextUnreferenced) {
1332 data->nextUnreferenced->prevUnreferencedPtr = data->prevUnreferencedPtr;
1333 data->nextUnreferenced->prevUnreferenced = data->prevUnreferenced;
1334 }
1335 if (m_lastUnreferencedPixmap == data)
1336 m_lastUnreferencedPixmap = data->prevUnreferenced;
1337
1338 data->nextUnreferenced = nullptr;
1339 data->prevUnreferencedPtr = nullptr;
1340 data->prevUnreferenced = nullptr;
1341
1342 m_unreferencedCost -= data->cost();
1343 qCDebug(lcImg) << data->url << "subtracts cost" << data->cost() << "of total" << m_unreferencedCost;
1344}
1345
1346/*! \internal
1347 Delete the least-recently-released QQuickPixmapData instances
1348 until the remaining bytes are less than cache_limit.
1349*/
1350void QQuickPixmapCache::shrinkCache(int remove)
1351{
1352 qCDebug(lcImg) << "reduce unreferenced cost" << m_unreferencedCost << "to less than limit" << cache_limit;
1353 while ((remove > 0 || m_unreferencedCost > cache_limit) && m_lastUnreferencedPixmap) {
1354 QQuickPixmapData *data = m_lastUnreferencedPixmap;
1355 Q_ASSERT(data->nextUnreferenced == nullptr);
1356
1357 *data->prevUnreferencedPtr = nullptr;
1358 m_lastUnreferencedPixmap = data->prevUnreferenced;
1359 data->prevUnreferencedPtr = nullptr;
1360 data->prevUnreferenced = nullptr;
1361
1362 if (!m_destroying) {
1363 remove -= data->cost();
1364 m_unreferencedCost -= data->cost();
1365 }
1366 data->removeFromCache(store: this);
1367 delete data;
1368 }
1369}
1370
1371void QQuickPixmapCache::timerEvent(QTimerEvent *)
1372{
1373 int removalCost = m_unreferencedCost / CACHE_REMOVAL_FRACTION;
1374
1375 shrinkCache(remove: removalCost);
1376
1377 if (m_unreferencedPixmaps == nullptr) {
1378 killTimer(id: m_timerId);
1379 m_timerId = -1;
1380 }
1381}
1382
1383void QQuickPixmapCache::purgeCache()
1384{
1385 shrinkCache(remove: m_unreferencedCost);
1386}
1387
1388void QQuickPixmap::purgeCache()
1389{
1390 QQuickPixmapCache::instance()->purgeCache();
1391}
1392
1393QQuickPixmapReply::QQuickPixmapReply(QQuickPixmapData *d)
1394 : data(d), engineForReader(nullptr), requestRegion(d->requestRegion), requestSize(d->requestSize),
1395 url(d->url), loading(false), providerOptions(d->providerOptions)
1396{
1397 if (finishedMethodIndex == -1) {
1398 finishedMethodIndex = QMetaMethod::fromSignal(signal: &QQuickPixmapReply::finished).methodIndex();
1399 downloadProgressMethodIndex =
1400 QMetaMethod::fromSignal(signal: &QQuickPixmapReply::downloadProgress).methodIndex();
1401 }
1402}
1403
1404QQuickPixmapReply::~QQuickPixmapReply()
1405{
1406 // note: this->data->reply must be set to zero if this->data->reply == this
1407 // but it must be done within mutex locking, to be guaranteed to be safe.
1408}
1409
1410bool QQuickPixmapReply::event(QEvent *event)
1411{
1412 if (event->type() == QEvent::User) {
1413
1414 if (data) {
1415 Event *de = static_cast<Event *>(event);
1416 data->pixmapStatus = (de->error == NoError) ? QQuickPixmap::Ready : QQuickPixmap::Error;
1417 if (data->pixmapStatus == QQuickPixmap::Ready) {
1418 data->textureFactory = de->textureFactory;
1419 de->textureFactory = nullptr;
1420 data->implicitSize = de->implicitSize;
1421 PIXMAP_PROFILE(pixmapLoadingFinished(data->url,
1422 data->textureFactory != nullptr && data->textureFactory->textureSize().isValid() ?
1423 data->textureFactory->textureSize() :
1424 (data->requestSize.isValid() ? data->requestSize : data->implicitSize)));
1425 } else {
1426 PIXMAP_PROFILE(pixmapStateChanged<QQuickProfiler::PixmapLoadingError>(data->url));
1427 data->errorString = de->errorString;
1428 data->removeFromCache(); // We don't continue to cache error'd pixmaps
1429 }
1430
1431 data->reply = nullptr;
1432 emit finished();
1433 } else {
1434 PIXMAP_PROFILE(pixmapStateChanged<QQuickProfiler::PixmapLoadingError>(url));
1435 }
1436
1437 delete this;
1438 return true;
1439 } else {
1440 return QObject::event(event);
1441 }
1442}
1443
1444int QQuickPixmapData::cost() const
1445{
1446 if (textureFactory)
1447 return textureFactory->textureByteCount();
1448 return 0;
1449}
1450
1451void QQuickPixmapData::addref()
1452{
1453 ++refCount;
1454 PIXMAP_PROFILE(pixmapCountChanged<QQuickProfiler::PixmapReferenceCountChanged>(url, refCount));
1455 if (prevUnreferencedPtr)
1456 QQuickPixmapCache::instance()->referencePixmap(data: this);
1457}
1458
1459void QQuickPixmapData::release(QQuickPixmapCache *store)
1460{
1461 Q_ASSERT(refCount > 0);
1462 --refCount;
1463 PIXMAP_PROFILE(pixmapCountChanged<QQuickProfiler::PixmapReferenceCountChanged>(url, refCount));
1464 if (refCount == 0) {
1465 if (reply) {
1466 QQuickPixmapReply *cancelReply = reply;
1467 reply->data = nullptr;
1468 reply = nullptr;
1469 QQuickPixmapReader::readerMutex.lock();
1470 QQuickPixmapReader *reader = QQuickPixmapReader::existingInstance(engine: cancelReply->engineForReader);
1471 if (reader)
1472 reader->cancel(reply: cancelReply);
1473 QQuickPixmapReader::readerMutex.unlock();
1474 }
1475
1476 store = store ? store : QQuickPixmapCache::instance();
1477 if (pixmapStatus == QQuickPixmap::Ready
1478#ifdef Q_OS_WEBOS
1479 && storeToCache
1480#endif
1481 ) {
1482 if (inCache)
1483 store->unreferencePixmap(data: this);
1484 else
1485 delete this;
1486 } else {
1487 removeFromCache(store);
1488 delete this;
1489 }
1490 }
1491}
1492
1493/*! \internal
1494 Add this to the QQuickPixmapCache singleton.
1495
1496 \note The actual image will end up in QQuickPixmapData::textureFactory.
1497 At the time addToCache() is called, it's generally not yet loaded; so the
1498 qCDebug() below cannot say how much data we're committing to storing.
1499 (On the other hand, removeFromCache() can tell.) QQuickTextureFactory is an
1500 abstraction for image data. See QQuickDefaultTextureFactory for example:
1501 it stores a QImage directly. Other QQuickTextureFactory subclasses store data
1502 in other ways.
1503*/
1504void QQuickPixmapData::addToCache()
1505{
1506 if (!inCache) {
1507 QQuickPixmapKey key = { .url: &url, .region: &requestRegion, .size: &requestSize, .frame: frame, .options: providerOptions };
1508 QMutexLocker locker(&QQuickPixmapCache::instance()->m_cacheMutex);
1509 if (lcImg().isDebugEnabled()) {
1510 qCDebug(lcImg) << "adding" << key << "to total" << QQuickPixmapCache::instance()->m_cache.size();
1511 for (auto it = QQuickPixmapCache::instance()->m_cache.keyBegin(); it != QQuickPixmapCache::instance()->m_cache.keyEnd(); ++it) {
1512 if (*(it->url) == url && it->frame == frame)
1513 qCDebug(lcImg) << " similar pre-existing:" << *it;
1514 }
1515 }
1516 QQuickPixmapCache::instance()->m_cache.insert(key, value: this);
1517 inCache = true;
1518 PIXMAP_PROFILE(pixmapCountChanged<QQuickProfiler::PixmapCacheCountChanged>(
1519 url, QQuickPixmapCache::instance()->m_cache.size()));
1520 }
1521}
1522
1523void QQuickPixmapData::removeFromCache(QQuickPixmapCache *store)
1524{
1525 if (inCache) {
1526 if (!store)
1527 store = QQuickPixmapCache::instance();
1528 QQuickPixmapKey key = { .url: &url, .region: &requestRegion, .size: &requestSize, .frame: frame, .options: providerOptions };
1529 QMutexLocker locker(&QQuickPixmapCache::instance()->m_cacheMutex);
1530 store->m_cache.remove(key);
1531 qCDebug(lcImg) << "removed" << key << implicitSize << "; total remaining" << QQuickPixmapCache::instance()->m_cache.size();
1532 inCache = false;
1533 PIXMAP_PROFILE(pixmapCountChanged<QQuickProfiler::PixmapCacheCountChanged>(
1534 url, store->m_cache.size()));
1535 }
1536}
1537
1538static QQuickPixmapData* createPixmapDataSync(QQmlEngine *engine, const QUrl &url,
1539 const QRect &requestRegion, const QSize &requestSize,
1540 const QQuickImageProviderOptions &providerOptions, int frame, bool *ok,
1541 qreal devicePixelRatio)
1542{
1543 if (url.scheme() == QLatin1String("image")) {
1544 QSize readSize;
1545
1546 QQuickImageProvider::ImageType imageType = QQuickImageProvider::Invalid;
1547 QQmlEnginePrivate *enginePrivate = QQmlEnginePrivate::get(e: engine);
1548 QSharedPointer<QQuickImageProvider> provider = enginePrivate->imageProvider(providerId: imageProviderId(url)).objectCast<QQuickImageProvider>();
1549 // it is safe to use get() as providerV2 does not escape and is outlived by provider
1550 QQuickImageProviderWithOptions *providerV2 = QQuickImageProviderWithOptions::checkedCast(provider: provider.get());
1551 if (provider)
1552 imageType = provider->imageType();
1553
1554 switch (imageType) {
1555 case QQuickImageProvider::Invalid:
1556 return new QQuickPixmapData(url, requestRegion, requestSize, providerOptions,
1557 QQuickPixmap::tr(sourceText: "Invalid image provider: %1").arg(a: url.toString()));
1558 case QQuickImageProvider::Texture:
1559 {
1560 QQuickTextureFactory *texture = providerV2 ? providerV2->requestTexture(id: imageId(url), size: &readSize, requestedSize: requestSize, options: providerOptions)
1561 : provider->requestTexture(id: imageId(url), size: &readSize, requestedSize: requestSize);
1562 if (texture) {
1563 *ok = true;
1564 return new QQuickPixmapData(url, texture, readSize, requestRegion, requestSize,
1565 providerOptions, QQuickImageProviderOptions::UsePluginDefaultTransform, frame);
1566 }
1567 break;
1568 }
1569
1570 case QQuickImageProvider::Image:
1571 {
1572 QImage image = providerV2 ? providerV2->requestImage(id: imageId(url), size: &readSize, requestedSize: requestSize, options: providerOptions)
1573 : provider->requestImage(id: imageId(url), size: &readSize, requestedSize: requestSize);
1574 if (!image.isNull()) {
1575 *ok = true;
1576 return new QQuickPixmapData(url, QQuickTextureFactory::textureFactoryForImage(image),
1577 readSize, requestRegion, requestSize, providerOptions,
1578 QQuickImageProviderOptions::UsePluginDefaultTransform, frame);
1579 }
1580 break;
1581 }
1582 case QQuickImageProvider::Pixmap:
1583 {
1584 QPixmap pixmap = providerV2 ? providerV2->requestPixmap(id: imageId(url), size: &readSize, requestedSize: requestSize, options: providerOptions)
1585 : provider->requestPixmap(id: imageId(url), size: &readSize, requestedSize: requestSize);
1586 if (!pixmap.isNull()) {
1587 *ok = true;
1588 return new QQuickPixmapData(url, QQuickTextureFactory::textureFactoryForImage(image: pixmap.toImage()),
1589 readSize, requestRegion, requestSize, providerOptions,
1590 QQuickImageProviderOptions::UsePluginDefaultTransform, frame);
1591 }
1592 break;
1593 }
1594 case QQuickImageProvider::ImageResponse:
1595 {
1596 // Fall through, ImageResponse providers never get here
1597 Q_ASSERT(imageType != QQuickImageProvider::ImageResponse && "Sync call to ImageResponse provider");
1598 }
1599 }
1600
1601 // provider has bad image type, or provider returned null image
1602 return new QQuickPixmapData(url, requestRegion, requestSize, providerOptions,
1603 QQuickPixmap::tr(sourceText: "Failed to get image from provider: %1").arg(a: url.toString()));
1604 }
1605
1606 QString localFile = QQmlFile::urlToLocalFileOrQrc(url);
1607 if (localFile.isEmpty())
1608 return nullptr;
1609
1610 QFile f(existingImageFileForPath(localFile));
1611 QSize readSize;
1612 QString errorString;
1613
1614 if (f.open(flags: QIODevice::ReadOnly)) {
1615 QSGTextureReader texReader(&f, localFile);
1616 if (backendSupport()->hasOpenGL && texReader.isTexture()) {
1617 QQuickTextureFactory *factory = texReader.read();
1618 if (factory) {
1619 *ok = true;
1620 return new QQuickPixmapData(url, factory, factory->textureSize(), requestRegion, requestSize,
1621 providerOptions, QQuickImageProviderOptions::UsePluginDefaultTransform, frame);
1622 } else {
1623 errorString = QQuickPixmap::tr(sourceText: "Error decoding: %1").arg(a: url.toString());
1624 if (f.fileName() != localFile)
1625 errorString += QString::fromLatin1(ba: " (%1)").arg(a: f.fileName());
1626 }
1627 } else {
1628 QImage image;
1629 QQuickImageProviderOptions::AutoTransform appliedTransform = providerOptions.autoTransform();
1630 int frameCount;
1631 if (readImage(url, dev: &f, image: &image, errorString: &errorString, impsize: &readSize, frameCount: &frameCount, requestRegion, requestSize,
1632 providerOptions, appliedTransform: &appliedTransform, frame, devicePixelRatio)) {
1633 *ok = true;
1634 return new QQuickPixmapData(url, QQuickTextureFactory::textureFactoryForImage(image), readSize, requestRegion, requestSize,
1635 providerOptions, appliedTransform, frame, frameCount);
1636 } else if (f.fileName() != localFile) {
1637 errorString += QString::fromLatin1(ba: " (%1)").arg(a: f.fileName());
1638 }
1639 }
1640 } else {
1641 errorString = QQuickPixmap::tr(sourceText: "Cannot open: %1").arg(a: url.toString());
1642 }
1643 return new QQuickPixmapData(url, requestRegion, requestSize, providerOptions, errorString);
1644}
1645
1646
1647struct QQuickPixmapNull {
1648 QUrl url;
1649 QRect region;
1650 QSize size;
1651};
1652Q_GLOBAL_STATIC(QQuickPixmapNull, nullPixmap);
1653
1654QQuickPixmap::QQuickPixmap()
1655: d(nullptr)
1656{
1657}
1658
1659QQuickPixmap::QQuickPixmap(QQmlEngine *engine, const QUrl &url)
1660: d(nullptr)
1661{
1662 load(engine, url);
1663}
1664
1665QQuickPixmap::QQuickPixmap(QQmlEngine *engine, const QUrl &url, Options options)
1666: d(nullptr)
1667{
1668 load(engine, url, options);
1669}
1670
1671QQuickPixmap::QQuickPixmap(QQmlEngine *engine, const QUrl &url, const QRect &region, const QSize &size)
1672: d(nullptr)
1673{
1674 load(engine, url, requestRegion: region, requestSize: size);
1675}
1676
1677QQuickPixmap::QQuickPixmap(const QUrl &url, const QImage &image)
1678{
1679 d = new QQuickPixmapData(url, new QQuickDefaultTextureFactory(image), image.size(), QRect(), QSize(),
1680 QQuickImageProviderOptions(), QQuickImageProviderOptions::UsePluginDefaultTransform);
1681 d->addToCache();
1682}
1683
1684QQuickPixmap::~QQuickPixmap()
1685{
1686 if (d) {
1687 d->release();
1688 d = nullptr;
1689 }
1690}
1691
1692bool QQuickPixmap::isNull() const
1693{
1694 return d == nullptr;
1695}
1696
1697bool QQuickPixmap::isReady() const
1698{
1699 return status() == Ready;
1700}
1701
1702bool QQuickPixmap::isError() const
1703{
1704 return status() == Error;
1705}
1706
1707bool QQuickPixmap::isLoading() const
1708{
1709 return status() == Loading;
1710}
1711
1712QString QQuickPixmap::error() const
1713{
1714 if (d)
1715 return d->errorString;
1716 else
1717 return QString();
1718}
1719
1720QQuickPixmap::Status QQuickPixmap::status() const
1721{
1722 if (d)
1723 return d->pixmapStatus;
1724 else
1725 return Null;
1726}
1727
1728const QUrl &QQuickPixmap::url() const
1729{
1730 if (d)
1731 return d->url;
1732 else
1733 return nullPixmap()->url;
1734}
1735
1736const QSize &QQuickPixmap::implicitSize() const
1737{
1738 if (d)
1739 return d->implicitSize;
1740 else
1741 return nullPixmap()->size;
1742}
1743
1744const QSize &QQuickPixmap::requestSize() const
1745{
1746 if (d)
1747 return d->requestSize;
1748 else
1749 return nullPixmap()->size;
1750}
1751
1752const QRect &QQuickPixmap::requestRegion() const
1753{
1754 if (d)
1755 return d->requestRegion;
1756 else
1757 return nullPixmap()->region;
1758}
1759
1760QQuickImageProviderOptions::AutoTransform QQuickPixmap::autoTransform() const
1761{
1762 if (d)
1763 return d->appliedTransform;
1764 else
1765 return QQuickImageProviderOptions::UsePluginDefaultTransform;
1766}
1767
1768int QQuickPixmap::frameCount() const
1769{
1770 if (d)
1771 return d->frameCount;
1772 return 0;
1773}
1774
1775QQuickTextureFactory *QQuickPixmap::textureFactory() const
1776{
1777 if (d)
1778 return d->textureFactory;
1779
1780 return nullptr;
1781}
1782
1783QImage QQuickPixmap::image() const
1784{
1785 if (d && d->textureFactory)
1786 return d->textureFactory->image();
1787 return QImage();
1788}
1789
1790void QQuickPixmap::setImage(const QImage &p)
1791{
1792 clear();
1793
1794 if (!p.isNull()) {
1795 if (d)
1796 d->release();
1797 d = new QQuickPixmapData(QQuickTextureFactory::textureFactoryForImage(image: p));
1798 }
1799}
1800
1801void QQuickPixmap::setPixmap(const QQuickPixmap &other)
1802{
1803 if (d == other.d)
1804 return;
1805 clear();
1806
1807 if (other.d) {
1808 if (d)
1809 d->release();
1810 d = other.d;
1811 d->addref();
1812 }
1813}
1814
1815int QQuickPixmap::width() const
1816{
1817 if (d && d->textureFactory)
1818 return d->textureFactory->textureSize().width();
1819 else
1820 return 0;
1821}
1822
1823int QQuickPixmap::height() const
1824{
1825 if (d && d->textureFactory)
1826 return d->textureFactory->textureSize().height();
1827 else
1828 return 0;
1829}
1830
1831QRect QQuickPixmap::rect() const
1832{
1833 if (d && d->textureFactory)
1834 return QRect(QPoint(), d->textureFactory->textureSize());
1835 else
1836 return QRect();
1837}
1838
1839void QQuickPixmap::load(QQmlEngine *engine, const QUrl &url)
1840{
1841 load(engine, url, requestRegion: QRect(), requestSize: QSize(), options: QQuickPixmap::Cache);
1842}
1843
1844void QQuickPixmap::load(QQmlEngine *engine, const QUrl &url, QQuickPixmap::Options options)
1845{
1846 load(engine, url, requestRegion: QRect(), requestSize: QSize(), options);
1847}
1848
1849void QQuickPixmap::load(QQmlEngine *engine, const QUrl &url, const QRect &requestRegion, const QSize &requestSize)
1850{
1851 load(engine, url, requestRegion, requestSize, options: QQuickPixmap::Cache);
1852}
1853
1854void QQuickPixmap::load(QQmlEngine *engine, const QUrl &url, const QRect &requestRegion, const QSize &requestSize, QQuickPixmap::Options options)
1855{
1856 load(engine, url, requestRegion, requestSize, options, providerOptions: QQuickImageProviderOptions());
1857}
1858
1859void QQuickPixmap::load(QQmlEngine *engine, const QUrl &url, const QRect &requestRegion, const QSize &requestSize,
1860 QQuickPixmap::Options options, const QQuickImageProviderOptions &providerOptions, int frame, int frameCount,
1861 qreal devicePixelRatio)
1862{
1863 if (d) {
1864 d->release();
1865 d = nullptr;
1866 }
1867
1868 QQuickPixmapKey key = { .url: &url, .region: &requestRegion, .size: &requestSize, .frame: frame, .options: providerOptions };
1869 QQuickPixmapCache *store = QQuickPixmapCache::instance();
1870
1871 QMutexLocker locker(&QQuickPixmapCache::instance()->m_cacheMutex);
1872 QHash<QQuickPixmapKey, QQuickPixmapData *>::Iterator iter = store->m_cache.end();
1873
1874#ifdef Q_OS_WEBOS
1875 QQuickPixmap::Options orgOptions = options;
1876 // In webOS, we suppose that cache is always enabled to share image instances along its source.
1877 // So, original option(orgOptions) for cache only decides whether to store the instances when it's unreferenced.
1878 options |= QQuickPixmap::Cache;
1879#endif
1880
1881 // If Cache is disabled, the pixmap will always be loaded, even if there is an existing
1882 // cached version. Unless it's an itemgrabber url, since the cache is used to pass
1883 // the result between QQuickItemGrabResult and QQuickImage.
1884 if (url.scheme() == itemGrabberScheme) {
1885 QRect dummyRegion;
1886 QSize dummySize;
1887 if (requestSize != dummySize)
1888 qWarning() << "Ignoring sourceSize request for image url that came from grabToImage. Use the targetSize parameter of the grabToImage() function instead.";
1889 const QQuickPixmapKey grabberKey = { .url: &url, .region: &dummyRegion, .size: &dummySize, .frame: 0, .options: QQuickImageProviderOptions() };
1890 iter = store->m_cache.find(key: grabberKey);
1891 } else if (options & QQuickPixmap::Cache)
1892 iter = store->m_cache.find(key);
1893
1894 if (iter == store->m_cache.end()) {
1895 locker.unlock();
1896 if (url.scheme() == QLatin1String("image")) {
1897 QQmlEnginePrivate *enginePrivate = QQmlEnginePrivate::get(e: engine);
1898 if (auto provider = enginePrivate->imageProvider(providerId: imageProviderId(url)).staticCast<QQuickImageProvider>()) {
1899 const bool threadedPixmaps = QGuiApplicationPrivate::platformIntegration()->hasCapability(cap: QPlatformIntegration::ThreadedPixmaps);
1900 if (!threadedPixmaps && provider->imageType() == QQuickImageProvider::Pixmap) {
1901 // pixmaps can only be loaded synchronously
1902 options &= ~QQuickPixmap::Asynchronous;
1903 } else if (provider->flags() & QQuickImageProvider::ForceAsynchronousImageLoading) {
1904 options |= QQuickPixmap::Asynchronous;
1905 }
1906 }
1907 }
1908
1909 if (!(options & QQuickPixmap::Asynchronous)) {
1910 bool ok = false;
1911 PIXMAP_PROFILE(pixmapStateChanged<QQuickProfiler::PixmapLoadingStarted>(url));
1912 d = createPixmapDataSync(engine, url, requestRegion, requestSize, providerOptions, frame, ok: &ok, devicePixelRatio);
1913 if (ok) {
1914 PIXMAP_PROFILE(pixmapLoadingFinished(url, QSize(width(), height())));
1915 if (options & QQuickPixmap::Cache)
1916 d->addToCache();
1917#ifdef Q_OS_WEBOS
1918 d->storeToCache = orgOptions & QQuickPixmap::Cache;
1919#endif
1920 return;
1921 }
1922 if (d) { // loadable, but encountered error while loading
1923 PIXMAP_PROFILE(pixmapStateChanged<QQuickProfiler::PixmapLoadingError>(url));
1924 return;
1925 }
1926 }
1927
1928 if (!engine)
1929 return;
1930
1931
1932 d = new QQuickPixmapData(url, requestRegion, requestSize, providerOptions,
1933 QQuickImageProviderOptions::UsePluginDefaultTransform, frame, frameCount);
1934 if (options & QQuickPixmap::Cache)
1935 d->addToCache();
1936#ifdef Q_OS_WEBOS
1937 d->storeToCache = orgOptions & QQuickPixmap::Cache;
1938#endif
1939
1940 QQuickPixmapReader::readerMutex.lock();
1941 QQuickPixmapReader *reader = QQuickPixmapReader::instance(engine);
1942 d->reply = reader->getImage(data: d);
1943 reader->startJob(job: d->reply);
1944 QQuickPixmapReader::readerMutex.unlock();
1945 } else {
1946 d = *iter;
1947 d->addref();
1948 qCDebug(lcImg) << "loaded from cache" << url << "frame" << frame;
1949 }
1950}
1951
1952/*! \internal
1953 Attempts to load an image from the given \a url via the given \a device.
1954 This is for special cases when the QImageIOHandler can benefit from reusing
1955 the I/O device, or from something extra that a subclass of QIODevice
1956 carries with it. So far, this code doesn't support loading anything other
1957 than a QImage, for example compressed textures. It can be added if needed.
1958*/
1959void QQuickPixmap::loadImageFromDevice(QQmlEngine *engine, QIODevice *device, const QUrl &url,
1960 const QRect &requestRegion, const QSize &requestSize,
1961 const QQuickImageProviderOptions &providerOptions, int frame, int frameCount)
1962{
1963 auto oldD = d;
1964 QQuickPixmapKey key = { .url: &url, .region: &requestRegion, .size: &requestSize, .frame: frame, .options: providerOptions };
1965 QQuickPixmapCache *store = QQuickPixmapCache::instance();
1966 QHash<QQuickPixmapKey, QQuickPixmapData *>::Iterator iter = store->m_cache.end();
1967 QMutexLocker locker(&store->m_cacheMutex);
1968 iter = store->m_cache.find(key);
1969 if (iter == store->m_cache.end()) {
1970 if (!engine)
1971 return;
1972
1973 locker.unlock();
1974 d = new QQuickPixmapData(url, requestRegion, requestSize, providerOptions,
1975 QQuickImageProviderOptions::UsePluginDefaultTransform, frame, frameCount);
1976 d->specialDevice = device;
1977 d->fromSpecialDevice = true;
1978 d->addToCache();
1979
1980 QQuickPixmapReader::readerMutex.lock();
1981 QQuickPixmapReader *reader = QQuickPixmapReader::instance(engine);
1982 d->reply = reader->getImage(data: d);
1983 if (oldD) {
1984 QObject::connect(sender: d->reply, signal: &QQuickPixmapReply::destroyed, context: store, slot: [oldD]() {
1985 oldD->release();
1986 }, type: Qt::QueuedConnection);
1987 }
1988 reader->startJob(job: d->reply);
1989 QQuickPixmapReader::readerMutex.unlock();
1990 } else {
1991 d = *iter;
1992 d->addref();
1993 qCDebug(lcImg) << "loaded from cache" << url << "frame" << frame << "refCount" << d->refCount;
1994 locker.unlock();
1995 if (oldD)
1996 oldD->release();
1997 }
1998}
1999
2000void QQuickPixmap::clear()
2001{
2002 if (d) {
2003 d->release();
2004 d = nullptr;
2005 }
2006}
2007
2008void QQuickPixmap::clear(QObject *obj)
2009{
2010 if (d) {
2011 if (d->reply)
2012 QObject::disconnect(sender: d->reply, signal: nullptr, receiver: obj, member: nullptr);
2013 d->release();
2014 d = nullptr;
2015 }
2016}
2017
2018bool QQuickPixmap::isCached(const QUrl &url, const QRect &requestRegion, const QSize &requestSize,
2019 const int frame, const QQuickImageProviderOptions &options)
2020{
2021 QQuickPixmapKey key = { .url: &url, .region: &requestRegion, .size: &requestSize, .frame: frame, .options: options };
2022 QQuickPixmapCache *store = QQuickPixmapCache::instance();
2023
2024 return store->m_cache.contains(key);
2025}
2026
2027bool QQuickPixmap::isScalableImageFormat(const QUrl &url)
2028{
2029 if (url.scheme() == "image"_L1)
2030 return true;
2031
2032 const QString stringUrl = url.path(options: QUrl::PrettyDecoded);
2033 return stringUrl.endsWith(s: "svg"_L1)
2034 || stringUrl.endsWith(s: "svgz"_L1)
2035 || stringUrl.endsWith(s: "pdf"_L1);
2036}
2037
2038bool QQuickPixmap::connectFinished(QObject *object, const char *method)
2039{
2040 if (!d || !d->reply) {
2041 qWarning(msg: "QQuickPixmap: connectFinished() called when not loading.");
2042 return false;
2043 }
2044
2045 return QObject::connect(sender: d->reply, SIGNAL(finished()), receiver: object, member: method);
2046}
2047
2048bool QQuickPixmap::connectFinished(QObject *object, int method)
2049{
2050 if (!d || !d->reply) {
2051 qWarning(msg: "QQuickPixmap: connectFinished() called when not loading.");
2052 return false;
2053 }
2054
2055 return QMetaObject::connect(sender: d->reply, signal_index: QQuickPixmapReply::finishedMethodIndex, receiver: object, method_index: method);
2056}
2057
2058bool QQuickPixmap::connectDownloadProgress(QObject *object, const char *method)
2059{
2060 if (!d || !d->reply) {
2061 qWarning(msg: "QQuickPixmap: connectDownloadProgress() called when not loading.");
2062 return false;
2063 }
2064
2065 return QObject::connect(sender: d->reply, SIGNAL(downloadProgress(qint64,qint64)), receiver: object,
2066 member: method);
2067}
2068
2069bool QQuickPixmap::connectDownloadProgress(QObject *object, int method)
2070{
2071 if (!d || !d->reply) {
2072 qWarning(msg: "QQuickPixmap: connectDownloadProgress() called when not loading.");
2073 return false;
2074 }
2075
2076 return QMetaObject::connect(sender: d->reply, signal_index: QQuickPixmapReply::downloadProgressMethodIndex, receiver: object,
2077 method_index: method);
2078}
2079
2080QColorSpace QQuickPixmap::colorSpace() const
2081{
2082 if (!d || !d->textureFactory)
2083 return QColorSpace();
2084 return d->textureFactory->image().colorSpace();
2085}
2086
2087QT_END_NAMESPACE
2088
2089#include <qquickpixmapcache.moc>
2090
2091#include "moc_qquickpixmapcache_p.cpp"
2092

source code of qtdeclarative/src/quick/util/qquickpixmapcache.cpp