#include "messages/Image.hpp" #include "Application.hpp" #include "common/NetworkRequest.hpp" #include "debug/AssertInGuiThread.hpp" #include "debug/Benchmark.hpp" #include "debug/Log.hpp" #include "singletons/Emotes.hpp" #include "singletons/WindowManager.hpp" #include "util/DebugCount.hpp" #include "util/PostToThread.hpp" #include #include #include #include #include #include #include #include namespace chatterino { namespace { // Frames Frames::Frames() { DebugCount::increase("images"); } Frames::Frames(const QVector> &frames) : items_(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() { this->durationOffset_ += GIF_FRAME_LENGTH; while (true) { this->index_ %= this->items_.size(); if (this->durationOffset_ > this->items_[this->index_].duration) { this->durationOffset_ -= this->items_[this->index_].duration; this->index_ = (this->index_ + 1) % this->items_.size(); } else { break; } } } bool Frames::animated() const { return this->items_.size() > 1; } boost::optional Frames::current() const { if (this->items_.size() == 0) return boost::none; return this->items_[this->index_].image; } boost::optional Frames::first() const { if (this->items_.size() == 0) return boost::none; return this->items_.front().image; } // functions QVector> readFrames(QImageReader &reader, const Url &url) { QVector> frames; if (reader.imageCount() == 0) { log("Error while reading image {}: '{}'", url.string, reader.errorString()); return frames; } QImage image; for (int index = 0; index < reader.imageCount(); ++index) { if (reader.read(&image)) { QPixmap::fromImage(image); int duration = std::max(20, reader.nextImageDelay()); frames.push_back(Frame{image, duration}); } } if (frames.size() == 0) { log("Error while reading image {}: '{}'", url.string, reader.errorString()); } return frames; } // parsed template void assignDelayed( std::queue>>> &queued, std::mutex &mutex, std::atomic_bool &loadedEventQueued) { std::lock_guard lock(mutex); int i = 0; while (!queued.empty()) { queued.front().first(queued.front().second); queued.pop(); if (++i > 50) { QTimer::singleShot( 3, [&] { assignDelayed(queued, mutex, loadedEventQueued); }); return; } } getApp()->windows->forceLayoutChannelViews(); loadedEventQueued = false; } template auto makeConvertCallback(const QVector> &parsed, Assign assign) { return [parsed, assign] { // convert to pixmap auto frames = QVector>(); std::transform(parsed.begin(), parsed.end(), std::back_inserter(frames), [](auto &frame) { return Frame{ QPixmap::fromImage(frame.image), frame.duration}; }); // put into stack static std::queue>>> queued; static std::mutex mutex; std::lock_guard lock(mutex); queued.emplace(assign, frames); static std::atomic_bool loadedEventQueued{false}; if (!loadedEventQueued) { loadedEventQueued = true; QTimer::singleShot( 100, [=] { assignDelayed(queued, mutex, loadedEventQueued); }); } }; } } // namespace // IMAGE2 ImagePtr Image::fromUrl(const Url &url, qreal scale) { static std::unordered_map> cache; static std::mutex mutex; std::lock_guard 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; } ImagePtr Image::fromPixmap(const QPixmap &pixmap, qreal scale) { return ImagePtr(new Image(pixmap, scale)); } ImagePtr Image::getEmpty() { static auto empty = ImagePtr(new Image); return empty; } Image::Image() : empty_(true) { } Image::Image(const Url &url, qreal scale) : url_(url) , scale_(scale) , shouldLoad_(true) { } Image::Image(const QPixmap &pixmap, qreal scale) : scale_(scale) , frames_(QVector>{Frame{pixmap, 1}}) { } const Url &Image::url() const { return this->url_; } boost::optional Image::pixmap() const { assertInGuiThread(); if (this->shouldLoad_) { const_cast(this)->shouldLoad_ = false; const_cast(this)->load(); } return this->frames_.current(); } qreal Image::scale() const { return this->scale_; } bool Image::isEmpty() const { return this->empty_; } bool Image::animated() const { assertInGuiThread(); return this->frames_.animated(); } int Image::width() const { assertInGuiThread(); if (auto pixmap = this->frames_.first()) return pixmap->width() * this->scale_; else return 16; } int Image::height() const { assertInGuiThread(); if (auto pixmap = this->frames_.first()) return pixmap->height() * this->scale_; else return 16; } void Image::load() { NetworkRequest req(this->url().string); req.setExecuteConcurrently(true); req.setCaller(&this->object_); req.setUseQuickLoadCache(true); req.onSuccess([that = this, weak = weakOf(this)](auto result) -> Outcome { auto shared = weak.lock(); if (!shared) return Failure; auto data = result.getData(); // const cast since we are only reading from it QBuffer buffer(const_cast(&data)); buffer.open(QIODevice::ReadOnly); QImageReader reader(&buffer); auto parsed = readFrames(reader, that->url()); postToThread(makeConvertCallback(parsed, [weak](auto frames) { if (auto shared = weak.lock()) shared->frames_ = frames; })); return Success; }); req.execute(); } bool Image::operator==(const Image &other) const { if (this->isEmpty() && other.isEmpty()) return true; if (!this->url_.string.isEmpty() && this->url_ == other.url_) return true; if (this->frames_.first() == other.frames_.first()) return true; return false; } bool Image::operator!=(const Image &other) const { return !this->operator==(other); } } // namespace chatterino