mirrors/ladybird
0
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-07-28 19:59:17 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 9

ImageDecoder: Handle decoding of images in an asynchronous manner

Browse source 
ImageDecoder now queues up image decoding requests and returns the
images back to the caller later. ImageDecoderClient has a new
promise-based API that allows callers to attach their own resolve/reject
handlers to the responses from ImageDecoder.
This commit is contained in:
Andrew Kaster 2024-04-19 14:23:16 -06:00 • committed by Andrew Kaster
commit b871bc082c
Notes: sideshowbarker 2024-07-16 21:45:42 +09:00
6 changed files with 132 additions and 31 deletions
Download patch file Download diff file Expand all files Collapse all files

93
Userland/Libraries/LibImageDecoderClient/Client.cpp
View file

@ -16,48 +16,101 @@ Client::Client(NonnullOwnPtr<Core::LocalSocket> socket)
void Client::die()
{
for (auto& [_, promise] : m_pending_decoded_images) {
promise->reject(Error::from_string_literal("ImageDecoder disconnected"));
}
m_pending_decoded_images.clear();
if (on_death)
on_death();
}
Optional<DecodedImage> Client::decode_image(ReadonlyBytes encoded_data, Optional<Gfx::IntSize> ideal_size, Optional<ByteString> mime_type)
NonnullRefPtr<Core::Promise<DecodedImage>> Client::decode_image(ReadonlyBytes encoded_data, Function<ErrorOr<void>(DecodedImage&)> on_resolved, Function<void(Error&)> on_rejected, Optional<Gfx::IntSize> ideal_size, Optional<ByteString> mime_type)
{
if (encoded_data.is_empty())
return {};
auto promise = Core::Promise<DecodedImage>::construct();
if (on_resolved)
promise->on_resolution = move(on_resolved);
if (on_rejected)
promise->on_rejection = move(on_rejected);
if (encoded_data.is_empty()) {
promise->reject(Error::from_string_literal("No encoded data"));
return promise;
}
auto encoded_buffer_or_error = Core::AnonymousBuffer::create_with_size(encoded_data.size());
if (encoded_buffer_or_error.is_error()) {
dbgln("Could not allocate encoded buffer");
return {};
dbgln("Could not allocate encoded buffer: {}", encoded_buffer_or_error.error());
promise->reject(encoded_buffer_or_error.release_error());
return promise;
}
auto encoded_buffer = encoded_buffer_or_error.release_value();
memcpy(encoded_buffer.data<void>(), encoded_data.data(), encoded_data.size());
auto response_or_error = try_decode_image(move(encoded_buffer), ideal_size, mime_type);
if (response_or_error.is_error()) {
dbgln("ImageDecoder died heroically");
return {};
auto response = send_sync_but_allow_failure<Messages::ImageDecoderServer::DecodeImage>(move(encoded_buffer), ideal_size, mime_type);
if (!response) {
dbgln("ImageDecoder disconnected trying to decode image");
promise->reject(Error::from_string_literal("ImageDecoder disconnected"));
return promise;
}
auto& response = response_or_error.value();
m_pending_decoded_images.set(response->image_id(), promise);
if (response.bitmaps().is_empty())
return promise;
}
Optional<DecodedImage> Client::decode_image(ReadonlyBytes encoded_data, Optional<Gfx::IntSize> ideal_size, Optional<ByteString> mime_type)
{
auto promise = decode_image(
encoded_data, [](auto) -> ErrorOr<void> { return {}; }, [](Error&) -> void {}, ideal_size, mime_type);
auto result = promise->await();
if (result.is_error())
return {};
return result.release_value();
}
void Client::did_decode_image(i64 image_id, bool is_animated, u32 loop_count, Vector<Gfx::ShareableBitmap> const& bitmaps, Vector<u32> const& durations, Gfx::FloatPoint scale)
{
VERIFY(!bitmaps.is_empty());
auto maybe_promise = m_pending_decoded_images.take(image_id);
if (!maybe_promise.has_value()) {
dbgln("ImageDecoderClient: No pending image with ID {}", image_id);
return;
}
auto promise = maybe_promise.release_value();
DecodedImage image;
image.is_animated = response.is_animated();
image.loop_count = response.loop_count();
image.scale = response.scale();
image.frames.ensure_capacity(response.bitmaps().size());
auto bitmaps = response.take_bitmaps();
image.is_animated = is_animated;
image.loop_count = loop_count;
image.scale = scale;
image.frames.ensure_capacity(bitmaps.size());
for (size_t i = 0; i < bitmaps.size(); ++i) {
if (!bitmaps[i].is_valid())
return {};
if (!bitmaps[i].is_valid()) {
dbgln("ImageDecoderClient: Invalid bitmap for request {} at index {}", image_id, i);
promise->reject(Error::from_string_literal("Invalid bitmap"));
return;
}
image.frames.empend(*bitmaps[i].bitmap(), response.durations()[i]);
image.frames.empend(*bitmaps[i].bitmap(), durations[i]);
}
return image;
promise->resolve(move(image));
}
void Client::did_fail_to_decode_image(i64 image_id, String const& error_message)
{
auto maybe_promise = m_pending_decoded_images.take(image_id);
if (!maybe_promise.has_value()) {
dbgln("ImageDecoderClient: No pending image with ID {}", image_id);
return;
}
auto promise = maybe_promise.release_value();
dbgln("ImageDecoderClient: Failed to decode image with ID {}: {}", image_id, error_message);
// FIXME: Include the error message in the Error object when Errors are allowed to hold Strings
promise->reject(Error::from_string_literal("Image decoding failed or aborted"));
}
}