Support for GIF emojis

Author: Desdaemon

CMakeLists.txt

@@ -241,6 +241,8 @@ add_library(${PROJECT_NAME} OBJECT
 	src/image_xyz.h
 	src/image_webp.cpp
 	src/image_webp.h
+	src/image_gif.cpp
+	src/image_gif.h
 	src/input_buttons_desktop.cpp
 	src/input_buttons.h
 	src/input.cpp

CMakePresets.json

@@ -0,0 +1,109 @@
+#include "image_gif.h"
+#include <gif_lib.h>
+#include "output.h"
+
+static int read_data(GifFileType* gifFile, GifByteType* buffer, int size) {
+    auto* bufp = reinterpret_cast<Filesystem_Stream::InputStream*>(gifFile->UserData);
+    if (bufp && *bufp) {
+        bufp->read(reinterpret_cast<char*>(buffer), size);
+        if (bufp->fail()) return 0; // Read failed
+        return size; // Return number of bytes read
+    }
+    return 0; // No data available
+}
+
+ImageGif::Decoder::Decoder(Filesystem_Stream::InputStream& is) noexcept : ImageGif::Decoder() {
+	int error = D_GIF_SUCCEEDED;
+    gifFile = DGifOpen(&is, read_data, &error);
+
+    if (!gifFile || error != D_GIF_SUCCEEDED) {
+        Output::Warning("ImageGif: Failed to open GIF file: {} ({})", is.GetName(), GifErrorString(error));
+        return;
+    }
+
+    if (DGifSlurp(gifFile) != GIF_OK) {
+        Output::Warning("ImageGif: Failed to read GIF data: {} ({})", is.GetName());
+        return;
+    }
+
+    currentFrame = 0;
+}
+
+ImageGif::Decoder::~Decoder() noexcept {
+	if (gifFile) DGifCloseFile(gifFile, nullptr);
+}
+
+bool ImageGif::Decoder::ReadNext(ImageOut& output, GifTimingInfo& timing) {
+    memset(&output, 0, sizeof(ImageOut));
+    memset(&timing, 0, sizeof(GifTimingInfo));
+
+    if (!gifFile || currentFrame >= gifFile->ImageCount) {
+        output.pixels = nullptr;
+        return false;
+    }
+
+    const SavedImage* frame = &gifFile->SavedImages[currentFrame];
+    const GifImageDesc& image = frame->ImageDesc;
+
+    ColorMapObject* colorMap = image.ColorMap ? image.ColorMap : gifFile->SColorMap;
+    if (!colorMap) {
+        Output::Warning("ImageGif: No color map found for frame {}", currentFrame);
+        output.pixels = nullptr;
+        return false;
+    }
+
+    output.width = image.Width;
+    output.height = image.Height;
+	output.bpp = 32;
+    output.pixels = new uint32_t[image.Width * image.Height];
+
+    const int left = image.Left;
+    const int top = image.Top;
+    const int width = image.Width;
+    const int height = image.Height;
+    const int bg = gifFile->SBackGroundColor;
+
+    const GifPixelType* src = frame->RasterBits;
+    // const GifPixelType* srcPrev = currentFrame > 0 ? gifFile->SavedImages[currentFrame - 1].RasterBits : nullptr;
+
+    int transparentIndex = -1;
+    int disposalMethod = 0;
+
+    for (int i = 0; i < frame->ExtensionBlockCount; ++i) {
+        if (frame->ExtensionBlocks[i].Function == GRAPHICS_EXT_FUNC_CODE) {
+            uint8_t fields = frame->ExtensionBlocks[i].Bytes[0];
+            disposalMethod = (fields & 0x1C) >> 2; // 3 bits for disposal method
+            bool transparency = (fields & 0x01) != 0; // 1 bit for transparency
+            if (transparency) {
+                transparentIndex = frame->ExtensionBlocks[i].Bytes[3]; // Transparency index
+            }
+            timing.delay = ((int)frame->ExtensionBlocks[i].Bytes[1] | ((int)frame->ExtensionBlocks[i].Bytes[2] << 8)) * 10; // Convert to milliseconds
+            break;
+        }
+    }
+
+    size_t srcIndex = 0;
+    for (int y = 0; y < height; ++y) {
+        for (int x = 0; x < width; ++x) {
+            GifPixelType index = src[srcIndex++];
+            if (index == transparentIndex) {
+                ((uint32_t*)output.pixels)[(top + y) * output.width + (left + x)] = 0; // Transparent pixel
+                continue;
+            }
+            // if (disposalMethod == 2)
+            //     ((uint32_t*)output.pixels)[(top + y) * output.width + (left + x)] = bg;
+            if (index < colorMap->ColorCount) {
+                const GifColorType& color = colorMap->Colors[index];
+                int dstX = left + x;
+                int dstY = top + y;
+                if (dstX < output.width && dstY < output.height) {
+                    ((uint32_t*)output.pixels)[dstY * output.width + dstX] =
+                        color.Red | (color.Green << 8) | (color.Blue << 16) | 0xFF000000;
+                }
+            }
+        }
+    }
+
+    currentFrame++;
+    return true;
+}

src/image_gif.cpp

@@ -0,0 +1,48 @@
+/*
+ * This file is part of EasyRPG Player.
+ *
+ * EasyRPG Player is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * EasyRPG Player is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with EasyRPG Player. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef EP_IMAGE_GIF_H
+#define EP_IMAGE_GIF_H
+
+#include <cstdint>
+#include <optional>
+#include "bitmap.h"
+#include "filesystem_stream.h"
+#include <gif_lib.h>
+
+struct GifTimingInfo {
+    int delay;
+};
+
+namespace ImageGif {
+    struct Decoder { 
+        ~Decoder() noexcept;
+
+        bool ReadNext(ImageOut& output, GifTimingInfo& timing);
+        Decoder(Filesystem_Stream::InputStream& is) noexcept;
+
+        inline operator bool() const noexcept { return gifFile != nullptr; }
+    private:
+        explicit Decoder() noexcept = default;
+
+        GifFileType* gifFile;
+		int currentFrame{};
+    };
+
+}
+
+#endif

src/image_gif.h

@@ -66,8 +66,8 @@ bool ImageWebP::Decoder::ReadNext(ImageOut& output, TimingInfo& timing) {
         Output::Warning("ImageWebP: Failed to decode next frame");
         return false;
     }
-    output.pixels = new uint32_t[animData.canvas_width * animData.canvas_height * 4];
-    memcpy(output.pixels, pixels, animData.canvas_width * animData.canvas_height * 4);
+    output.pixels = new uint32_t[animData.canvas_width * animData.canvas_height];
+    memcpy(output.pixels, pixels, animData.canvas_width * animData.canvas_height * sizeof(uint32_t));
     output.bpp = 32; // WebP always uses 32 bits per pixel (RGBA)
     output.height = animData.canvas_height;
     output.width = animData.canvas_width;

src/image_webp.cpp

@@ -41,6 +41,7 @@ using json = nlohmann::json;
 #include "icons.h"
 #include "overlay_utils.h"
 #include "image_webp.h"
+#include "image_gif.h"
 
 namespace {
 	Point ChatTextSquare() {
@@ -201,17 +202,18 @@ void ChatOverlay::Draw(Bitmap& dst) {
 				// semitransparent bg
 				int yidx = lidx + 1 + input_row_offset;
 				int line_height = text_height;
+				bool emojis_only = false;
 
 				// begin override line height for components
 
 				// expand messages with only emojis
-				if (std::all_of(line->cbegin(), line->cend(), [](const std::shared_ptr<ChatComponent>& comp) { return bool(comp->Downcast<ChatComponents::Emoji>()); })) {
-					line_height = OverlayUtils::LargeScreen() ? 56 : 18;
-				}
-
 				if (std::any_of(line->cbegin(), line->cend(), [](const std::shared_ptr<ChatComponent>& comp) { return bool(comp->Downcast<ChatComponents::Screenshot>()); })) {
 					line_height = ChatScreenshot::sizer().y;
 				}
+				else if (std::all_of(line->cbegin(), line->cend(), [](const std::shared_ptr<ChatComponent>& comp) { return bool(comp->Downcast<ChatComponents::Emoji>()); })) {
+					emojis_only = true;
+					line_height = OverlayUtils::LargeScreen() ? 56 : 18;
+				}
 
 				// end override line height
 
@@ -247,22 +249,21 @@ void ChatOverlay::Draw(Bitmap& dst) {
 					}
 					else if (auto emoji = span->Downcast<ChatComponents::Emoji>()) {
 						Point dims = emoji->GetSize();
+						if (emojis_only) dims.x = dims.y = line_height;
 						int comp_y = y + (baseline ? baseline - text_height : 0);
 						if (emoji->bitmap) {
-							double zoom = emoji->bitmap->GetRect().y / (double)text_height;
-							bitmap->StretchBlit({offset, comp_y, line_height, line_height}, *emoji->bitmap, emoji->bitmap->GetRect(), 255);
+							bitmap->StretchBlit({offset, comp_y, dims.x, dims.y}, *emoji->bitmap, emoji->bitmap->GetRect(), 255);
 						}
-						else {
+						else if (!emoji->HasAnimation()) {
 							// the emoji is still live, request it now
 							emoji->RequestBitmap(this);
-							bitmap->FillRect({ offset, comp_y, line_height, line_height }, offwhite);
+							bitmap->FillRect({ offset, comp_y, dims.y, dims.y }, offwhite);
 						}
-						offset += line_height;
+						offset += dims.x;
 					}
 					else if (auto screenshot = span->Downcast<ChatComponents::Screenshot>()) {
 						Point dims = screenshot->GetSize();
 						if (screenshot->bitmap) {
-							double zoom = screenshot->bitmap->GetRect().y / (double)text_height;
 							bitmap->StretchBlit({offset, y, dims.x, dims.y}, *screenshot->bitmap, screenshot->bitmap->GetRect(), 255);
 						}
 						else {
@@ -608,6 +609,8 @@ void ChatEmoji::RequestBitmap(ChatOverlay* parent_) {
 	if (emoji.empty()) return;
 	parent = parent_;
 
+	if (request) return;
+
 	auto req = AsyncHandler::RequestFile("../images/ynomoji", emoji);
 	req->SetGraphicFile(true);
 	req->SetParentScope(true);
@@ -627,6 +630,7 @@ void ChatEmoji::RequestBitmap(ChatOverlay* parent_) {
 	}
 
 	request = req->Bind([this, extension](FileRequestResult* result) {
+		request.reset(); // Clear the request after processing
 		if (!result->success) {
 			emoji.clear();
 			Output::Debug("failed: {}", result->file);
@@ -650,25 +654,51 @@ void ChatEmoji::RequestBitmap(ChatOverlay* parent_) {
 }
 
 void ChatEmoji::DecodeGif(const std::string& filePath) {
-	// Use a GIF decoding library to load frames and delays
-	// Example: giflib or similar library
-	// Pseudo-code:
+	constexpr int minimum_frame_delay = 64;
 	frames.clear();
 	frameDelays.clear();
-	// Load GIF file and extract frames and delays
-	// for each frame in GIF:
-	//     Convert frame to Bitmap and store in gifFrames
-	//     Store delay in frameDelays
-	// Set currentFrame to 0
+	auto fs = FileFinder::OpenImage("../images/ynomoji", filePath);
+	if (!fs) return;
+
+	ImageGif::Decoder dec(fs);
+	if (!dec) return;
+
+	ImageOut image{};
+	GifTimingInfo timing{};
+	while (dec.ReadNext(image, timing)) {
+		auto bitmap = Bitmap::Create(image.pixels, image.width, image.height, 0, format_R8G8B8A8_a().format());
+		if (!bitmap) {
+			if (image.pixels) delete[] image.pixels;
+			continue;
+		}
+		bitmap->SetBilinear();
+		frames.push_back(std::move(bitmap));
+
+		if (!timing.delay)
+			timing.delay = 100;
+
+		int delay = std::min(minimum_frame_delay, timing.delay);
+		frameDelays.push_back(delay);
+		loopLength += frameDelays.back();
+	}
+
 	currentFrame = 0;
-	lastFrameTime = std::chrono::steady_clock::now();
+	if (loopLength && frames.size() > 1) {
+		lastFrameTime = std::chrono::steady_clock::now();
+		int loopDelta = std::chrono::duration_cast<std::chrono::milliseconds>(lastFrameTime.time_since_epoch()).count() % loopLength;
+		while (currentFrame < frameDelays.size() && loopDelta >= frameDelays[currentFrame]) {
+			loopDelta -= frameDelays[currentFrame];
+			currentFrame = (currentFrame + 1) % frames.size();
+		}
+	}
 }
 
 void ChatEmoji::DecodeWebP(const std::string& filePath) {
 	// Use a WebP decoding library to load the image
 	// Example: libwebp or similar library
 	// Pseudo-code:
 	frames.clear();
+	frameDelays.clear();
 	auto fs = FileFinder::OpenImage("../images/ynomoji", filePath);
 	if (!fs) return;
 
@@ -714,7 +744,8 @@ void ChatEmoji::DecodeWebP(const std::string& filePath) {
 }
 
 void ChatEmoji::UpdateAnimation() {
-	if (frames.size() < 2 || frameDelays.empty()) return; // No animation to update
+	if (frames.size() == 1) bitmap = frames[0]; // If there's only one frame, just display it
+	else if (frames.size() < 2 || frameDelays.empty()) return; // No animation to update
 
 	auto now = std::chrono::steady_clock::now();
 	auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(now - lastFrameTime).count();

src/multiplayer/chat_overlay.cpp

@@ -23,6 +23,7 @@
 #include <lcf/span.h>
 #include <chrono>
 #include <uv.h>
+#include <mutex>
 
 #include "drawable.h"
 #include "bitmap.h"
@@ -183,6 +184,9 @@ class ChatEmoji : public ChatComponent {
 	void UpdateAnimation();
 	static std::shared_ptr<ChatEmoji> GetOrCreate(const std::string& emojiKey, ChatOverlay* parent);
 
+	inline bool HasAnimation() const noexcept {
+		return frames.size() > 1;
+	}
 private:
 	std::vector<std::shared_ptr<Bitmap>> frames; // Store frames for GIFs
 	std::vector<int> frameDelays; // Store delays for each frame in milliseconds