Support for animated stickers

TGS are gzipped Lottie-Animations.
This commit is contained in:
Slava Monich 2020-11-09 03:32:26 +02:00
parent 9de92e1b6c
commit 449784883e
6 changed files with 411 additions and 57 deletions

View file

@ -14,10 +14,12 @@ TARGET = harbour-fernschreiber
CONFIG += sailfishapp sailfishapp_i18n CONFIG += sailfishapp sailfishapp_i18n
PKGCONFIG += nemonotifications-qt5 ngf-qt5 PKGCONFIG += nemonotifications-qt5 ngf-qt5 zlib
QT += core dbus sql QT += core dbus sql
DEFINES += QT_STATICPLUGIN
SOURCES += src/harbour-fernschreiber.cpp \ SOURCES += src/harbour-fernschreiber.cpp \
src/appsettings.cpp \ src/appsettings.cpp \
src/chatlistmodel.cpp \ src/chatlistmodel.cpp \
@ -31,7 +33,8 @@ SOURCES += src/harbour-fernschreiber.cpp \
src/stickermanager.cpp \ src/stickermanager.cpp \
src/tdlibfile.cpp \ src/tdlibfile.cpp \
src/tdlibreceiver.cpp \ src/tdlibreceiver.cpp \
src/tdlibwrapper.cpp src/tdlibwrapper.cpp \
src/tgsplugin.cpp
DISTFILES += qml/harbour-fernschreiber.qml \ DISTFILES += qml/harbour-fernschreiber.qml \
qml/components/AudioPreview.qml \ qml/components/AudioPreview.qml \
@ -145,7 +148,8 @@ HEADERS += \
src/tdlibfile.h \ src/tdlibfile.h \
src/tdlibreceiver.h \ src/tdlibreceiver.h \
src/tdlibsecrets.h \ src/tdlibsecrets.h \
src/tdlibwrapper.h src/tdlibwrapper.h \
src/tgsplugin.h
# https://github.com/Samsung/rlottie.git # https://github.com/Samsung/rlottie.git

View file

