File indexing completed on 2024-04-28 04:05:03

 /*
     SPDX-FileCopyrightText: 2010-2012 Stefan Majewsky <majewsky@gmx.net>
 
     SPDX-License-Identifier: LGPL-2.0-only
 */
 
 #include "kgamerenderer.h"
 #include "kgamerenderer_p.h"
 
 // own
 #include "colorproxy_p.h"
 #include "kgamerendererclient.h"
 #include "kgametheme.h"
 #include "kgamethemeprovider.h"
 #include <kdegames_logging.h>
 // Qt
 #include <QDateTime>
 #include <QFileInfo>
 #include <QGuiApplication>
 #include <QPainter>
 #include <QVariant>
 
 // TODO: automatically schedule pre-rendering of animation frames
 // TODO: multithreaded SVG loading?
 
 static const QString cacheName(QByteArray theme)
 {
     const QString appName = QCoreApplication::instance()->applicationName();
     // e.g. "themes/foobar.desktop" -> "themes/foobar"
     if (theme.endsWith(QByteArrayLiteral(".desktop")))
         theme.chop(8); // 8 = strlen(".desktop")
     return QStringLiteral("kgamerenderer-%1-%2").arg(appName, QString::fromUtf8(theme));
 }
 
 KGameRendererPrivate::KGameRendererPrivate(KGameThemeProvider *provider, unsigned cacheSize, KGameRenderer *parent)
     : m_parent(parent)
     , m_provider(provider)
     , m_frameSuffix(QStringLiteral("_%1"))
     , m_sizePrefix(QStringLiteral("%1-%2-"))
     , m_frameCountPrefix(QStringLiteral("fc-"))
     , m_boundsPrefix(QStringLiteral("br-"))
     // default cache size: 3 MiB = 3 << 20 bytes
     , m_cacheSize((cacheSize == 0 ? 3 : cacheSize) << 20)
     , m_rendererPool(&m_workerPool)
 {
     qRegisterMetaType<KGRInternal::Job *>();
 }
 
 KGameRenderer::KGameRenderer(KGameThemeProvider *provider, unsigned cacheSize)
     : d_ptr(new KGameRendererPrivate(provider, cacheSize, this))
 {
     if (!provider->parent()) {
         provider->setParent(this);
     }
     connect(provider, &KGameThemeProvider::currentThemeChanged, this, [this](const KGameTheme *theme) {
         Q_D(KGameRenderer);
         d->_k_setTheme(theme);
     });
 }
 
 static KGameThemeProvider *providerForSingleTheme(KGameTheme *theme, QObject *parent)
 {
     KGameThemeProvider *prov = new KGameThemeProvider(QByteArray(), parent);
     prov->addTheme(theme);
     return prov;
 }
 
 KGameRenderer::KGameRenderer(KGameTheme *theme, unsigned cacheSize)
     : d_ptr(new KGameRendererPrivate(providerForSingleTheme(theme, this), cacheSize, this))
 {
 }
 
 KGameRenderer::~KGameRenderer()
 {
     Q_D(KGameRenderer);
 
     // cleanup clients
     while (!d->m_clients.isEmpty()) {
         delete d->m_clients.constBegin().key();
     }
     // cleanup own stuff
     d->m_workerPool.waitForDone();
     delete d->m_imageCache;
 }
 
 int KGameRenderer::frameBaseIndex() const
 {
     Q_D(const KGameRenderer);
 
     return d->m_frameBaseIndex;
 }
 
 void KGameRenderer::setFrameBaseIndex(int frameBaseIndex)
 {
     Q_D(KGameRenderer);
 
     d->m_frameBaseIndex = frameBaseIndex;
 }
 
 QString KGameRenderer::frameSuffix() const
 {
     Q_D(const KGameRenderer);
 
     return d->m_frameSuffix;
 }
 
 void KGameRenderer::setFrameSuffix(const QString &suffix)
 {
     Q_D(KGameRenderer);
 
     d->m_frameSuffix = suffix.contains(QLatin1String("%1")) ? suffix : QStringLiteral("_%1");
 }
 
 KGameRenderer::Strategies KGameRenderer::strategies() const
 {
     Q_D(const KGameRenderer);
 
     return d->m_strategies;
 }
 
 void KGameRenderer::setStrategyEnabled(KGameRenderer::Strategy strategy, bool enabled)
 {
     Q_D(KGameRenderer);
 
     const bool oldEnabled = d->m_strategies & strategy;
     if (enabled) {
         d->m_strategies |= strategy;
     } else {
         d->m_strategies &= ~strategy;
     }
     if (strategy == KGameRenderer::UseDiskCache && oldEnabled != enabled) {
         // reload theme
         const KGameTheme *theme = d->m_currentTheme;
         if (theme) {
             d->m_currentTheme = nullptr; // or setTheme() will return immediately
             d->_k_setTheme(theme);
         }
     }
 }
 
 void KGameRendererPrivate::_k_setTheme(const KGameTheme *theme)
 {
     const KGameTheme *oldTheme = m_currentTheme;
     if (oldTheme == theme) {
         return;
     }
     qCDebug(KDEGAMES_LOG) << "Setting theme:" << theme->name();
     if (!setTheme(theme)) {
         const KGameTheme *defaultTheme = m_provider->defaultTheme();
         if (theme != defaultTheme) {
             qCDebug(KDEGAMES_LOG) << "Falling back to default theme:" << defaultTheme->name();
             setTheme(defaultTheme);
             m_provider->setCurrentTheme(defaultTheme);
         }
     }
     // announce change to KGameRendererClients
     QHash<KGameRendererClient *, QString>::iterator it1 = m_clients.begin(), it2 = m_clients.end();
     for (; it1 != it2; ++it1) {
         it1.value().clear(); // because the pixmap is outdated
         it1.key()->d_ptr->fetchPixmap();
     }
     Q_EMIT m_parent->themeChanged(m_currentTheme);
 }
 
 bool KGameRendererPrivate::setTheme(const KGameTheme *theme)
 {
     if (!theme) {
         return false;
     }
     // open cache (and SVG file, if necessary)
     if (m_strategies & KGameRenderer::UseDiskCache) {
         std::unique_ptr<KImageCache> oldCache(m_imageCache);
         const QString imageCacheName = cacheName(theme->identifier());
         m_imageCache = new KImageCache(imageCacheName, m_cacheSize);
         m_imageCache->setPixmapCaching(false); // see big comment in KGRPrivate class declaration
         // check timestamp of cache vs. last write access to theme/SVG
         const uint svgTimestamp =
             qMax(QFileInfo(theme->graphicsPath()).lastModified().toSecsSinceEpoch(), theme->property("_k_themeDescTimestamp").value<qint64>());
         QByteArray buffer;
         if (!m_imageCache->find(QStringLiteral("kgr_timestamp"), &buffer))
             buffer = "0";
         const uint cacheTimestamp = buffer.toInt();
         // try to instantiate renderer immediately if the cache does not exist or is outdated
         // FIXME: This logic breaks if the cache evicts the "kgr_timestamp" key. We need additional API in KSharedDataCache to make sure that this key does not
         // get evicted.
         if (cacheTimestamp < svgTimestamp) {
             qCDebug(KDEGAMES_LOG) << "Theme newer than cache, checking SVG";
             std::unique_ptr<QSvgRenderer> renderer(new QSvgRenderer(theme->graphicsPath()));
             if (renderer->isValid()) {
                 m_rendererPool.setPath(theme->graphicsPath(), renderer.release());
                 m_imageCache->clear();
                 m_imageCache->insert(QStringLiteral("kgr_timestamp"), QByteArray::number(svgTimestamp));
             } else {
                 // The SVG file is broken, so we deny to change the theme without
                 // breaking the previous theme.
                 delete m_imageCache;
                 KSharedDataCache::deleteCache(imageCacheName);
                 m_imageCache = oldCache.release();
                 qCDebug(KDEGAMES_LOG) << "Theme change failed: SVG file broken";
                 return false;
             }
         }
         // theme is cached - just delete the old renderer after making sure that no worker threads are using it anymore
         else if (m_currentTheme != theme)
             m_rendererPool.setPath(theme->graphicsPath());
     } else // !(m_strategies & KGameRenderer::UseDiskCache) -> no cache is used
     {
         // load SVG file
         std::unique_ptr<QSvgRenderer> renderer(new QSvgRenderer(theme->graphicsPath()));
         if (renderer->isValid()) {
             m_rendererPool.setPath(theme->graphicsPath(), renderer.release());
         } else {
             qCDebug(KDEGAMES_LOG) << "Theme change failed: SVG file broken";
             return false;
         }
         // disconnect from disk cache (only needed if changing strategy)
         delete m_imageCache;
         m_imageCache = nullptr;
     }
     // clear in-process caches
     m_pixmapCache.clear();
     m_frameCountCache.clear();
     m_boundsCache.clear();
     // done
     m_currentTheme = theme;
     return true;
 }
 
 const KGameTheme *KGameRenderer::theme() const
 {
     Q_D(const KGameRenderer);
 
     // ensure that some theme is loaded
     if (!d->m_currentTheme) {
         const_cast<KGameRendererPrivate *>(d)->_k_setTheme(d->m_provider->currentTheme());
     }
     return d->m_currentTheme;
 }
 
 KGameThemeProvider *KGameRenderer::themeProvider() const
 {
     Q_D(const KGameRenderer);
 
     return d->m_provider;
 }
 
 QString KGameRendererPrivate::spriteFrameKey(const QString &key, int frame, bool normalizeFrameNo) const
 {
     // fast path for non-animated sprites
     if (frame < 0) {
         return key;
     }
     // normalize frame number
     if (normalizeFrameNo) {
         const int frameCount = m_parent->frameCount(key);
         if (frameCount <= 0) {
             // non-animated sprite
             return key;
         } else {
             frame = (frame - m_frameBaseIndex) % frameCount + m_frameBaseIndex;
         }
     }
     return key + m_frameSuffix.arg(frame);
 }
 
 int KGameRenderer::frameCount(const QString &key) const
 {
     Q_D(const KGameRenderer);
 
     // ensure that some theme is loaded
     if (!d->m_currentTheme) {
         const_cast<KGameRendererPrivate *>(d)->_k_setTheme(d->m_provider->currentTheme());
     }
     // look up in in-process cache
     QHash<QString, int>::const_iterator it = d->m_frameCountCache.constFind(key);
     if (it != d->m_frameCountCache.constEnd()) {
         return it.value();
     }
     // look up in shared cache (if SVG is not yet loaded)
     int count = -1;
     bool countFound = false;
     const QString cacheKey = d->m_frameCountPrefix + key;
     if (d->m_rendererPool.hasAvailableRenderers() && (d->m_strategies & KGameRenderer::UseDiskCache)) {
         QByteArray buffer;
         if (d->m_imageCache->find(cacheKey, &buffer)) {
             count = buffer.toInt();
             countFound = true;
         }
     }
     // determine from SVG
     if (!countFound) {
         QSvgRenderer *renderer = d->m_rendererPool.allocRenderer();
         // look for animated sprite first
         count = d->m_frameBaseIndex;
         while (renderer->elementExists(d->spriteFrameKey(key, count, false))) {
             ++count;
         }
         count -= d->m_frameBaseIndex;
         // look for non-animated sprite instead
         if (count == 0) {
             if (!renderer->elementExists(key)) {
                 count = -1;
             }
         }
         d->m_rendererPool.freeRenderer(renderer);
         // save in shared cache for following requests
         if (d->m_strategies & KGameRenderer::UseDiskCache) {
             d->m_imageCache->insert(cacheKey, QByteArray::number(count));
         }
     }
     d->m_frameCountCache.insert(key, count);
     return count;
 }
 
 QRectF KGameRenderer::boundsOnSprite(const QString &key, int frame) const
 {
     Q_D(const KGameRenderer);
 
     const QString elementKey = d->spriteFrameKey(key, frame);
     // ensure that some theme is loaded
     if (!d->m_currentTheme) {
         const_cast<KGameRendererPrivate *>(d)->_k_setTheme(d->m_provider->currentTheme());
     }
     // look up in in-process cache
     QHash<QString, QRectF>::const_iterator it = d->m_boundsCache.constFind(elementKey);
     if (it != d->m_boundsCache.constEnd()) {
         return it.value();
     }
     // look up in shared cache (if SVG is not yet loaded)
     QRectF bounds;
     bool boundsFound = false;
     const QString cacheKey = d->m_boundsPrefix + elementKey;
     if (!d->m_rendererPool.hasAvailableRenderers() && (d->m_strategies & KGameRenderer::UseDiskCache)) {
         QByteArray buffer;
         if (d->m_imageCache->find(cacheKey, &buffer)) {
             QDataStream stream(buffer);
             stream >> bounds;
             boundsFound = true;
         }
     }
     // determine from SVG
     if (!boundsFound) {
         QSvgRenderer *renderer = d->m_rendererPool.allocRenderer();
         bounds = renderer->boundsOnElement(elementKey);
         d->m_rendererPool.freeRenderer(renderer);
         // save in shared cache for following requests
         if (d->m_strategies & KGameRenderer::UseDiskCache) {
             QByteArray buffer;
             {
                 QDataStream stream(&buffer, QIODevice::WriteOnly);
                 stream << bounds;
             }
             d->m_imageCache->insert(cacheKey, buffer);
         }
     }
     d->m_boundsCache.insert(elementKey, bounds);
     return bounds;
 }
 
 bool KGameRenderer::spriteExists(const QString &key) const
 {
     Q_D(const KGameRenderer);
 
     return this->frameCount(key) >= 0;
 }
 
 QPixmap KGameRenderer::spritePixmap(const QString &key, QSize size, int frame, const QHash<QColor, QColor> &customColors) const
 {
     Q_D(const KGameRenderer);
 
     QPixmap result;
     const_cast<KGameRendererPrivate *>(d)->requestPixmap(KGRInternal::ClientSpec(key, frame, size, customColors), nullptr, &result);
     return result;
 }
 
 // Helper function for KGameRendererPrivate::requestPixmap.
 void KGameRendererPrivate::requestPixmap__propagateResult(const QPixmap &pixmap, KGameRendererClient *client, QPixmap *synchronousResult)
 {
     if (client) {
         client->receivePixmap(pixmap);
     }
     if (synchronousResult) {
         *synchronousResult = pixmap;
     }
 }
 
 void KGameRendererPrivate::requestPixmap(const KGRInternal::ClientSpec &spec, KGameRendererClient *client, QPixmap *synchronousResult)
 {
     // NOTE: If client == 0, the request is synchronous and must be finished when this method returns. This behavior is used by KGR::spritePixmap(). Instead of
     // KGameRendererClient::receivePixmap, the QPixmap* argument is then used to return the result. parse request
     if (spec.size.isEmpty()) {
         requestPixmap__propagateResult(QPixmap(), client, synchronousResult);
         return;
     }
     const QString elementKey = spriteFrameKey(spec.spriteKey, spec.frame);
     const qreal dpr = qApp->devicePixelRatio();
     const QSize size = spec.size * dpr;
     QString cacheKey = m_sizePrefix.arg(size.width()).arg(size.height()) + elementKey;
     QHash<QColor, QColor>::const_iterator it1 = spec.customColors.constBegin(), it2 = spec.customColors.constEnd();
     static const QString colorSuffix(QStringLiteral("-%1-%2"));
     for (; it1 != it2; ++it1) {
         cacheKey += colorSuffix.arg(it1.key().rgba()).arg(it1.value().rgba());
     }
     // check if update is needed
     if (client) {
         if (m_clients.value(client) == cacheKey) {
             return;
         }
         m_clients[client] = cacheKey;
     }
     // ensure that some theme is loaded
     if (!m_currentTheme) {
         _k_setTheme(m_provider->currentTheme());
     }
     // try to serve from high-speed cache
     QHash<QString, QPixmap>::const_iterator it = m_pixmapCache.constFind(cacheKey);
     if (it != m_pixmapCache.constEnd()) {
         QPixmap p = it.value();
         p.setDevicePixelRatio(dpr);
         requestPixmap__propagateResult(p, client, synchronousResult);
         return;
     }
     // try to serve from low-speed cache
     if (m_strategies & KGameRenderer::UseDiskCache) {
         QPixmap pix;
         if (m_imageCache->findPixmap(cacheKey, &pix)) {
             pix.setDevicePixelRatio(dpr);
             m_pixmapCache.insert(cacheKey, pix);
             requestPixmap__propagateResult(pix, client, synchronousResult);
             return;
         }
     }
     // if asynchronous request, is such a rendering job already running?
     if (client && m_pendingRequests.contains(cacheKey)) {
         return;
     }
     // create job
     KGRInternal::Job *job = new KGRInternal::Job;
     job->rendererPool = &m_rendererPool;
     job->cacheKey = cacheKey;
     job->elementKey = elementKey;
     job->spec = spec;
     job->spec.size = size;
     const bool synchronous = !client;
     if (synchronous || !(m_strategies & KGameRenderer::UseRenderingThreads)) {
         KGRInternal::Worker worker(job, true, this);
         worker.run();
         // if everything worked fine, result is in high-speed cache now
         const QPixmap result = m_pixmapCache.value(cacheKey);
         requestPixmap__propagateResult(result, client, synchronousResult);
     } else {
         m_workerPool.start(new KGRInternal::Worker(job, !client, this));
         m_pendingRequests << cacheKey;
     }
 }
 
 void KGameRendererPrivate::jobFinished(KGRInternal::Job *job, bool isSynchronous)
 {
     // read job
     const qreal dpr = qApp->devicePixelRatio();
     const QString cacheKey = job->cacheKey;
     QImage result = job->result;
     result.setDevicePixelRatio(dpr);
     delete job;
     // check who wanted this pixmap
     m_pendingRequests.removeAll(cacheKey);
     const QList<KGameRendererClient *> requesters = m_clients.keys(cacheKey);
     // put result into image cache
     if (m_strategies & KGameRenderer::UseDiskCache) {
         m_imageCache->insertImage(cacheKey, result);
         // convert result to pixmap (and put into pixmap cache) only if it is needed now
         // This optimization saves the image-pixmap conversion for intermediate sizes which occur during smooth resize events or window initializations.
         if (!isSynchronous && requesters.isEmpty()) {
             return;
         }
     }
     const QPixmap pixmap = QPixmap::fromImage(result);
     m_pixmapCache.insert(cacheKey, pixmap);
     for (KGameRendererClient *requester : requesters) {
         requester->receivePixmap(pixmap);
     }
 }
 
 // BEGIN KGRInternal::Job/Worker
 
 KGRInternal::Worker::Worker(KGRInternal::Job *job, bool isSynchronous, KGameRendererPrivate *parent)
     : m_job(job)
     , m_synchronous(isSynchronous)
     , m_parent(parent)
 {
 }
 
 static const uint transparentRgba = QColor(Qt::transparent).rgba();
 
 void KGRInternal::Worker::run()
 {
     QImage image(m_job->spec.size, QImage::Format_ARGB32_Premultiplied);
     // image might not be created if size is too large for needed memory, or invalid
     if (image.isNull()) {
         qCWarning(KDEGAMES_LOG) << "Could not create QImage. Key:" << m_job->spec.spriteKey << "Frame:" << m_job->spec.frame << "Size:" << m_job->spec.size;
     } else {
         image.fill(transparentRgba);
         QPainter *painter = nullptr;
         QPaintDeviceColorProxy *proxy = nullptr;
         // if no custom colors requested, paint directly onto image
         if (m_job->spec.customColors.isEmpty()) {
             painter = new QPainter(&image);
         } else {
             proxy = new QPaintDeviceColorProxy(&image, m_job->spec.customColors);
             painter = new QPainter(proxy);
         }
 
         // do renderering
         QSvgRenderer *renderer = m_job->rendererPool->allocRenderer();
         renderer->render(painter, m_job->elementKey);
         m_job->rendererPool->freeRenderer(renderer);
         delete painter;
         delete proxy;
     }
     // talk back to the main thread
     m_job->result = image;
     QMetaObject::invokeMethod(m_parent, "jobFinished", Qt::AutoConnection, Q_ARG(KGRInternal::Job *, m_job), Q_ARG(bool, m_synchronous));
     // NOTE: KGR::spritePixmap relies on Qt::DirectConnection when this method is run in the main thread.
 }
 
 // END KGRInternal::Job/Worker
 
 // BEGIN KGRInternal::RendererPool
 
 KGRInternal::RendererPool::RendererPool(QThreadPool *threadPool)
     : m_valid(Checked_Invalid) // don't try to allocate renderers until given a valid SVG file
     , m_threadPool(threadPool)
 {
 }
 
 KGRInternal::RendererPool::~RendererPool()
 {
     // This deletes all renderers.
     setPath(QString());
 }
 
 void KGRInternal::RendererPool::setPath(const QString &graphicsPath, QSvgRenderer *renderer)
 {
     QMutexLocker locker(&m_mutex);
     // delete all renderers
     m_threadPool->waitForDone();
     QHash<QSvgRenderer *, QThread *>::const_iterator it1 = m_hash.constBegin(), it2 = m_hash.constEnd();
     for (; it1 != it2; ++it1) {
         Q_ASSERT(it1.value() == nullptr); // nobody may be using our renderers anymore now
         delete it1.key();
     }
     m_hash.clear();
     // set path
     m_path = graphicsPath;
     // existence of a renderer instance is evidence for the validity of the SVG file
     if (renderer) {
         m_valid = Checked_Valid;
         m_hash.insert(renderer, nullptr);
     } else {
         m_valid = Unchecked;
     }
 }
 
 bool KGRInternal::RendererPool::hasAvailableRenderers() const
 {
     // look for a renderer which is not associated with a thread
     QMutexLocker locker(&m_mutex);
     return m_hash.key(nullptr) != nullptr;
 }
 
 QSvgRenderer *KGRInternal::RendererPool::allocRenderer()
 {
     QThread *thread = QThread::currentThread();
     // look for an available renderer
     QMutexLocker locker(&m_mutex);
     QSvgRenderer *renderer = m_hash.key(nullptr);
     if (!renderer) {
         // instantiate a new renderer (only if the SVG file has not been found to be invalid yet)
         if (m_valid == Checked_Invalid) {
             return nullptr;
         }
         renderer = new QSvgRenderer(m_path);
         m_valid = renderer->isValid() ? Checked_Valid : Checked_Invalid;
     }
     // mark renderer as used
     m_hash.insert(renderer, thread);
     return renderer;
 }
 
 void KGRInternal::RendererPool::freeRenderer(QSvgRenderer *renderer)
 {
     // mark renderer as available
     QMutexLocker locker(&m_mutex);
     m_hash.insert(renderer, nullptr);
 }
 
 // END KGRInternal::RendererPool
 
 #include "moc_kgamerenderer.cpp"
 #include "moc_kgamerenderer_p.cpp"