tg_windows5.12.6/Telegram/lib_ui/ui/text/custom_emoji_instance.cpp

// 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 "ui/text/custom_emoji_instance.h"

#include "ui/effects/animation_value.h"
#include "ui/effects/frame_generator.h"
#include "ui/dynamic_image.h"
#include "ui/ui_utility.h"
#include "ui/painter.h"

#include <crl/crl_async.h>
#include <lz4.h>

class QPainter;

namespace Ui::CustomEmoji {
namespace {

constexpr auto kMaxFrames = 180;
constexpr auto kCacheVersion = 1;
constexpr auto kPreloadFrames = 3;

struct CacheHeader {
	int version = 0;
	int size = 0;
	int frames = 0;
	int length = 0;
};

void PaintScaledImage(
		QPainter &p,
		const QRect &target,
		const Cache::Frame &frame,
		const Context &context) {
	static QImage PaintCache;
	const auto cache = context.internal.colorized ? &PaintCache : nullptr;
	auto q = std::optional<QPainter>();
	if (cache) {
		const auto ratio = style::DevicePixelRatio();
		if (cache->width() < target.width() * ratio
			|| cache->height() < target.height() * ratio) {
			*cache = QImage(
				std::max(cache->width(), target.width() * ratio),
				std::max(cache->height(), target.height() * ratio),
				QImage::Format_ARGB32_Premultiplied);
			cache->setDevicePixelRatio(ratio);
		}
		q.emplace(cache);
		q->setCompositionMode(QPainter::CompositionMode_Source);
		if (context.scaled) {
			q->fillRect(QRect(QPoint(), target.size()), Qt::transparent);
		}
		q->translate(-target.topLeft());
	}
	const auto to = q ? &*q : &p;
	if (context.scaled) {
		const auto sx = anim::interpolate(
			target.width() / 2,
			0,
			context.scale);
		const auto sy = (target.height() == target.width())
			? sx
			: anim::interpolate(target.height() / 2, 0, context.scale);
		const auto scaled = target.marginsRemoved({ sx, sy, sx, sy });
		if (frame.source.isNull()) {
			to->drawImage(scaled, *frame.image);
		} else {
			to->drawImage(scaled, *frame.image, frame.source);
		}
	} else if (frame.source.isNull()) {
		to->drawImage(target, *frame.image);
	} else {
		to->drawImage(target, *frame.image, frame.source);
	}
	if (q) {
		q.reset();
		const auto ratio = style::DevicePixelRatio();
		const auto source = QRect(QPoint(), target.size() * ratio);
		const auto &color = context.textColor;
		style::colorizeImage(*cache, color, cache, source, {}, true);
		p.drawImage(target, *cache, source);
	}
}

} // namespace

QColor PreviewColorFromTextColor(QColor color) {
	color.setAlpha((color.alpha() + 1) / 8);
	return color;
}

Preview::Preview(QPainterPath path, float64 scale)
: _data(ScaledPath{ std::move(path), scale }) {
}

Preview::Preview(QImage image, bool exact)
: _data(Image{ .data = std::move(image), .exact = exact }) {
}

void Preview::paint(QPainter &p, const Context &context) {
	if (const auto path = std::get_if<ScaledPath>(&_data)) {
		paintPath(p, context, *path);
	} else if (const auto image = std::get_if<Image>(&_data)) {
		const auto &data = image->data;
		const auto factor = style::DevicePixelRatio();
		const auto rect = QRect(context.position, data.size() / factor);
		PaintScaledImage(p, rect, { .image = &data }, context);
	}
}

bool Preview::isImage() const {
	return v::is<Image>(_data);
}

bool Preview::isExactImage() const {
	if (const auto image = std::get_if<Image>(&_data)) {
		return image->exact;
	}
	return false;
}

QImage Preview::image() const {
	if (const auto image = std::get_if<Image>(&_data)) {
		return image->data;
	}
	return QImage();
}

void Preview::paintPath(
		QPainter &p,
		const Context &context,
		const ScaledPath &path) {
	auto hq = PainterHighQualityEnabler(p);
	p.setBrush(PreviewColorFromTextColor(context.textColor));
	p.setPen(Qt::NoPen);
	const auto scale = path.scale;
	const auto required = (scale != 1.) || context.scaled;
	if (required) {
		p.save();
	}
	p.translate(context.position);
	if (required) {
		p.scale(scale, scale);
		const auto center = QPoint(
			context.size.width() / 2,
			context.size.height() / 2);
		if (context.scaled) {
			p.translate(center);
			p.scale(context.scale, context.scale);
			p.translate(-center);
		}
	}
	p.drawPath(path.path);
	if (required) {
		p.restore();
	} else {
		p.translate(-context.position);
	}
}

Cache::Cache(int size) : _size(size) {
}

std::optional<Cache> Cache::FromSerialized(
		const QByteArray &serialized,
		int requestedSize) {
	if (serialized.size() <= sizeof(CacheHeader)) {
		return {};
	}
	auto header = CacheHeader();
	memcpy(&header, serialized.data(), sizeof(header));
	const auto size = header.size;
	if (size != requestedSize
		|| header.frames <= 0
		|| header.frames >= kMaxFrames
		|| header.length <= 0
		|| header.length > (size * size * header.frames * sizeof(int32))
		|| (serialized.size() != sizeof(CacheHeader)
			+ header.length
			+ (header.frames * sizeof(Cache(0)._durations[0])))) {
		return {};
	}
	const auto rows = (header.frames + kPerRow - 1) / kPerRow;
	const auto columns = std::min(header.frames, kPerRow);
	auto durations = std::vector<uint16>(header.frames, 0);
	auto full = QImage(
		columns * size,
		rows * size,
		QImage::Format_ARGB32_Premultiplied);
	Assert(full.bytesPerLine() == full.width() * sizeof(int32));

	const auto decompressed = LZ4_decompress_safe(
		serialized.data() + sizeof(CacheHeader),
		reinterpret_cast<char*>(full.bits()),
		header.length,
		full.bytesPerLine() * full.height());
	if (decompressed <= 0) {
		return {};
	}
	memcpy(
		durations.data(),
		serialized.data() + sizeof(CacheHeader) + header.length,
		header.frames * sizeof(durations[0]));

	auto result = Cache(size);
	result._finished = true;
	result._full = std::move(full);
	result._frames = header.frames;
	result._durations = std::move(durations);
	return result;
}

QByteArray Cache::serialize() {
	Expects(_finished);
	Expects(_durations.size() == _frames);
	Expects(_full.bytesPerLine() == sizeof(int32) * _full.width());

	auto header = CacheHeader{
		.version = kCacheVersion,
		.size = _size,
		.frames = _frames,
	};
	const auto input = _full.width() * _full.height() * sizeof(int32);
	const auto max = sizeof(CacheHeader)
		+ LZ4_compressBound(input)
		+ (_frames * sizeof(_durations[0]));
	auto result = QByteArray(max, Qt::Uninitialized);
	header.length = LZ4_compress_default(
		reinterpret_cast<const char*>(_full.constBits()),
		result.data() + sizeof(CacheHeader),
		input,
		result.size() - sizeof(CacheHeader));
	Assert(header.length > 0);
	memcpy(result.data(), &header, sizeof(CacheHeader));
	memcpy(
		result.data() + sizeof(CacheHeader) + header.length,
		_durations.data(),
		_frames * sizeof(_durations[0]));
	result.resize(sizeof(CacheHeader)
		+ header.length
		+ _frames * sizeof(_durations[0]));

	return result;
}

int Cache::frames() const {
	return _frames;
}

bool Cache::readyInDefaultState() const {
	return (_frames > 0) && !_frame;
}

Cache::Frame Cache::frame(int index) const {
	Expects(index < _frames);

	const auto row = index / kPerRow;
	const auto inrow = index % kPerRow;
	if (_finished) {
		return { &_full, { inrow * _size, row * _size, _size, _size } };
	}
	return { &_images[row], { 0, inrow * _size, _size, _size } };
}

int Cache::size() const {
	return _size;
}

Preview Cache::makePreview() const {
	Expects(_frames > 0);

	const auto first = frame(0);
	return { first.image->copy(first.source), true };
}

void Cache::reserve(int frames) {
	Expects(!_finished);

	const auto rows = (frames + kPerRow - 1) / kPerRow;
	if (const auto add = rows - int(_images.size()); add > 0) {
		_images.resize(rows);
		for (auto e = end(_images), i = e - add; i != e; ++i) {
			(*i) = QImage(
				_size,
				_size * kPerRow,
				QImage::Format_ARGB32_Premultiplied);
		}
	}
	_durations.reserve(frames);
}

int Cache::frameRowByteSize() const {
	return _size * 4;
}

int Cache::frameByteSize() const {
	return _size * frameRowByteSize();
}

void Cache::add(crl::time duration, const QImage &frame) {
	Expects(!_finished);
	Expects(frame.size() == QSize(_size, _size));
	Expects(frame.format() == QImage::Format_ARGB32_Premultiplied);

	const auto row = (_frames / kPerRow);
	const auto inrow = (_frames % kPerRow);
	const auto rows = row + 1;
	while (_images.size() < rows) {
		_images.emplace_back();
		_images.back() = QImage(
			_size,
			_size * kPerRow,
			QImage::Format_ARGB32_Premultiplied);
	}
	const auto srcPerLine = frame.bytesPerLine();
	const auto dstPerLine = _images[row].bytesPerLine();
	const auto perLine = std::min(srcPerLine, dstPerLine);
	auto dst = _images[row].bits() + inrow * _size * dstPerLine;
	auto src = frame.constBits();
	for (auto y = 0; y != _size; ++y) {
		memcpy(dst, src, perLine);
		dst += dstPerLine;
		src += srcPerLine;
	}
	++_frames;
	_durations.push_back(std::clamp(
		duration,
		crl::time(0),
		crl::time(std::numeric_limits<uint16>::max())));
}

void Cache::finish() {
	_finished = true;
	if (_frame == _frames) {
		_frame = 0;
	}
	const auto rows = (_frames + kPerRow - 1) / kPerRow;
	const auto columns = std::min(_frames, kPerRow);
	const auto zero = (rows * columns) - _frames;
	_full = QImage(
		columns * _size,
		rows * _size,
		QImage::Format_ARGB32_Premultiplied);
	auto dstData = _full.bits();
	const auto perLine = _size * 4;
	const auto dstPerLine = _full.bytesPerLine();
	for (auto y = 0; y != rows; ++y) {
		auto &row = _images[y];
		auto src = row.bits();
		const auto srcPerLine = row.bytesPerLine();
		const auto till = columns - ((y + 1 == rows) ? zero : 0);
		for (auto x = 0; x != till; ++x) {
			auto dst = dstData + y * dstPerLine * _size + x * perLine;
			for (auto line = 0; line != _size; ++line) {
				memcpy(dst, src, perLine);
				src += srcPerLine;
				dst += dstPerLine;
			}
		}
	}
	if (const auto perLine = zero * _size) {
		auto dst = dstData
			+ (rows - 1) * dstPerLine * _size
			+ (columns - zero) * _size * 4;
		for (auto left = 0; left != _size; ++left) {
			memset(dst, 0, perLine);
			dst += dstPerLine;
		}
	}
}

PaintFrameResult Cache::paintCurrentFrame(
		QPainter &p,
		const Context &context) {
	if (!_frames) {
		return {};
	}
	const auto first = context.internal.forceFirstFrame;
	auto last = context.internal.forceLastFrame;
	if (!first && !last) {
		const auto now = context.paused ? 0 : context.now;
		const auto finishes = now ? currentFrameFinishes() : 0;
		if (finishes && now >= finishes) {
			++_frame;
			if (_finished && _frame == _frames) {
				_frame = 0;
				if (context.internal.overrideFirstWithLastFrame) {
					last = true;
				}
			}
			_shown = now;
		} else if (!_shown) {
			_shown = now;
		}
	}
	const auto index = first
		? 0
		: last
		? (_frames - 1)
		: std::min(_frame, _frames - 1);
	const auto info = frame(index);
	const auto size = _size / style::DevicePixelRatio();
	const auto rect = QRect(context.position, QSize(size, size));
	PaintScaledImage(p, rect, info, context);
	const auto next = first ? 0 : currentFrameFinishes();
	return {
		.painted = true,
		.next = next,
		.duration = next ? (next - _shown) : 0,
	};
}

int Cache::currentFrame() const {
	return _frame;
}

crl::time Cache::currentFrameFinishes() const {
	if (!_shown || _frame >= _durations.size()) {
		return 0;
	} else if (const auto duration = _durations[_frame]) {
		return _shown + duration;
	}
	return 0;
}

Cached::Cached(
	const QString &entityData,
	Fn<std::unique_ptr<Loader>()> unloader,
	Cache cache)
: _unloader(std::move(unloader))
, _cache(std::move(cache))
, _entityData(entityData) {
}

QString Cached::entityData() const {
	return _entityData;
}

PaintFrameResult Cached::paint(QPainter &p, const Context &context) {
	return _cache.paintCurrentFrame(p, context);
}

bool Cached::inDefaultState() const {
	return _cache.readyInDefaultState();
}

Preview Cached::makePreview() const {
	return _cache.makePreview();
}

Loading Cached::unload() {
	return Loading(_unloader(), makePreview());
}

Renderer::Renderer(RendererDescriptor &&descriptor)
: _cache(descriptor.size)
, _put(std::move(descriptor.put))
, _loader(std::move(descriptor.loader)) {
	Expects(_loader != nullptr);

	const auto size = _cache.size();
	const auto guard = base::make_weak(this);
	crl::async([=, factory = std::move(descriptor.generator)]() mutable {
		auto generator = factory();
		auto rendered = generator->renderNext(
			QImage(),
			QSize(size, size),
			Qt::KeepAspectRatio);
		if (rendered.image.isNull()) {
			return;
		}
		crl::on_main(guard, [
			=,
			frame = std::move(rendered),
			generator = std::move(generator)
		]() mutable {
			frameReady(
				std::move(generator),
				frame.duration,
				std::move(frame.image));
		});
	});
}

Renderer::~Renderer() = default;

void Renderer::frameReady(
		std::unique_ptr<Ui::FrameGenerator> generator,
		crl::time duration,
		QImage frame) {
	if (frame.isNull()) {
		finish();
		return;
	}
	if (const auto count = generator->count()) {
		if (!_cache.frames()) {
			_cache.reserve(std::max(count, kMaxFrames));
		}
	}
	const auto current = _cache.currentFrame();
	const auto total = _cache.frames();
	const auto explicitRepaint = (current == total);
	_cache.add(duration, frame);
	if (explicitRepaint && _repaint) {
		_repaint();
	}
	if (!duration || total + 1 >= kMaxFrames) {
		finish();
	} else if (current + kPreloadFrames > total) {
		renderNext(std::move(generator), std::move(frame));
	} else {
		_generator = std::move(generator);
		_storage = std::move(frame);
	}
}

void Renderer::renderNext(
		std::unique_ptr<Ui::FrameGenerator> generator,
		QImage storage) {
	const auto size = _cache.size();
	const auto guard = base::make_weak(this);
	crl::async([
		=,
		storage = std::move(storage),
		generator = std::move(generator)
	]() mutable {
		auto rendered = generator->renderNext(
			std::move(storage),
			QSize(size, size),
			Qt::KeepAspectRatio);
		crl::on_main(guard, [
			=,
			frame = std::move(rendered),
			generator = std::move(generator)
		]() mutable {
			frameReady(
				std::move(generator),
				frame.duration,
				std::move(frame.image));
		});
	});
}

void Renderer::finish() {
	_finished = true;
	_cache.finish();
	if (_put) {
		_put(_cache.serialize());
	}
}

PaintFrameResult Renderer::paint(QPainter &p, const Context &context) {
	const auto result = _cache.paintCurrentFrame(p, context);
	if (_generator
		&& (!result.painted
			|| _cache.currentFrame() + kPreloadFrames >= _cache.frames())) {
		renderNext(std::move(_generator), std::move(_storage));
	}
	return result;
}

std::optional<Cached> Renderer::ready(const QString &entityData) {
	return _finished
		? Cached{ entityData, std::move(_loader), std::move(_cache) }
		: std::optional<Cached>();
}

std::unique_ptr<Loader> Renderer::cancel() {
	return _loader();
}

bool Renderer::canMakePreview() const {
	return _cache.frames() > 0;
}

Preview Renderer::makePreview() const {
	return _cache.makePreview();
}

bool Renderer::readyInDefaultState() const {
	return _cache.readyInDefaultState();
}

void Renderer::setRepaintCallback(Fn<void()> repaint) {
	_repaint = std::move(repaint);
}

Cache Renderer::takeCache() {
	return std::move(_cache);
}

Loading::Loading(std::unique_ptr<Loader> loader, Preview preview)
: _loader(std::move(loader))
, _preview(std::move(preview)) {
}

QString Loading::entityData() const {
	return _loader->entityData();
}

void Loading::load(Fn<void(Loader::LoadResult)> done) {
	_loader->load(crl::guard(this, [this, done = std::move(done)](
			Loader::LoadResult result) mutable {
		if (const auto caching = std::get_if<Caching>(&result)) {
			caching->preview = _preview
				? std::move(_preview)
				: _loader->preview();
		}
		done(std::move(result));
	}));
}

bool Loading::loading() const {
	return _loader->loading();
}

void Loading::paint(QPainter &p, const Context &context) {
	if (!_preview) {
		if (auto preview = _loader->preview()) {
			_preview = std::move(preview);
		}
	}
	_preview.paint(p, context);
}

bool Loading::hasImagePreview() const {
	return _preview.isImage();
}

Preview Loading::imagePreview() const {
	return _preview.isImage() ? _preview : Preview();
}

void Loading::updatePreview(Preview preview) {
	if (!_preview.isImage() && preview.isImage()) {
		_preview = std::move(preview);
	} else if (!_preview) {
		if (auto loaderPreview = _loader->preview()) {
			_preview = std::move(loaderPreview);
		} else if (preview) {
			_preview = std::move(preview);
		}
	}
}

void Loading::cancel() {
	_loader->cancel();
	invalidate_weak_ptrs(this);
}

Instance::Instance(
	Loading loading,
	Fn<void(not_null<Instance*>, RepaintRequest)> repaintLater)
: _state(std::move(loading))
, _repaintLater(std::move(repaintLater)) {
}

QString Instance::entityData() const {
	return v::match(_state, [](const Loading &state) {
		return state.entityData();
	}, [](const Caching &state) {
		return state.entityData;
	}, [](const Cached &state) {
		return state.entityData();
	});
}

void Instance::paint(QPainter &p, const Context &context) {
	context.internal.colorized = _colored;

	v::match(_state, [&](Loading &state) {
		state.paint(p, context);
		load(state);
	}, [&](Caching &state) {
		auto result = state.renderer->paint(p, context);
		if (!result.painted) {
			state.preview.paint(p, context);
		} else {
			if (!state.preview.isExactImage()) {
				state.preview = state.renderer->makePreview();
			}
			if (result.next > context.now) {
				_repaintLater(this, { result.next, result.duration });
			}
		}
		if (auto cached = state.renderer->ready(state.entityData)) {
			_state = std::move(*cached);
		}
	}, [&](Cached &state) {
		const auto result = state.paint(p, context);
		if (result.next > context.now) {
			_repaintLater(this, { result.next, result.duration });
		}
	});
}

bool Instance::ready() {
	return v::match(_state, [&](Loading &state) {
		if (state.hasImagePreview()) {
			return true;
		}
		if (!_usage.empty()) {
			load(state);
		}
		return false;
	}, [](Caching &state) {
		return state.renderer->canMakePreview();
	}, [](Cached &state) {
		return true;
	});
}

bool Instance::readyInDefaultState() {
	return v::match(_state, [&](Loading &state) {
		if (state.hasImagePreview()) {
			return true;
		}
		load(state);
		return false;
	}, [](Caching &state) {
		return state.renderer->readyInDefaultState();
	}, [](Cached &state) {
		return state.inDefaultState();
	});
}

void Instance::load(Loading &state) {
	state.load([=](Loader::LoadResult result) {
		if (auto caching = std::get_if<Caching>(&result)) {
			caching->renderer->setRepaintCallback([=] { repaint(); });
			_state = std::move(*caching);
		} else if (auto cached = std::get_if<Cached>(&result)) {
			_state = std::move(*cached);
			repaint();
		} else {
			Unexpected("Value in Loader::LoadResult.");
		}
	});
}

bool Instance::hasImagePreview() const {
	return v::match(_state, [](const Loading &state) {
		return state.hasImagePreview();
	}, [](const Caching &state) {
		return state.preview.isImage();
	}, [](const Cached &state) {
		return true;
	});
}

Preview Instance::imagePreview() const {
	return v::match(_state, [](const Loading &state) {
		return state.imagePreview();
	}, [](const Caching &state) {
		return state.preview.isImage() ? state.preview : Preview();
	}, [](const Cached &state) {
		return state.makePreview();
	});
}

void Instance::updatePreview(Preview preview) {
	v::match(_state, [&](Loading &state) {
		state.updatePreview(std::move(preview));
	}, [&](Caching &state) {
		if ((!state.preview.isImage() && preview.isImage())
			|| (!state.preview && preview)) {
			state.preview = std::move(preview);
		}
	}, [](const Cached &) {});
}

void Instance::setColored() {
	if (!_colored) {
		_colored = true;
		if (ready()) {
			_repaintLater(this, { .when = crl::now() + 1 });
		}
	}
}

void Instance::repaint() {
	for (const auto &object : _usage) {
		object->repaint();
	}
}

void Instance::incrementUsage(not_null<Object*> object) {
	_usage.emplace(object);
}

void Instance::decrementUsage(not_null<Object*> object) {
	_usage.remove(object);
	if (!_usage.empty()) {
		return;
	}
	v::match(_state, [](Loading &state) {
		state.cancel();
	}, [&](Caching &state) {
		_state = Loading{
			state.renderer->cancel(),
			std::move(state.preview),
		};
	}, [&](Cached &state) {
		_state = state.unload();
	});
	_repaintLater(this, RepaintRequest());
}

Object::Object(not_null<Instance*> instance, Fn<void()> repaint)
: _instance(instance)
, _repaint(std::move(repaint)) {
}

Object::~Object() {
	unload();
}

int Object::width() {
	return st::emojiSize + 2 * st::emojiPadding;
}

QString Object::entityData() {
	return _instance->entityData();
}

void Object::paint(QPainter &p, const Context &context) {
	if (!_using) {
		_using = true;
		_instance->incrementUsage(this);
	}
	_instance->paint(p, context);
}

void Object::unload() {
	if (_using) {
		_using = false;
		_instance->decrementUsage(this);
	}
}

bool Object::ready() {
	if (!_using) {
		_using = true;
		_instance->incrementUsage(this);
	}
	return _instance->ready();
}

bool Object::readyInDefaultState() {
	if (!_using) {
		_using = true;
		_instance->incrementUsage(this);
	}
	return _instance->readyInDefaultState();
}

void Object::repaint() {
	if (const auto onstack = _repaint) {
		onstack();
	}
}

Internal::Internal(
	QString entityData,
	QImage image,
	QMargins padding,
	bool colored)
: _entityData(std::move(entityData))
, _image(std::move(image))
, _padding(padding)
, _colored(colored) {
}

int Internal::width() {
	return _padding.left()
		+ (_image.width() / _image.devicePixelRatio())
		+ _padding.right();
}

QString Internal::entityData() {
	return _entityData;
}

void Internal::paint(QPainter &p, const Context &context) {
	context.internal.colorized = _colored;

	const auto size = _image.size() / style::DevicePixelRatio();
	const auto rect = QRect(
		context.position + QPoint(_padding.left(), _padding.top()),
		size);
	PaintScaledImage(p, rect, { &_image }, context);
}

void Internal::unload() {
}

bool Internal::ready() {
	return true;
}

bool Internal::readyInDefaultState() {
	return true;
}

DynamicImageEmoji::DynamicImageEmoji(
	QString entityData,
	std::shared_ptr<DynamicImage> image,
	Fn<void()> repaint,
	QMargins padding,
	int size)
: _entityData(entityData)
, _image(std::move(image))
, _repaint(std::move(repaint))
, _padding(padding)
, _size(size) {
}

int DynamicImageEmoji::width() {
	return _padding.left() + _size + _padding.right();
}

QString DynamicImageEmoji::entityData() {
	return _entityData;
}

void DynamicImageEmoji::paint(QPainter &p, const Context &context) {
	if (!_subscribed) {
		_subscribed = true;
		_image->subscribeToUpdates(_repaint);
	}

	auto image = _image->image(_size);
	const auto size = image.size() / image.devicePixelRatio();
	const auto rect = QRect(
		context.position + QPoint(_padding.left(), _padding.top()),
		size);
	context.internal.colorized = false;
	PaintScaledImage(p, rect, { &image }, context);
}

void DynamicImageEmoji::unload() {
	if (_subscribed) {
		_subscribed = false;
		_image->subscribeToUpdates(nullptr);
	}
}

bool DynamicImageEmoji::ready() {
	return true;
}

bool DynamicImageEmoji::readyInDefaultState() {
	return true;
}

void PaintIconEmoji(
		QPainter &p,
		const Context &context,
		not_null<const style::IconEmoji*> emoji,
		IconEmojiFrameCache &cache) {
	context.internal.colorized = !emoji->useIconColor;

	const auto size = emoji->icon.size();
	const auto rect = QRect(context.position
		+ QPoint(emoji->padding.left(), emoji->padding.top()), size);

	const auto ratio = style::DevicePixelRatio();
	const auto full = size * ratio;
	const auto invalid = (cache.frame.size() != full);
	if (invalid
		|| (emoji->useIconColor
			&& cache.paletteVersion != style::PaletteVersion())) {
		cache.paletteVersion = style::PaletteVersion();
		if (invalid) {
			cache.frame = QImage(full, QImage::Format_ARGB32_Premultiplied);
		}
		cache.frame.setDevicePixelRatio(ratio);
		cache.frame.fill(Qt::transparent);
		auto q = QPainter(&cache.frame);
		emoji->icon.paint(q, 0, 0, size.width());
	}
	PaintScaledImage(p, rect, { &cache.frame }, context);
}

} // namespace Ui::CustomEmoji