@ -18,76 +18,77 @@
*/ */
import QtQuick 2.6 import QtQuick 2.6
import Sailfish.Silica 1.0 import Sailfish.Silica 1.0
import WerkWolf.Fernschreiber 1.0
Item { Item {
property ListItem messageListItem property ListItem messageListItem
property var rawMessage: messageListItem.myMessage
property var stickerData: rawMessage.content.sticker; readonly property var stickerData: messageListItem.myMessage.content.sticker;
property int usedFileId; readonly property bool animated: stickerData.is_animated
readonly property bool stickerVisible: staticStickerLoader.item ? staticStickerLoader.item.visible :
animatedStickerLoader.item ? animatedStickerLoader.item.visible : false
width: stickerData.width implicitWidth: stickerData.width
height: stickerData.height implicitHeight: stickerData.height
Component.onCompleted: { TDLibFile {
if (stickerData) { id: file
if (stickerData.is_animated) { tdlib: tdLibWrapper
// Use thumbnail until we can decode TGS files fileInformation: stickerData.sticker
usedFileId = stickerData.thumbnail.photo.id; autoLoad: true
if (stickerData.thumbnail.photo.local.is_downloading_completed) { }
stickerImage.source = stickerData.thumbnail.photo.local.path;
} else { Item {
tdLibWrapper.downloadFile(usedFileId); width: stickerData.width
} height: stickerData.height
} else { // (centered in image mode, text-like in sticker mode)
usedFileId = stickerData.sticker.id; x: appSettings.showStickersAsImages ? (parent.width - width)/2 :
if (stickerData.sticker.local.is_downloading_completed) { messageListItem.isOwnMessage ? (parent.width - width) : 0
stickerImage.source = stickerData.sticker.local.path; anchors.verticalCenter: parent.verticalCenter
} else {
tdLibWrapper.downloadFile(usedFileId); Loader {
id: animatedStickerLoader
anchors.fill: parent
active: animated
sourceComponent: Component {
AnimatedImage {
anchors.fill: parent
source: file.path
asynchronous: true
paused: !Qt.application.active
cache: false
} }
} }
} }
}
Connections { Loader {
target: tdLibWrapper id: staticStickerLoader
onFileUpdated: { anchors.fill: parent
if (stickerData) { active: !animated
if (fileId === usedFileId && fileInformation.local.is_downloading_completed) { sourceComponent: Component {
if (stickerData.is_animated) { Image {
stickerData.thumbnail.photo = fileInformation; anchors.fill: parent
} else { source: file.path
stickerData.sticker = fileInformation; fillMode: Image.PreserveAspectFit
} autoTransform: true
stickerImage.source = fileInformation.local.path; asynchronous: true
visible: opacity > 0
opacity: status === Image.Ready ? 1 : 0
Behavior on opacity { FadeAnimation {} }
} }
} }
} }
}
Image { Loader {
id: stickerImage anchors.fill: parent
anchors.fill: parent sourceComponent: Component {
BackgroundImage {}
}
fillMode: Image.PreserveAspectFit active: opacity > 0
autoTransform: true opacity: !stickerVisible && !placeHolderDelayTimer.running ? 0.15 : 0
asynchronous: true Behavior on opacity { FadeAnimation {} }
visible: opacity > 0
opacity: status === Image.Ready ? 1 : 0
Behavior on opacity { FadeAnimation {} }
}
Loader {
anchors.fill: parent
sourceComponent: Component {
BackgroundImage {}
} }
active: opacity > 0
opacity: !stickerImage.visible && !placeHolderDelayTimer.running ? 0.15 : 0
Behavior on opacity { FadeAnimation {} }
} }
Timer { Timer {

View file

@ -38,6 +38,9 @@
#include "dbusadaptor.h" #include "dbusadaptor.h"
#include "processlauncher.h" #include "processlauncher.h"
#include "stickermanager.h" #include "stickermanager.h"
#include "tgsplugin.h"
Q_IMPORT_PLUGIN(TgsIOPlugin)
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {

310
src/tgsplugin.cpp Normal file
View file

@ -0,0 +1,310 @@
/*
Copyright (C) 2020 Slava Monich at al.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, 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 General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "tgsplugin.h"
#include "rlottie.h"
#include <QDebug>
#include <QSize>
#include <QImage>
#include <QImageIOHandler>
#include <QFileDevice>
#include <QFileInfo>
#include <zlib.h>
#define LOG(x) qDebug() << "[TgsIOHandler]" << qPrintable(fileName) << x
#define WARN(x) qWarning() << "[TgsIOHandler]" << qPrintable(fileName) << x
class TgsIOHandler : public QImageIOHandler
{
public:
static const QByteArray NAME;
static const QByteArray GZ_MAGIC;
typedef std::string ByteArray;
TgsIOHandler(QIODevice* device, const QByteArray& format);
~TgsIOHandler();
ByteArray uncompress();
bool load();
void render(int frameIndex);
void finishRendering();
// QImageIOHandler
bool canRead() const Q_DECL_OVERRIDE;
QByteArray name() const Q_DECL_OVERRIDE;
bool read(QImage* image) Q_DECL_OVERRIDE;
QVariant option(ImageOption option) const Q_DECL_OVERRIDE;
bool supportsOption(ImageOption option) const Q_DECL_OVERRIDE;
bool jumpToNextImage() Q_DECL_OVERRIDE;
bool jumpToImage(int imageNumber) Q_DECL_OVERRIDE;
int loopCount() const Q_DECL_OVERRIDE;
int imageCount() const Q_DECL_OVERRIDE;
int nextImageDelay() const Q_DECL_OVERRIDE;
int currentImageNumber() const Q_DECL_OVERRIDE;
QRect currentImageRect() const Q_DECL_OVERRIDE;
public:
QString fileName;
QSize size;
qreal frameRate;
int frameCount;
int currentFrame;
QImage firstImage;
QImage prevImage;
QImage currentImage;
std::future<rlottie::Surface> currentRender;
std::unique_ptr<rlottie::Animation> animation;
};
const QByteArray TgsIOHandler::NAME("tgs");
const QByteArray TgsIOHandler::GZ_MAGIC("\x1f\x8b");
TgsIOHandler::TgsIOHandler(QIODevice* device, const QByteArray& format) :
frameRate(0.),
frameCount(0),
currentFrame(0)
{
QFileDevice* file = qobject_cast<QFileDevice*>(device);
if (file) {
fileName = QFileInfo(file->fileName()).fileName();
}
setDevice(device);
setFormat(format);
}
TgsIOHandler::~TgsIOHandler()
{
if (currentRender.valid()) {
currentRender.get();
}
LOG("Done");
}
TgsIOHandler::ByteArray TgsIOHandler::uncompress()
{
ByteArray unzipped;
const QByteArray zipped(device()->readAll());
if (!zipped.isEmpty()) {
z_stream unzip;
memset(&unzip, 0, sizeof(unzip));
unzip.next_in = (Bytef*)zipped.constData();
// Add 16 for decoding gzip header
int zerr = inflateInit2(&unzip, MAX_WBITS + 16);
if (zerr == Z_OK) {
const uint chunk = 0x1000;
unzipped.resize(chunk);
unzip.next_out = (Bytef*)unzipped.data();
unzip.avail_in = zipped.size();
unzip.avail_out = chunk;
LOG("Compressed size" << zipped.size());
while (unzip.avail_out > 0 && zerr == Z_OK) {
zerr = inflate(&unzip, Z_NO_FLUSH);
if (zerr == Z_OK && unzip.avail_out < chunk) {
// Data may get relocated, update next_out too
unzipped.resize(unzipped.size() + chunk);
unzip.next_out = (Bytef*)unzipped.data() + unzip.total_out;
unzip.avail_out += chunk;
}
}
if (zerr == Z_STREAM_END) {
unzipped.resize(unzip.next_out - (Bytef*)unzipped.data());
LOG("Uncompressed size" << unzipped.size());
} else {
unzipped.clear();
}
inflateEnd(&unzip);
}
}
return unzipped;
}
bool TgsIOHandler::load()
{
if (!animation && device()) {
ByteArray json(uncompress());
if (json.size() > 0) {
animation = rlottie::Animation::loadFromData(json, std::string(), std::string(), false);
if (animation) {
size_t width, height;
animation->size(width, height);
frameRate = animation->frameRate();
frameCount = (int) animation->totalFrame();
size = QSize(width, height);
LOG(size << frameCount << "frames," << frameRate << "fps");
render(0); // Pre-render first frame
}
}
}
return animation != Q_NULLPTR;
}
void TgsIOHandler::finishRendering()
{
if (currentRender.valid()) {
currentRender.get();
prevImage = currentImage;
if (!currentFrame && !firstImage.isNull()) {
LOG("Rendered first frame");
firstImage = currentImage;
}
} else {
// Must be the first frame
prevImage = currentImage;
}
}
void TgsIOHandler::render(int frameIndex)
{
currentFrame = frameIndex % frameCount;
if (!currentFrame && !firstImage.isNull()) {
// The first frame only gets rendered once
currentImage = firstImage;
} else {
const int width = (int)size.width();
const int height = (int)size.height();
currentImage = QImage(width, height, QImage::Format_ARGB32_Premultiplied);
currentRender = animation->render(currentFrame,
rlottie::Surface((uint32_t*)currentImage.bits(),
width, height, currentImage.bytesPerLine()));
}
}
bool TgsIOHandler::read(QImage* out)
{
if (load() && frameCount > 0) {
// We must have the first frame, will wait if necessary
if (currentFrame && currentRender.valid()) {
std::future_status status = currentRender.wait_for(std::chrono::milliseconds(0));
if (status != std::future_status::ready) {
LOG("Skipping frame" << currentFrame);
currentFrame = (currentFrame + 1) % frameCount;
*out = prevImage;
return true;
}
}
finishRendering();
*out = currentImage;
render(currentFrame + 1);
return true;
}
return false;
}
bool TgsIOHandler::canRead() const
{
if (!device()) {
return false;
} else if (animation) {
return true;
} else {
// Need to support uncompressed data?
return device()->peek(2) == GZ_MAGIC;
}
}
QByteArray TgsIOHandler::name() const
{
return NAME;
}
QVariant TgsIOHandler::option(ImageOption option) const
{
switch (option) {
case Size:
((TgsIOHandler*)this)->load(); // Cast off const
return size;
case Animation:
return true;
case ImageFormat:
return QImage::Format_ARGB32_Premultiplied;
default:
break;
}
return QVariant();
}
bool TgsIOHandler::supportsOption(ImageOption option) const
{
switch(option) {
case Size:
case Animation:
case ImageFormat:
return true;
default:
break;
}
return false;
}
bool TgsIOHandler::jumpToNextImage()
{
if (frameCount) {
finishRendering();
render(currentFrame + 1);
return true;
}
return false;
}
bool TgsIOHandler::jumpToImage(int imageNumber)
{
if (frameCount) {
if (imageNumber != currentFrame) {
finishRendering();
render(imageNumber);
}
return true;
}
return false;
}
int TgsIOHandler::loopCount() const
{
return -1;
}
int TgsIOHandler::imageCount() const
{
return frameCount;
}
int TgsIOHandler::currentImageNumber() const
{
return currentFrame;
}
QRect TgsIOHandler::currentImageRect() const
{
return QRect(QPoint(), size);
}
int TgsIOHandler::nextImageDelay() const
{
return frameRate > 0 ? (int)(1000/frameRate) : 33;
}
QImageIOPlugin::Capabilities TgsIOPlugin::capabilities(QIODevice*, const QByteArray& format) const
{
return Capabilities((format == TgsIOHandler::NAME) ? CanRead : 0);
}
QImageIOHandler* TgsIOPlugin::create(QIODevice* device, const QByteArray& format) const
{
return new TgsIOHandler(device, format);
}

33
src/tgsplugin.h Normal file
View file

@ -0,0 +1,33 @@
/*
Copyright (C) 2020 Slava Monich at al.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, 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 General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef TGS_IMAGE_IO_PLUGIN
#define TGS_IMAGE_IO_PLUGIN
#include <QStringList>
#include <QImageIOPlugin>
class TgsIOPlugin : public QImageIOPlugin
{
Q_OBJECT
Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "tgsplugin.json")
public:
Capabilities capabilities(QIODevice* device, const QByteArray& format) const Q_DECL_OVERRIDE;
QImageIOHandler* create(QIODevice* device, const QByteArray& format) const Q_DECL_OVERRIDE;
};
#endif // TGS_IMAGE_IO_PLUGIN

3
src/tgsplugin.json Normal file
View file

@ -0,0 +1,3 @@
{
"Keys": [ "tgs" ]
}