dmaax/ladybird
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
ladybird/Libraries/LibWeb/HTML/AnimatedBitmapDecodedImageData.h

115 lines
3.6 KiB
C
Raw Permalink Normal View History

LibWeb: Stream animated image frames on demand Add AnimatedDecodedImageData which implements DecodedImageData with an 8-slot buffer pool instead of storing all frames in memory. Frames are requested on demand from the ImageDecoder service as the animation progresses. For a 344-frame animated image at 1920x1080, this reduces WebContent memory from ~1.3 GB to ~66 MB. The streaming class owns frame progression and synchronizes multiple callers (HTMLImageElement and ImageStyleValue) through notify_frame_advanced() returning the authoritative frame index. When a frame isn't in the pool, the last displayed frame is shown as a fallback (brief freeze rather than blank). Rename the old AnimatedBitmapDecodedImageData (which now only handles static/single-frame images) to BitmapDecodedImageData.
2026-02-13 11:04:08 -03:00
/*
* Copyright (c) 2026, Andreas Kling <andreas@ladybird.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/Array.h>
#include <AK/HashMap.h>
#include <LibGC/Ptr.h>
#include <LibGfx/ColorSpace.h>
LibGfx+LibWeb: Add DecodedImageFrame Decoded image data should not continue to traffic in ImmutableBitmap now that the bitmap wrapper is being retired. Introduce DecodedImageFrame as the paintable decoded-image unit and store a Bitmap plus ColorSpace in it directly. Thread the new frame type through decoded image data, display-list image commands, filters, canvas drawImage, patterns, WebGL texture upload, and CSS/SVG image consumers. ImmutableBitmap remains only at the legacy boundaries that still need it, such as HTML video snapshots and callers that explicitly ask for a bitmap snapshot. This keeps color-space ownership with the decoded frame while making the expensive or legacy ImmutableBitmap path explicit at the few call sites that still need it.
2026-05-05 08:52:33 -03:00
#include <LibGfx/DecodedImageFrame.h>
LibWeb: Stream animated image frames on demand Add AnimatedDecodedImageData which implements DecodedImageData with an 8-slot buffer pool instead of storing all frames in memory. Frames are requested on demand from the ImageDecoder service as the animation progresses. For a 344-frame animated image at 1920x1080, this reduces WebContent memory from ~1.3 GB to ~66 MB. The streaming class owns frame progression and synchronizes multiple callers (HTMLImageElement and ImageStyleValue) through notify_frame_advanced() returning the authoritative frame index. When a frame isn't in the pool, the last displayed frame is shown as a fallback (brief freeze rather than blank). Rename the old AnimatedBitmapDecodedImageData (which now only handles static/single-frame images) to BitmapDecodedImageData.
2026-02-13 11:04:08 -03:00
#include <LibGfx/Forward.h>
LibWeb: Transfer animation ownership to `AnimatedBitmapDecodedImageData` Previously animation ownership was a messy split between `AnimatedBitmapDecodedImageData` and the consumers (i.e. `ImageStyleValueResource`, `HTMLImageElement`, and `SVGImageElement`) with `AnimatedBitmapDecodedImageData` owning the frames and a current frame index, and the consumers owning the rest of the state (e.g. loop count, timers to drive the animation forward, their own current index). This had a couple of main issues: - While `AnimatedDecodedImageData` partially synchronized animations by dropping unexpected advancement notifications, this didn't apply to other animation state which meant, for instance, that a later started consumer could drive the animation of an earlier one past the max loop count (albeit without invalidating the earlier consumer). - Multiple consumers didn't share frame timings, meaning animations could be up to a full frame out of sync visually. - Animations were paused depending on whether there were any consumers, this is different to the behavior in other browsers (where they continue regardless of whether there are any consumers). - It was an overgeneralization of how animations need to work - only `AnimatedBitmapDecodedImageData` works with an indexed frame model, with animated SVGs (although not yet implemented) relying on their internal event loop to be driven forward. Given the above the new approach implemented in this commit is: - The API for `DecodedImageData` is animation system agnostic, only exposing `default_frame`, `current_frame`, and `restart_animation` methods not reliant on providing a specific frame index. - `AnimatedBitmapDecodedImageData` owns its own timer, loop count, etc. The animation starts when the first consumer registers and ends when the document is hidden or becomes inactive (or completes in the case of finite animations). - Consumers are invalidated by `AnimatedBitmapDecodedImageData` when required. Tests have been added for: - Animations being paused when the document becomes inactive and restarted when it becomes active again. - Frame timings being synchronized across consumers. - Restarts triggered by `HTMLImageElement` applying to all consumers. - Processing ending once a non-infinite animation plays to completion. The tests to ensure animations are cancelled when consumers are removed (e.g. `animated-background-image-timer-stops-when-hidden.html`) have been updated to assert the inverse since animation state is now per resource not per consumer.
2026-06-15 19:56:00 -03:00
#include <LibWeb/HTML/AnimatedDecodedImageData.h>
LibWeb: Stream animated image frames on demand Add AnimatedDecodedImageData which implements DecodedImageData with an 8-slot buffer pool instead of storing all frames in memory. Frames are requested on demand from the ImageDecoder service as the animation progresses. For a 344-frame animated image at 1920x1080, this reduces WebContent memory from ~1.3 GB to ~66 MB. The streaming class owns frame progression and synchronizes multiple callers (HTMLImageElement and ImageStyleValue) through notify_frame_advanced() returning the authoritative frame index. When a frame isn't in the pool, the last displayed frame is shown as a fallback (brief freeze rather than blank). Rename the old AnimatedBitmapDecodedImageData (which now only handles static/single-frame images) to BitmapDecodedImageData.
2026-02-13 11:04:08 -03:00
#include <LibWeb/HTML/DecodedImageData.h>
namespace Web::HTML {
LibWeb: Transfer animation ownership to `AnimatedBitmapDecodedImageData` Previously animation ownership was a messy split between `AnimatedBitmapDecodedImageData` and the consumers (i.e. `ImageStyleValueResource`, `HTMLImageElement`, and `SVGImageElement`) with `AnimatedBitmapDecodedImageData` owning the frames and a current frame index, and the consumers owning the rest of the state (e.g. loop count, timers to drive the animation forward, their own current index). This had a couple of main issues: - While `AnimatedDecodedImageData` partially synchronized animations by dropping unexpected advancement notifications, this didn't apply to other animation state which meant, for instance, that a later started consumer could drive the animation of an earlier one past the max loop count (albeit without invalidating the earlier consumer). - Multiple consumers didn't share frame timings, meaning animations could be up to a full frame out of sync visually. - Animations were paused depending on whether there were any consumers, this is different to the behavior in other browsers (where they continue regardless of whether there are any consumers). - It was an overgeneralization of how animations need to work - only `AnimatedBitmapDecodedImageData` works with an indexed frame model, with animated SVGs (although not yet implemented) relying on their internal event loop to be driven forward. Given the above the new approach implemented in this commit is: - The API for `DecodedImageData` is animation system agnostic, only exposing `default_frame`, `current_frame`, and `restart_animation` methods not reliant on providing a specific frame index. - `AnimatedBitmapDecodedImageData` owns its own timer, loop count, etc. The animation starts when the first consumer registers and ends when the document is hidden or becomes inactive (or completes in the case of finite animations). - Consumers are invalidated by `AnimatedBitmapDecodedImageData` when required. Tests have been added for: - Animations being paused when the document becomes inactive and restarted when it becomes active again. - Frame timings being synchronized across consumers. - Restarts triggered by `HTMLImageElement` applying to all consumers. - Processing ending once a non-infinite animation plays to completion. The tests to ensure animations are cancelled when consumers are removed (e.g. `animated-background-image-timer-stops-when-hidden.html`) have been updated to assert the inverse since animation state is now per resource not per consumer.
2026-06-15 19:56:00 -03:00
class AnimatedBitmapDecodedImageData final : public AnimatedDecodedImageData {
GC_CELL(AnimatedBitmapDecodedImageData, AnimatedDecodedImageData);
LibWeb: Rename `AnimatedDecodedImageData` To `AnimatedBitmapDecodedImageData`. This better reflects what it is and frees up `AnimatedDecodedImageData` to be used as an abstract class in a later commit.
2026-06-14 22:49:36 -03:00
GC_DECLARE_ALLOCATOR(AnimatedBitmapDecodedImageData);
LibWeb: Transfer animation ownership to `AnimatedBitmapDecodedImageData` Previously animation ownership was a messy split between `AnimatedBitmapDecodedImageData` and the consumers (i.e. `ImageStyleValueResource`, `HTMLImageElement`, and `SVGImageElement`) with `AnimatedBitmapDecodedImageData` owning the frames and a current frame index, and the consumers owning the rest of the state (e.g. loop count, timers to drive the animation forward, their own current index). This had a couple of main issues: - While `AnimatedDecodedImageData` partially synchronized animations by dropping unexpected advancement notifications, this didn't apply to other animation state which meant, for instance, that a later started consumer could drive the animation of an earlier one past the max loop count (albeit without invalidating the earlier consumer). - Multiple consumers didn't share frame timings, meaning animations could be up to a full frame out of sync visually. - Animations were paused depending on whether there were any consumers, this is different to the behavior in other browsers (where they continue regardless of whether there are any consumers). - It was an overgeneralization of how animations need to work - only `AnimatedBitmapDecodedImageData` works with an indexed frame model, with animated SVGs (although not yet implemented) relying on their internal event loop to be driven forward. Given the above the new approach implemented in this commit is: - The API for `DecodedImageData` is animation system agnostic, only exposing `default_frame`, `current_frame`, and `restart_animation` methods not reliant on providing a specific frame index. - `AnimatedBitmapDecodedImageData` owns its own timer, loop count, etc. The animation starts when the first consumer registers and ends when the document is hidden or becomes inactive (or completes in the case of finite animations). - Consumers are invalidated by `AnimatedBitmapDecodedImageData` when required. Tests have been added for: - Animations being paused when the document becomes inactive and restarted when it becomes active again. - Frame timings being synchronized across consumers. - Restarts triggered by `HTMLImageElement` applying to all consumers. - Processing ending once a non-infinite animation plays to completion. The tests to ensure animations are cancelled when consumers are removed (e.g. `animated-background-image-timer-stops-when-hidden.html`) have been updated to assert the inverse since animation state is now per resource not per consumer.
2026-06-15 19:56:00 -03:00
friend class Web::Internals::Internals;
LibWeb: Stream animated image frames on demand Add AnimatedDecodedImageData which implements DecodedImageData with an 8-slot buffer pool instead of storing all frames in memory. Frames are requested on demand from the ImageDecoder service as the animation progresses. For a 344-frame animated image at 1920x1080, this reduces WebContent memory from ~1.3 GB to ~66 MB. The streaming class owns frame progression and synchronizes multiple callers (HTMLImageElement and ImageStyleValue) through notify_frame_advanced() returning the authoritative frame index. When a frame isn't in the pool, the last displayed frame is shown as a fallback (brief freeze rather than blank). Rename the old AnimatedBitmapDecodedImageData (which now only handles static/single-frame images) to BitmapDecodedImageData.
2026-02-13 11:04:08 -03:00
public:
static constexpr bool OVERRIDES_FINALIZE = true;
LibWeb: Rename `AnimatedDecodedImageData` To `AnimatedBitmapDecodedImageData`. This better reflects what it is and frees up `AnimatedDecodedImageData` to be used as an abstract class in a later commit.
2026-06-14 22:49:36 -03:00
static GC::Ref<AnimatedBitmapDecodedImageData> create(
LibWeb: Stream animated image frames on demand Add AnimatedDecodedImageData which implements DecodedImageData with an 8-slot buffer pool instead of storing all frames in memory. Frames are requested on demand from the ImageDecoder service as the animation progresses. For a 344-frame animated image at 1920x1080, this reduces WebContent memory from ~1.3 GB to ~66 MB. The streaming class owns frame progression and synchronizes multiple callers (HTMLImageElement and ImageStyleValue) through notify_frame_advanced() returning the authoritative frame index. When a frame isn't in the pool, the last displayed frame is shown as a fallback (brief freeze rather than blank). Rename the old AnimatedBitmapDecodedImageData (which now only handles static/single-frame images) to BitmapDecodedImageData.
2026-02-13 11:04:08 -03:00
JS::Realm&,
LibWeb: Transfer animation ownership to `AnimatedBitmapDecodedImageData` Previously animation ownership was a messy split between `AnimatedBitmapDecodedImageData` and the consumers (i.e. `ImageStyleValueResource`, `HTMLImageElement`, and `SVGImageElement`) with `AnimatedBitmapDecodedImageData` owning the frames and a current frame index, and the consumers owning the rest of the state (e.g. loop count, timers to drive the animation forward, their own current index). This had a couple of main issues: - While `AnimatedDecodedImageData` partially synchronized animations by dropping unexpected advancement notifications, this didn't apply to other animation state which meant, for instance, that a later started consumer could drive the animation of an earlier one past the max loop count (albeit without invalidating the earlier consumer). - Multiple consumers didn't share frame timings, meaning animations could be up to a full frame out of sync visually. - Animations were paused depending on whether there were any consumers, this is different to the behavior in other browsers (where they continue regardless of whether there are any consumers). - It was an overgeneralization of how animations need to work - only `AnimatedBitmapDecodedImageData` works with an indexed frame model, with animated SVGs (although not yet implemented) relying on their internal event loop to be driven forward. Given the above the new approach implemented in this commit is: - The API for `DecodedImageData` is animation system agnostic, only exposing `default_frame`, `current_frame`, and `restart_animation` methods not reliant on providing a specific frame index. - `AnimatedBitmapDecodedImageData` owns its own timer, loop count, etc. The animation starts when the first consumer registers and ends when the document is hidden or becomes inactive (or completes in the case of finite animations). - Consumers are invalidated by `AnimatedBitmapDecodedImageData` when required. Tests have been added for: - Animations being paused when the document becomes inactive and restarted when it becomes active again. - Frame timings being synchronized across consumers. - Restarts triggered by `HTMLImageElement` applying to all consumers. - Processing ending once a non-infinite animation plays to completion. The tests to ensure animations are cancelled when consumers are removed (e.g. `animated-background-image-timer-stops-when-hidden.html`) have been updated to assert the inverse since animation state is now per resource not per consumer.
2026-06-15 19:56:00 -03:00
DOM::Document&,
LibWeb: Stream animated image frames on demand Add AnimatedDecodedImageData which implements DecodedImageData with an 8-slot buffer pool instead of storing all frames in memory. Frames are requested on demand from the ImageDecoder service as the animation progresses. For a 344-frame animated image at 1920x1080, this reduces WebContent memory from ~1.3 GB to ~66 MB. The streaming class owns frame progression and synchronizes multiple callers (HTMLImageElement and ImageStyleValue) through notify_frame_advanced() returning the authoritative frame index. When a frame isn't in the pool, the last displayed frame is shown as a fallback (brief freeze rather than blank). Rename the old AnimatedBitmapDecodedImageData (which now only handles static/single-frame images) to BitmapDecodedImageData.
2026-02-13 11:04:08 -03:00
i64 session_id,
u32 frame_count,
u32 loop_count,
Gfx::IntSize,
Gfx::ColorSpace,
Vector<u32> durations,
Vector<NonnullRefPtr<Gfx::Bitmap>> initial_bitmaps);
LibWeb: Rename `AnimatedDecodedImageData` To `AnimatedBitmapDecodedImageData`. This better reflects what it is and frees up `AnimatedDecodedImageData` to be used as an abstract class in a later commit.
2026-06-14 22:49:36 -03:00
virtual ~AnimatedBitmapDecodedImageData() override;
LibWeb: Stream animated image frames on demand Add AnimatedDecodedImageData which implements DecodedImageData with an 8-slot buffer pool instead of storing all frames in memory. Frames are requested on demand from the ImageDecoder service as the animation progresses. For a 344-frame animated image at 1920x1080, this reduces WebContent memory from ~1.3 GB to ~66 MB. The streaming class owns frame progression and synchronizes multiple callers (HTMLImageElement and ImageStyleValue) through notify_frame_advanced() returning the authoritative frame index. When a frame isn't in the pool, the last displayed frame is shown as a fallback (brief freeze rather than blank). Rename the old AnimatedBitmapDecodedImageData (which now only handles static/single-frame images) to BitmapDecodedImageData.
2026-02-13 11:04:08 -03:00
virtual void finalize() override;
LibWeb: Transfer animation ownership to `AnimatedBitmapDecodedImageData` Previously animation ownership was a messy split between `AnimatedBitmapDecodedImageData` and the consumers (i.e. `ImageStyleValueResource`, `HTMLImageElement`, and `SVGImageElement`) with `AnimatedBitmapDecodedImageData` owning the frames and a current frame index, and the consumers owning the rest of the state (e.g. loop count, timers to drive the animation forward, their own current index). This had a couple of main issues: - While `AnimatedDecodedImageData` partially synchronized animations by dropping unexpected advancement notifications, this didn't apply to other animation state which meant, for instance, that a later started consumer could drive the animation of an earlier one past the max loop count (albeit without invalidating the earlier consumer). - Multiple consumers didn't share frame timings, meaning animations could be up to a full frame out of sync visually. - Animations were paused depending on whether there were any consumers, this is different to the behavior in other browsers (where they continue regardless of whether there are any consumers). - It was an overgeneralization of how animations need to work - only `AnimatedBitmapDecodedImageData` works with an indexed frame model, with animated SVGs (although not yet implemented) relying on their internal event loop to be driven forward. Given the above the new approach implemented in this commit is: - The API for `DecodedImageData` is animation system agnostic, only exposing `default_frame`, `current_frame`, and `restart_animation` methods not reliant on providing a specific frame index. - `AnimatedBitmapDecodedImageData` owns its own timer, loop count, etc. The animation starts when the first consumer registers and ends when the document is hidden or becomes inactive (or completes in the case of finite animations). - Consumers are invalidated by `AnimatedBitmapDecodedImageData` when required. Tests have been added for: - Animations being paused when the document becomes inactive and restarted when it becomes active again. - Frame timings being synchronized across consumers. - Restarts triggered by `HTMLImageElement` applying to all consumers. - Processing ending once a non-infinite animation plays to completion. The tests to ensure animations are cancelled when consumers are removed (e.g. `animated-background-image-timer-stops-when-hidden.html`) have been updated to assert the inverse since animation state is now per resource not per consumer.
2026-06-15 19:56:00 -03:00
virtual void visit_edges(Cell::Visitor&) override;
LibWeb: Stream animated image frames on demand Add AnimatedDecodedImageData which implements DecodedImageData with an 8-slot buffer pool instead of storing all frames in memory. Frames are requested on demand from the ImageDecoder service as the animation progresses. For a 344-frame animated image at 1920x1080, this reduces WebContent memory from ~1.3 GB to ~66 MB. The streaming class owns frame progression and synchronizes multiple callers (HTMLImageElement and ImageStyleValue) through notify_frame_advanced() returning the authoritative frame index. When a frame isn't in the pool, the last displayed frame is shown as a fallback (brief freeze rather than blank). Rename the old AnimatedBitmapDecodedImageData (which now only handles static/single-frame images) to BitmapDecodedImageData.
2026-02-13 11:04:08 -03:00
LibWeb: Add `DecodedImageData::default_frame` helper The index based `frame(size_t, ...)` getter is going to be removed in a future commit.
2026-06-12 08:45:06 -03:00
virtual Optional<Gfx::DecodedImageFrame> default_frame(Gfx::IntSize = {}) const override;
LibWeb: Transfer animation ownership to `AnimatedBitmapDecodedImageData` Previously animation ownership was a messy split between `AnimatedBitmapDecodedImageData` and the consumers (i.e. `ImageStyleValueResource`, `HTMLImageElement`, and `SVGImageElement`) with `AnimatedBitmapDecodedImageData` owning the frames and a current frame index, and the consumers owning the rest of the state (e.g. loop count, timers to drive the animation forward, their own current index). This had a couple of main issues: - While `AnimatedDecodedImageData` partially synchronized animations by dropping unexpected advancement notifications, this didn't apply to other animation state which meant, for instance, that a later started consumer could drive the animation of an earlier one past the max loop count (albeit without invalidating the earlier consumer). - Multiple consumers didn't share frame timings, meaning animations could be up to a full frame out of sync visually. - Animations were paused depending on whether there were any consumers, this is different to the behavior in other browsers (where they continue regardless of whether there are any consumers). - It was an overgeneralization of how animations need to work - only `AnimatedBitmapDecodedImageData` works with an indexed frame model, with animated SVGs (although not yet implemented) relying on their internal event loop to be driven forward. Given the above the new approach implemented in this commit is: - The API for `DecodedImageData` is animation system agnostic, only exposing `default_frame`, `current_frame`, and `restart_animation` methods not reliant on providing a specific frame index. - `AnimatedBitmapDecodedImageData` owns its own timer, loop count, etc. The animation starts when the first consumer registers and ends when the document is hidden or becomes inactive (or completes in the case of finite animations). - Consumers are invalidated by `AnimatedBitmapDecodedImageData` when required. Tests have been added for: - Animations being paused when the document becomes inactive and restarted when it becomes active again. - Frame timings being synchronized across consumers. - Restarts triggered by `HTMLImageElement` applying to all consumers. - Processing ending once a non-infinite animation plays to completion. The tests to ensure animations are cancelled when consumers are removed (e.g. `animated-background-image-timer-stops-when-hidden.html`) have been updated to assert the inverse since animation state is now per resource not per consumer.
2026-06-15 19:56:00 -03:00
virtual Optional<Gfx::DecodedImageFrame> current_frame(Gfx::IntSize = {}) const override;
LibWeb: Stream animated image frames on demand Add AnimatedDecodedImageData which implements DecodedImageData with an 8-slot buffer pool instead of storing all frames in memory. Frames are requested on demand from the ImageDecoder service as the animation progresses. For a 344-frame animated image at 1920x1080, this reduces WebContent memory from ~1.3 GB to ~66 MB. The streaming class owns frame progression and synchronizes multiple callers (HTMLImageElement and ImageStyleValue) through notify_frame_advanced() returning the authoritative frame index. When a frame isn't in the pool, the last displayed frame is shown as a fallback (brief freeze rather than blank). Rename the old AnimatedBitmapDecodedImageData (which now only handles static/single-frame images) to BitmapDecodedImageData.
2026-02-13 11:04:08 -03:00
virtual Optional<CSSPixels> intrinsic_width() const override;
virtual Optional<CSSPixels> intrinsic_height() const override;
virtual Optional<CSSPixelFraction> intrinsic_aspect_ratio() const override;
LibWeb: Transfer animation ownership to `AnimatedBitmapDecodedImageData` Previously animation ownership was a messy split between `AnimatedBitmapDecodedImageData` and the consumers (i.e. `ImageStyleValueResource`, `HTMLImageElement`, and `SVGImageElement`) with `AnimatedBitmapDecodedImageData` owning the frames and a current frame index, and the consumers owning the rest of the state (e.g. loop count, timers to drive the animation forward, their own current index). This had a couple of main issues: - While `AnimatedDecodedImageData` partially synchronized animations by dropping unexpected advancement notifications, this didn't apply to other animation state which meant, for instance, that a later started consumer could drive the animation of an earlier one past the max loop count (albeit without invalidating the earlier consumer). - Multiple consumers didn't share frame timings, meaning animations could be up to a full frame out of sync visually. - Animations were paused depending on whether there were any consumers, this is different to the behavior in other browsers (where they continue regardless of whether there are any consumers). - It was an overgeneralization of how animations need to work - only `AnimatedBitmapDecodedImageData` works with an indexed frame model, with animated SVGs (although not yet implemented) relying on their internal event loop to be driven forward. Given the above the new approach implemented in this commit is: - The API for `DecodedImageData` is animation system agnostic, only exposing `default_frame`, `current_frame`, and `restart_animation` methods not reliant on providing a specific frame index. - `AnimatedBitmapDecodedImageData` owns its own timer, loop count, etc. The animation starts when the first consumer registers and ends when the document is hidden or becomes inactive (or completes in the case of finite animations). - Consumers are invalidated by `AnimatedBitmapDecodedImageData` when required. Tests have been added for: - Animations being paused when the document becomes inactive and restarted when it becomes active again. - Frame timings being synchronized across consumers. - Restarts triggered by `HTMLImageElement` applying to all consumers. - Processing ending once a non-infinite animation plays to completion. The tests to ensure animations are cancelled when consumers are removed (e.g. `animated-background-image-timer-stops-when-hidden.html`) have been updated to assert the inverse since animation state is now per resource not per consumer.
2026-06-15 19:56:00 -03:00
virtual void paint(DisplayListRecordingContext&, Gfx::IntRect dst_rect, CSS::ImageRendering) const override;
LibWeb: Stream animated image frames on demand Add AnimatedDecodedImageData which implements DecodedImageData with an 8-slot buffer pool instead of storing all frames in memory. Frames are requested on demand from the ImageDecoder service as the animation progresses. For a 344-frame animated image at 1920x1080, this reduces WebContent memory from ~1.3 GB to ~66 MB. The streaming class owns frame progression and synchronizes multiple callers (HTMLImageElement and ImageStyleValue) through notify_frame_advanced() returning the authoritative frame index. When a frame isn't in the pool, the last displayed frame is shown as a fallback (brief freeze rather than blank). Rename the old AnimatedBitmapDecodedImageData (which now only handles static/single-frame images) to BitmapDecodedImageData.
2026-02-13 11:04:08 -03:00
void receive_frames(Vector<NonnullRefPtr<Gfx::Bitmap>>, u32 start_frame_index);
i64 session_id() const { return m_session_id; }
static void deliver_frames_for_session(i64 session_id, Vector<NonnullRefPtr<Gfx::Bitmap>>);
static void install_frame_delivery_callback();
private:
LibWeb: Rename `AnimatedDecodedImageData` To `AnimatedBitmapDecodedImageData`. This better reflects what it is and frees up `AnimatedDecodedImageData` to be used as an abstract class in a later commit.
2026-06-14 22:49:36 -03:00
static HashMap<i64, GC::RawPtr<AnimatedBitmapDecodedImageData>>& session_registry();
LibWeb: Stream animated image frames on demand Add AnimatedDecodedImageData which implements DecodedImageData with an 8-slot buffer pool instead of storing all frames in memory. Frames are requested on demand from the ImageDecoder service as the animation progresses. For a 344-frame animated image at 1920x1080, this reduces WebContent memory from ~1.3 GB to ~66 MB. The streaming class owns frame progression and synchronizes multiple callers (HTMLImageElement and ImageStyleValue) through notify_frame_advanced() returning the authoritative frame index. When a frame isn't in the pool, the last displayed frame is shown as a fallback (brief freeze rather than blank). Rename the old AnimatedBitmapDecodedImageData (which now only handles static/single-frame images) to BitmapDecodedImageData.
2026-02-13 11:04:08 -03:00
static constexpr u32 BUFFER_POOL_SIZE = 8;
static constexpr u32 REQUEST_BATCH_SIZE = 4;
struct BufferSlot {
Optional<u32> frame_index;
LibGfx+LibWeb: Make DecodedImageFrame a value type DecodedImageFrame only wraps a ref-counted Bitmap and color-space metadata. The frame object itself does not provide shared mutable state or lifetime ownership beyond those members, so ref-counting it adds an unnecessary layer of indirection.
2026-05-07 09:39:50 -03:00
Optional<Gfx::DecodedImageFrame> frame;
LibWeb: Stream animated image frames on demand Add AnimatedDecodedImageData which implements DecodedImageData with an 8-slot buffer pool instead of storing all frames in memory. Frames are requested on demand from the ImageDecoder service as the animation progresses. For a 344-frame animated image at 1920x1080, this reduces WebContent memory from ~1.3 GB to ~66 MB. The streaming class owns frame progression and synchronizes multiple callers (HTMLImageElement and ImageStyleValue) through notify_frame_advanced() returning the authoritative frame index. When a frame isn't in the pool, the last displayed frame is shown as a fallback (brief freeze rather than blank). Rename the old AnimatedBitmapDecodedImageData (which now only handles static/single-frame images) to BitmapDecodedImageData.
2026-02-13 11:04:08 -03:00
u64 generation { 0 };
};
LibWeb: Rename `AnimatedDecodedImageData` To `AnimatedBitmapDecodedImageData`. This better reflects what it is and frees up `AnimatedDecodedImageData` to be used as an abstract class in a later commit.
2026-06-14 22:49:36 -03:00
AnimatedBitmapDecodedImageData(
LibWeb: Stream animated image frames on demand Add AnimatedDecodedImageData which implements DecodedImageData with an 8-slot buffer pool instead of storing all frames in memory. Frames are requested on demand from the ImageDecoder service as the animation progresses. For a 344-frame animated image at 1920x1080, this reduces WebContent memory from ~1.3 GB to ~66 MB. The streaming class owns frame progression and synchronizes multiple callers (HTMLImageElement and ImageStyleValue) through notify_frame_advanced() returning the authoritative frame index. When a frame isn't in the pool, the last displayed frame is shown as a fallback (brief freeze rather than blank). Rename the old AnimatedBitmapDecodedImageData (which now only handles static/single-frame images) to BitmapDecodedImageData.
2026-02-13 11:04:08 -03:00
i64 session_id,
u32 frame_count,
u32 loop_count,
Gfx::IntSize,
Gfx::ColorSpace,
LibWeb: Transfer animation ownership to `AnimatedBitmapDecodedImageData` Previously animation ownership was a messy split between `AnimatedBitmapDecodedImageData` and the consumers (i.e. `ImageStyleValueResource`, `HTMLImageElement`, and `SVGImageElement`) with `AnimatedBitmapDecodedImageData` owning the frames and a current frame index, and the consumers owning the rest of the state (e.g. loop count, timers to drive the animation forward, their own current index). This had a couple of main issues: - While `AnimatedDecodedImageData` partially synchronized animations by dropping unexpected advancement notifications, this didn't apply to other animation state which meant, for instance, that a later started consumer could drive the animation of an earlier one past the max loop count (albeit without invalidating the earlier consumer). - Multiple consumers didn't share frame timings, meaning animations could be up to a full frame out of sync visually. - Animations were paused depending on whether there were any consumers, this is different to the behavior in other browsers (where they continue regardless of whether there are any consumers). - It was an overgeneralization of how animations need to work - only `AnimatedBitmapDecodedImageData` works with an indexed frame model, with animated SVGs (although not yet implemented) relying on their internal event loop to be driven forward. Given the above the new approach implemented in this commit is: - The API for `DecodedImageData` is animation system agnostic, only exposing `default_frame`, `current_frame`, and `restart_animation` methods not reliant on providing a specific frame index. - `AnimatedBitmapDecodedImageData` owns its own timer, loop count, etc. The animation starts when the first consumer registers and ends when the document is hidden or becomes inactive (or completes in the case of finite animations). - Consumers are invalidated by `AnimatedBitmapDecodedImageData` when required. Tests have been added for: - Animations being paused when the document becomes inactive and restarted when it becomes active again. - Frame timings being synchronized across consumers. - Restarts triggered by `HTMLImageElement` applying to all consumers. - Processing ending once a non-infinite animation plays to completion. The tests to ensure animations are cancelled when consumers are removed (e.g. `animated-background-image-timer-stops-when-hidden.html`) have been updated to assert the inverse since animation state is now per resource not per consumer.
2026-06-15 19:56:00 -03:00
Vector<u32> durations,
GC::Ref<Platform::Timer>,
GC::Ref<DOM::DocumentObserver>);
LibWeb: Stream animated image frames on demand Add AnimatedDecodedImageData which implements DecodedImageData with an 8-slot buffer pool instead of storing all frames in memory. Frames are requested on demand from the ImageDecoder service as the animation progresses. For a 344-frame animated image at 1920x1080, this reduces WebContent memory from ~1.3 GB to ~66 MB. The streaming class owns frame progression and synchronizes multiple callers (HTMLImageElement and ImageStyleValue) through notify_frame_advanced() returning the authoritative frame index. When a frame isn't in the pool, the last displayed frame is shown as a fallback (brief freeze rather than blank). Rename the old AnimatedBitmapDecodedImageData (which now only handles static/single-frame images) to BitmapDecodedImageData.
2026-02-13 11:04:08 -03:00
LibWeb: Account text and image storage as external memory Report DOM character data, decoded image frames, ImageBitmap pixel buffers, and 2D canvas surfaces through the GC external memory hook. This lets image and text-heavy pages participate in GC threshold calculations through their retained backing storage.
2026-05-05 19:34:52 -03:00
virtual size_t external_memory_size() const override;
LibWeb: Transfer animation ownership to `AnimatedBitmapDecodedImageData` Previously animation ownership was a messy split between `AnimatedBitmapDecodedImageData` and the consumers (i.e. `ImageStyleValueResource`, `HTMLImageElement`, and `SVGImageElement`) with `AnimatedBitmapDecodedImageData` owning the frames and a current frame index, and the consumers owning the rest of the state (e.g. loop count, timers to drive the animation forward, their own current index). This had a couple of main issues: - While `AnimatedDecodedImageData` partially synchronized animations by dropping unexpected advancement notifications, this didn't apply to other animation state which meant, for instance, that a later started consumer could drive the animation of an earlier one past the max loop count (albeit without invalidating the earlier consumer). - Multiple consumers didn't share frame timings, meaning animations could be up to a full frame out of sync visually. - Animations were paused depending on whether there were any consumers, this is different to the behavior in other browsers (where they continue regardless of whether there are any consumers). - It was an overgeneralization of how animations need to work - only `AnimatedBitmapDecodedImageData` works with an indexed frame model, with animated SVGs (although not yet implemented) relying on their internal event loop to be driven forward. Given the above the new approach implemented in this commit is: - The API for `DecodedImageData` is animation system agnostic, only exposing `default_frame`, `current_frame`, and `restart_animation` methods not reliant on providing a specific frame index. - `AnimatedBitmapDecodedImageData` owns its own timer, loop count, etc. The animation starts when the first consumer registers and ends when the document is hidden or becomes inactive (or completes in the case of finite animations). - Consumers are invalidated by `AnimatedBitmapDecodedImageData` when required. Tests have been added for: - Animations being paused when the document becomes inactive and restarted when it becomes active again. - Frame timings being synchronized across consumers. - Restarts triggered by `HTMLImageElement` applying to all consumers. - Processing ending once a non-infinite animation plays to completion. The tests to ensure animations are cancelled when consumers are removed (e.g. `animated-background-image-timer-stops-when-hidden.html`) have been updated to assert the inverse since animation state is now per resource not per consumer.
2026-06-15 19:56:00 -03:00
virtual void reset_animation() override;
virtual void start_animation() override;
virtual void stop_animation() override;
void advance_animation();
bool animation_has_completed() const;
int frame_duration(size_t frame_index) const;
Optional<Gfx::DecodedImageFrame> frame(size_t frame_index, Gfx::IntSize = {}) const;
LibWeb: Stream animated image frames on demand Add AnimatedDecodedImageData which implements DecodedImageData with an 8-slot buffer pool instead of storing all frames in memory. Frames are requested on demand from the ImageDecoder service as the animation progresses. For a 344-frame animated image at 1920x1080, this reduces WebContent memory from ~1.3 GB to ~66 MB. The streaming class owns frame progression and synchronizes multiple callers (HTMLImageElement and ImageStyleValue) through notify_frame_advanced() returning the authoritative frame index. When a frame isn't in the pool, the last displayed frame is shown as a fallback (brief freeze rather than blank). Rename the old AnimatedBitmapDecodedImageData (which now only handles static/single-frame images) to BitmapDecodedImageData.
2026-02-13 11:04:08 -03:00
BufferSlot const* find_slot(u32 frame_index) const;
BufferSlot& evict_oldest_slot();
void maybe_request_more_frames(size_t current_frame_index);
i64 m_session_id;
u32 m_frame_count;
u32 m_loop_count;
Gfx::IntSize m_size;
Gfx::ColorSpace m_color_space;
Vector<u32> m_durations;
Array<BufferSlot, BUFFER_POOL_SIZE> m_buffer_slots;
LibGfx+LibWeb: Make DecodedImageFrame a value type DecodedImageFrame only wraps a ref-counted Bitmap and color-space metadata. The frame object itself does not provide shared mutable state or lifetime ownership beyond those members, so ref-counting it adds an unnecessary layer of indirection.
2026-05-07 09:39:50 -03:00
mutable Optional<Gfx::DecodedImageFrame> m_last_displayed_frame;
LibWeb: Stream animated image frames on demand Add AnimatedDecodedImageData which implements DecodedImageData with an 8-slot buffer pool instead of storing all frames in memory. Frames are requested on demand from the ImageDecoder service as the animation progresses. For a 344-frame animated image at 1920x1080, this reduces WebContent memory from ~1.3 GB to ~66 MB. The streaming class owns frame progression and synchronizes multiple callers (HTMLImageElement and ImageStyleValue) through notify_frame_advanced() returning the authoritative frame index. When a frame isn't in the pool, the last displayed frame is shown as a fallback (brief freeze rather than blank). Rename the old AnimatedBitmapDecodedImageData (which now only handles static/single-frame images) to BitmapDecodedImageData.
2026-02-13 11:04:08 -03:00
u64 m_write_generation { 0 };
bool m_request_in_flight { false };
u32 m_current_frame_index { 0 };
u32 m_last_requested_start_frame { 0 };
LibWeb: Transfer animation ownership to `AnimatedBitmapDecodedImageData` Previously animation ownership was a messy split between `AnimatedBitmapDecodedImageData` and the consumers (i.e. `ImageStyleValueResource`, `HTMLImageElement`, and `SVGImageElement`) with `AnimatedBitmapDecodedImageData` owning the frames and a current frame index, and the consumers owning the rest of the state (e.g. loop count, timers to drive the animation forward, their own current index). This had a couple of main issues: - While `AnimatedDecodedImageData` partially synchronized animations by dropping unexpected advancement notifications, this didn't apply to other animation state which meant, for instance, that a later started consumer could drive the animation of an earlier one past the max loop count (albeit without invalidating the earlier consumer). - Multiple consumers didn't share frame timings, meaning animations could be up to a full frame out of sync visually. - Animations were paused depending on whether there were any consumers, this is different to the behavior in other browsers (where they continue regardless of whether there are any consumers). - It was an overgeneralization of how animations need to work - only `AnimatedBitmapDecodedImageData` works with an indexed frame model, with animated SVGs (although not yet implemented) relying on their internal event loop to be driven forward. Given the above the new approach implemented in this commit is: - The API for `DecodedImageData` is animation system agnostic, only exposing `default_frame`, `current_frame`, and `restart_animation` methods not reliant on providing a specific frame index. - `AnimatedBitmapDecodedImageData` owns its own timer, loop count, etc. The animation starts when the first consumer registers and ends when the document is hidden or becomes inactive (or completes in the case of finite animations). - Consumers are invalidated by `AnimatedBitmapDecodedImageData` when required. Tests have been added for: - Animations being paused when the document becomes inactive and restarted when it becomes active again. - Frame timings being synchronized across consumers. - Restarts triggered by `HTMLImageElement` applying to all consumers. - Processing ending once a non-infinite animation plays to completion. The tests to ensure animations are cancelled when consumers are removed (e.g. `animated-background-image-timer-stops-when-hidden.html`) have been updated to assert the inverse since animation state is now per resource not per consumer.
2026-06-15 19:56:00 -03:00
u32 m_loops_completed { 0 };
GC::Ref<Platform::Timer> m_animation_timer;
LibWeb: Stream animated image frames on demand Add AnimatedDecodedImageData which implements DecodedImageData with an 8-slot buffer pool instead of storing all frames in memory. Frames are requested on demand from the ImageDecoder service as the animation progresses. For a 344-frame animated image at 1920x1080, this reduces WebContent memory from ~1.3 GB to ~66 MB. The streaming class owns frame progression and synchronizes multiple callers (HTMLImageElement and ImageStyleValue) through notify_frame_advanced() returning the authoritative frame index. When a frame isn't in the pool, the last displayed frame is shown as a fallback (brief freeze rather than blank). Rename the old AnimatedBitmapDecodedImageData (which now only handles static/single-frame images) to BitmapDecodedImageData.
2026-02-13 11:04:08 -03:00
};
}
Reference in a new issue Copy permalink