Everywhere: Hoist the Libraries folder to the top-level

Author: https://github.com/trflynn89
Commit: 93712b24bf
Pull-request: https://github.com/LadybirdBrowser/ladybird/pull/2256
Reviewed-by: https://github.com/sideshowbarker

Libraries/LibGfx/ImageFormats/AVIFLoader.cpp

@@ -0,0 +1,196 @@
+/*
+ * Copyright (c) 2023, Nico Weber <thakis@chromium.org>
+ * Copyright (c) 2024, doctortheemh <doctortheemh@gmail.com>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <AK/ByteBuffer.h>
+#include <AK/Error.h>
+#include <LibGfx/ImageFormats/AVIFLoader.h>
+
+#include <avif/avif.h>
+
+namespace Gfx {
+
+class AVIFLoadingContext {
+    AK_MAKE_NONMOVABLE(AVIFLoadingContext);
+    AK_MAKE_NONCOPYABLE(AVIFLoadingContext);
+
+public:
+    enum State {
+        NotDecoded = 0,
+        Error,
+        HeaderDecoded,
+        BitmapDecoded,
+    };
+
+    State state { State::NotDecoded };
+    ReadonlyBytes data;
+
+    avifDecoder* decoder { nullptr };
+
+    // image properties
+    Optional<IntSize> size;
+    bool has_alpha { false };
+    size_t image_count { 0 };
+    size_t repetition_count { 0 };
+    ByteBuffer icc_data;
+
+    Vector<ImageFrameDescriptor> frame_descriptors;
+
+    AVIFLoadingContext() = default;
+    ~AVIFLoadingContext()
+    {
+        avifDecoderDestroy(decoder);
+        decoder = nullptr;
+    }
+};
+
+AVIFImageDecoderPlugin::AVIFImageDecoderPlugin(ReadonlyBytes data, OwnPtr<AVIFLoadingContext> context)
+    : m_context(move(context))
+{
+    m_context->data = data;
+}
+
+AVIFImageDecoderPlugin::~AVIFImageDecoderPlugin()
+{
+}
+
+static ErrorOr<void> decode_avif_header(AVIFLoadingContext& context)
+{
+    if (context.state >= AVIFLoadingContext::HeaderDecoded)
+        return {};
+
+    if (context.decoder == nullptr) {
+        context.decoder = avifDecoderCreate();
+
+        if (context.decoder == nullptr) {
+            return Error::from_string_literal("failed to allocate AVIF decoder");
+        }
+    }
+
+    avifResult result = avifDecoderSetIOMemory(context.decoder, context.data.data(), context.data.size());
+    if (result != AVIF_RESULT_OK)
+        return Error::from_string_literal("Cannot set IO on avifDecoder");
+
+    result = avifDecoderParse(context.decoder);
+    if (result != AVIF_RESULT_OK)
+        return Error::from_string_literal("Failed to decode AVIF");
+
+    if (context.decoder->image->depth != 8)
+        return Error::from_string_literal("Unsupported bitdepth");
+
+    // Image header now decoded, save some results for fast access in other parts of the plugin.
+    context.size = IntSize { context.decoder->image->width, context.decoder->image->height };
+    context.has_alpha = context.decoder->alphaPresent == 1;
+    context.image_count = context.decoder->imageCount;
+    context.repetition_count = context.decoder->repetitionCount <= 0 ? 0 : context.decoder->repetitionCount;
+    context.state = AVIFLoadingContext::State::HeaderDecoded;
+
+    if (context.decoder->image->icc.size > 0) {
+        context.icc_data.resize(context.decoder->image->icc.size);
+        memcpy(context.icc_data.data(), context.decoder->image->icc.data, context.decoder->image->icc.size);
+    }
+
+    return {};
+}
+
+static ErrorOr<void> decode_avif_image(AVIFLoadingContext& context)
+{
+    VERIFY(context.state >= AVIFLoadingContext::State::HeaderDecoded);
+
+    avifRGBImage rgb;
+    while (avifDecoderNextImage(context.decoder) == AVIF_RESULT_OK) {
+        auto bitmap_format = context.has_alpha ? BitmapFormat::BGRA8888 : BitmapFormat::BGRx8888;
+        auto bitmap = TRY(Bitmap::create(bitmap_format, context.size.value()));
+
+        avifRGBImageSetDefaults(&rgb, context.decoder->image);
+        rgb.pixels = bitmap->scanline_u8(0);
+        rgb.rowBytes = bitmap->pitch();
+        rgb.format = avifRGBFormat::AVIF_RGB_FORMAT_BGRA;
+
+        avifResult result = avifImageYUVToRGB(context.decoder->image, &rgb);
+        if (result != AVIF_RESULT_OK)
+            return Error::from_string_literal("Conversion from YUV to RGB failed");
+
+        auto duration = context.decoder->imageCount == 1 ? 0 : static_cast<int>(context.decoder->imageTiming.duration * 1000);
+        context.frame_descriptors.append(ImageFrameDescriptor { bitmap, duration });
+
+        context.state = AVIFLoadingContext::BitmapDecoded;
+    }
+
+    return {};
+}
+
+IntSize AVIFImageDecoderPlugin::size()
+{
+    return m_context->size.value();
+}
+
+bool AVIFImageDecoderPlugin::sniff(ReadonlyBytes data)
+{
+    AVIFLoadingContext context;
+    context.data = data;
+    return !decode_avif_header(context).is_error();
+}
+
+ErrorOr<NonnullOwnPtr<ImageDecoderPlugin>> AVIFImageDecoderPlugin::create(ReadonlyBytes data)
+{
+    auto context = TRY(try_make<AVIFLoadingContext>());
+    auto plugin = TRY(adopt_nonnull_own_or_enomem(new (nothrow) AVIFImageDecoderPlugin(data, move(context))));
+    TRY(decode_avif_header(*plugin->m_context));
+    return plugin;
+}
+
+bool AVIFImageDecoderPlugin::is_animated()
+{
+    return m_context->image_count > 1;
+}
+
+size_t AVIFImageDecoderPlugin::loop_count()
+{
+    return is_animated() ? m_context->repetition_count : 0;
+}
+
+size_t AVIFImageDecoderPlugin::frame_count()
+{
+    if (!is_animated())
+        return 1;
+    return m_context->image_count;
+}
+
+size_t AVIFImageDecoderPlugin::first_animated_frame_index()
+{
+    return 0;
+}
+
+ErrorOr<ImageFrameDescriptor> AVIFImageDecoderPlugin::frame(size_t index, Optional<IntSize>)
+{
+    if (index >= frame_count())
+        return Error::from_string_literal("AVIFImageDecoderPlugin: Invalid frame index");
+
+    if (m_context->state == AVIFLoadingContext::State::Error)
+        return Error::from_string_literal("AVIFImageDecoderPlugin: Decoding failed");
+
+    if (m_context->state < AVIFLoadingContext::State::BitmapDecoded) {
+        TRY(decode_avif_image(*m_context));
+        m_context->state = AVIFLoadingContext::State::BitmapDecoded;
+    }
+
+    if (index >= m_context->frame_descriptors.size())
+        return Error::from_string_literal("AVIFImageDecoderPlugin: Invalid frame index");
+    return m_context->frame_descriptors[index];
+}
+
+ErrorOr<Optional<ReadonlyBytes>> AVIFImageDecoderPlugin::icc_data()
+{
+    if (m_context->state < AVIFLoadingContext::State::HeaderDecoded)
+        (void)frame(0);
+
+    if (!m_context->icc_data.is_empty())
+        return m_context->icc_data;
+    return OptionalNone {};
+}
+
+}