init

Telegram/lib_lottie/lottie/lottie_animation.cpp

@@ -0,0 +1,334 @@
+// This file is part of Desktop App Toolkit,
+// a set of libraries for developing nice desktop applications.
+//
+// For license and copyright information please follow this link:
+// https://github.com/desktop-app/legal/blob/master/LEGAL
+//
+#include "lottie/lottie_animation.h"
+
+#include "lottie/details/lottie_frame_renderer.h"
+#include "lottie/details/lottie_frame_provider_direct.h"
+#include "lottie/lottie_player.h"
+#include "ui/image/image_prepare.h"
+#include "base/algorithm.h"
+#include "base/assertion.h"
+#include "base/variant.h"
+
+#ifdef LOTTIE_USE_CACHE
+#include "lottie/details/lottie_frame_provider_cached.h"
+#include "lottie/details/lottie_frame_provider_cached_multi.h"
+#endif // LOTTIE_USE_CACHE
+
+#include <QFile>
+#include <rlottie.h>
+#include <crl/crl_async.h>
+#include <crl/crl_on_main.h>
+
+namespace Lottie {
+namespace {
+
+const auto kIdealSize = QSize(512, 512);
+
+details::InitData CheckSharedState(std::unique_ptr<SharedState> state) {
+	Expects(state != nullptr);
+
+	auto information = state->information();
+	if (!information.frameRate
+		|| information.framesCount <= 0
+		|| information.size.isEmpty()) {
+		return Error::NotSupported;
+	}
+	return state;
+}
+
+details::InitData Init(
+		const QByteArray &content,
+		const FrameRequest &request,
+		Quality quality,
+		const ColorReplacements *replacements) {
+	if (const auto error = ContentError(content)) {
+		return *error;
+	}
+	auto provider = std::make_shared<FrameProviderDirect>(quality);
+	if (!provider->load(content, replacements)) {
+		return Error::ParseFailed;
+	}
+	return CheckSharedState(std::make_unique<SharedState>(
+		std::move(provider),
+		request.empty() ? FrameRequest{ kIdealSize } : request));
+}
+
+#ifdef LOTTIE_USE_CACHE
+details::InitData Init(
+		const QByteArray &content,
+		FnMut<void(QByteArray &&cached)> put,
+		const QByteArray &cached,
+		const FrameRequest &request,
+		Quality quality,
+		const ColorReplacements *replacements) {
+	Expects(!request.empty());
+
+	if (const auto error = ContentError(content)) {
+		return *error;
+	}
+	auto provider = std::make_shared<FrameProviderCached>(
+		content,
+		std::move(put),
+		cached,
+		request,
+		quality,
+		replacements);
+	return provider->valid()
+		? CheckSharedState(std::make_unique<SharedState>(
+			std::move(provider),
+			request.empty() ? FrameRequest{ kIdealSize } : request))
+		: Error::ParseFailed;
+}
+
+details::InitData Init(
+		const QByteArray &content,
+		FnMut<void(int, QByteArray &&cached)> put,
+		std::vector<QByteArray> caches,
+		const FrameRequest &request,
+		Quality quality,
+		const ColorReplacements *replacements) {
+	Expects(!request.empty());
+
+	if (const auto error = ContentError(content)) {
+		return *error;
+	}
+	auto provider = std::make_shared<FrameProviderCachedMulti>(
+		content,
+		std::move(put),
+		std::move(caches),
+		request,
+		quality,
+		replacements);
+	return provider->valid()
+		? CheckSharedState(std::make_unique<SharedState>(
+			std::move(provider),
+			request.empty() ? FrameRequest{ kIdealSize } : request))
+		: Error::ParseFailed;
+}
+#endif // LOTTIE_USE_CACHE
+
+details::InitData Init(
+		std::shared_ptr<FrameProvider> provider,
+		const FrameRequest &request) {
+	Expects(!request.empty());
+
+	return provider->valid()
+		? CheckSharedState(std::make_unique<SharedState>(
+			std::move(provider),
+			request.empty() ? FrameRequest{ kIdealSize } : request))
+		: Error::ParseFailed;
+}
+
+} // namespace
+
+std::shared_ptr<FrameRenderer> MakeFrameRenderer() {
+	return FrameRenderer::CreateIndependent();
+}
+
+QImage ReadThumbnail(const QByteArray &content) {
+	return v::match(Init(content, FrameRequest(), Quality::High, nullptr), [](
+			const std::unique_ptr<SharedState> &state) {
+		return state->frameForPaint()->original;
+	}, [](Error) {
+		return QImage();
+	});
+}
+
+Animation::Animation(
+	not_null<Player*> player,
+	const QByteArray &content,
+	const FrameRequest &request,
+	Quality quality,
+	const ColorReplacements *replacements)
+: _player(player) {
+	if (quality == Quality::Synchronous) {
+		initDone(Init(content, request, quality, replacements));
+	} else {
+		const auto weak = base::make_weak(this);
+		crl::async([=] {
+			auto result = Init(content, request, quality, replacements);
+			crl::on_main(weak, [=, data = std::move(result)]() mutable {
+				initDone(std::move(data));
+			});
+		});
+	}
+}
+
+Animation::Animation(
+	not_null<Player*> player,
+	FnMut<void(FnMut<void(QByteArray &&cached)>)> get, // Main thread.
+	FnMut<void(QByteArray &&cached)> put, // Unknown thread.
+	const QByteArray &content,
+	const FrameRequest &request,
+	Quality quality,
+	const ColorReplacements *replacements)
+#ifdef LOTTIE_USE_CACHE
+: _player(player) {
+	const auto weak = base::make_weak(this);
+	get([=, put = std::move(put)](QByteArray &&cached) mutable {
+		crl::async([=, put = std::move(put)]() mutable {
+			auto result = Init(
+				content,
+				std::move(put),
+				cached,
+				request,
+				quality,
+				replacements);
+			crl::on_main(weak, [=, data = std::move(result)]() mutable {
+				initDone(std::move(data));
+			});
+		});
+	});
+#else // LOTTIE_USE_CACHE
+: Animation(player, content, request, quality, replacements) {
+#endif // LOTTIE_USE_CACHE
+}
+
+Animation::Animation(
+	not_null<Player*> player,
+	int keysCount,
+	FnMut<void(int, FnMut<void(QByteArray &&)>)> get,
+	FnMut<void(int, QByteArray &&cached)> put,
+	const QByteArray &content,
+	const FrameRequest &request,
+	Quality quality,
+	const ColorReplacements *replacements)
+#ifdef LOTTIE_USE_CACHE
+: _player(player) {
+	const auto weak = base::make_weak(this);
+	struct State {
+		std::atomic<int> left = 0;
+		std::vector<QByteArray> caches;
+		FnMut<void(int, QByteArray &&cached)> put;
+	};
+	const auto state = std::make_shared<State>();
+	state->left = keysCount;
+	state->put = std::move(put);
+	state->caches.resize(keysCount);
+	for (auto i = 0; i != keysCount; ++i) {
+		get(i, [=](QByteArray &&cached) {
+			state->caches[i] = std::move(cached);
+			if (--state->left) {
+				return;
+			}
+			crl::async([=] {
+				auto result = Init(
+					content,
+					std::move(state->put),
+					std::move(state->caches),
+					request,
+					quality,
+					replacements);
+				crl::on_main(weak, [=, data = std::move(result)]() mutable {
+					initDone(std::move(data));
+				});
+			});
+		});
+	}
+#else // LOTTIE_USE_CACHE
+: Animation(player, content, request, quality, replacements) {
+#endif // LOTTIE_USE_CACHE
+}
+
+Animation::Animation(
+	not_null<Player*> player,
+	std::shared_ptr<FrameProvider> provider,
+	const FrameRequest &request)
+: _player(player) {
+	const auto weak = base::make_weak(this);
+	crl::async([=, provider = std::move(provider)]() mutable {
+		auto result = Init(std::move(provider), request);
+		crl::on_main(weak, [=, data = std::move(result)]() mutable {
+			initDone(std::move(data));
+		});
+	});
+}
+
+bool Animation::ready() const {
+	return (_state != nullptr);
+}
+
+void Animation::initDone(details::InitData &&data) {
+	v::match(data, [&](std::unique_ptr<SharedState> &state) {
+		parseDone(std::move(state));
+	}, [&](Error error) {
+		parseFailed(error);
+	});
+}
+
+void Animation::parseDone(std::unique_ptr<SharedState> state) {
+	Expects(state != nullptr);
+
+	_state = state.get();
+	_player->start(this, std::move(state));
+}
+
+void Animation::parseFailed(Error error) {
+	_player->failed(this, error);
+}
+
+QImage Animation::frame() const {
+	Expects(_state != nullptr);
+
+	return PrepareFrameByRequest(_state->frameForPaint(), true);
+}
+
+QImage Animation::frame(const FrameRequest &request) const {
+	Expects(_state != nullptr);
+
+	const auto frame = _state->frameForPaint();
+	const auto changed = (frame->request != request);
+	if (changed) {
+		frame->request = request;
+		_player->updateFrameRequest(this, request);
+	}
+	return PrepareFrameByRequest(frame, !changed);
+}
+
+auto Animation::frameInfo(const FrameRequest &request) const -> FrameInfo {
+	Expects(_state != nullptr);
+
+	const auto frame = _state->frameForPaint();
+	const auto changed = (frame->request != request);
+	if (changed) {
+		frame->request = request;
+		_player->updateFrameRequest(this, request);
+	}
+	return {
+		PrepareFrameByRequest(frame, !changed),
+		frame->index % _state->framesCount()
+	};
+}
+
+int Animation::frameIndex() const {
+	Expects(_state != nullptr);
+
+	const auto frame = _state->frameForPaint();
+	return frame->index % _state->framesCount();
+}
+
+int Animation::framesCount() const {
+	Expects(_state != nullptr);
+
+	return _state->framesCount();
+}
+
+Information Animation::information() const {
+	Expects(_state != nullptr);
+
+	return _state->information();
+}
+
+std::optional<Error> ContentError(const QByteArray &content) {
+	if (content.size() > kMaxFileSize) {
+		return Error::ParseFailed;
+	}
+	return std::nullopt;
+}
+
+} // namespace Lottie