Ручное слияние для Windows-клиента: оригинал в dev не попадал с v7.3.1, так как синхронизация v7.3.2-v7.3.4 встала на конфликте lib_ui. Таймер upstream-sync на время слияния остановлен. - lib_ui: форк 7e5d8bc (слияние с оригиналом 1ff7be7). - Версия 7.3.4 без бета-признака: BetaChannel 0, AppBetaVersion false. - mtproto: «плохая конфигурация прокси» теперь учитывает прокси (колбэк рантайма, делегат сессии, соединение); правки session_private перенесены в mtproto/session/private/* (лимиты длины, пустые RPC-ответы, DEBUG_LOG дампов). - update_checker: ограничение размера ответа и отключение HTTP/2 оригинала поверх гонки зеркал форка. - thanos_effect_renderer: версия оригинала (R32F вместо RGBA32F); проверка возможностей — по compute. - download_manager_mtproto: проверка слишком большой части оригинала. - prepare.py: патчи qtsvg и Windows 7 оригинала вместе с patches_extra форка. - Файлы .agents/.claude/.github, удалённые форком, остаются удалёнными. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
246 lines
6.3 KiB
C++
246 lines
6.3 KiB
C++
/*
|
|
This file is part of Telegram Desktop,
|
|
the official desktop application for the Telegram messaging service.
|
|
|
|
For license and copyright information please follow this link:
|
|
https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
|
|
*/
|
|
#include "data/data_photo_media.h"
|
|
|
|
#include "data/data_file_origin.h"
|
|
#include "data/data_session.h"
|
|
#include "core/mime_type.h"
|
|
#include "history/history.h"
|
|
#include "history/history_item.h"
|
|
#include "main/main_session.h"
|
|
#include "main/main_session_settings.h"
|
|
#include "platform/platform_file_utilities.h"
|
|
#include "storage/file_download.h"
|
|
|
|
namespace Data {
|
|
|
|
PhotoMedia::PhotoMedia(not_null<PhotoData*> owner)
|
|
: _owner(owner) {
|
|
}
|
|
|
|
// NB! Right now DocumentMedia can outlive Main::Session!
|
|
// In DocumentData::collectLocalData a shared_ptr is sent on_main.
|
|
// In case this is a problem the ~Gif code should be rewritten.
|
|
PhotoMedia::~PhotoMedia() = default;
|
|
|
|
not_null<PhotoData*> PhotoMedia::owner() const {
|
|
return _owner;
|
|
}
|
|
|
|
Image *PhotoMedia::thumbnailInline() const {
|
|
if (!_inlineThumbnail) {
|
|
const auto bytes = _owner->inlineThumbnailBytes();
|
|
if (!bytes.isEmpty()) {
|
|
auto image = Images::FromInlineBytes(bytes);
|
|
if (image.isNull()) {
|
|
_owner->clearInlineThumbnailBytes();
|
|
} else {
|
|
_inlineThumbnail = std::make_unique<Image>(std::move(image));
|
|
}
|
|
}
|
|
}
|
|
return _inlineThumbnail.get();
|
|
}
|
|
|
|
Image *PhotoMedia::image(PhotoSize size) const {
|
|
if (const auto resolved = resolveLoadedImage(size)) {
|
|
return resolved->data.get();
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
QByteArray PhotoMedia::imageBytes(PhotoSize size) const {
|
|
if (const auto resolved = resolveLoadedImage(size)) {
|
|
return resolved->bytes;
|
|
}
|
|
return QByteArray();
|
|
}
|
|
|
|
auto PhotoMedia::resolveLoadedImage(PhotoSize size) const
|
|
-> const PhotoImage * {
|
|
const auto &original = _images[PhotoSizeIndex(size)];
|
|
if (original.data) {
|
|
if (original.goodFor >= size) {
|
|
return &original;
|
|
}
|
|
}
|
|
const auto &valid = _images[_owner->validSizeIndex(size)];
|
|
if (valid.data.get()) {
|
|
if (valid.goodFor >= size) {
|
|
return &valid;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void PhotoMedia::wanted(PhotoSize size, Data::FileOrigin origin) {
|
|
const auto index = _owner->validSizeIndex(size);
|
|
if (!_images[index].data || _images[index].goodFor < size) {
|
|
_owner->load(size, origin);
|
|
}
|
|
}
|
|
|
|
QSize PhotoMedia::size(PhotoSize size) const {
|
|
const auto index = PhotoSizeIndex(size);
|
|
if (const auto image = _images[index].data.get()) {
|
|
return image->size();
|
|
}
|
|
const auto &location = _owner->location(size);
|
|
return { location.width(), location.height() };
|
|
}
|
|
|
|
void PhotoMedia::set(
|
|
PhotoSize size,
|
|
PhotoSize goodFor,
|
|
QImage image,
|
|
QByteArray bytes) {
|
|
const auto index = PhotoSizeIndex(size);
|
|
const auto limit = PhotoData::SideLimit();
|
|
if (image.width() > limit || image.height() > limit) {
|
|
image = image.scaled(
|
|
limit,
|
|
limit,
|
|
Qt::KeepAspectRatio,
|
|
Qt::SmoothTransformation);
|
|
}
|
|
_images[index] = PhotoImage{
|
|
.data = std::make_unique<Image>(std::move(image)),
|
|
.bytes = std::move(bytes),
|
|
.goodFor = goodFor,
|
|
};
|
|
_owner->session().notifyDownloaderTaskFinished();
|
|
}
|
|
|
|
QByteArray PhotoMedia::videoContent(PhotoSize size) const {
|
|
const auto small = (size == PhotoSize::Small) && _owner->hasVideoSmall();
|
|
return small ? _videoBytesSmall : _videoBytesLarge;
|
|
}
|
|
|
|
QSize PhotoMedia::videoSize(PhotoSize size) const {
|
|
const auto &location = _owner->videoLocation(size);
|
|
return { location.width(), location.height() };
|
|
}
|
|
|
|
void PhotoMedia::videoWanted(PhotoSize size, Data::FileOrigin origin) {
|
|
if (videoContent(size).isEmpty()) {
|
|
_owner->loadVideo(size, origin);
|
|
}
|
|
}
|
|
|
|
void PhotoMedia::setVideo(PhotoSize size, QByteArray content) {
|
|
const auto small = (size == PhotoSize::Small) && _owner->hasVideoSmall();
|
|
(small ? _videoBytesSmall : _videoBytesLarge) = std::move(content);
|
|
}
|
|
|
|
bool PhotoMedia::loaded() const {
|
|
const auto index = PhotoSizeIndex(PhotoSize::Large);
|
|
return (_images[index].data != nullptr)
|
|
&& (_images[index].goodFor >= PhotoSize::Large);
|
|
}
|
|
|
|
float64 PhotoMedia::progress() const {
|
|
return (_owner->uploading() || _owner->loading())
|
|
? _owner->progress()
|
|
: (loaded() ? 1. : 0.);
|
|
}
|
|
|
|
bool PhotoMedia::autoLoadThumbnailAllowed(not_null<PeerData*> peer) const {
|
|
if (loaded() || _owner->cancelled()) {
|
|
return false;
|
|
}
|
|
return _owner->hasExact(PhotoSize::Small)
|
|
|| _owner->hasExact(PhotoSize::Thumbnail)
|
|
|| AutoDownload::Should(
|
|
_owner->session().settings().autoDownload(),
|
|
peer,
|
|
_owner);
|
|
}
|
|
|
|
void PhotoMedia::automaticLoad(
|
|
FileOrigin origin,
|
|
const HistoryItem *item) {
|
|
if (item) {
|
|
automaticLoad(origin, item->history()->peer);
|
|
}
|
|
}
|
|
|
|
void PhotoMedia::automaticLoad(
|
|
FileOrigin origin,
|
|
not_null<PeerData*> peer) {
|
|
if (loaded() || _owner->cancelled()) {
|
|
return;
|
|
}
|
|
const auto loadFromCloud = Data::AutoDownload::Should(
|
|
_owner->session().settings().autoDownload(),
|
|
peer,
|
|
_owner);
|
|
_owner->load(
|
|
origin,
|
|
loadFromCloud ? LoadFromCloudOrLocal : LoadFromLocalOnly,
|
|
true);
|
|
}
|
|
|
|
void PhotoMedia::collectLocalData(not_null<PhotoMedia*> local) {
|
|
if (const auto image = local->_inlineThumbnail.get()) {
|
|
_inlineThumbnail = std::make_unique<Image>(image->original());
|
|
}
|
|
for (auto i = 0; i != kPhotoSizeCount; ++i) {
|
|
if (const auto image = local->_images[i].data.get()) {
|
|
_images[i] = PhotoImage{
|
|
.data = std::make_unique<Image>(image->original()),
|
|
.goodFor = local->_images[i].goodFor
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
bool PhotoMedia::saveToFile(const QString &path) {
|
|
constexpr auto large = PhotoSize::Large;
|
|
const auto video = videoContent(large);
|
|
const auto bytes = video.isEmpty() ? imageBytes(large) : video;
|
|
if (!bytes.isEmpty()) {
|
|
auto file = QFile(path);
|
|
if (!file.open(QIODevice::WriteOnly)
|
|
|| file.write(bytes) != bytes.size()
|
|
|| !file.flush()) {
|
|
return false;
|
|
}
|
|
file.close();
|
|
} else {
|
|
const auto loaded = image(large);
|
|
if (!loaded || !loaded->original().save(path, "JPG")) {
|
|
return false;
|
|
}
|
|
}
|
|
Platform::File::PostprocessDownloaded(
|
|
QFileInfo(path).absoluteFilePath());
|
|
return true;
|
|
}
|
|
|
|
bool PhotoMedia::setToClipboard() {
|
|
constexpr auto large = PhotoSize::Large;
|
|
if (const auto video = videoContent(large); !video.isEmpty()) {
|
|
return false;
|
|
}
|
|
const auto loaded = image(large);
|
|
if (!loaded) {
|
|
return false;
|
|
}
|
|
auto fallback = loaded->original();
|
|
if (fallback.isNull()) {
|
|
return false;
|
|
}
|
|
return Core::SetMediaClipboard({
|
|
.content = imageBytes(large),
|
|
.mime = u"image/jpeg"_q,
|
|
.image = std::move(fallback),
|
|
.suggestedName = u"photo.jpg"_q,
|
|
});
|
|
}
|
|
|
|
} // namespace Data
|