Revision control

// Copyright (C) 2018 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
#include <QtLottie/private/qbatchrenderer_p.h>
#include <QImage>
#include <QPainter>
#include <QHash>
#include <QMap>
#include <QMutexLocker>
#include <QLoggingCategory>
#include <QThread>
#include <QJsonDocument>
#include <QJsonArray>
#include <QtLottie/private/qlottieconstants_p.h>
#include <QtLottie/private/qlottiebase_p.h>
#include <QtLottie/private/qlottieimagelayer_p.h>
+ #include <QtLottie/private/qlottieroot_p.h>
#include <QtLottie/private/qlottielayer_p.h>
#include "qlottieanimation.h"
#include <QtLottie/private/qlottierasterrenderer_p.h>
QT_BEGIN_NAMESPACE
Q_LOGGING_CATEGORY(lcLottieQtLottieRenderThread, "qt.lottieqt.lottie.render.thread");
QBatchRenderer *QBatchRenderer::m_rendererInstance = nullptr;
QBatchRenderer::QBatchRenderer()
: QThread()
{
const QByteArray cacheStr = qgetenv("QLOTTIE_RENDER_CACHE_SIZE");
int cacheSize = cacheStr.toInt();
if (cacheSize > 0) {
qCDebug(lcLottieQtLottieRenderThread) << "Setting frame cache size to" << cacheSize;
m_cacheSize = cacheSize;
}
}
QBatchRenderer::~QBatchRenderer()
{
QMutexLocker mlocker(&m_mutex);
for (Entry *entry : std::as_const(m_animData)) {
qDeleteAll(entry->frameCache);
delete entry->lottieTreeBlueprint;
delete entry;
}
}
QBatchRenderer *QBatchRenderer::instance()
{
if (!m_rendererInstance)
m_rendererInstance = new QBatchRenderer;
return m_rendererInstance;
}
void QBatchRenderer::deleteInstance()
{
delete m_rendererInstance;
m_rendererInstance = nullptr;
}
void QBatchRenderer::registerAnimator(QLottieAnimation *animator)
{
QMutexLocker mlocker(&m_mutex);
qCDebug(lcLottieQtLottieRenderThread) << "Register Animator:"
<< static_cast<void*>(animator);
Entry *&entry = m_animData[animator];
if (entry) {
qDeleteAll(entry->frameCache);
delete entry->lottieTreeBlueprint;
delete entry;
entry = nullptr;
}
Q_ASSERT(entry == nullptr);
entry = new Entry;
entry->animator = animator;
entry->startFrame = animator->startFrame();
entry->endFrame = animator->endFrame();
entry->currentFrame = animator->startFrame();
entry->animDir = animator->direction();
- entry->lottieTreeBlueprint = new QLottieBase;
- parse(entry->lottieTreeBlueprint, animator->jsonSource(), animator->version());
+ QLottieRoot *root = new QLottieRoot;
+ root->parseSource(animator->jsonSource(),
+ m_animData.keys().last()->source(),
+ animator->version());
+ entry->lottieTreeBlueprint = root;
m_waitCondition.wakeAll();
}
void QBatchRenderer::deregisterAnimator(QLottieAnimation *animator)
{
QMutexLocker mlocker(&m_mutex);
qCDebug(lcLottieQtLottieRenderThread) << "Deregister Animator:"
<< static_cast<void*>(animator);
Entry *entry = m_animData.take(animator);
if (entry) {
qDeleteAll(entry->frameCache);
delete entry->lottieTreeBlueprint;
delete entry;
}
}
bool QBatchRenderer::gotoFrame(QLottieAnimation *animator, int frame)
{
QMutexLocker mlocker(&m_mutex);
Entry *entry = m_animData.value(animator, nullptr);
if (entry) {
qCDebug(lcLottieQtLottieRenderThread) << "Animator:"
<< static_cast<void*>(animator)
<< "Goto frame:" << frame;
entry->currentFrame = frame;
entry->animDir = animator->direction();
pruneFrameCache(entry);
m_waitCondition.wakeAll();
return true;
}
return false;
}
void QBatchRenderer::pruneFrameCache(Entry* e)
{
QHash<int, QLottieBase*>::iterator removeCandidate = e->frameCache.end();
if (e->frameCache.size() == m_cacheSize &&
!e->frameCache.contains(e->currentFrame))
removeCandidate = e->frameCache.begin();
QHash<int, QLottieBase*>::iterator it = e->frameCache.begin();
while (it != e->frameCache.end()) {
int frame = it.key();
if ((frame - e->currentFrame) * e->animDir >= 0) { // same frame or same direction
if (removeCandidate != e->frameCache.end() &&
(removeCandidate.key() - frame) * e->animDir < 0)
removeCandidate = it;
++it;
} else {
qCDebug(lcLottieQtLottieRenderThread) << "Animator:" << static_cast<void*>(e->animator)
<< "Remove frame from cache" << frame;
delete it.value();
it = e->frameCache.erase(it);
removeCandidate = e->frameCache.end();
}
}
if (removeCandidate != e->frameCache.end()) {
qCDebug(lcLottieQtLottieRenderThread) << "Animator:"
<< static_cast<void*>(e->animator)
<< "Remove frame from cache"
<< removeCandidate.key()
<< "(Reason - cache is full)";
e->frameCache.erase(removeCandidate);
}
m_lastRenderedFrame = -1;
}
QLottieBase *QBatchRenderer::getFrame(QLottieAnimation *animator, int frameNumber)
{
QMutexLocker mlocker(&m_mutex);
Entry *entry = m_animData.value(animator, nullptr);
if (entry)
return entry->frameCache.value(frameNumber, nullptr);
else
return nullptr;
}
void QBatchRenderer::prerender(Entry *animEntry)
{
while (animEntry->frameCache.size() < m_cacheSize) {
if (m_lastRenderedFrame == animEntry->currentFrame)
animEntry->currentFrame += animEntry->animDir;
QLottieBase *&lottieTree = animEntry->frameCache[animEntry->currentFrame];
if (lottieTree == nullptr) {
lottieTree = new QLottieBase(*animEntry->lottieTreeBlueprint);
for (QLottieBase *elem : lottieTree->children()) {
if (elem->active(animEntry->currentFrame))
elem->updateProperties( animEntry->currentFrame);
}
}
qCDebug(lcLottieQtLottieRenderThread) << "Animator:"
<< static_cast<void*>(animEntry->animator)
<< "Frame drawn to cache. FN:"
<< animEntry->currentFrame;
emit frameReady(animEntry->animator, animEntry->currentFrame);
animEntry->currentFrame += animEntry->animDir;
if (animEntry->currentFrame > animEntry->endFrame) {
animEntry->currentFrame = animEntry->startFrame;
} else if (animEntry->currentFrame < animEntry->startFrame) {
animEntry->currentFrame = animEntry->endFrame;
}
}
}
void QBatchRenderer::frameRendered(QLottieAnimation *animator, int frameNumber)
{
QMutexLocker mlocker(&m_mutex);
Entry *entry = m_animData.value(animator, nullptr);
if (entry) {
qCDebug(lcLottieQtLottieRenderThread) << "Animator:" << static_cast<void*>(animator)
<< "Remove frame from cache" << frameNumber;
QLottieBase *root = entry->frameCache.take(frameNumber);
if (root != nullptr) {
delete root;
m_waitCondition.wakeAll();
}
m_lastRenderedFrame = frameNumber;
}
}
void QBatchRenderer::run()
{
qCDebug(lcLottieQtLottieRenderThread) << "rendering thread" << QThread::currentThread();
while (!isInterruptionRequested()) {
QMutexLocker mlocker(&m_mutex);
for (Entry *e : std::as_const(m_animData))
prerender(e);
m_waitCondition.wait(&m_mutex);
}
}
- int QBatchRenderer::parse(QLottieBase *rootElement, const QByteArray &jsonSource,
- const QVersionNumber &version) const
- {
- QJsonDocument doc = QJsonDocument::fromJson(jsonSource);
- QJsonObject rootObj = doc.object();
-
- if (rootObj.empty())
- return -1;
-
- QMap<QString, QJsonObject> assets;
- QJsonArray jsonLayers = rootObj.value(QLatin1String("layers")).toArray();
- QJsonArray jsonAssets = rootObj.value(QLatin1String("assets")).toArray();
- QJsonArray::const_iterator jsonAssetsIt = jsonAssets.constBegin();
- while (jsonAssetsIt != jsonAssets.constEnd()) {
- QJsonObject jsonAsset = (*jsonAssetsIt).toObject();
-
- jsonAsset.insert(QLatin1String("fileSource"), QJsonValue::fromVariant(m_animData.keys().last()->source()));
- QString id = jsonAsset.value(QLatin1String("id")).toString();
- assets.insert(id, jsonAsset);
- jsonAssetsIt++;
- }
-
- QJsonArray::const_iterator jsonLayerIt = jsonLayers.constEnd();
- while (jsonLayerIt != jsonLayers.constBegin()) {
- jsonLayerIt--;
- QJsonObject jsonLayer = (*jsonLayerIt).toObject();
- if (jsonLayer.value(QStringLiteral("ty")).toInt() == 2) {
- QString refId = jsonLayer.value(QStringLiteral("refId")).toString();
- jsonLayer.insert(QStringLiteral("ty"), assets.value(refId));
- }
- QLottieLayer *layer = QLottieLayer::construct(jsonLayer, version);
- if (layer) {
- layer->setParent(rootElement);
- // Mask layers must be rendered before the layers they affect to
- // although they appear after in layer hierarchy. For this reason
- // move a mask in front of the affected layer, so it will be rendered first
- if (layer->isMaskLayer())
- rootElement->insertChildBeforeLast(layer);
- else
- rootElement->appendChild(layer);
- }
- }
-
- return 0;
- }
-
QT_END_NAMESPACE