Fix animated emojis decoding, webview layout

Author: Desdaemon

src/audio_generic.cpp

@@ -471,7 +471,31 @@ void GenericAudio::Decode(uint8_t* output_buffer, int buffer_length) {
 			channel_active = true;
 		}
 	}
-	return {channel_active, total_volume, samples_per_frame};
+	if (channel_active) {
+		if (total_volume > 1.0) {
+			float threshold = 0.8f;
+			for (unsigned i = 0; i < (unsigned)(samples_per_frame * 2); i++) {
+				float sample = mixer_buffer[i];
+				float sign = (sample < 0) ? -1.0 : 1.0;
+				sample /= sign;
+				//dynamic range compression
+				if (sample > threshold) {
+					sample_buffer[i] = sign * 32768.0 * (threshold + (1.0 - threshold) * (sample - threshold) / (total_volume - threshold));
+				} else {
+					sample_buffer[i] = sign * sample * 32768.0;
+				}
+			}
+		} else {
+			//No dynamic range compression necessary
+			for (unsigned i = 0; i < (unsigned)(samples_per_frame * 2); i++) {
+				sample_buffer[i] = mixer_buffer[i] * 32768.0;
+			}
+		}
+
+		memcpy(output_buffer, sample_buffer.data(), buffer_length);
+	} else {
+		memset(output_buffer, '\0', buffer_length);
+	}
 }
 
 void GenericAudio::BgmChannel::Stop() {

src/image_gif.cpp

@@ -26,6 +26,9 @@ ImageGif::Decoder::Decoder(Filesystem_Stream::InputStream& is) noexcept : ImageG
         return;
     }
 
+    scratch.resize(gifFile->SWidth * gifFile->SHeight);
+    std::fill(scratch.begin(), scratch.end(), gifFile->SBackGroundColor | 0xFF000000);
+
     currentFrame = 0;
 }
 
@@ -34,37 +37,35 @@ ImageGif::Decoder::~Decoder() noexcept {
 }
 
 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;
+    const GifImageDesc& frameInfo = frame->ImageDesc;
 
-    ColorMapObject* colorMap = image.ColorMap ? image.ColorMap : gifFile->SColorMap;
+    ColorMapObject* colorMap = frameInfo.ColorMap ? frameInfo.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 fullWidth = gifFile->SWidth;
+    const int fullHeight = gifFile->SHeight;
+    output.width = fullWidth;
+    output.height = fullHeight;
+	output.bpp = 0;
 
-    const int left = image.Left;
-    const int top = image.Top;
-    const int width = image.Width;
-    const int height = image.Height;
+    const int left = frameInfo.Left;
+    const int top = frameInfo.Top;
+    const int width = frameInfo.Width;
+    const int height = frameInfo.Height;
     const int bg = gifFile->SBackGroundColor;
+    timing.delay = 0;
 
     const GifPixelType* src = frame->RasterBits;
-    // const GifPixelType* srcPrev = currentFrame > 0 ? gifFile->SavedImages[currentFrame - 1].RasterBits : nullptr;
 
     int transparentIndex = -1;
     int disposalMethod = 0;
@@ -82,28 +83,28 @@ bool ImageGif::Decoder::ReadNext(ImageOut& output, GifTimingInfo& timing) {
         }
     }
 
+    if (disposalMethod == 2) {
+        std::fill(scratch.begin(), scratch.end(), bg | 0xFF000000); // Fill with background color
+    }
+
     size_t srcIndex = 0;
-    for (int y = 0; y < height; ++y) {
-        for (int x = 0; x < width; ++x) {
+    for (int y = top; y < top + height; ++y) {
+        for (int x = left; x < left + 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) {
+                if (disposalMethod != 1)
+                    scratch[y * fullWidth + x] = 0; // Transparent pixel
+            } else 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;
-                }
+                scratch[y * fullWidth + x] =
+                    color.Red | (color.Green << 8) | (color.Blue << 16) | 0xFF000000;
             }
         }
     }
 
