2014-05-30 08:53:19 +00:00
|
|
|
/*
|
|
|
|
This file is part of Telegram Desktop,
|
2018-01-03 10:23:14 +00:00
|
|
|
the official desktop application for the Telegram messaging service.
|
2014-05-30 08:53:19 +00:00
|
|
|
|
2018-01-03 10:23:14 +00:00
|
|
|
For license and copyright information please follow this link:
|
|
|
|
https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
|
2014-05-30 08:53:19 +00:00
|
|
|
*/
|
2017-03-04 10:23:56 +00:00
|
|
|
#include "storage/localimageloader.h"
|
2015-10-27 02:39:02 +00:00
|
|
|
|
2017-09-26 11:49:16 +00:00
|
|
|
#include "data/data_document.h"
|
2017-02-28 14:05:30 +00:00
|
|
|
#include "core/file_utilities.h"
|
2018-06-13 22:06:21 +00:00
|
|
|
#include "core/mime_type.h"
|
2019-02-13 12:36:59 +00:00
|
|
|
#include "media/audio/media_audio.h"
|
|
|
|
#include "media/clip/media_clip_reader.h"
|
2018-12-26 07:22:36 +00:00
|
|
|
#include "history/history_item.h"
|
2016-11-28 15:45:07 +00:00
|
|
|
#include "boxes/send_files_box.h"
|
2017-04-06 14:38:10 +00:00
|
|
|
#include "boxes/confirm_box.h"
|
2019-02-13 12:36:59 +00:00
|
|
|
#include "lang/lang_keys.h"
|
2017-08-15 15:59:40 +00:00
|
|
|
#include "storage/file_download.h"
|
2017-12-19 16:57:42 +00:00
|
|
|
#include "storage/storage_media_prepare.h"
|
2019-02-13 12:36:59 +00:00
|
|
|
#include "mainwidget.h"
|
|
|
|
#include "mainwindow.h"
|
2014-05-30 08:53:19 +00:00
|
|
|
|
2018-10-25 08:47:06 +00:00
|
|
|
namespace {
|
|
|
|
|
|
|
|
constexpr auto kThumbnailQuality = 87;
|
2019-01-18 07:37:41 +00:00
|
|
|
constexpr auto kThumbnailSize = 320;
|
2019-01-18 11:26:43 +00:00
|
|
|
constexpr auto kPhotoUploadPartSize = 32 * 1024;
|
|
|
|
|
|
|
|
using Storage::ValidateThumbDimensions;
|
2019-01-18 07:37:41 +00:00
|
|
|
|
|
|
|
struct PreparedFileThumbnail {
|
|
|
|
uint64 id = 0;
|
|
|
|
QString name;
|
|
|
|
QImage image;
|
|
|
|
QByteArray bytes;
|
|
|
|
MTPPhotoSize mtpSize = MTP_photoSizeEmpty(MTP_string(""));
|
|
|
|
};
|
|
|
|
|
|
|
|
PreparedFileThumbnail PrepareFileThumbnail(QImage &&original) {
|
|
|
|
const auto width = original.width();
|
|
|
|
const auto height = original.height();
|
2019-01-18 11:26:43 +00:00
|
|
|
if (!ValidateThumbDimensions(width, height)) {
|
2019-01-18 07:37:41 +00:00
|
|
|
return {};
|
|
|
|
}
|
|
|
|
auto result = PreparedFileThumbnail();
|
|
|
|
result.id = rand_value<uint64>();
|
|
|
|
const auto scaled = (width > kThumbnailSize || height > kThumbnailSize);
|
|
|
|
const auto scaledWidth = [&] {
|
|
|
|
return (width > height)
|
|
|
|
? kThumbnailSize
|
|
|
|
: int(std::round(kThumbnailSize * width / float64(height)));
|
|
|
|
};
|
|
|
|
const auto scaledHeight = [&] {
|
|
|
|
return (width > height)
|
|
|
|
? int(std::round(kThumbnailSize * height / float64(width)))
|
|
|
|
: kThumbnailSize;
|
|
|
|
};
|
|
|
|
result.image = scaled
|
|
|
|
? original.scaled(
|
|
|
|
scaledWidth(),
|
|
|
|
scaledHeight(),
|
|
|
|
Qt::IgnoreAspectRatio,
|
|
|
|
Qt::SmoothTransformation)
|
|
|
|
: std::move(original);
|
|
|
|
result.mtpSize = MTP_photoSize(
|
|
|
|
MTP_string(""),
|
2019-03-22 14:19:43 +00:00
|
|
|
MTP_fileLocationToBeDeprecated(MTP_long(0), MTP_int(0)),
|
2019-01-18 07:37:41 +00:00
|
|
|
MTP_int(result.image.width()),
|
|
|
|
MTP_int(result.image.height()),
|
|
|
|
MTP_int(0));
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool FileThumbnailUploadRequired(const QString &filemime, int32 filesize) {
|
|
|
|
constexpr auto kThumbnailUploadBySize = 5 * 1024 * 1024;
|
|
|
|
const auto kThumbnailKnownMimes = {
|
|
|
|
"image/jpeg",
|
|
|
|
"image/gif",
|
|
|
|
"image/png",
|
|
|
|
"image/webp",
|
|
|
|
"video/mp4",
|
|
|
|
};
|
|
|
|
return (filesize > kThumbnailUploadBySize)
|
|
|
|
|| (ranges::find(kThumbnailKnownMimes, filemime.toLower())
|
|
|
|
== end(kThumbnailKnownMimes));
|
|
|
|
}
|
|
|
|
|
|
|
|
PreparedFileThumbnail FinalizeFileThumbnail(
|
|
|
|
PreparedFileThumbnail &&prepared,
|
|
|
|
const QString &filemime,
|
|
|
|
int32 filesize,
|
|
|
|
bool isSticker) {
|
|
|
|
prepared.name = isSticker ? qsl("thumb.webp") : qsl("thumb.jpg");
|
|
|
|
if (FileThumbnailUploadRequired(filemime, filesize)) {
|
|
|
|
const auto format = QByteArray(isSticker ? "WEBP" : "JPG");
|
|
|
|
auto buffer = QBuffer(&prepared.bytes);
|
|
|
|
prepared.image.save(&buffer, format, kThumbnailQuality);
|
|
|
|
}
|
|
|
|
return std::move(prepared);
|
|
|
|
}
|
2018-10-25 08:47:06 +00:00
|
|
|
|
2018-12-26 07:22:36 +00:00
|
|
|
auto FindAlbumItem(
|
|
|
|
std::vector<SendingAlbum::Item> &items,
|
|
|
|
not_null<HistoryItem*> item) {
|
|
|
|
const auto result = ranges::find(
|
|
|
|
items,
|
|
|
|
item->fullId(),
|
|
|
|
&SendingAlbum::Item::msgId);
|
|
|
|
|
|
|
|
Ensures(result != end(items));
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
MTPInputSingleMedia PrepareAlbumItemMedia(
|
|
|
|
not_null<HistoryItem*> item,
|
|
|
|
const MTPInputMedia &media,
|
|
|
|
uint64 randomId) {
|
|
|
|
auto caption = item->originalText();
|
|
|
|
TextUtilities::Trim(caption);
|
|
|
|
auto sentEntities = TextUtilities::EntitiesToMTP(
|
|
|
|
caption.entities,
|
|
|
|
TextUtilities::ConvertOption::SkipLocal);
|
|
|
|
const auto flags = !sentEntities.v.isEmpty()
|
|
|
|
? MTPDinputSingleMedia::Flag::f_entities
|
|
|
|
: MTPDinputSingleMedia::Flag(0);
|
|
|
|
|
|
|
|
return MTP_inputSingleMedia(
|
|
|
|
MTP_flags(flags),
|
|
|
|
media,
|
|
|
|
MTP_long(randomId),
|
|
|
|
MTP_string(caption.text),
|
|
|
|
sentEntities);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-10-25 08:47:06 +00:00
|
|
|
} // namespace
|
|
|
|
|
2019-01-18 11:26:43 +00:00
|
|
|
SendMediaReady::SendMediaReady(
|
|
|
|
SendMediaType type,
|
|
|
|
const QString &file,
|
|
|
|
const QString &filename,
|
|
|
|
int32 filesize,
|
|
|
|
const QByteArray &data,
|
|
|
|
const uint64 &id,
|
|
|
|
const uint64 &thumbId,
|
|
|
|
const QString &thumbExt,
|
|
|
|
const PeerId &peer,
|
|
|
|
const MTPPhoto &photo,
|
|
|
|
const PreparedPhotoThumbs &photoThumbs,
|
|
|
|
const MTPDocument &document,
|
|
|
|
const QByteArray &jpeg,
|
|
|
|
MsgId replyTo)
|
|
|
|
: replyTo(replyTo)
|
|
|
|
, type(type)
|
|
|
|
, file(file)
|
|
|
|
, filename(filename)
|
|
|
|
, filesize(filesize)
|
|
|
|
, data(data)
|
|
|
|
, thumbExt(thumbExt)
|
|
|
|
, id(id)
|
|
|
|
, thumbId(thumbId)
|
|
|
|
, peer(peer)
|
|
|
|
, photo(photo)
|
|
|
|
, document(document)
|
|
|
|
, photoThumbs(photoThumbs) {
|
|
|
|
if (!jpeg.isEmpty()) {
|
|
|
|
int32 size = jpeg.size();
|
|
|
|
for (int32 i = 0, part = 0; i < size; i += kPhotoUploadPartSize, ++part) {
|
|
|
|
parts.insert(part, jpeg.mid(i, kPhotoUploadPartSize));
|
|
|
|
}
|
|
|
|
jpeg_md5.resize(32);
|
|
|
|
hashMd5Hex(jpeg.constData(), jpeg.size(), jpeg_md5.data());
|
|
|
|
}
|
|
|
|
}
|
2017-03-09 09:47:45 +00:00
|
|
|
|
2018-09-06 11:13:54 +00:00
|
|
|
SendMediaReady PreparePeerPhoto(PeerId peerId, QImage &&image) {
|
|
|
|
PreparedPhotoThumbs photoThumbs;
|
|
|
|
QVector<MTPPhotoSize> photoSizes;
|
|
|
|
|
|
|
|
QByteArray jpeg;
|
|
|
|
QBuffer jpegBuffer(&jpeg);
|
|
|
|
image.save(&jpegBuffer, "JPG", 87);
|
|
|
|
|
|
|
|
const auto scaled = [&](int size) {
|
2018-10-12 16:41:51 +00:00
|
|
|
return image.scaled(
|
2018-09-06 11:13:54 +00:00
|
|
|
size,
|
|
|
|
size,
|
|
|
|
Qt::KeepAspectRatio,
|
2018-10-12 16:41:51 +00:00
|
|
|
Qt::SmoothTransformation);
|
2018-09-06 11:13:54 +00:00
|
|
|
};
|
2018-10-12 16:41:51 +00:00
|
|
|
const auto push = [&](const char *type, QImage &&image) {
|
2018-09-06 11:13:54 +00:00
|
|
|
photoSizes.push_back(MTP_photoSize(
|
|
|
|
MTP_string(type),
|
2019-03-22 14:19:43 +00:00
|
|
|
MTP_fileLocationToBeDeprecated(MTP_long(0), MTP_int(0)),
|
2018-10-12 16:41:51 +00:00
|
|
|
MTP_int(image.width()),
|
|
|
|
MTP_int(image.height()), MTP_int(0)));
|
2019-01-25 14:37:28 +00:00
|
|
|
photoThumbs.emplace(type[0], std::move(image));
|
2018-09-06 11:13:54 +00:00
|
|
|
};
|
|
|
|
push("a", scaled(160));
|
|
|
|
push("b", scaled(320));
|
2018-10-12 16:41:51 +00:00
|
|
|
push("c", std::move(image));
|
2018-09-06 11:13:54 +00:00
|
|
|
|
|
|
|
const auto id = rand_value<PhotoId>();
|
|
|
|
const auto photo = MTP_photo(
|
|
|
|
MTP_flags(0),
|
|
|
|
MTP_long(id),
|
|
|
|
MTP_long(0),
|
|
|
|
MTP_bytes(QByteArray()),
|
|
|
|
MTP_int(unixtime()),
|
2019-03-22 14:19:43 +00:00
|
|
|
MTP_vector<MTPPhotoSize>(photoSizes),
|
|
|
|
MTP_int(MTP::maindc()));
|
2018-09-06 11:13:54 +00:00
|
|
|
|
|
|
|
QString file, filename;
|
|
|
|
int32 filesize = 0;
|
|
|
|
QByteArray data;
|
|
|
|
|
|
|
|
return SendMediaReady(
|
|
|
|
SendMediaType::Photo,
|
|
|
|
file,
|
|
|
|
filename,
|
|
|
|
filesize,
|
|
|
|
data,
|
|
|
|
id,
|
|
|
|
id,
|
|
|
|
qsl("jpg"),
|
|
|
|
peerId,
|
|
|
|
photo,
|
|
|
|
photoThumbs,
|
|
|
|
MTP_documentEmpty(MTP_long(0)),
|
|
|
|
jpeg,
|
|
|
|
0);
|
|
|
|
}
|
|
|
|
|
2019-02-08 16:20:08 +00:00
|
|
|
SendMediaReady PrepareWallPaper(const QImage &image) {
|
|
|
|
PreparedPhotoThumbs thumbnails;
|
|
|
|
QVector<MTPPhotoSize> sizes;
|
|
|
|
|
|
|
|
QByteArray jpeg;
|
|
|
|
QBuffer jpegBuffer(&jpeg);
|
|
|
|
image.save(&jpegBuffer, "JPG", 87);
|
|
|
|
|
|
|
|
const auto scaled = [&](int size) {
|
|
|
|
return image.scaled(
|
|
|
|
size,
|
|
|
|
size,
|
|
|
|
Qt::KeepAspectRatio,
|
|
|
|
Qt::SmoothTransformation);
|
|
|
|
};
|
|
|
|
const auto push = [&](const char *type, QImage &&image) {
|
|
|
|
sizes.push_back(MTP_photoSize(
|
|
|
|
MTP_string(type),
|
2019-03-22 14:19:43 +00:00
|
|
|
MTP_fileLocationToBeDeprecated(MTP_long(0), MTP_int(0)),
|
2019-02-08 16:20:08 +00:00
|
|
|
MTP_int(image.width()),
|
|
|
|
MTP_int(image.height()), MTP_int(0)));
|
|
|
|
thumbnails.emplace(type[0], std::move(image));
|
|
|
|
};
|
|
|
|
push("s", scaled(320));
|
|
|
|
|
|
|
|
const auto filename = qsl("wallpaper.jpg");
|
|
|
|
auto attributes = QVector<MTPDocumentAttribute>(
|
|
|
|
1,
|
|
|
|
MTP_documentAttributeFilename(MTP_string(filename)));
|
|
|
|
attributes.push_back(MTP_documentAttributeImageSize(
|
|
|
|
MTP_int(image.width()),
|
|
|
|
MTP_int(image.height())));
|
|
|
|
const auto id = rand_value<DocumentId>();
|
|
|
|
const auto document = MTP_document(
|
|
|
|
MTP_flags(0),
|
|
|
|
MTP_long(id),
|
|
|
|
MTP_long(0),
|
|
|
|
MTP_bytes(QByteArray()),
|
|
|
|
MTP_int(unixtime()),
|
|
|
|
MTP_string("image/jpeg"),
|
|
|
|
MTP_int(jpeg.size()),
|
|
|
|
MTP_vector<MTPPhotoSize>(sizes),
|
|
|
|
MTP_int(MTP::maindc()),
|
|
|
|
MTP_vector<MTPDocumentAttribute>(attributes));
|
|
|
|
|
|
|
|
return SendMediaReady(
|
|
|
|
SendMediaType::WallPaper,
|
|
|
|
QString(), // filepath
|
|
|
|
filename,
|
|
|
|
jpeg.size(),
|
|
|
|
jpeg,
|
|
|
|
id,
|
|
|
|
0,
|
|
|
|
QString(),
|
|
|
|
PeerId(),
|
|
|
|
MTP_photoEmpty(MTP_long(0)),
|
|
|
|
thumbnails,
|
|
|
|
document,
|
|
|
|
QByteArray(),
|
|
|
|
0);
|
|
|
|
}
|
|
|
|
|
2019-02-19 06:57:53 +00:00
|
|
|
TaskQueue::TaskQueue(crl::time stopTimeoutMs) {
|
2015-09-29 18:44:31 +00:00
|
|
|
if (stopTimeoutMs > 0) {
|
|
|
|
_stopTimer = new QTimer(this);
|
|
|
|
connect(_stopTimer, SIGNAL(timeout()), this, SLOT(stop()));
|
|
|
|
_stopTimer->setSingleShot(true);
|
2017-12-19 16:57:42 +00:00
|
|
|
_stopTimer->setInterval(int(stopTimeoutMs));
|
2015-09-29 18:44:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-12-18 10:38:14 +00:00
|
|
|
TaskId TaskQueue::addTask(std::unique_ptr<Task> &&task) {
|
|
|
|
const auto result = task->id();
|
2015-09-29 18:44:31 +00:00
|
|
|
{
|
|
|
|
QMutexLocker lock(&_tasksToProcessMutex);
|
2017-12-18 10:38:14 +00:00
|
|
|
_tasksToProcess.push_back(std::move(task));
|
2015-09-29 18:44:31 +00:00
|
|
|
}
|
2015-10-28 02:41:13 +00:00
|
|
|
|
|
|
|
wakeThread();
|
|
|
|
|
2017-12-18 10:38:14 +00:00
|
|
|
return result;
|
2015-10-28 02:41:13 +00:00
|
|
|
}
|
|
|
|
|
2017-12-18 10:38:14 +00:00
|
|
|
void TaskQueue::addTasks(std::vector<std::unique_ptr<Task>> &&tasks) {
|
2015-10-28 02:41:13 +00:00
|
|
|
{
|
|
|
|
QMutexLocker lock(&_tasksToProcessMutex);
|
2017-12-18 10:38:14 +00:00
|
|
|
for (auto &task : tasks) {
|
|
|
|
_tasksToProcess.push_back(std::move(task));
|
|
|
|
}
|
2015-10-28 02:41:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
wakeThread();
|
|
|
|
}
|
|
|
|
|
|
|
|
void TaskQueue::wakeThread() {
|
2015-09-29 18:44:31 +00:00
|
|
|
if (!_thread) {
|
|
|
|
_thread = new QThread();
|
|
|
|
|
|
|
|
_worker = new TaskQueueWorker(this);
|
|
|
|
_worker->moveToThread(_thread);
|
|
|
|
|
|
|
|
connect(this, SIGNAL(taskAdded()), _worker, SLOT(onTaskAdded()));
|
|
|
|
connect(_worker, SIGNAL(taskProcessed()), this, SLOT(onTaskProcessed()));
|
|
|
|
|
|
|
|
_thread->start();
|
|
|
|
}
|
|
|
|
if (_stopTimer) _stopTimer->stop();
|
|
|
|
emit taskAdded();
|
|
|
|
}
|
|
|
|
|
|
|
|
void TaskQueue::cancelTask(TaskId id) {
|
2017-12-18 10:38:14 +00:00
|
|
|
const auto removeFrom = [&](std::deque<std::unique_ptr<Task>> &queue) {
|
|
|
|
const auto proj = [](const std::unique_ptr<Task> &task) {
|
|
|
|
return task->id();
|
|
|
|
};
|
|
|
|
auto i = ranges::find(queue, id, proj);
|
|
|
|
if (i != queue.end()) {
|
|
|
|
queue.erase(i);
|
|
|
|
}
|
|
|
|
};
|
2015-11-23 16:05:30 +00:00
|
|
|
{
|
|
|
|
QMutexLocker lock(&_tasksToProcessMutex);
|
2017-12-18 10:38:14 +00:00
|
|
|
removeFrom(_tasksToProcess);
|
|
|
|
if (_taskInProcessId == id) {
|
|
|
|
_taskInProcessId = TaskId();
|
2015-11-23 16:05:30 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
QMutexLocker lock(&_tasksToFinishMutex);
|
2017-12-18 10:38:14 +00:00
|
|
|
removeFrom(_tasksToFinish);
|
2015-09-29 18:44:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void TaskQueue::onTaskProcessed() {
|
|
|
|
do {
|
2017-12-18 10:38:14 +00:00
|
|
|
auto task = std::unique_ptr<Task>();
|
2015-09-29 18:44:31 +00:00
|
|
|
{
|
|
|
|
QMutexLocker lock(&_tasksToFinishMutex);
|
2017-12-18 10:38:14 +00:00
|
|
|
if (_tasksToFinish.empty()) break;
|
|
|
|
task = std::move(_tasksToFinish.front());
|
2015-09-29 18:44:31 +00:00
|
|
|
_tasksToFinish.pop_front();
|
|
|
|
}
|
|
|
|
task->finish();
|
|
|
|
} while (true);
|
|
|
|
|
|
|
|
if (_stopTimer) {
|
|
|
|
QMutexLocker lock(&_tasksToProcessMutex);
|
2017-12-18 10:38:14 +00:00
|
|
|
if (_tasksToProcess.empty() && !_taskInProcessId) {
|
2015-09-29 18:44:31 +00:00
|
|
|
_stopTimer->start();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void TaskQueue::stop() {
|
|
|
|
if (_thread) {
|
|
|
|
_thread->requestInterruption();
|
|
|
|
_thread->quit();
|
2016-03-01 02:36:23 +00:00
|
|
|
DEBUG_LOG(("Waiting for taskThread to finish"));
|
2015-09-29 18:44:31 +00:00
|
|
|
_thread->wait();
|
2019-01-18 11:26:43 +00:00
|
|
|
delete base::take(_worker);
|
|
|
|
delete base::take(_thread);
|
2015-09-29 18:44:31 +00:00
|
|
|
}
|
|
|
|
_tasksToProcess.clear();
|
|
|
|
_tasksToFinish.clear();
|
2017-12-18 10:38:14 +00:00
|
|
|
_taskInProcessId = TaskId();
|
2015-09-29 18:44:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
TaskQueue::~TaskQueue() {
|
|
|
|
stop();
|
|
|
|
delete _stopTimer;
|
|
|
|
}
|
|
|
|
|
|
|
|
void TaskQueueWorker::onTaskAdded() {
|
|
|
|
if (_inTaskAdded) return;
|
|
|
|
_inTaskAdded = true;
|
2016-01-05 04:28:06 +00:00
|
|
|
|
2015-09-29 18:44:31 +00:00
|
|
|
bool someTasksLeft = false;
|
|
|
|
do {
|
2017-12-18 10:38:14 +00:00
|
|
|
auto task = std::unique_ptr<Task>();
|
2015-09-29 18:44:31 +00:00
|
|
|
{
|
|
|
|
QMutexLocker lock(&_queue->_tasksToProcessMutex);
|
2017-12-18 10:38:14 +00:00
|
|
|
if (!_queue->_tasksToProcess.empty()) {
|
|
|
|
task = std::move(_queue->_tasksToProcess.front());
|
|
|
|
_queue->_tasksToProcess.pop_front();
|
|
|
|
_queue->_taskInProcessId = task->id();
|
2015-09-29 18:44:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (task) {
|
|
|
|
task->process();
|
|
|
|
bool emitTaskProcessed = false;
|
|
|
|
{
|
|
|
|
QMutexLocker lockToProcess(&_queue->_tasksToProcessMutex);
|
2017-12-18 10:38:14 +00:00
|
|
|
if (_queue->_taskInProcessId == task->id()) {
|
|
|
|
_queue->_taskInProcessId = TaskId();
|
|
|
|
someTasksLeft = !_queue->_tasksToProcess.empty();
|
2015-09-29 18:44:31 +00:00
|
|
|
|
|
|
|
QMutexLocker lockToFinish(&_queue->_tasksToFinishMutex);
|
2017-12-18 10:38:14 +00:00
|
|
|
emitTaskProcessed = _queue->_tasksToFinish.empty();
|
|
|
|
_queue->_tasksToFinish.push_back(std::move(task));
|
2015-09-29 18:44:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (emitTaskProcessed) {
|
|
|
|
emit taskProcessed();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
QCoreApplication::processEvents();
|
|
|
|
} while (someTasksLeft && !thread()->isInterruptionRequested());
|
|
|
|
|
|
|
|
_inTaskAdded = false;
|
|
|
|
}
|
2015-10-27 02:39:02 +00:00
|
|
|
|
2017-12-19 16:57:42 +00:00
|
|
|
SendingAlbum::SendingAlbum() : groupId(rand_value<uint64>()) {
|
|
|
|
}
|
|
|
|
|
2018-12-26 07:22:36 +00:00
|
|
|
void SendingAlbum::fillMedia(
|
|
|
|
not_null<HistoryItem*> item,
|
|
|
|
const MTPInputMedia &media,
|
|
|
|
uint64 randomId) {
|
|
|
|
const auto i = FindAlbumItem(items, item);
|
|
|
|
Assert(!i->media);
|
|
|
|
|
|
|
|
i->media = PrepareAlbumItemMedia(item, media, randomId);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SendingAlbum::refreshMediaCaption(not_null<HistoryItem*> item) {
|
|
|
|
const auto i = FindAlbumItem(items, item);
|
|
|
|
if (!i->media) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
i->media = i->media->match([&](const MTPDinputSingleMedia &data) {
|
|
|
|
return PrepareAlbumItemMedia(item, data.vmedia, data.vrandom_id.v);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
void SendingAlbum::removeItem(not_null<HistoryItem*> item) {
|
|
|
|
const auto localId = item->fullId();
|
|
|
|
const auto i = ranges::find(items, localId, &Item::msgId);
|
|
|
|
const auto moveCaption = (items.size() > 1) && (i == begin(items));
|
|
|
|
Assert(i != end(items));
|
|
|
|
items.erase(i);
|
|
|
|
if (moveCaption) {
|
|
|
|
const auto caption = item->originalText();
|
|
|
|
const auto firstId = items.front().msgId;
|
|
|
|
if (const auto first = App::histItemById(firstId)) {
|
|
|
|
// We don't need to finishEdition() here, because the whole
|
|
|
|
// album will be rebuilt after one item was removed from it.
|
|
|
|
first->setText(caption);
|
|
|
|
refreshMediaCaption(first);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-12-19 16:57:42 +00:00
|
|
|
FileLoadResult::FileLoadResult(
|
|
|
|
TaskId taskId,
|
|
|
|
uint64 id,
|
|
|
|
const FileLoadTo &to,
|
2018-05-24 13:03:21 +00:00
|
|
|
const TextWithTags &caption,
|
2017-12-19 16:57:42 +00:00
|
|
|
std::shared_ptr<SendingAlbum> album)
|
|
|
|
: taskId(taskId)
|
|
|
|
, id(id)
|
|
|
|
, to(to)
|
2017-12-26 15:05:17 +00:00
|
|
|
, album(std::move(album))
|
|
|
|
, caption(caption) {
|
2017-12-19 16:57:42 +00:00
|
|
|
}
|
|
|
|
|
2019-01-18 11:26:43 +00:00
|
|
|
void FileLoadResult::setFileData(const QByteArray &filedata) {
|
|
|
|
if (filedata.isEmpty()) {
|
|
|
|
partssize = 0;
|
|
|
|
} else {
|
|
|
|
partssize = filedata.size();
|
|
|
|
for (int32 i = 0, part = 0; i < partssize; i += kPhotoUploadPartSize, ++part) {
|
|
|
|
fileparts.insert(part, filedata.mid(i, kPhotoUploadPartSize));
|
|
|
|
}
|
|
|
|
filemd5.resize(32);
|
|
|
|
hashMd5Hex(filedata.constData(), filedata.size(), filemd5.data());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void FileLoadResult::setThumbData(const QByteArray &thumbdata) {
|
|
|
|
if (!thumbdata.isEmpty()) {
|
|
|
|
int32 size = thumbdata.size();
|
|
|
|
for (int32 i = 0, part = 0; i < size; i += kPhotoUploadPartSize, ++part) {
|
|
|
|
thumbparts.insert(part, thumbdata.mid(i, kPhotoUploadPartSize));
|
|
|
|
}
|
|
|
|
thumbmd5.resize(32);
|
|
|
|
hashMd5Hex(thumbdata.constData(), thumbdata.size(), thumbmd5.data());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-12-19 16:57:42 +00:00
|
|
|
FileLoadTask::FileLoadTask(
|
|
|
|
const QString &filepath,
|
2017-12-21 16:15:37 +00:00
|
|
|
const QByteArray &content,
|
2017-12-19 16:57:42 +00:00
|
|
|
std::unique_ptr<FileMediaInformation> information,
|
|
|
|
SendMediaType type,
|
|
|
|
const FileLoadTo &to,
|
2018-05-24 13:03:21 +00:00
|
|
|
const TextWithTags &caption,
|
2017-12-19 16:57:42 +00:00
|
|
|
std::shared_ptr<SendingAlbum> album)
|
|
|
|
: _id(rand_value<uint64>())
|
2015-10-27 02:39:02 +00:00
|
|
|
, _to(to)
|
2017-12-19 16:57:42 +00:00
|
|
|
, _album(std::move(album))
|
2015-10-27 02:39:02 +00:00
|
|
|
, _filepath(filepath)
|
|
|
|
, _content(content)
|
2017-12-21 16:15:37 +00:00
|
|
|
, _information(std::move(information))
|
2015-10-28 02:41:13 +00:00
|
|
|
, _type(type)
|
2016-11-28 15:45:07 +00:00
|
|
|
, _caption(caption) {
|
2015-10-27 02:39:02 +00:00
|
|
|
}
|
|
|
|
|
2017-12-19 16:57:42 +00:00
|
|
|
FileLoadTask::FileLoadTask(
|
|
|
|
const QByteArray &voice,
|
|
|
|
int32 duration,
|
|
|
|
const VoiceWaveform &waveform,
|
|
|
|
const FileLoadTo &to,
|
2018-05-24 13:03:21 +00:00
|
|
|
const TextWithTags &caption)
|
2017-12-19 16:57:42 +00:00
|
|
|
: _id(rand_value<uint64>())
|
2015-10-27 02:39:02 +00:00
|
|
|
, _to(to)
|
2016-02-12 16:35:06 +00:00
|
|
|
, _content(voice)
|
2015-10-27 02:39:02 +00:00
|
|
|
, _duration(duration)
|
2016-02-12 16:35:06 +00:00
|
|
|
, _waveform(waveform)
|
2016-11-28 15:45:07 +00:00
|
|
|
, _type(SendMediaType::Audio)
|
|
|
|
, _caption(caption) {
|
2015-10-27 02:39:02 +00:00
|
|
|
}
|
|
|
|
|
2017-12-19 16:57:42 +00:00
|
|
|
std::unique_ptr<FileMediaInformation> FileLoadTask::ReadMediaInformation(
|
|
|
|
const QString &filepath,
|
|
|
|
const QByteArray &content,
|
|
|
|
const QString &filemime) {
|
|
|
|
auto result = std::make_unique<FileMediaInformation>();
|
2017-03-10 14:14:10 +00:00
|
|
|
result->filemime = filemime;
|
|
|
|
|
|
|
|
if (CheckForSong(filepath, content, result)) {
|
|
|
|
return result;
|
|
|
|
} else if (CheckForVideo(filepath, content, result)) {
|
|
|
|
return result;
|
|
|
|
} else if (CheckForImage(filepath, content, result)) {
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename Mimes, typename Extensions>
|
2017-12-19 16:57:42 +00:00
|
|
|
bool FileLoadTask::CheckMimeOrExtensions(
|
|
|
|
const QString &filepath,
|
|
|
|
const QString &filemime,
|
|
|
|
Mimes &mimes,
|
|
|
|
Extensions &extensions) {
|
2017-03-10 14:14:10 +00:00
|
|
|
if (std::find(std::begin(mimes), std::end(mimes), filemime) != std::end(mimes)) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
if (std::find_if(std::begin(extensions), std::end(extensions), [&filepath](auto &extension) {
|
|
|
|
return filepath.endsWith(extension, Qt::CaseInsensitive);
|
|
|
|
}) != std::end(extensions)) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-12-19 16:57:42 +00:00
|
|
|
bool FileLoadTask::CheckForSong(
|
|
|
|
const QString &filepath,
|
|
|
|
const QByteArray &content,
|
|
|
|
std::unique_ptr<FileMediaInformation> &result) {
|
2017-03-10 14:14:10 +00:00
|
|
|
static const auto mimes = {
|
|
|
|
qstr("audio/mp3"),
|
|
|
|
qstr("audio/m4a"),
|
|
|
|
qstr("audio/aac"),
|
|
|
|
qstr("audio/ogg"),
|
|
|
|
qstr("audio/flac"),
|
|
|
|
};
|
|
|
|
static const auto extensions = {
|
|
|
|
qstr(".mp3"),
|
|
|
|
qstr(".m4a"),
|
|
|
|
qstr(".aac"),
|
|
|
|
qstr(".ogg"),
|
|
|
|
qstr(".flac"),
|
|
|
|
};
|
|
|
|
if (!CheckMimeOrExtensions(filepath, result->filemime, mimes, extensions)) {
|
|
|
|
return false;
|
|
|
|
}
|
2017-12-12 12:43:39 +00:00
|
|
|
|
2017-03-10 14:14:10 +00:00
|
|
|
auto media = Media::Player::PrepareForSending(filepath, content);
|
2017-03-27 12:50:40 +00:00
|
|
|
if (media.duration < 0) {
|
2017-03-10 14:14:10 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (!ValidateThumbDimensions(media.cover.width(), media.cover.height())) {
|
|
|
|
media.cover = QImage();
|
|
|
|
}
|
|
|
|
result->media = std::move(media);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2017-12-19 16:57:42 +00:00
|
|
|
bool FileLoadTask::CheckForVideo(
|
|
|
|
const QString &filepath,
|
|
|
|
const QByteArray &content,
|
|
|
|
std::unique_ptr<FileMediaInformation> &result) {
|
2017-03-10 14:14:10 +00:00
|
|
|
static const auto mimes = {
|
|
|
|
qstr("video/mp4"),
|
|
|
|
qstr("video/quicktime"),
|
|
|
|
};
|
|
|
|
static const auto extensions = {
|
|
|
|
qstr(".mp4"),
|
|
|
|
qstr(".mov"),
|
|
|
|
};
|
|
|
|
if (!CheckMimeOrExtensions(filepath, result->filemime, mimes, extensions)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto media = Media::Clip::PrepareForSending(filepath, content);
|
2017-03-27 12:50:40 +00:00
|
|
|
if (media.duration < 0) {
|
2017-03-10 14:14:10 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto coverWidth = media.thumbnail.width();
|
|
|
|
auto coverHeight = media.thumbnail.height();
|
|
|
|
if (!ValidateThumbDimensions(coverWidth, coverHeight)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (filepath.endsWith(qstr(".mp4"), Qt::CaseInsensitive)) {
|
|
|
|
result->filemime = qstr("video/mp4");
|
|
|
|
}
|
|
|
|
result->media = std::move(media);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2017-12-19 16:57:42 +00:00
|
|
|
bool FileLoadTask::CheckForImage(
|
|
|
|
const QString &filepath,
|
|
|
|
const QByteArray &content,
|
|
|
|
std::unique_ptr<FileMediaInformation> &result) {
|
2017-03-10 14:14:10 +00:00
|
|
|
auto animated = false;
|
|
|
|
auto image = ([&filepath, &content, &animated] {
|
|
|
|
if (!content.isEmpty()) {
|
|
|
|
return App::readImage(content, nullptr, false, &animated);
|
|
|
|
} else if (!filepath.isEmpty()) {
|
|
|
|
return App::readImage(filepath, nullptr, false, &animated);
|
|
|
|
}
|
|
|
|
return QImage();
|
|
|
|
})();
|
2017-12-21 16:15:37 +00:00
|
|
|
return FillImageInformation(std::move(image), animated, result);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool FileLoadTask::FillImageInformation(
|
|
|
|
QImage &&image,
|
|
|
|
bool animated,
|
|
|
|
std::unique_ptr<FileMediaInformation> &result) {
|
|
|
|
Expects(result != nullptr);
|
2017-03-10 14:14:10 +00:00
|
|
|
|
|
|
|
if (image.isNull()) {
|
|
|
|
return false;
|
|
|
|
}
|
2017-12-19 16:57:42 +00:00
|
|
|
auto media = FileMediaInformation::Image();
|
2017-03-10 14:14:10 +00:00
|
|
|
media.data = std::move(image);
|
|
|
|
media.animated = animated;
|
|
|
|
result->media = media;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-10-27 02:39:02 +00:00
|
|
|
void FileLoadTask::process() {
|
2017-03-10 15:45:22 +00:00
|
|
|
const auto stickerMime = qsl("image/webp");
|
2015-10-27 02:39:02 +00:00
|
|
|
|
2017-12-19 16:57:42 +00:00
|
|
|
_result = std::make_shared<FileLoadResult>(
|
|
|
|
id(),
|
|
|
|
_id,
|
|
|
|
_to,
|
|
|
|
_caption,
|
|
|
|
_album);
|
2015-10-27 02:39:02 +00:00
|
|
|
|
|
|
|
QString filename, filemime;
|
|
|
|
qint64 filesize = 0;
|
|
|
|
QByteArray filedata;
|
|
|
|
|
2017-03-10 14:14:10 +00:00
|
|
|
auto isAnimation = false;
|
|
|
|
auto isSong = false;
|
|
|
|
auto isVideo = false;
|
|
|
|
auto isVoice = (_type == SendMediaType::Audio);
|
2019-01-18 07:37:41 +00:00
|
|
|
auto isSticker = false;
|
2017-03-10 14:14:10 +00:00
|
|
|
|
2017-12-21 16:15:37 +00:00
|
|
|
auto fullimage = QImage();
|
2017-01-13 11:58:41 +00:00
|
|
|
auto info = _filepath.isEmpty() ? QFileInfo() : QFileInfo(_filepath);
|
|
|
|
if (info.exists()) {
|
2015-11-02 22:36:26 +00:00
|
|
|
if (info.isDir()) {
|
|
|
|
_result->filesize = -1;
|
|
|
|
return;
|
|
|
|
}
|
2017-03-10 14:14:10 +00:00
|
|
|
|
|
|
|
// Voice sending is supported only from memory for now.
|
|
|
|
// Because for voice we force mime type and don't read MediaInformation.
|
|
|
|
// For a real file we always read mime type and read MediaInformation.
|
2017-08-17 09:06:26 +00:00
|
|
|
Assert(!isVoice);
|
2017-03-10 14:14:10 +00:00
|
|
|
|
2015-10-27 02:39:02 +00:00
|
|
|
filesize = info.size();
|
|
|
|
filename = info.fileName();
|
2017-03-10 14:14:10 +00:00
|
|
|
if (!_information) {
|
2018-06-13 22:06:21 +00:00
|
|
|
_information = readMediaInformation(Core::MimeTypeForFile(info).name());
|
2017-03-10 14:14:10 +00:00
|
|
|
}
|
|
|
|
filemime = _information->filemime;
|
2017-12-19 16:57:42 +00:00
|
|
|
if (auto image = base::get_if<FileMediaInformation::Image>(
|
|
|
|
&_information->media)) {
|
2017-03-10 14:14:10 +00:00
|
|
|
fullimage = base::take(image->data);
|
|
|
|
if (auto opaque = (filemime != stickerMime)) {
|
|
|
|
fullimage = Images::prepareOpaque(std::move(fullimage));
|
|
|
|
}
|
|
|
|
isAnimation = image->animated;
|
|
|
|
}
|
2015-10-27 02:39:02 +00:00
|
|
|
} else if (!_content.isEmpty()) {
|
|
|
|
filesize = _content.size();
|
2017-03-10 14:14:10 +00:00
|
|
|
if (isVoice) {
|
2015-10-27 02:39:02 +00:00
|
|
|
filename = filedialogDefaultName(qsl("audio"), qsl(".ogg"), QString(), true);
|
|
|
|
filemime = "audio/ogg";
|
|
|
|
} else {
|
2017-12-21 16:15:37 +00:00
|
|
|
if (_information) {
|
|
|
|
if (auto image = base::get_if<FileMediaInformation::Image>(
|
|
|
|
&_information->media)) {
|
|
|
|
fullimage = base::take(image->data);
|
|
|
|
}
|
|
|
|
}
|
2018-06-13 22:06:21 +00:00
|
|
|
const auto mimeType = Core::MimeTypeForData(_content);
|
2016-02-12 16:35:06 +00:00
|
|
|
filemime = mimeType.name();
|
2016-11-28 15:45:07 +00:00
|
|
|
if (filemime != stickerMime) {
|
2017-02-21 13:45:56 +00:00
|
|
|
fullimage = Images::prepareOpaque(std::move(fullimage));
|
2016-02-12 16:35:06 +00:00
|
|
|
}
|
|
|
|
if (filemime == "image/jpeg") {
|
2016-11-28 15:45:07 +00:00
|
|
|
filename = filedialogDefaultName(qsl("photo"), qsl(".jpg"), QString(), true);
|
|
|
|
} else if (filemime == "image/png") {
|
|
|
|
filename = filedialogDefaultName(qsl("image"), qsl(".png"), QString(), true);
|
2016-02-12 16:35:06 +00:00
|
|
|
} else {
|
|
|
|
QString ext;
|
|
|
|
QStringList patterns = mimeType.globPatterns();
|
|
|
|
if (!patterns.isEmpty()) {
|
|
|
|
ext = patterns.front().replace('*', QString());
|
|
|
|
}
|
|
|
|
filename = filedialogDefaultName(qsl("file"), ext, QString(), true);
|
2015-10-27 02:39:02 +00:00
|
|
|
}
|
|
|
|
}
|
2017-03-18 09:44:31 +00:00
|
|
|
} else {
|
|
|
|
if (_information) {
|
2017-12-19 16:57:42 +00:00
|
|
|
if (auto image = base::get_if<FileMediaInformation::Image>(
|
|
|
|
&_information->media)) {
|
2017-03-18 09:44:31 +00:00
|
|
|
fullimage = base::take(image->data);
|
2016-12-13 17:07:56 +00:00
|
|
|
}
|
|
|
|
}
|
2017-03-18 09:44:31 +00:00
|
|
|
if (!fullimage.isNull() && fullimage.width() > 0) {
|
|
|
|
if (_type == SendMediaType::Photo) {
|
|
|
|
if (ValidateThumbDimensions(fullimage.width(), fullimage.height())) {
|
|
|
|
filesize = -1; // Fill later.
|
2018-06-13 22:06:21 +00:00
|
|
|
filemime = Core::MimeTypeForName("image/jpeg").name();
|
2017-03-18 09:44:31 +00:00
|
|
|
filename = filedialogDefaultName(qsl("image"), qsl(".jpg"), QString(), true);
|
|
|
|
} else {
|
|
|
|
_type = SendMediaType::File;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (_type == SendMediaType::File) {
|
2018-06-13 22:06:21 +00:00
|
|
|
filemime = Core::MimeTypeForName("image/png").name();
|
2017-03-18 09:44:31 +00:00
|
|
|
filename = filedialogDefaultName(qsl("image"), qsl(".png"), QString(), true);
|
|
|
|
{
|
|
|
|
QBuffer buffer(&_content);
|
|
|
|
fullimage.save(&buffer, "PNG");
|
|
|
|
}
|
|
|
|
filesize = _content.size();
|
2016-12-13 17:07:56 +00:00
|
|
|
}
|
2017-03-18 09:44:31 +00:00
|
|
|
fullimage = Images::prepareOpaque(std::move(fullimage));
|
2015-10-27 02:39:02 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
_result->filesize = (int32)qMin(filesize, qint64(INT_MAX));
|
|
|
|
|
2016-11-28 15:45:07 +00:00
|
|
|
if (!filesize || filesize > App::kFileSizeLimit) {
|
2015-10-27 02:39:02 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
PreparedPhotoThumbs photoThumbs;
|
|
|
|
QVector<MTPPhotoSize> photoSizes;
|
2019-01-18 07:37:41 +00:00
|
|
|
QImage goodThumbnail;
|
2018-10-25 08:47:06 +00:00
|
|
|
QByteArray goodThumbnailBytes;
|
2015-10-27 02:39:02 +00:00
|
|
|
|
|
|
|
QVector<MTPDocumentAttribute> attributes(1, MTP_documentAttributeFilename(MTP_string(filename)));
|
|
|
|
|
2019-01-18 07:37:41 +00:00
|
|
|
auto thumbnail = PreparedFileThumbnail();
|
|
|
|
|
2017-08-17 09:45:23 +00:00
|
|
|
auto photo = MTP_photoEmpty(MTP_long(0));
|
|
|
|
auto document = MTP_documentEmpty(MTP_long(0));
|
2015-10-27 02:39:02 +00:00
|
|
|
|
2017-03-10 14:14:10 +00:00
|
|
|
if (!isVoice) {
|
|
|
|
if (!_information) {
|
|
|
|
_information = readMediaInformation(filemime);
|
|
|
|
filemime = _information->filemime;
|
2015-10-27 02:39:02 +00:00
|
|
|
}
|
2017-12-19 16:57:42 +00:00
|
|
|
if (auto song = base::get_if<FileMediaInformation::Song>(
|
|
|
|
&_information->media)) {
|
2017-03-10 14:14:10 +00:00
|
|
|
isSong = true;
|
|
|
|
auto flags = MTPDdocumentAttributeAudio::Flag::f_title | MTPDdocumentAttributeAudio::Flag::f_performer;
|
|
|
|
attributes.push_back(MTP_documentAttributeAudio(MTP_flags(flags), MTP_int(song->duration), MTP_string(song->title), MTP_string(song->performer), MTPstring()));
|
2019-01-18 07:37:41 +00:00
|
|
|
thumbnail = PrepareFileThumbnail(std::move(song->cover));
|
2017-12-19 16:57:42 +00:00
|
|
|
} else if (auto video = base::get_if<FileMediaInformation::Video>(
|
|
|
|
&_information->media)) {
|
2017-03-10 14:14:10 +00:00
|
|
|
isVideo = true;
|
|
|
|
auto coverWidth = video->thumbnail.width();
|
|
|
|
auto coverHeight = video->thumbnail.height();
|
2017-12-25 11:13:27 +00:00
|
|
|
if (video->isGifv && !_album) {
|
2017-03-10 14:14:10 +00:00
|
|
|
attributes.push_back(MTP_documentAttributeAnimated());
|
|
|
|
}
|
2017-03-23 16:11:35 +00:00
|
|
|
auto flags = MTPDdocumentAttributeVideo::Flags(0);
|
2018-11-07 14:07:20 +00:00
|
|
|
if (video->supportsStreaming) {
|
|
|
|
flags |= MTPDdocumentAttributeVideo::Flag::f_supports_streaming;
|
|
|
|
}
|
2017-03-23 16:11:35 +00:00
|
|
|
attributes.push_back(MTP_documentAttributeVideo(MTP_flags(flags), MTP_int(video->duration), MTP_int(coverWidth), MTP_int(coverHeight)));
|
2017-03-10 14:14:10 +00:00
|
|
|
|
2018-10-25 08:47:06 +00:00
|
|
|
goodThumbnail = video->thumbnail;
|
|
|
|
{
|
|
|
|
QBuffer buffer(&goodThumbnailBytes);
|
|
|
|
goodThumbnail.save(&buffer, "JPG", kThumbnailQuality);
|
|
|
|
}
|
|
|
|
|
2019-01-18 07:37:41 +00:00
|
|
|
thumbnail = PrepareFileThumbnail(std::move(video->thumbnail));
|
2015-12-28 15:34:45 +00:00
|
|
|
}
|
2015-10-27 02:39:02 +00:00
|
|
|
}
|
|
|
|
|
2017-03-10 14:14:10 +00:00
|
|
|
if (!fullimage.isNull() && fullimage.width() > 0 && !isSong && !isVideo && !isVoice) {
|
2016-11-15 11:56:49 +00:00
|
|
|
auto w = fullimage.width(), h = fullimage.height();
|
2015-10-27 02:39:02 +00:00
|
|
|
attributes.push_back(MTP_documentAttributeImageSize(MTP_int(w), MTP_int(h)));
|
|
|
|
|
2017-03-09 09:47:45 +00:00
|
|
|
if (ValidateThumbDimensions(w, h)) {
|
2017-03-10 14:14:10 +00:00
|
|
|
if (isAnimation) {
|
2015-10-27 02:39:02 +00:00
|
|
|
attributes.push_back(MTP_documentAttributeAnimated());
|
2016-11-28 15:45:07 +00:00
|
|
|
} else if (_type != SendMediaType::File) {
|
2018-10-12 16:41:51 +00:00
|
|
|
auto thumb = (w > 100 || h > 100) ? fullimage.scaled(100, 100, Qt::KeepAspectRatio, Qt::SmoothTransformation) : fullimage;
|
2019-01-25 14:37:28 +00:00
|
|
|
photoThumbs.emplace('s', thumb);
|
2019-03-22 14:19:43 +00:00
|
|
|
photoSizes.push_back(MTP_photoSize(MTP_string("s"), MTP_fileLocationToBeDeprecated(MTP_long(0), MTP_int(0)), MTP_int(thumb.width()), MTP_int(thumb.height()), MTP_int(0)));
|
2015-10-27 02:39:02 +00:00
|
|
|
|
2018-10-12 16:41:51 +00:00
|
|
|
auto medium = (w > 320 || h > 320) ? fullimage.scaled(320, 320, Qt::KeepAspectRatio, Qt::SmoothTransformation) : fullimage;
|
2019-01-25 14:37:28 +00:00
|
|
|
photoThumbs.emplace('m', medium);
|
2019-03-22 14:19:43 +00:00
|
|
|
photoSizes.push_back(MTP_photoSize(MTP_string("m"), MTP_fileLocationToBeDeprecated(MTP_long(0), MTP_int(0)), MTP_int(medium.width()), MTP_int(medium.height()), MTP_int(0)));
|
2015-10-27 02:39:02 +00:00
|
|
|
|
2018-10-12 16:41:51 +00:00
|
|
|
auto full = (w > 1280 || h > 1280) ? fullimage.scaled(1280, 1280, Qt::KeepAspectRatio, Qt::SmoothTransformation) : fullimage;
|
2019-01-25 14:37:28 +00:00
|
|
|
photoThumbs.emplace('y', full);
|
2019-03-22 14:19:43 +00:00
|
|
|
photoSizes.push_back(MTP_photoSize(MTP_string("y"), MTP_fileLocationToBeDeprecated(MTP_long(0), MTP_int(0)), MTP_int(full.width()), MTP_int(full.height()), MTP_int(0)));
|
2015-10-27 02:39:02 +00:00
|
|
|
|
|
|
|
{
|
|
|
|
QBuffer buffer(&filedata);
|
2016-12-02 19:16:35 +00:00
|
|
|
full.save(&buffer, "JPG", 87);
|
2015-10-27 02:39:02 +00:00
|
|
|
}
|
|
|
|
|
2018-07-13 16:49:46 +00:00
|
|
|
photo = MTP_photo(
|
|
|
|
MTP_flags(0),
|
|
|
|
MTP_long(_id),
|
|
|
|
MTP_long(0),
|
|
|
|
MTP_bytes(QByteArray()),
|
|
|
|
MTP_int(unixtime()),
|
2019-03-22 14:19:43 +00:00
|
|
|
MTP_vector<MTPPhotoSize>(photoSizes),
|
|
|
|
MTP_int(MTP::maindc()));
|
2016-12-13 17:07:56 +00:00
|
|
|
|
|
|
|
if (filesize < 0) {
|
|
|
|
filesize = _result->filesize = filedata.size();
|
|
|
|
}
|
2015-10-27 02:39:02 +00:00
|
|
|
}
|
|
|
|
|
2019-01-18 07:37:41 +00:00
|
|
|
isSticker = !isAnimation
|
|
|
|
&& (filemime == stickerMime)
|
|
|
|
&& (w > 0)
|
|
|
|
&& (h > 0)
|
|
|
|
&& (w <= StickerMaxSize)
|
|
|
|
&& (h <= StickerMaxSize)
|
|
|
|
&& (filesize < Storage::kMaxStickerInMemory);
|
|
|
|
if (isSticker) {
|
|
|
|
attributes.push_back(MTP_documentAttributeSticker(
|
|
|
|
MTP_flags(0),
|
|
|
|
MTP_string(QString()),
|
|
|
|
MTP_inputStickerSetEmpty(),
|
|
|
|
MTPMaskCoords()));
|
2015-10-27 02:39:02 +00:00
|
|
|
}
|
2019-01-18 07:37:41 +00:00
|
|
|
thumbnail = PrepareFileThumbnail(std::move(fullimage));
|
2015-10-27 02:39:02 +00:00
|
|
|
}
|
|
|
|
}
|
2019-01-18 07:37:41 +00:00
|
|
|
thumbnail = FinalizeFileThumbnail(
|
|
|
|
std::move(thumbnail),
|
|
|
|
filemime,
|
|
|
|
filesize,
|
|
|
|
isSticker);
|
2015-10-27 02:39:02 +00:00
|
|
|
|
2017-08-17 09:45:23 +00:00
|
|
|
if (_type == SendMediaType::Photo && photo.type() == mtpc_photoEmpty) {
|
|
|
|
_type = SendMediaType::File;
|
|
|
|
}
|
|
|
|
|
2017-03-10 14:14:10 +00:00
|
|
|
if (isVoice) {
|
2017-03-25 15:42:01 +00:00
|
|
|
auto flags = MTPDdocumentAttributeAudio::Flag::f_voice | MTPDdocumentAttributeAudio::Flag::f_waveform;
|
|
|
|
attributes[0] = MTP_documentAttributeAudio(MTP_flags(flags), MTP_int(_duration), MTPstring(), MTPstring(), MTP_bytes(documentWaveformEncode5bit(_waveform)));
|
2016-02-12 16:35:06 +00:00
|
|
|
attributes.resize(1);
|
2018-07-13 16:49:46 +00:00
|
|
|
document = MTP_document(
|
2019-01-03 14:39:19 +00:00
|
|
|
MTP_flags(0),
|
2018-07-13 16:49:46 +00:00
|
|
|
MTP_long(_id),
|
|
|
|
MTP_long(0),
|
|
|
|
MTP_bytes(QByteArray()),
|
|
|
|
MTP_int(unixtime()),
|
|
|
|
MTP_string(filemime),
|
|
|
|
MTP_int(filesize),
|
2019-01-18 07:37:41 +00:00
|
|
|
MTP_vector<MTPPhotoSize>(1, thumbnail.mtpSize),
|
2018-07-13 16:49:46 +00:00
|
|
|
MTP_int(MTP::maindc()),
|
|
|
|
MTP_vector<MTPDocumentAttribute>(attributes));
|
2016-12-13 17:07:56 +00:00
|
|
|
} else if (_type != SendMediaType::Photo) {
|
2018-07-13 16:49:46 +00:00
|
|
|
document = MTP_document(
|
2019-01-03 14:39:19 +00:00
|
|
|
MTP_flags(0),
|
2018-07-13 16:49:46 +00:00
|
|
|
MTP_long(_id),
|
|
|
|
MTP_long(0),
|
|
|
|
MTP_bytes(QByteArray()),
|
|
|
|
MTP_int(unixtime()),
|
|
|
|
MTP_string(filemime),
|
|
|
|
MTP_int(filesize),
|
2019-01-18 07:37:41 +00:00
|
|
|
MTP_vector<MTPPhotoSize>(1, thumbnail.mtpSize),
|
2018-07-13 16:49:46 +00:00
|
|
|
MTP_int(MTP::maindc()),
|
|
|
|
MTP_vector<MTPDocumentAttribute>(attributes));
|
2016-12-13 17:07:56 +00:00
|
|
|
_type = SendMediaType::File;
|
2015-10-27 02:39:02 +00:00
|
|
|
}
|
2016-01-05 04:28:06 +00:00
|
|
|
|
2015-10-27 02:39:02 +00:00
|
|
|
_result->type = _type;
|
|
|
|
_result->filepath = _filepath;
|
|
|
|
_result->content = _content;
|
|
|
|
|
|
|
|
_result->filename = filename;
|
2015-12-19 14:37:28 +00:00
|
|
|
_result->filemime = filemime;
|
2015-10-27 02:39:02 +00:00
|
|
|
_result->setFileData(filedata);
|
|
|
|
|
2019-01-18 07:37:41 +00:00
|
|
|
_result->thumbId = thumbnail.id;
|
|
|
|
_result->thumbname = thumbnail.name;
|
|
|
|
_result->setThumbData(thumbnail.bytes);
|
|
|
|
_result->thumb = std::move(thumbnail.image);
|
2015-10-27 02:39:02 +00:00
|
|
|
|
2018-10-25 08:47:06 +00:00
|
|
|
_result->goodThumbnail = std::move(goodThumbnail);
|
|
|
|
_result->goodThumbnailBytes = std::move(goodThumbnailBytes);
|
|
|
|
|
2015-10-27 02:39:02 +00:00
|
|
|
_result->photo = photo;
|
|
|
|
_result->document = document;
|
|
|
|
_result->photoThumbs = photoThumbs;
|
|
|
|
}
|
|
|
|
|
|
|
|
void FileLoadTask::finish() {
|
2017-09-28 20:11:10 +00:00
|
|
|
if (!_result || !_result->filesize || _result->filesize < 0) {
|
2017-09-15 17:34:41 +00:00
|
|
|
Ui::show(
|
|
|
|
Box<InformBox>(lng_send_image_empty(lt_name, _filepath)),
|
|
|
|
LayerOption::KeepOther);
|
2017-12-19 16:57:42 +00:00
|
|
|
removeFromAlbum();
|
2016-11-28 15:45:07 +00:00
|
|
|
} else if (_result->filesize > App::kFileSizeLimit) {
|
2017-09-15 17:34:41 +00:00
|
|
|
Ui::show(
|
|
|
|
Box<InformBox>(
|
|
|
|
lng_send_image_too_large(lt_name, _filepath)),
|
|
|
|
LayerOption::KeepOther);
|
2017-12-19 16:57:42 +00:00
|
|
|
removeFromAlbum();
|
2016-11-28 15:45:07 +00:00
|
|
|
} else if (App::main()) {
|
|
|
|
App::main()->onSendFileConfirm(_result);
|
2015-10-27 02:39:02 +00:00
|
|
|
}
|
|
|
|
}
|
2017-12-19 16:57:42 +00:00
|
|
|
|
|
|
|
void FileLoadTask::removeFromAlbum() {
|
|
|
|
if (!_album) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
const auto proj = [](const SendingAlbum::Item &item) {
|
|
|
|
return item.taskId;
|
|
|
|
};
|
|
|
|
const auto it = ranges::find(_album->items, id(), proj);
|
|
|
|
Assert(it != _album->items.end());
|
|
|
|
|
|
|
|
_album->items.erase(it);
|
|
|
|
}
|