plasma-framework/private/wallpaperrenderthread.cpp
Aaron Seigo 97743420a0 add a wallpaper render that takes a pre-loaded QImage. FAR FAR faster than re-loading from disk if already in memory.
new API (new overload, really), but required to fix iperformance issues elsewhere, so considered a bug fix
2011-10-30 10:24:57 +01:00

270 lines
9.1 KiB
C++

/*
* Copyright (c) 2007 Paolo Capriotti <p.capriotti@gmail.com>
* Copyright (c) 2009 Aaron Seigo <aseigo@kde.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License as
* published by the Free Software Foundation; either version 2, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details
*
* You should have received a copy of the GNU Library General Public
* License along with this program; if not, write to the
* Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include "plasma/private/wallpaperrenderthread_p.h"
#include <QCoreApplication>
#include <QPainter>
#include <QFile>
#include <QSvgRenderer>
#include "config-plasma.h"
#ifndef PLASMA_NO_SOLID
#include <solid/device.h>
#include <solid/deviceinterface.h>
#endif
#include <kdebug.h>
namespace Plasma
{
int WallpaperRenderRequest::s_token = 0;
int WallpaperRenderThread::s_rendererCount = 0;
QQueue<WallpaperRenderRequest> WallpaperRenderThread::s_renderQueue;
WallpaperRenderThread::WallpaperRenderThread(const WallpaperRenderRequest &request, QObject *parent)
: QThread(parent),
m_request(request),
m_abort(false)
{
qRegisterMetaType<WallpaperRenderRequest>("WallpaperRenderRequest");
if (!request.requester) {
deleteLater();
return;
}
++s_rendererCount;
connect(this, SIGNAL(done(WallpaperRenderRequest,QImage)),
request.requester.data(), SLOT(newRenderCompleted(WallpaperRenderRequest,QImage)));
}
WallpaperRenderThread::~WallpaperRenderThread()
{
kDebug() << "rendering done";
m_abort = true;
wait();
--s_rendererCount;
checkQueue();
}
void WallpaperRenderThread::render(const WallpaperRenderRequest &request)
{
QObject *requester = request.requester.data();
if (!requester) {
return;
}
// remove all dead requests and requests previously made for the same parent
QMutableListIterator<WallpaperRenderRequest> it(s_renderQueue);
while (it.hasNext()) {
const WallpaperRenderRequest &request = it.next();
if (!request.requester || request.requester.data() == requester) {
it.remove();
}
}
s_renderQueue.append(request);
checkQueue();
}
void WallpaperRenderThread::checkQueue()
{
if (s_renderQueue.isEmpty()) {
return;
}
if (QCoreApplication::closingDown()) {
s_renderQueue.clear();
return;
}
#ifndef PLASMA_NO_SOLID
const int numProcs = qMax(1, Solid::Device::listFromType(Solid::DeviceInterface::Processor).count());
#else
const int numProcs = 1;
#endif
kDebug() << "checking rendering against" << s_rendererCount << numProcs;
if (s_rendererCount < numProcs) {
WallpaperRenderThread *renderThread = new WallpaperRenderThread(s_renderQueue.dequeue());
renderThread->start();
}
}
void WallpaperRenderThread::run()
{
kDebug() << "rendering wallpaper" << m_request.file;
QImage result(m_request.size, QImage::Format_ARGB32_Premultiplied);
result.fill(m_request.color.rgba());
if (m_request.file.isEmpty() && m_request.providedImage.isNull() && !QFile::exists(m_request.file)) {
if (!m_abort) {
emit done(m_request, result);
}
kDebug() << "wrong request or file does not exist";
deleteLater();
return;
}
QPoint pos(0, 0);
//const float ratio = qMax(float(1), m_request.size.width() / float(m_request.size.height()));
const bool scalable = m_request.file.endsWith(QLatin1String("svg")) || m_request.file.endsWith(QLatin1String("svgz"));
bool tiled = false;
QSize scaledSize;
QImage img;
// set image size
QSize imgSize(1, 1);
if (!m_request.providedImage.isNull()) {
img = m_request.providedImage;
kDebug() << "going to resize the img" << img.size();
imgSize = imgSize.expandedTo(img.size());
} else if (scalable) {
// scalable: image can be of any size
imgSize = imgSize.expandedTo(m_request.size);
} else {
// otherwise, use the natural size of the loaded image
img = QImage(m_request.file);
imgSize = imgSize.expandedTo(img.size());
//kDebug() << "loaded with" << imgSize << ratio;
}
// set render parameters according to resize mode
switch (m_request.resizeMethod)
{
case Wallpaper::ScaledResize:
scaledSize = m_request.size;
break;
case Wallpaper::CenteredResize:
scaledSize = imgSize;
pos = QPoint((m_request.size.width() - scaledSize.width()) / 2,
(m_request.size.height() - scaledSize.height()) / 2);
//If the picture is bigger than the screen, shrink it
if (m_request.size.width() < imgSize.width() && imgSize.width() > imgSize.height()) {
int width = m_request.size.width();
int height = width * scaledSize.height() / imgSize.width();
scaledSize = QSize(width, height);
pos = QPoint((m_request.size.width() - scaledSize.width()) / 2,
(m_request.size.height() - scaledSize.height()) / 2);
} else if (m_request.size.height() < imgSize.height()) {
int height = m_request.size.height();
int width = height * imgSize.width() / imgSize.height();
scaledSize = QSize(width, height);
pos = QPoint((m_request.size.width() - scaledSize.width()) / 2,
(m_request.size.height() - scaledSize.height()) / 2);
}
break;
case Wallpaper::MaxpectResize: {
float xratio = (float) m_request.size.width() / imgSize.width();
float yratio = (float) m_request.size.height() / imgSize.height();
if (xratio > yratio) {
int height = m_request.size.height();
int width = height * imgSize.width() / imgSize.height();
scaledSize = QSize(width, height);
} else {
int width = m_request.size.width();
int height = width * imgSize.height() / imgSize.width();
scaledSize = QSize(width, height);
}
pos = QPoint((m_request.size.width() - scaledSize.width()) / 2,
(m_request.size.height() - scaledSize.height()) / 2);
break;
}
case Wallpaper::ScaledAndCroppedResize: {
float xratio = (float) m_request.size.width() / imgSize.width();
float yratio = (float) m_request.size.height() / imgSize.height();
if (xratio > yratio) {
int width = m_request.size.width();
int height = width * imgSize.height() / imgSize.width();
scaledSize = QSize(width, height);
} else {
int height = m_request.size.height();
int width = height * imgSize.width() / imgSize.height();
scaledSize = QSize(width, height);
}
pos = QPoint((m_request.size.width() - scaledSize.width()) / 2,
(m_request.size.height() - scaledSize.height()) / 2);
break;
}
case Wallpaper::TiledResize:
scaledSize = imgSize;
tiled = true;
break;
case Wallpaper::CenterTiledResize:
scaledSize = imgSize;
pos = QPoint(-scaledSize.width() + ((m_request.size.width() - scaledSize.width()) / 2) % scaledSize.width(),
-scaledSize.height() + ((m_request.size.height() - scaledSize.height()) / 2) % scaledSize.height());
tiled = true;
break;
}
QPainter p(&result);
//kDebug() << token << scalable << scaledSize << imgSize;
if (scalable) {
// tiling is ignored for scalable wallpapers
QSvgRenderer svg(m_request.file);
if (m_abort) {
deleteLater();
return;
}
svg.render(&p);
} else {
if (scaledSize != imgSize) {
img = img.scaled(scaledSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
}
if (m_abort) {
deleteLater();
return;
}
if (tiled) {
for (int x = pos.x(); x < m_request.size.width(); x += scaledSize.width()) {
for (int y = pos.y(); y < m_request.size.height(); y += scaledSize.height()) {
p.drawImage(QPoint(x, y), img);
if (m_abort) {
deleteLater();
return;
}
}
}
} else {
p.drawImage(pos, img);
}
}
// signal we're done
if (!m_abort) {
emit done(m_request, result);
}
deleteLater();
}
} // namespace Plasma
#include "wallpaperrenderthread_p.moc"