+    output.pixels = new uint32_t[fullWidth * fullHeight];
+    memcpy(output.pixels, scratch.data(), fullWidth * fullHeight * sizeof(uint32_t));
+
     currentFrame++;
     return true;
 }

src/image_gif.h

@@ -38,6 +38,7 @@ namespace ImageGif {
         inline operator bool() const noexcept { return gifFile != nullptr; }
     private:
         explicit Decoder() noexcept = default;
+        std::vector<uint32_t> scratch;
 
         GifFileType* gifFile;
 		int currentFrame{};

src/image_webp.cpp

@@ -20,38 +20,36 @@
 #include "output.h"
 
 ImageWebP::Decoder::~Decoder() noexcept {
-    // if (decoder) WebPAnimDecoderDelete(decoder);
-    // WebPDataClear(&data);
+    if (decoder) WebPAnimDecoderDelete(decoder);
+    WebPDataClear(&data);
 }
 
-std::optional<ImageWebP::Decoder> ImageWebP::Decoder::Create(Filesystem_Stream::InputStream& is) noexcept {
-    ImageWebP::Decoder dec;
-
+ImageWebP::Decoder::Decoder(Filesystem_Stream::InputStream& is) noexcept {
     // is.read(reinterpret_cast<char*>(&dec.data.bytes));
     // WebPMalloc
-    dec.data.size = is.GetSize();
-    dec.data.bytes = (uint8_t*)WebPMalloc(dec.data.size + 1);
-    ((char*)dec.data.bytes)[dec.data.size] = 0;
-    is.read((char*)dec.data.bytes, dec.data.size);
-    if (is.fail()) return {};
+    data.size = is.GetSize();
+    data.bytes = (uint8_t*)WebPMalloc(data.size + 1);
+    ((char*)data.bytes)[data.size] = 0;
+    is.read((char*)data.bytes, data.size);
+    if (is.fail()) return;
 
-    if (!WebPGetInfo(dec.data.bytes, dec.data.size, nullptr, nullptr)) {
+    if (!WebPGetInfo(data.bytes, data.size, nullptr, nullptr)) {
         Output::Warning("ImageWebP: {} is not webp", is.GetName());
-        return {};
+        return;
     }
 
-    dec.decoder = WebPAnimDecoderNew(&dec.data, nullptr);
-    if (!dec.decoder) {
+    decoder = WebPAnimDecoderNew(&data, nullptr);
+    if (!decoder) {
         Output::Warning("ImageWebP: Failed to create decoder for {}", is.GetName());
-        return {};
+        return;
     }
 
-    if (!WebPAnimDecoderGetInfo(dec.decoder, &dec.animData)) {
+    if (!WebPAnimDecoderGetInfo(decoder, &animData)) {
+        if (decoder) WebPAnimDecoderDelete(decoder);
+        decoder = nullptr;
         Output::Warning("ImageWebP: Failed to get animation info for {}", is.GetName());
-        return {};
+        return;
     }
-
-    return dec;
 }
 
 
@@ -68,7 +66,6 @@ bool ImageWebP::Decoder::ReadNext(ImageOut& output, TimingInfo& timing) {
     }
     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.h

@@ -33,7 +33,9 @@ namespace ImageWebP {
         ~Decoder() noexcept;
 
         bool ReadNext(ImageOut& output, TimingInfo& timing);
-        static std::optional<Decoder> Create(Filesystem_Stream::InputStream& is) noexcept;
+        // static std::optional<Decoder> Create(Filesystem_Stream::InputStream& is) noexcept;
+        Decoder(Filesystem_Stream::InputStream& is) noexcept;
+        inline operator bool() const noexcept { return decoder != nullptr; }
     private:
         explicit Decoder() noexcept = default;
         WebPAnimDecoder* decoder;

src/multiplayer/chat_overlay.cpp

@@ -125,6 +125,12 @@ void ChatOverlay::Draw(Bitmap& dst) {
 		text_height = 12;
 	}
 
+	for (auto it = emojiCache.begin(); it != emojiCache.end(); ++it) {
+		if (auto emoji = it->second.lock()) {
+			emoji->in_viewport = false;
+		} 
+	}
+
 	int i = 0;
 	int half_screen = y_end / 2 / text_height;
 
@@ -205,6 +211,7 @@ void ChatOverlay::Draw(Bitmap& dst) {
 				bool emojis_only = false;
 
 				// begin override line height for components
+				// if adding new components, remember to update LayoutViewport
 
 				// expand messages with only emojis
 				if (std::any_of(line->cbegin(), line->cend(), [](const std::shared_ptr<ChatComponent>& comp) { return bool(comp->Downcast<ChatComponents::Screenshot>()); })) {
@@ -248,6 +255,7 @@ void ChatOverlay::Draw(Bitmap& dst) {
 						offset += Text::Draw(*bitmap, offset, y + (baseline ? baseline - text_height : 0), font, str->color, str->string).x;
 					}
 					else if (auto emoji = span->Downcast<ChatComponents::Emoji>()) {
+						emoji->in_viewport = true;
 						Point dims = emoji->GetSize();
 						if (emojis_only) dims.x = dims.y = line_height;
 						int comp_y = y + (baseline ? baseline - text_height : 0);
@@ -301,6 +309,44 @@ void ChatOverlay::Draw(Bitmap& dst) {
 	dirty = false;
 }
 
+ViewportInfo ChatOverlay::LayoutViewport(int text_height, const Font& font) const {
+	Rect screen_rect = DisplayUi->GetScreenSurfaceRect();
+	int y_end = screen_rect.height;
+	int half_screen = y_end / 2 / text_height;
+
+	bool unlocked_start = scroll < half_screen;
+	bool unlocked_end = scroll > messages.size() - half_screen;
+	int last_sticky = std::max(0, (int)messages.size() - half_screen * 2);
+	int viewport = show_all
+		? std::clamp(scroll - half_screen, 0, std::min(scroll + half_screen, last_sticky))
+		: 0;
+
+	int extra = 0, lidx = viewport, scroll_extra = 0, last_sticky_extra = 0;
+	for (auto message = messages.rbegin() + viewport; message != messages.rend(); ++message) {
+		const auto& components = message->text;
+		if (std::any_of(components.cbegin(), components.cend(), [](const std::shared_ptr<ChatComponent>& comp) { return bool(comp->Downcast<ChatComponents::Screenshot>()); })) {
+			last_sticky_extra += extra = ChatScreenshot::sizer().y - text_height;
+		} else if (std::all_of(components.cbegin(), components.cend(), [](const std::shared_ptr<ChatComponent>& comp) { return bool(comp->Downcast<ChatComponents::Emoji>()); })) {
+			last_sticky_extra += extra = (OverlayUtils::LargeScreen() ? 56 : 18) - text_height;
+		} else {
+			auto dims = Text::GetSize(font, message->text_orig);
+			int lines = ceilf(dims.width / (double)bitmap->width());
+			last_sticky_extra += extra = std::max(0, lines - 1) * text_height;
+			lidx += std::max(0, lines - 1);
+		}
+		if (lidx <= scroll) scroll_extra += extra;
+		if (lidx >= last_sticky) break;
+		lidx += 1;
+	}
+
+	ViewportInfo out{};
+	out.scroll_px = scroll * text_height + scroll_extra;
+	out.last_sticky_px = last_sticky * text_height + last_sticky_extra;
+	out.extra = last_sticky_extra;
+
+	return out;
+}
+
 ChatOverlayMessage& ChatOverlay::AddMessage(
 	std::string_view message, std::string_view sender, std::string_view sender_uuid, std::string_view system, std::string_view badge,
 	bool account, bool global, int rank) {
@@ -416,8 +462,8 @@ void ChatOverlay::UpdateScene() {
 	if (Input::IsRawKeyTriggered(Input::Keys::RETURN) && !input.empty()) {
 		// TODO: map chat and party chat
 		std::string encoded = Utils::EncodeUTF(input);
-		ChatOverlay::AddMessage(encoded, "blah", "00000000000000000000", "", "", true, true, 0);
-		// GMI().sessionConn.SendPacket(Messages::C2S::SessionGSay{ std::move(encoded) });
+		// ChatOverlay::AddMessage(encoded, "blah", "00000000000000000000", "", "", true, true, 0);
+		GMI().sessionConn.SendPacket(Messages::C2S::SessionSay{ std::move(encoded) });
 		input.clear();
 		dirty = true;
 	}
@@ -654,7 +700,7 @@ void ChatEmoji::RequestBitmap(ChatOverlay* parent_) {
 }
 
 void ChatEmoji::DecodeGif(const std::string& filePath) {
-	constexpr int minimum_frame_delay = 64;
+	constexpr int minimum_frame_delay = 20;
 	frames.clear();
 	frameDelays.clear();
 	auto fs = FileFinder::OpenImage("../images/ynomoji", filePath);
@@ -694,24 +740,21 @@ void ChatEmoji::DecodeGif(const std::string& filePath) {
 }
 
 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;
 
-	auto dec = ImageWebP::Decoder::Create(fs);
+	ImageWebP::Decoder dec(fs);
 	if (!dec) return;
 
 	ImageOut image{};
 	TimingInfo timing{};
 	int smear = 0;
-	while (dec.value().ReadNext(image, timing)) {
-		auto bitmap = Bitmap::Create(image.pixels, image.width, image.height, image.bpp, format_R8G8B8A8_a().format());
+	while (dec.ReadNext(image, timing)) {
+		auto bitmap = Bitmap::Create(image.pixels, image.width, image.height, 0, format_R8G8B8A8_a().format());
 		if (!bitmap) {
-			delete image.pixels;
+			delete[] image.pixels;
 			continue;
 		}
 		bitmap->SetBilinear();
@@ -730,7 +773,6 @@ void ChatEmoji::DecodeWebP(const std::string& filePath) {
 		}
 		loopLength += frameDelays.back();
 	}
-	// if (image.pixels) delete image.pixels;
 
 	currentFrame = 0;
 	if (loopLength && frames.size() > 1) {
@@ -754,7 +796,7 @@ void ChatEmoji::UpdateAnimation() {
 		currentFrame = (currentFrame + 1) % frames.size();
 		lastFrameTime = now;
 		bitmap = frames[currentFrame]; // Update the displayed frame
-		if (parent) parent->MarkDirty(); // Mark the parent as dirty to trigger a redraw
+		if (parent && in_viewport) parent->MarkDirty(); // Mark the parent as dirty to trigger a redraw
 	}
 }
 

src/multiplayer/chat_overlay.h

@@ -100,6 +100,10 @@ class ChatOverlayMessage {
 
 inline void ChatOverlayMessage::SetOnInteract(std::function<void(ChatOverlayMessage&)> on_interact) { OnInteract = on_interact; }
 
+struct ViewportInfo {
+	int scroll_px, last_sticky_px, extra;
+};
+
 class ChatOverlay : public Drawable {
 public:
 	ChatOverlay();
@@ -121,6 +125,8 @@ class ChatOverlay : public Drawable {
 private:
 	bool IsAnyMessageVisible() const;
 
+	ViewportInfo LayoutViewport(int text_height, const Font& font) const;
+
 	bool dirty = false;
 	bool show_all = false;
 	int ox = 0;
@@ -178,6 +184,7 @@ class ChatEmoji : public ChatComponent {
 	BitmapRef bitmap = nullptr;
 	ChatOverlay* parent = nullptr;
 	FileRequestBinding request = nullptr;
+	bool in_viewport = false;
 
 	ChatEmoji(ChatOverlay* parent, int width, int height, std::string emoji);
 	void RequestBitmap(ChatOverlay* parent);