2018-06-26 14:09:39 +02:00
|
|
|
#include "messages/Image.hpp"
|
2018-04-27 22:11:19 +02:00
|
|
|
|
2018-06-26 14:09:39 +02:00
|
|
|
#include "Application.hpp"
|
2018-07-15 14:11:46 +02:00
|
|
|
#include "common/NetworkRequest.hpp"
|
2018-08-02 14:23:27 +02:00
|
|
|
#include "debug/AssertInGuiThread.hpp"
|
2018-06-26 14:09:39 +02:00
|
|
|
#include "debug/Log.hpp"
|
2018-06-28 19:46:45 +02:00
|
|
|
#include "singletons/Emotes.hpp"
|
2018-06-26 14:09:39 +02:00
|
|
|
#include "singletons/WindowManager.hpp"
|
|
|
|
#include "util/PostToThread.hpp"
|
2017-01-11 18:52:09 +01:00
|
|
|
|
2017-02-06 17:42:28 +01:00
|
|
|
#include <QBuffer>
|
|
|
|
#include <QImageReader>
|
2017-01-11 18:52:09 +01:00
|
|
|
#include <QNetworkAccessManager>
|
|
|
|
#include <QNetworkReply>
|
|
|
|
#include <QNetworkRequest>
|
2017-02-06 17:42:28 +01:00
|
|
|
#include <QTimer>
|
2017-06-06 21:18:05 +02:00
|
|
|
|
2017-01-11 18:52:09 +01:00
|
|
|
#include <functional>
|
2017-10-27 20:09:02 +02:00
|
|
|
#include <thread>
|
2017-01-11 18:52:09 +01:00
|
|
|
|
2017-01-18 21:30:23 +01:00
|
|
|
namespace chatterino {
|
2018-08-06 18:25:47 +02:00
|
|
|
namespace {
|
2018-08-06 20:00:04 +02:00
|
|
|
const QPixmap *getPixmap(const Pixmap &pixmap)
|
2018-08-06 18:25:47 +02:00
|
|
|
{
|
2018-08-06 20:00:04 +02:00
|
|
|
if (pixmap.which() == 0)
|
|
|
|
return boost::get<const QPixmap *>(pixmap);
|
|
|
|
else
|
|
|
|
return boost::get<std::unique_ptr<QPixmap>>(pixmap).get();
|
2018-08-06 18:25:47 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Frames
|
|
|
|
Frames::Frames()
|
|
|
|
{
|
|
|
|
DebugCount::increase("images");
|
|
|
|
}
|
|
|
|
|
|
|
|
Frames::Frames(std::vector<Frame> &&frames)
|
|
|
|
: items_(std::move(frames))
|
|
|
|
{
|
|
|
|
DebugCount::increase("images");
|
|
|
|
if (this->animated()) DebugCount::increase("animated images");
|
|
|
|
}
|
|
|
|
|
|
|
|
Frames::~Frames()
|
|
|
|
{
|
|
|
|
DebugCount::decrease("images");
|
|
|
|
if (this->animated()) DebugCount::decrease("animated images");
|
|
|
|
}
|
|
|
|
|
|
|
|
void Frames::advance()
|
|
|
|
{
|
2018-08-06 20:00:04 +02:00
|
|
|
this->durationOffset_ += GIF_FRAME_LENGTH;
|
2018-08-06 18:25:47 +02:00
|
|
|
|
|
|
|
while (true) {
|
|
|
|
this->index_ %= this->items_.size();
|
2018-08-06 20:00:04 +02:00
|
|
|
if (this->durationOffset_ > this->items_[this->index_].duration) {
|
|
|
|
this->durationOffset_ -= this->items_[this->index_].duration;
|
2018-08-06 18:25:47 +02:00
|
|
|
this->index_ = (this->index_ + 1) % this->items_.size();
|
|
|
|
} else {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Frames::animated() const
|
|
|
|
{
|
|
|
|
return this->items_.size() > 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
const QPixmap *Frames::current() const
|
|
|
|
{
|
|
|
|
if (this->items_.size() == 0) return nullptr;
|
2018-08-06 20:00:04 +02:00
|
|
|
return getPixmap(this->items_[this->index_].pixmap);
|
2018-08-06 18:25:47 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
const QPixmap *Frames::first() const
|
|
|
|
{
|
|
|
|
if (this->items_.size() == 0) return nullptr;
|
2018-08-06 20:00:04 +02:00
|
|
|
return getPixmap(this->items_.front().pixmap);
|
2018-08-06 18:25:47 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// functions
|
|
|
|
std::vector<Frame> readFrames(QImageReader &reader, const Url &url)
|
|
|
|
{
|
|
|
|
std::vector<Frame> frames;
|
|
|
|
|
|
|
|
if (reader.imageCount() <= 0) {
|
2018-08-06 21:17:03 +02:00
|
|
|
Log("Error while reading image {}: '{}'", url.string,
|
|
|
|
reader.errorString());
|
2018-08-06 18:25:47 +02:00
|
|
|
return frames;
|
|
|
|
}
|
|
|
|
|
|
|
|
QImage image;
|
|
|
|
for (int index = 0; index < reader.imageCount(); ++index) {
|
|
|
|
if (reader.read(&image)) {
|
|
|
|
auto pixmap = std::make_unique<QPixmap>(QPixmap::fromImage(image));
|
|
|
|
|
|
|
|
int duration = std::max(20, reader.nextImageDelay());
|
2018-08-06 20:00:04 +02:00
|
|
|
frames.push_back(Frame{std::move(pixmap), duration});
|
2018-08-06 18:25:47 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (frames.size() != 0) {
|
2018-08-06 21:17:03 +02:00
|
|
|
Log("Error while reading image {}: '{}'", url.string,
|
|
|
|
reader.errorString());
|
2018-08-06 18:25:47 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return frames;
|
|
|
|
}
|
|
|
|
|
|
|
|
void queueLoadedEvent()
|
|
|
|
{
|
|
|
|
static auto eventQueued = false;
|
|
|
|
|
|
|
|
if (!eventQueued) {
|
|
|
|
eventQueued = true;
|
|
|
|
|
|
|
|
QTimer::singleShot(250, [] {
|
|
|
|
getApp()->windows->incGeneration();
|
|
|
|
getApp()->windows->layoutChannelViews();
|
|
|
|
eventQueued = false;
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} // namespace
|
2017-01-18 21:30:23 +01:00
|
|
|
|
2018-08-02 14:23:27 +02:00
|
|
|
// IMAGE2
|
|
|
|
std::atomic<bool> Image::loadedEventQueued{false};
|
2018-04-18 17:03:37 +02:00
|
|
|
|
2018-08-02 14:23:27 +02:00
|
|
|
ImagePtr Image::fromUrl(const Url &url, qreal scale)
|
2017-01-05 16:07:20 +01:00
|
|
|
{
|
2018-08-02 14:23:27 +02:00
|
|
|
static std::unordered_map<Url, std::weak_ptr<Image>> cache;
|
|
|
|
static std::mutex mutex;
|
|
|
|
|
|
|
|
std::lock_guard<std::mutex> lock(mutex);
|
|
|
|
|
|
|
|
auto shared = cache[url].lock();
|
|
|
|
|
|
|
|
if (!shared) {
|
|
|
|
cache[url] = shared = ImagePtr(new Image(url, scale));
|
|
|
|
} else {
|
|
|
|
Warn("same image loaded multiple times: {}", url.string);
|
|
|
|
}
|
|
|
|
|
|
|
|
return shared;
|
2017-01-05 16:07:20 +01:00
|
|
|
}
|
|
|
|
|
2018-08-02 14:23:27 +02:00
|
|
|
ImagePtr Image::fromOwningPixmap(std::unique_ptr<QPixmap> pixmap, qreal scale)
|
2017-01-11 18:52:09 +01:00
|
|
|
{
|
2018-08-02 14:23:27 +02:00
|
|
|
return ImagePtr(new Image(std::move(pixmap), scale));
|
2018-04-06 16:37:30 +02:00
|
|
|
}
|
|
|
|
|
2018-08-02 14:23:27 +02:00
|
|
|
ImagePtr Image::fromNonOwningPixmap(QPixmap *pixmap, qreal scale)
|
2018-04-06 16:37:30 +02:00
|
|
|
{
|
2018-08-02 14:23:27 +02:00
|
|
|
return ImagePtr(new Image(pixmap, scale));
|
|
|
|
}
|
2018-04-06 16:37:30 +02:00
|
|
|
|
2018-08-02 14:23:27 +02:00
|
|
|
ImagePtr Image::getEmpty()
|
|
|
|
{
|
|
|
|
static auto empty = ImagePtr(new Image);
|
|
|
|
return empty;
|
|
|
|
}
|
2018-04-06 16:37:30 +02:00
|
|
|
|
2018-08-02 14:23:27 +02:00
|
|
|
Image::Image()
|
2018-08-06 18:25:47 +02:00
|
|
|
: empty_(true)
|
2018-08-02 14:23:27 +02:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
Image::Image(const Url &url, qreal scale)
|
2018-08-06 18:25:47 +02:00
|
|
|
: url_(url)
|
|
|
|
, scale_(scale)
|
|
|
|
, shouldLoad_(true)
|
2018-08-02 14:23:27 +02:00
|
|
|
{
|
2017-01-11 18:52:09 +01:00
|
|
|
}
|
|
|
|
|
2018-08-02 14:23:27 +02:00
|
|
|
Image::Image(std::unique_ptr<QPixmap> owning, qreal scale)
|
2018-08-06 18:25:47 +02:00
|
|
|
: scale_(scale)
|
2017-01-04 15:12:31 +01:00
|
|
|
{
|
2018-08-06 18:25:47 +02:00
|
|
|
std::vector<Frame> vec;
|
2018-08-06 20:00:04 +02:00
|
|
|
vec.push_back(Frame{std::move(owning)});
|
2018-08-06 18:25:47 +02:00
|
|
|
this->frames_ = std::move(vec);
|
2018-08-02 14:23:27 +02:00
|
|
|
}
|
2017-10-27 20:09:02 +02:00
|
|
|
|
2018-08-02 14:23:27 +02:00
|
|
|
Image::Image(QPixmap *nonOwning, qreal scale)
|
2018-08-06 18:25:47 +02:00
|
|
|
: scale_(scale)
|
2018-08-02 14:23:27 +02:00
|
|
|
{
|
2018-08-06 18:25:47 +02:00
|
|
|
std::vector<Frame> vec;
|
2018-08-06 20:00:04 +02:00
|
|
|
vec.push_back(Frame{nonOwning});
|
2018-08-06 18:25:47 +02:00
|
|
|
this->frames_ = std::move(vec);
|
2018-08-02 14:23:27 +02:00
|
|
|
}
|
2017-10-27 20:09:02 +02:00
|
|
|
|
2018-08-06 18:25:47 +02:00
|
|
|
const Url &Image::url() const
|
2018-08-02 14:23:27 +02:00
|
|
|
{
|
|
|
|
return this->url_;
|
|
|
|
}
|
2017-10-27 20:09:02 +02:00
|
|
|
|
2018-08-06 18:25:47 +02:00
|
|
|
const QPixmap *Image::pixmap() const
|
2018-08-02 14:23:27 +02:00
|
|
|
{
|
|
|
|
assertInGuiThread();
|
2018-04-06 17:46:12 +02:00
|
|
|
|
2018-08-06 18:25:47 +02:00
|
|
|
if (this->shouldLoad_) {
|
|
|
|
const_cast<Image *>(this)->shouldLoad_ = false;
|
2018-08-02 14:23:27 +02:00
|
|
|
const_cast<Image *>(this)->load();
|
|
|
|
}
|
2018-04-16 23:48:30 +02:00
|
|
|
|
2018-08-06 18:25:47 +02:00
|
|
|
return this->frames_.current();
|
2018-08-02 14:23:27 +02:00
|
|
|
}
|
2018-04-16 23:48:30 +02:00
|
|
|
|
2018-08-06 18:25:47 +02:00
|
|
|
qreal Image::scale() const
|
2018-08-02 14:23:27 +02:00
|
|
|
{
|
|
|
|
return this->scale_;
|
|
|
|
}
|
2017-10-27 20:09:02 +02:00
|
|
|
|
2018-08-06 18:25:47 +02:00
|
|
|
bool Image::empty() const
|
2018-08-02 14:23:27 +02:00
|
|
|
{
|
2018-08-06 18:25:47 +02:00
|
|
|
return this->empty_;
|
2018-08-02 14:23:27 +02:00
|
|
|
}
|
2017-10-27 20:09:02 +02:00
|
|
|
|
2018-08-06 18:25:47 +02:00
|
|
|
bool Image::animated() const
|
2018-08-02 14:23:27 +02:00
|
|
|
{
|
2018-08-06 18:25:47 +02:00
|
|
|
assertInGuiThread();
|
2017-10-27 20:09:02 +02:00
|
|
|
|
2018-08-06 18:25:47 +02:00
|
|
|
return this->frames_.animated();
|
2018-08-02 14:23:27 +02:00
|
|
|
}
|
2017-10-27 20:09:02 +02:00
|
|
|
|
2018-08-06 18:25:47 +02:00
|
|
|
int Image::width() const
|
2018-08-02 14:23:27 +02:00
|
|
|
{
|
2018-08-06 18:25:47 +02:00
|
|
|
assertInGuiThread();
|
2018-04-16 23:48:30 +02:00
|
|
|
|
2018-08-06 18:25:47 +02:00
|
|
|
if (auto pixmap = this->frames_.first())
|
|
|
|
return pixmap->width() * this->scale_;
|
|
|
|
else
|
|
|
|
return 16;
|
2018-08-02 14:23:27 +02:00
|
|
|
}
|
2018-04-18 17:20:33 +02:00
|
|
|
|
2018-08-06 18:25:47 +02:00
|
|
|
int Image::height() const
|
2018-08-02 14:23:27 +02:00
|
|
|
{
|
2018-08-06 18:25:47 +02:00
|
|
|
assertInGuiThread();
|
2017-10-27 20:09:02 +02:00
|
|
|
|
2018-08-06 18:25:47 +02:00
|
|
|
if (auto pixmap = this->frames_.first())
|
|
|
|
return pixmap->height() * this->scale_;
|
|
|
|
else
|
|
|
|
return 16;
|
2018-08-02 14:23:27 +02:00
|
|
|
}
|
2018-01-19 22:45:33 +01:00
|
|
|
|
2018-08-02 14:23:27 +02:00
|
|
|
void Image::load()
|
|
|
|
{
|
2018-08-06 18:25:47 +02:00
|
|
|
NetworkRequest req(this->url().string);
|
2018-08-02 14:23:27 +02:00
|
|
|
req.setCaller(&this->object_);
|
|
|
|
req.setUseQuickLoadCache(true);
|
|
|
|
req.onSuccess([this, weak = weakOf(this)](auto result) -> Outcome {
|
2018-08-06 18:25:47 +02:00
|
|
|
assertInGuiThread();
|
|
|
|
|
2018-08-02 14:23:27 +02:00
|
|
|
auto shared = weak.lock();
|
|
|
|
if (!shared) return Failure;
|
2018-04-18 17:10:17 +02:00
|
|
|
|
2018-08-06 18:25:47 +02:00
|
|
|
// const cast since we are only reading from it
|
|
|
|
QBuffer buffer(const_cast<QByteArray *>(&result.getData()));
|
|
|
|
buffer.open(QIODevice::ReadOnly);
|
|
|
|
QImageReader reader(&buffer);
|
2018-08-02 14:23:27 +02:00
|
|
|
|
2018-08-06 18:25:47 +02:00
|
|
|
this->frames_ = readFrames(reader, this->url());
|
2018-08-02 14:23:27 +02:00
|
|
|
return Success;
|
2018-08-06 18:25:47 +02:00
|
|
|
});
|
|
|
|
req.onError([this, weak = weakOf(this)](int) {
|
|
|
|
auto shared = weak.lock();
|
|
|
|
if (!shared) return false;
|
2018-08-02 14:23:27 +02:00
|
|
|
|
2018-08-06 18:25:47 +02:00
|
|
|
this->frames_ = std::vector<Frame>();
|
2017-09-12 19:06:16 +02:00
|
|
|
|
2018-08-06 18:25:47 +02:00
|
|
|
return false;
|
|
|
|
});
|
2018-08-02 14:23:27 +02:00
|
|
|
|
2018-08-06 18:25:47 +02:00
|
|
|
req.execute();
|
2017-09-12 19:06:16 +02:00
|
|
|
}
|
|
|
|
|
2018-08-02 14:23:27 +02:00
|
|
|
bool Image::operator==(const Image &other) const
|
2017-09-12 19:06:16 +02:00
|
|
|
{
|
2018-08-06 18:25:47 +02:00
|
|
|
if (this->empty() && other.empty()) return true;
|
|
|
|
if (!this->url_.string.isEmpty() && this->url_ == other.url_) return true;
|
|
|
|
if (this->frames_.first() == other.frames_.first()) return true;
|
2018-01-19 22:45:33 +01:00
|
|
|
|
2018-08-02 14:23:27 +02:00
|
|
|
return false;
|
2017-09-12 19:06:16 +02:00
|
|
|
}
|
|
|
|
|
2018-08-02 14:23:27 +02:00
|
|
|
bool Image::operator!=(const Image &other) const
|
2017-09-12 19:06:16 +02:00
|
|
|
{
|
2018-08-02 14:23:27 +02:00
|
|
|
return !this->operator==(other);
|
2017-09-12 19:06:16 +02:00
|
|
|
}
|
|
|
|
|
2017-04-14 17:52:22 +02:00
|
|
|
} // namespace chatterino
|