ladybird/Userland/Libraries/LibGfx/Font/WOFF2/Font.cpp

/*
 * Copyright (c) 2022, Luke Wilde <lukew@serenityos.org>
 * Copyright (c) 2023, Andreas Kling <kling@serenityos.org>
 * Copyright (c) 2023, Sam Atkins <atkinssj@serenityos.org>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#include <AK/BitStream.h>
#include <AK/MemoryStream.h>
#include <LibCompress/Brotli.h>
#include <LibCore/Resource.h>
#include <LibGfx/Font/Font.h>
#include <LibGfx/Font/OpenType/Font.h>
#include <LibGfx/Font/WOFF2/Font.h>

// The following is an implementation of the WOFF2 specification.
// https://www.w3.org/TR/WOFF2/

namespace WOFF2 {

// https://www.w3.org/TR/WOFF2/#woff20Header
struct [[gnu::packed]] Header {
    BigEndian<u32> signature;             // 0x774F4632 'wOF2'
    BigEndian<u32> flavor;                // The "sfnt version" of the input font.
    BigEndian<u32> length;                // Total size of the WOFF file.
    BigEndian<u16> num_tables;            // Number of entries in directory of font tables.
    BigEndian<u16> reserved;              // Reserved; set to 0.
    BigEndian<u32> total_sfnt_size;       // Total size needed for the uncompressed font data, including the sfnt header,
                                          // directory, and font tables (including padding).
    BigEndian<u32> total_compressed_size; // Total length of the compressed data block.
    BigEndian<u16> major_version;         // Major version of the WOFF file.
    BigEndian<u16> minor_version;         // Minor version of the WOFF file.
    BigEndian<u32> meta_offset;           // Offset to metadata block, from beginning of WOFF file.
    BigEndian<u32> meta_length;           // Length of compressed metadata block.
    BigEndian<u32> meta_orig_length;      // Uncompressed size of metadata block.
    BigEndian<u32> priv_offset;           // Offset to private data block, from beginning of WOFF file.
    BigEndian<u32> priv_length;           // Length of private data block.
};
static_assert(AssertSize<Header, 48>());

}

template<>
class AK::Traits<WOFF2::Header> : public DefaultTraits<WOFF2::Header> {
public:
    static constexpr bool is_trivially_serializable() { return true; }
};

namespace WOFF2 {

static constexpr u32 WOFF2_SIGNATURE = 0x774F4632;
static constexpr u32 TTCF_SIGNAURE = 0x74746366;
static constexpr size_t SFNT_HEADER_SIZE = 12;
static constexpr size_t SFNT_TABLE_SIZE = 16;

[[maybe_unused]] static ErrorOr<u16> read_255_u_short(FixedMemoryStream& stream)
{
    constexpr u8 one_more_byte_code_1 = 255;
    constexpr u8 one_more_byte_code_2 = 254;
    constexpr u8 word_code = 253;
    constexpr u8 lowest_u_code = 253;
    constexpr u16 lowest_u_code_multiplied_by_2 = lowest_u_code * 2;

    auto code = TRY(stream.read_value<u8>());

    if (code == word_code) {
        return TRY(stream.read_value<BigEndian<u16>>());
    }

    if (code == one_more_byte_code_1) {
        u16 final_value = TRY(stream.read_value<u8>());
        final_value += lowest_u_code;
        return final_value;
    }

    if (code == one_more_byte_code_2) {
        u16 final_value = TRY(stream.read_value<u8>());
        final_value += lowest_u_code_multiplied_by_2;
        return final_value;
    }
    return code;
}

static ErrorOr<u32> read_uint_base_128(SeekableStream& stream)
{
    u32 accumulator = 0;

    for (u8 i = 0; i < 5; ++i) {
        u8 const next_byte = TRY(stream.read_value<u8>());

        if (i == 0 && next_byte == 0x80)
            return Error::from_string_literal("UIntBase128 type contains a leading zero");

        if (accumulator & 0xfe000000)
            return Error::from_string_literal("UIntBase128 type exceeds the length of a u32");

        accumulator = (accumulator << 7) | (next_byte & 0x7F);

        if ((next_byte & 0x80) == 0)
            return accumulator;
    }

    return Error::from_string_literal("UIntBase128 type is larger than 5 bytes");
}

static i16 be_i16(u8 const* ptr)
{
    return (((i16)ptr[0]) << 8) | ((i16)ptr[1]);
}

static u16 pow_2_less_than_or_equal(u16 x)
{
    VERIFY(x > 0);
    VERIFY(x < 32769);
    return 1 << (sizeof(u16) * 8 - count_leading_zeroes_safe<u16>(x - 1));
}

enum class TransformationVersion {
    Version0,
    Version1,
    Version2,
    Version3,
};

struct TableDirectoryEntry {
    TransformationVersion transformation_version { TransformationVersion::Version0 };
    OpenType::Tag tag;
    u32 original_length { 0 };
    Optional<u32> transform_length;

    bool has_transformation() const
    {
        return transform_length.has_value();
    }
};

// NOTE: Any tags less than 4 characters long are padded with spaces at the end.
static constexpr Array<OpenType::Tag, 63> known_tag_names = {
    OpenType::Tag("cmap"),
    OpenType::Tag("head"),
    OpenType::Tag("hhea"),
    OpenType::Tag("hmtx"),
    OpenType::Tag("maxp"),
    OpenType::Tag("name"),
    OpenType::Tag("OS/2"),
    OpenType::Tag("post"),
    OpenType::Tag("cvt "),
    OpenType::Tag("fpgm"),
    OpenType::Tag("glyf"),
    OpenType::Tag("loca"),
    OpenType::Tag("prep"),
    OpenType::Tag("CFF "),
    OpenType::Tag("VORG"),
    OpenType::Tag("EBDT"),
    OpenType::Tag("EBLC"),
    OpenType::Tag("gasp"),
    OpenType::Tag("hdmx"),
    OpenType::Tag("kern"),
    OpenType::Tag("LTSH"),
    OpenType::Tag("PCLT"),
    OpenType::Tag("VDMX"),
    OpenType::Tag("vhea"),
    OpenType::Tag("vmtx"),
    OpenType::Tag("BASE"),
    OpenType::Tag("GDEF"),
    OpenType::Tag("GPOS"),
    OpenType::Tag("GSUB"),
    OpenType::Tag("EBSC"),
    OpenType::Tag("JSTF"),
    OpenType::Tag("MATH"),
    OpenType::Tag("CBDT"),
    OpenType::Tag("CBLC"),
    OpenType::Tag("COLR"),
    OpenType::Tag("CPAL"),
    OpenType::Tag("SVG "),
    OpenType::Tag("sbix"),
    OpenType::Tag("acnt"),
    OpenType::Tag("avar"),
    OpenType::Tag("bdat"),
    OpenType::Tag("bloc"),
    OpenType::Tag("bsln"),
    OpenType::Tag("cvar"),
    OpenType::Tag("fdsc"),
    OpenType::Tag("feat"),
    OpenType::Tag("fmtx"),
    OpenType::Tag("fvar"),
    OpenType::Tag("gvar"),
    OpenType::Tag("hsty"),
    OpenType::Tag("just"),
    OpenType::Tag("lcar"),
    OpenType::Tag("mort"),
    OpenType::Tag("morx"),
    OpenType::Tag("opbd"),
    OpenType::Tag("prop"),
    OpenType::Tag("trak"),
    OpenType::Tag("Zapf"),
    OpenType::Tag("Silf"),
    OpenType::Tag("Glat"),
    OpenType::Tag("Gloc"),
    OpenType::Tag("Feat"),
    OpenType::Tag("Sill"),
};

struct CoordinateTripletEncoding {
    u8 byte_count { 0 };
    u8 x_bits { 0 };
    u8 y_bits { 0 };
    Optional<u16> delta_x;
    Optional<u16> delta_y;
    Optional<bool> positive_x;
    Optional<bool> positive_y;
};

// https://www.w3.org/TR/WOFF2/#triplet_decoding
// 5.2. Decoding of variable-length X and Y coordinates
static CoordinateTripletEncoding const coordinate_triplet_encodings[128] = {
    { 2, 0, 8, {}, 0, {}, false },       // 0
    { 2, 0, 8, {}, 0, {}, true },        // 1
    { 2, 0, 8, {}, 256, {}, false },     // 2
    { 2, 0, 8, {}, 256, {}, true },      // 3
    { 2, 0, 8, {}, 512, {}, false },     // 4
    { 2, 0, 8, {}, 512, {}, true },      // 5
    { 2, 0, 8, {}, 768, {}, false },     // 6
    { 2, 0, 8, {}, 768, {}, true },      // 7
    { 2, 0, 8, {}, 1024, {}, false },    // 8
    { 2, 0, 8, {}, 1024, {}, true },     // 9
    { 2, 8, 0, 0, {}, false, {} },       // 10
    { 2, 8, 0, 0, {}, true, {} },        // 11
    { 2, 8, 0, 256, {}, false, {} },     // 12
    { 2, 8, 0, 256, {}, true, {} },      // 13
    { 2, 8, 0, 512, {}, false, {} },     // 14
    { 2, 8, 0, 512, {}, true, {} },      // 15
    { 2, 8, 0, 768, {}, false, {} },     // 16
    { 2, 8, 0, 768, {}, true, {} },      // 17
    { 2, 8, 0, 1024, {}, false, {} },    // 18
    { 2, 8, 0, 1024, {}, true, {} },     // 19
    { 2, 4, 4, 1, 1, false, false },     // 20
    { 2, 4, 4, 1, 1, true, false },      // 21
    { 2, 4, 4, 1, 1, false, true },      // 22
    { 2, 4, 4, 1, 1, true, true },       // 23
    { 2, 4, 4, 1, 17, false, false },    // 24
    { 2, 4, 4, 1, 17, true, false },     // 25
    { 2, 4, 4, 1, 17, false, true },     // 26
    { 2, 4, 4, 1, 17, true, true },      // 27
    { 2, 4, 4, 1, 33, false, false },    // 28
    { 2, 4, 4, 1, 33, true, false },     // 29
    { 2, 4, 4, 1, 33, false, true },     // 30
    { 2, 4, 4, 1, 33, true, true },      // 31
    { 2, 4, 4, 1, 49, false, false },    // 32
    { 2, 4, 4, 1, 49, true, false },     // 33
    { 2, 4, 4, 1, 49, false, true },     // 34
    { 2, 4, 4, 1, 49, true, true },      // 35
    { 2, 4, 4, 17, 1, false, false },    // 36
    { 2, 4, 4, 17, 1, true, false },     // 37
    { 2, 4, 4, 17, 1, false, true },     // 38
    { 2, 4, 4, 17, 1, true, true },      // 39
    { 2, 4, 4, 17, 17, false, false },   // 40
    { 2, 4, 4, 17, 17, true, false },    // 41
    { 2, 4, 4, 17, 17, false, true },    // 42
    { 2, 4, 4, 17, 17, true, true },     // 43
    { 2, 4, 4, 17, 33, false, false },   // 44
    { 2, 4, 4, 17, 33, true, false },    // 45
    { 2, 4, 4, 17, 33, false, true },    // 46
    { 2, 4, 4, 17, 33, true, true },     // 47
    { 2, 4, 4, 17, 49, false, false },   // 48
    { 2, 4, 4, 17, 49, true, false },    // 49
    { 2, 4, 4, 17, 49, false, true },    // 50
    { 2, 4, 4, 17, 49, true, true },     // 51
    { 2, 4, 4, 33, 1, false, false },    // 52
    { 2, 4, 4, 33, 1, true, false },     // 53
    { 2, 4, 4, 33, 1, false, true },     // 54
    { 2, 4, 4, 33, 1, true, true },      // 55
    { 2, 4, 4, 33, 17, false, false },   // 56
    { 2, 4, 4, 33, 17, true, false },    // 57
    { 2, 4, 4, 33, 17, false, true },    // 58
    { 2, 4, 4, 33, 17, true, true },     // 59
    { 2, 4, 4, 33, 33, false, false },   // 60
    { 2, 4, 4, 33, 33, true, false },    // 61
    { 2, 4, 4, 33, 33, false, true },    // 62
    { 2, 4, 4, 33, 33, true, true },     // 63
    { 2, 4, 4, 33, 49, false, false },   // 64
    { 2, 4, 4, 33, 49, true, false },    // 65
    { 2, 4, 4, 33, 49, false, true },    // 66
    { 2, 4, 4, 33, 49, true, true },     // 67
    { 2, 4, 4, 49, 1, false, false },    // 68
    { 2, 4, 4, 49, 1, true, false },     // 69
    { 2, 4, 4, 49, 1, false, true },     // 70
    { 2, 4, 4, 49, 1, true, true },      // 71
    { 2, 4, 4, 49, 17, false, false },   // 72
    { 2, 4, 4, 49, 17, true, false },    // 73
    { 2, 4, 4, 49, 17, false, true },    // 74
    { 2, 4, 4, 49, 17, true, true },     // 75
    { 2, 4, 4, 49, 33, false, false },   // 76
    { 2, 4, 4, 49, 33, true, false },    // 77
    { 2, 4, 4, 49, 33, false, true },    // 78
    { 2, 4, 4, 49, 33, true, true },     // 79
    { 2, 4, 4, 49, 49, false, false },   // 80
    { 2, 4, 4, 49, 49, true, false },    // 81
    { 2, 4, 4, 49, 49, false, true },    // 82
    { 2, 4, 4, 49, 49, true, true },     // 83
    { 3, 8, 8, 1, 1, false, false },     // 84
    { 3, 8, 8, 1, 1, true, false },      // 85
    { 3, 8, 8, 1, 1, false, true },      // 86
    { 3, 8, 8, 1, 1, true, true },       // 87
    { 3, 8, 8, 1, 257, false, false },   // 88
    { 3, 8, 8, 1, 257, true, false },    // 89
    { 3, 8, 8, 1, 257, false, true },    // 90
    { 3, 8, 8, 1, 257, true, true },     // 91
    { 3, 8, 8, 1, 513, false, false },   // 92
    { 3, 8, 8, 1, 513, true, false },    // 93
    { 3, 8, 8, 1, 513, false, true },    // 94
    { 3, 8, 8, 1, 513, true, true },     // 95
    { 3, 8, 8, 257, 1, false, false },   // 96
    { 3, 8, 8, 257, 1, true, false },    // 97
    { 3, 8, 8, 257, 1, false, true },    // 98
    { 3, 8, 8, 257, 1, true, true },     // 99
    { 3, 8, 8, 257, 257, false, false }, // 100
    { 3, 8, 8, 257, 257, true, false },  // 101
    { 3, 8, 8, 257, 257, false, true },  // 102
    { 3, 8, 8, 257, 257, true, true },   // 103
    { 3, 8, 8, 257, 513, false, false }, // 104
    { 3, 8, 8, 257, 513, true, false },  // 105
    { 3, 8, 8, 257, 513, false, true },  // 106
    { 3, 8, 8, 257, 513, true, true },   // 107
    { 3, 8, 8, 513, 1, false, false },   // 108
    { 3, 8, 8, 513, 1, true, false },    // 109
    { 3, 8, 8, 513, 1, false, true },    // 110
    { 3, 8, 8, 513, 1, true, true },     // 111
    { 3, 8, 8, 513, 257, false, false }, // 112
    { 3, 8, 8, 513, 257, true, false },  // 113
    { 3, 8, 8, 513, 257, false, true },  // 114
    { 3, 8, 8, 513, 257, true, true },   // 115
    { 3, 8, 8, 513, 513, false, false }, // 116
    { 3, 8, 8, 513, 513, true, false },  // 117
    { 3, 8, 8, 513, 513, false, true },  // 118
    { 3, 8, 8, 513, 513, true, true },   // 119
    { 4, 12, 12, 0, 0, false, false },   // 120
    { 4, 12, 12, 0, 0, true, false },    // 121
    { 4, 12, 12, 0, 0, false, true },    // 122
    { 4, 12, 12, 0, 0, true, true },     // 123
    { 5, 16, 16, 0, 0, false, false },   // 124
    { 5, 16, 16, 0, 0, true, false },    // 125
    { 5, 16, 16, 0, 0, false, true },    // 126
    { 5, 16, 16, 0, 0, true, true },     // 127
};

struct FontPoint {
    i16 x { 0 };
    i16 y { 0 };
    bool on_curve { false };
};

static ErrorOr<Vector<FontPoint>> retrieve_points_of_simple_glyph(FixedMemoryStream& flags_stream, FixedMemoryStream& glyph_stream, u16 number_of_points)
{
    Vector<FontPoint> points;
    TRY(points.try_ensure_capacity(number_of_points));

    i16 x = 0;
    i16 y = 0;

    for (u32 point = 0; point < number_of_points; ++point) {
        u8 flags = TRY(flags_stream.read_value<u8>());
        bool on_curve = (flags & 0x80) == 0;
        u8 coordinate_triplet_index = flags & 0x7F;

        auto const& coordinate_triplet_encoding = coordinate_triplet_encodings[coordinate_triplet_index];

        // The byte_count in the array accounts for the flags, but we already read them in from a different stream.
        u8 const byte_count_not_including_flags = coordinate_triplet_encoding.byte_count - 1;

        u8 point_coordinates_buffer[4];
        Bytes point_coordinates { point_coordinates_buffer, byte_count_not_including_flags };
        TRY(glyph_stream.read_until_filled(point_coordinates));

        int delta_x = 0;
        int delta_y = 0;

        switch (coordinate_triplet_encoding.x_bits) {
        case 0:
            break;
        case 4:
            delta_x = static_cast<i16>(point_coordinates[0] >> 4);
            break;
        case 8:
            delta_x = static_cast<i16>(point_coordinates[0]);
            break;
        case 12:
            delta_x = (static_cast<i16>(point_coordinates[0]) << 4) | (static_cast<i16>(point_coordinates[1]) >> 4);
            break;
        case 16:
            delta_x = be_i16(point_coordinates.data());
            break;
        default:
            VERIFY_NOT_REACHED();
        }

        switch (coordinate_triplet_encoding.y_bits) {
        case 0:
            break;
        case 4:
            delta_y = static_cast<i16>(point_coordinates[0] & 0x0f);
            break;
        case 8:
            delta_y = byte_count_not_including_flags == 2 ? static_cast<i16>(point_coordinates[1]) : static_cast<i16>(point_coordinates[0]);
            break;
        case 12:
            delta_y = (static_cast<i16>(point_coordinates[1] & 0x0f) << 8) | static_cast<i16>(point_coordinates[2]);
            break;
        case 16:
            delta_y = be_i16(point_coordinates.offset(2));
            break;
        default:
            VERIFY_NOT_REACHED();
        }

        if (coordinate_triplet_encoding.delta_x.has_value()) {
            if (Checked<i16>::addition_would_overflow(delta_x, coordinate_triplet_encoding.delta_x.value()))
                return Error::from_string_literal("EOVERFLOW 3");

            delta_x += coordinate_triplet_encoding.delta_x.value();
        }

        if (coordinate_triplet_encoding.delta_y.has_value()) {
            if (Checked<i16>::addition_would_overflow(delta_y, coordinate_triplet_encoding.delta_y.value()))
                return Error::from_string_literal("EOVERFLOW 4");

            delta_y += coordinate_triplet_encoding.delta_y.value();
        }

        if (coordinate_triplet_encoding.positive_x.has_value() && !coordinate_triplet_encoding.positive_x.value())
            delta_x = -delta_x;

        if (coordinate_triplet_encoding.positive_y.has_value() && !coordinate_triplet_encoding.positive_y.value())
            delta_y = -delta_y;

        if (Checked<i16>::addition_would_overflow(x, delta_x))
            return Error::from_string_literal("EOVERFLOW 5");

        if (Checked<i16>::addition_would_overflow(y, delta_y))
            return Error::from_string_literal("EOVERFLOW 6");

        x += delta_x;
        y += delta_y;

        points.unchecked_append(FontPoint { .x = x, .y = y, .on_curve = on_curve });
    }

    return points;
}

// https://www.w3.org/TR/WOFF2/#glyf_table_format
struct [[gnu::packed]] TransformedGlyfTable {
    BigEndian<u16> reserved;                // = 0x0000
    BigEndian<u16> option_flags;            // Bit 0: if set, indicates the presence of the overlapSimpleBitmap[] bit array.
                                            // Bits 1-15: Reserved.
    BigEndian<u16> num_glyphs;              // Number of glyphs
    BigEndian<u16> index_format;            // Offset format for loca table, should be consistent with indexToLocFormat of the
                                            // original head table (see [OFF] specification)
    BigEndian<u32> n_contour_stream_size;   // Size of nContour stream in bytes
    BigEndian<u32> n_points_stream_size;    // Size of nPoints stream in bytes
    BigEndian<u32> flag_stream_size;        // Size of flag stream in bytes
    BigEndian<u32> glyph_stream_size;       // Size of glyph stream in bytes (a stream of variable-length encoded values, see
                                            // description below)
    BigEndian<u32> composite_stream_size;   // Size of composite stream in bytes (a stream of variable-length encoded values,
                                            // see description below)
    BigEndian<u32> bbox_stream_size;        // Size of bbox data in bytes representing combined length of bboxBitmap
                                            // (a packed bit array) and bboxStream (a stream of Int16 values)
    BigEndian<u32> instruction_stream_size; // Size of instruction stream (a stream of UInt8 values)

    // Other fields are variable-length, and so are not represented in this struct:
    // Int16      nContourStream[]       Stream of Int16 values representing number of contours for each glyph record
    // 255UInt16  nPointsStream[]        Stream of values representing number of outline points for each contour in glyph records
    // UInt8      flagStream[]           Stream of UInt8 values representing flag values for each outline point.
    // Vary       glyphStream[]          Stream of bytes representing point coordinate values using variable length encoding
    //                                   format (defined in subclause 5.2)
    // Vary       compositeStream[]      Stream of bytes representing component flag values and associated composite glyph data
    // UInt8      bboxBitmap[]           Bitmap (a numGlyphs-long bit array) indicating explicit bounding boxes
    // Int16      bboxStream[]           Stream of Int16 values representing glyph bounding box data
    // UInt8      instructionStream[]    Stream of UInt8 values representing a set of instructions for each corresponding glyph
    // UInt8      overlapSimpleBitmap[]  A numGlyphs-long bit array that provides values for the overlap flag [bit 6] for each
    //                                   simple glyph. (Flag values for composite glyphs are already encoded as part of the
    //                                   compositeStream[]).
};
static_assert(AssertSize<TransformedGlyfTable, 36>());

}

template<>
class AK::Traits<WOFF2::TransformedGlyfTable> : public DefaultTraits<WOFF2::TransformedGlyfTable> {
public:
    static constexpr bool is_trivially_serializable() { return true; }
};

namespace WOFF2 {

enum class LocaElementSize {
    TwoBytes,
    FourBytes,
};

struct GlyfAndLocaTableBuffers {
    ByteBuffer glyf_table;
    ByteBuffer loca_table;
};

enum SimpleGlyphFlags : u8 {
    OnCurve = 0x01,
    XShortVector = 0x02,
    YShortVector = 0x04,
    RepeatFlag = 0x08,
    XIsSameOrPositiveXShortVector = 0x10,
    YIsSameOrPositiveYShortVector = 0x20,
};

static ErrorOr<GlyfAndLocaTableBuffers> create_glyf_and_loca_tables_from_transformed_glyf_table(FixedMemoryStream& table_stream)
{
    auto header = TRY(table_stream.read_value<TransformedGlyfTable>());

    auto loca_element_size = header.index_format == 0 ? LocaElementSize::TwoBytes : LocaElementSize::FourBytes;

    size_t table_size = TRY(table_stream.size());
    u64 total_size_of_streams = header.n_contour_stream_size;
    total_size_of_streams += header.n_points_stream_size;
    total_size_of_streams += header.flag_stream_size;
    total_size_of_streams += header.glyph_stream_size;
    total_size_of_streams += header.composite_stream_size;
    total_size_of_streams += header.bbox_stream_size;
    total_size_of_streams += header.instruction_stream_size;

    if (table_size < total_size_of_streams)
        return Error::from_string_literal("Not enough data to read in streams of transformed glyf table");

    auto number_of_contours_stream = FixedMemoryStream(TRY(table_stream.read_in_place<u8>(header.n_contour_stream_size)));
    auto number_of_points_stream = FixedMemoryStream(TRY(table_stream.read_in_place<u8>(header.n_points_stream_size)));
    auto flag_stream = FixedMemoryStream(TRY(table_stream.read_in_place<u8>(header.flag_stream_size)));
    auto glyph_stream = FixedMemoryStream(TRY(table_stream.read_in_place<u8>(header.glyph_stream_size)));
    auto composite_stream = FixedMemoryStream(TRY(table_stream.read_in_place<u8>(header.composite_stream_size)));

    size_t bounding_box_bitmap_length = ((header.num_glyphs + 31) >> 5) << 2;
    auto bounding_box_bitmap_memory_stream = FixedMemoryStream(TRY(table_stream.read_in_place<u8>(bounding_box_bitmap_length)));
    auto bounding_box_bitmap_bit_stream = BigEndianInputBitStream { MaybeOwned<Stream>(bounding_box_bitmap_memory_stream) };

    if (header.bbox_stream_size < bounding_box_bitmap_length)
        return Error::from_string_literal("Not enough data to read bounding box stream of transformed glyf table");
    auto bounding_box_stream = FixedMemoryStream(TRY(table_stream.read_in_place<u8>(header.bbox_stream_size - bounding_box_bitmap_length)));

    auto instruction_stream = FixedMemoryStream(TRY(table_stream.read_in_place<u8>(header.instruction_stream_size)));

    ByteBuffer reconstructed_glyf_table;
    Vector<u32> loca_indexes;

    auto append_u16 = [&](BigEndian<u16> value) -> ErrorOr<void> {
        return reconstructed_glyf_table.try_append(&value, sizeof(value));
    };

    auto append_i16 = [&](BigEndian<i16> value) -> ErrorOr<void> {
        return reconstructed_glyf_table.try_append(&value, sizeof(value));
    };

    auto append_bytes = [&](ReadonlyBytes bytes) -> ErrorOr<void> {
        return reconstructed_glyf_table.try_append(bytes);
    };

    for (size_t glyph_index = 0; glyph_index < header.num_glyphs; ++glyph_index) {
        size_t starting_glyf_table_size = reconstructed_glyf_table.size();

        bool has_bounding_box = TRY(bounding_box_bitmap_bit_stream.read_bit());

        auto number_of_contours = TRY(number_of_contours_stream.read_value<BigEndian<i16>>());

        if (number_of_contours == 0) {
            // Empty glyph

            // Reconstruction of an empty glyph (when nContour = 0) is a simple step
            // that involves incrementing the glyph record count and creating a new entry in the loca table
            // where loca[n] = loca[n-1].

            // If the bboxBitmap flag indicates that the bounding box values are explicitly encoded in the bboxStream
            // the decoder MUST reject WOFF2 file as invalid.
            if (has_bounding_box)
                return Error::from_string_literal("Empty glyphs cannot have an explicit bounding box");
        } else if (number_of_contours < 0) {
            // Decoding of Composite Glyphs

            [[maybe_unused]] i16 bounding_box_x_min = 0;
            [[maybe_unused]] i16 bounding_box_y_min = 0;
            [[maybe_unused]] i16 bounding_box_x_max = 0;
            [[maybe_unused]] i16 bounding_box_y_max = 0;

            if (has_bounding_box) {
                bounding_box_x_min = TRY(bounding_box_stream.read_value<BigEndian<i16>>());
                bounding_box_y_min = TRY(bounding_box_stream.read_value<BigEndian<i16>>());
                bounding_box_x_max = TRY(bounding_box_stream.read_value<BigEndian<i16>>());
                bounding_box_y_max = TRY(bounding_box_stream.read_value<BigEndian<i16>>());
            }

            TRY(append_i16(number_of_contours));
            TRY(append_i16(bounding_box_x_min));
            TRY(append_i16(bounding_box_y_min));
            TRY(append_i16(bounding_box_x_max));
            TRY(append_i16(bounding_box_y_max));

            bool have_instructions = false;
            u16 flags = to_underlying(OpenType::Glyf::CompositeFlags::MoreComponents);
            while (flags & to_underlying(OpenType::Glyf::CompositeFlags::MoreComponents)) {
                // 1a. Read a UInt16 from compositeStream. This is interpreted as a component flag word as in the TrueType spec.
                //     Based on the flag values, there are between 4 and 14 additional argument bytes,
                //     interpreted as glyph index, arg1, arg2, and optional scale or affine matrix.

                flags = TRY(composite_stream.read_value<BigEndian<u16>>());

                if (flags & to_underlying(OpenType::Glyf::CompositeFlags::WeHaveInstructions)) {
                    have_instructions = true;
                }

                // 2a. Read the number of argument bytes as determined in step 1a from the composite stream,
                //     and store these in the reconstructed glyph.
                //     If the flag word read in step 1a has the FLAG_MORE_COMPONENTS bit (bit 5) set, go back to step 1a.

                size_t argument_byte_count = 2;

                if (flags & to_underlying(OpenType::Glyf::CompositeFlags::Arg1AndArg2AreWords)) {
                    argument_byte_count += 4;
                } else {
                    argument_byte_count += 2;
                }

                if (flags & to_underlying(OpenType::Glyf::CompositeFlags::WeHaveAScale)) {
                    argument_byte_count += 2;
                } else if (flags & to_underlying(OpenType::Glyf::CompositeFlags::WeHaveAnXAndYScale)) {
                    argument_byte_count += 4;
                } else if (flags & to_underlying(OpenType::Glyf::CompositeFlags::WeHaveATwoByTwo)) {
                    argument_byte_count += 8;
                }

                TRY(append_u16(flags));
                TRY(reconstructed_glyf_table.try_append(TRY(composite_stream.read_in_place<u8>(argument_byte_count))));
            }

            if (have_instructions) {
                auto number_of_instructions = TRY(read_255_u_short(glyph_stream));
                TRY(append_u16(number_of_instructions));

                if (number_of_instructions)
                    TRY(reconstructed_glyf_table.try_append(TRY(instruction_stream.read_in_place<u8>(number_of_instructions))));
            }
        } else if (number_of_contours > 0) {
            // Decoding of Simple Glyphs

            // For a simple glyph (when nContour > 0), the process continues as follows:
            // Each of these is the number of points of that contour.
            // Convert this into the endPtsOfContours[] array by computing the cumulative sum, then subtracting one.

            Vector<size_t> end_points_of_contours;
            size_t number_of_points = 0;

            for (size_t contour_index = 0; contour_index < static_cast<size_t>(number_of_contours); ++contour_index) {
                size_t number_of_points_for_this_contour = TRY(read_255_u_short(number_of_points_stream));
                if (Checked<size_t>::addition_would_overflow(number_of_points, number_of_points_for_this_contour))
                    return Error::from_string_literal("EOVERFLOW 1");

                number_of_points += number_of_points_for_this_contour;
                if (number_of_points == 0)
                    return Error::from_string_literal("EOVERFLOW 2");

                TRY(end_points_of_contours.try_append(number_of_points - 1));
            }

            auto points = TRY(retrieve_points_of_simple_glyph(flag_stream, glyph_stream, number_of_points));

            auto instruction_size = TRY(read_255_u_short(glyph_stream));
            auto instructions_buffer = TRY(ByteBuffer::create_zeroed(instruction_size));
            if (instruction_size != 0)
                TRY(instruction_stream.read_until_filled(instructions_buffer));

            i16 bounding_box_x_min = 0;
            i16 bounding_box_y_min = 0;
            i16 bounding_box_x_max = 0;
            i16 bounding_box_y_max = 0;

            if (has_bounding_box) {
                bounding_box_x_min = TRY(bounding_box_stream.read_value<BigEndian<i16>>());
                bounding_box_y_min = TRY(bounding_box_stream.read_value<BigEndian<i16>>());
                bounding_box_x_max = TRY(bounding_box_stream.read_value<BigEndian<i16>>());
                bounding_box_y_max = TRY(bounding_box_stream.read_value<BigEndian<i16>>());
            } else {
                for (size_t point_index = 0; point_index < points.size(); ++point_index) {
                    auto& point = points.at(point_index);

                    if (point_index == 0) {
                        bounding_box_x_min = bounding_box_x_max = point.x;
                        bounding_box_y_min = bounding_box_y_max = point.y;
                        continue;
                    }

                    bounding_box_x_min = min(bounding_box_x_min, point.x);
                    bounding_box_x_max = max(bounding_box_x_max, point.x);
                    bounding_box_y_min = min(bounding_box_y_min, point.y);
                    bounding_box_y_max = max(bounding_box_y_max, point.y);
                }
            }

            TRY(append_i16(number_of_contours));
            TRY(append_i16(bounding_box_x_min));
            TRY(append_i16(bounding_box_y_min));
            TRY(append_i16(bounding_box_x_max));
            TRY(append_i16(bounding_box_y_max));

            for (auto end_point : end_points_of_contours)
                TRY(append_u16(end_point));

            TRY(append_u16(instruction_size));
            if (instruction_size != 0)
                TRY(append_bytes(instructions_buffer));

            Vector<FontPoint> relative_points;
            TRY(relative_points.try_ensure_capacity(points.size()));

            {
                i16 previous_point_x = 0;
                i16 previous_point_y = 0;
                for (auto& point : points) {
                    i16 x = point.x - previous_point_x;
                    i16 y = point.y - previous_point_y;
                    relative_points.unchecked_append({ x, y, point.on_curve });
                    previous_point_x = point.x;
                    previous_point_y = point.y;
                }
            }

            Optional<u8> last_flags;
            u8 repeat_count = 0;

            for (auto& point : relative_points) {
                u8 flags = 0;

                if (point.on_curve)
                    flags |= SimpleGlyphFlags::OnCurve;

                if (point.x == 0) {
                    flags |= SimpleGlyphFlags::XIsSameOrPositiveXShortVector;
                } else if (point.x > -256 && point.x < 256) {
                    flags |= SimpleGlyphFlags::XShortVector;

                    if (point.x > 0)
                        flags |= SimpleGlyphFlags::XIsSameOrPositiveXShortVector;
                }

                if (point.y == 0) {
                    flags |= SimpleGlyphFlags::YIsSameOrPositiveYShortVector;
                } else if (point.y > -256 && point.y < 256) {
                    flags |= SimpleGlyphFlags::YShortVector;

                    if (point.y > 0)
                        flags |= SimpleGlyphFlags::YIsSameOrPositiveYShortVector;
                }

                if (last_flags.has_value() && flags == last_flags.value() && repeat_count != 0xff) {
                    // NOTE: Update the previous entry to say it's repeating.
                    reconstructed_glyf_table[reconstructed_glyf_table.size() - 1] |= SimpleGlyphFlags::RepeatFlag;
                    ++repeat_count;
                } else {
                    if (repeat_count != 0) {
                        TRY(reconstructed_glyf_table.try_append(repeat_count));
                        repeat_count = 0;
                    }
                    TRY(reconstructed_glyf_table.try_append(flags));
                }
                last_flags = flags;
            }
            if (repeat_count != 0) {
                TRY(reconstructed_glyf_table.try_append(repeat_count));
            }

            for (auto& point : relative_points) {
                if (point.x == 0) {
                    // No need to write to the table.
                } else if (point.x > -256 && point.x < 256) {
                    TRY(reconstructed_glyf_table.try_append(abs(point.x)));
                } else {
                    TRY(append_i16(point.x));
                }
            }

            for (auto& point : relative_points) {
                if (point.y == 0) {
                    // No need to write to the table.
                } else if (point.y > -256 && point.y < 256) {
                    TRY(reconstructed_glyf_table.try_append(abs(point.y)));
                } else {
                    TRY(append_i16(point.y));
                }
            }
        }

        // NOTE: Make sure each glyph starts on a 4-byte boundary.
        //       I haven't found the spec text for this, but it matches other implementations.
        while (reconstructed_glyf_table.size() % 4 != 0) {
            TRY(reconstructed_glyf_table.try_append(0));
        }

        TRY(loca_indexes.try_append(starting_glyf_table_size));
    }

    TRY(loca_indexes.try_append(reconstructed_glyf_table.size()));

    size_t loca_element_size_in_bytes = loca_element_size == LocaElementSize::TwoBytes ? sizeof(u16) : sizeof(u32);
    size_t loca_table_buffer_size = loca_indexes.size() * loca_element_size_in_bytes;
    ByteBuffer loca_table_buffer;
    TRY(loca_table_buffer.try_ensure_capacity(loca_table_buffer_size));
    for (auto loca_index : loca_indexes) {
        if (loca_element_size == LocaElementSize::TwoBytes) {
            auto value = BigEndian<u16>(loca_index >> 1);
            loca_table_buffer.append({ &value, sizeof(value) });
        } else {
            auto value = BigEndian<u32>(loca_index);
            loca_table_buffer.append({ &value, sizeof(value) });
        }
    }

    return GlyfAndLocaTableBuffers { .glyf_table = move(reconstructed_glyf_table), .loca_table = move(loca_table_buffer) };
}

ErrorOr<NonnullRefPtr<Font>> Font::try_load_from_resource(Core::Resource const& resource)
{
    return try_load_from_externally_owned_memory(resource.data());
}

ErrorOr<NonnullRefPtr<Font>> Font::try_load_from_externally_owned_memory(ReadonlyBytes bytes)
{
    FixedMemoryStream stream(bytes);
    return try_load_from_externally_owned_memory(stream);
}

ErrorOr<NonnullRefPtr<Font>> Font::try_load_from_externally_owned_memory(SeekableStream& stream)
{
    auto header = TRY(stream.read_value<Header>());

    // The signature field in the WOFF2 header MUST contain the value of 0x774F4632 ('wOF2'), which distinguishes it from WOFF 1.0 files.
    // If the field does not contain this value, user agents MUST reject the file as invalid.
    if (header.signature != WOFF2_SIGNATURE)
        return Error::from_string_literal("Invalid WOFF2 signature");

    // The interpretation of the WOFF2 Header is the same as the WOFF Header in [WOFF1], with the addition of one new totalCompressedSize field.
    // NOTE: See WOFF/Font.cpp for more comments about this.

    static constexpr size_t MAX_BUFFER_SIZE = 10 * MiB;
    if (header.length > TRY(stream.size()))
        return Error::from_string_literal("Invalid WOFF length");
    if (header.num_tables == 0 || header.num_tables > NumericLimits<u16>::max() / 16)
        return Error::from_string_literal("Invalid WOFF numTables");
    if (header.total_compressed_size > MAX_BUFFER_SIZE)
        return Error::from_string_literal("Compressed font is more than 10 MiB");
    if (header.meta_length == 0 && header.meta_offset != 0)
        return Error::from_string_literal("Invalid WOFF meta block offset");
    if (header.priv_length == 0 && header.priv_offset != 0)
        return Error::from_string_literal("Invalid WOFF private block offset");
    if (header.flavor == TTCF_SIGNAURE)
        return Error::from_string_literal("Font collections not yet supported");

    // NOTE: "The "totalSfntSize" value in the WOFF2 Header is intended to be used for reference purposes only. It may represent the size of the uncompressed input font file,
    //        but if the transformed 'glyf' and 'loca' tables are present, the uncompressed size of the reconstructed tables and the total decompressed font size may differ
    //        substantially from the original total size specified in the WOFF2 Header."
    //        We use it as an initial size of the font buffer and extend it as necessary.
    auto font_buffer_size = clamp(header.total_sfnt_size, sizeof(OpenType::TableDirectory) + header.num_tables * sizeof(TableDirectoryEntry), MAX_BUFFER_SIZE);
    auto font_buffer = TRY(ByteBuffer::create_zeroed(font_buffer_size));

    u16 search_range = pow_2_less_than_or_equal(header.num_tables);
    OpenType::TableDirectory table_directory {
        .sfnt_version = header.flavor,
        .num_tables = header.num_tables,
        .search_range = search_range * 16,
        .entry_selector = log2(search_range),
        .range_shift = header.num_tables * 16 - search_range * 16,
    };
    font_buffer.overwrite(0, &table_directory, sizeof(table_directory));

    Vector<TableDirectoryEntry> table_entries;
    TRY(table_entries.try_ensure_capacity(header.num_tables));

    u64 total_length_of_all_tables = 0;

    for (size_t table_entry_index = 0; table_entry_index < header.num_tables; ++table_entry_index) {
        TableDirectoryEntry table_directory_entry;
        u8 const flags_byte = TRY(stream.read_value<u8>());

        switch ((flags_byte & 0xC0) >> 6) {
        case 0:
            table_directory_entry.transformation_version = TransformationVersion::Version0;
            break;
        case 1:
            table_directory_entry.transformation_version = TransformationVersion::Version1;
            break;
        case 2:
            table_directory_entry.transformation_version = TransformationVersion::Version2;
            break;
        case 3:
            table_directory_entry.transformation_version = TransformationVersion::Version3;
            break;
        default:
            VERIFY_NOT_REACHED();
        }

        u8 tag_number = flags_byte & 0x3F;

        if (tag_number != 0x3F) {
            table_directory_entry.tag = known_tag_names[tag_number];
        } else {
            table_directory_entry.tag = TRY(stream.read_value<OpenType::Tag>());
        }

        table_directory_entry.original_length = TRY(read_uint_base_128(stream));

        bool needs_to_read_transform_length = false;
        if (table_directory_entry.tag == OpenType::Tag("glyf") || table_directory_entry.tag == OpenType::Tag("loca"))
            needs_to_read_transform_length = table_directory_entry.transformation_version == TransformationVersion::Version0;
        else
            needs_to_read_transform_length = table_directory_entry.transformation_version != TransformationVersion::Version0;

        if (needs_to_read_transform_length) {
            u32 transform_length = TRY(read_uint_base_128(stream));
            table_directory_entry.transform_length = transform_length;
            total_length_of_all_tables += transform_length;
        } else {
            total_length_of_all_tables += table_directory_entry.original_length;
        }

        table_entries.unchecked_append(move(table_directory_entry));
    }

    // FIXME: Read in collection header and entries.

    auto glyf_table = table_entries.find_if([](TableDirectoryEntry const& entry) {
        return entry.tag == OpenType::Tag("glyf");
    });

    auto loca_table = table_entries.find_if([](TableDirectoryEntry const& entry) {
        return entry.tag == OpenType::Tag("loca");
    });

    // "In other words, both glyf and loca tables must either be present in their transformed format or with null transform applied to both tables."
    if (glyf_table.is_end() != loca_table.is_end())
        return Error::from_string_literal("Must have both 'loca' and 'glyf' tables if one of them is present");

    if (!glyf_table.is_end() && !loca_table.is_end()) {
        if (glyf_table->transformation_version != loca_table->transformation_version)
            return Error::from_string_literal("The 'loca' and 'glyf' tables must have the same transformation version");
    }

    if (!loca_table.is_end()) {
        if (loca_table->has_transformation() && loca_table->transform_length.value() != 0)
            return Error::from_string_literal("Transformed 'loca' table must have a transform length of 0");
    }

    auto compressed_bytes_read_buffer = TRY(ByteBuffer::create_zeroed(header.total_compressed_size));
    auto compressed_bytes = TRY(stream.read_some(compressed_bytes_read_buffer));
    if (compressed_bytes.size() != header.total_compressed_size)
        return Error::from_string_literal("Not enough data to read in the reported size of the compressed data");

    auto compressed_stream = FixedMemoryStream(compressed_bytes);
    auto brotli_stream = Compress::BrotliDecompressionStream { MaybeOwned<Stream>(compressed_stream) };
    auto decompressed_table_data = TRY(brotli_stream.read_until_eof());
    if (decompressed_table_data.size() != total_length_of_all_tables)
        return Error::from_string_literal("Size of the decompressed data is not equal to the total of the reported lengths of each table");

    auto decompressed_data_stream = FixedMemoryStream(decompressed_table_data.bytes());
    size_t font_buffer_offset = SFNT_HEADER_SIZE + header.num_tables * SFNT_TABLE_SIZE;
    Optional<GlyfAndLocaTableBuffers> glyf_and_loca_buffer;
    for (size_t table_entry_index = 0; table_entry_index < header.num_tables; ++table_entry_index) {
        auto& table_entry = table_entries.at(table_entry_index);
        u32 length_to_read = table_entry.has_transformation() ? table_entry.transform_length.value() : table_entry.original_length;

        auto table_buffer = TRY(ByteBuffer::create_zeroed(length_to_read));
        auto table_bytes = TRY(decompressed_data_stream.read_some(table_buffer));
        if (table_bytes.size() != length_to_read)
            return Error::from_string_literal("Not enough data to read decompressed table");

        size_t table_directory_offset = SFNT_HEADER_SIZE + table_entry_index * SFNT_TABLE_SIZE;

        if (table_entry.has_transformation()) {
            if (table_entry.tag == OpenType::Tag("glyf")) {
                auto table_stream = FixedMemoryStream(table_bytes);
                glyf_and_loca_buffer = TRY(create_glyf_and_loca_tables_from_transformed_glyf_table(table_stream));

                if (font_buffer.size() < (font_buffer_offset + glyf_and_loca_buffer->glyf_table.size()))
                    TRY(font_buffer.try_resize(font_buffer_offset + glyf_and_loca_buffer->glyf_table.size()));

                OpenType::TableRecord table_record {
                    .table_tag = table_entry.tag,
                    .checksum = 0, // FIXME: WOFF2 does not give us the original checksum.
                    .offset = font_buffer_offset,
                    .length = glyf_and_loca_buffer->glyf_table.size(),
                };
                font_buffer.overwrite(table_directory_offset, &table_record, sizeof(table_record));

                font_buffer.overwrite(font_buffer_offset, glyf_and_loca_buffer->glyf_table.data(), glyf_and_loca_buffer->glyf_table.size());
                font_buffer_offset += glyf_and_loca_buffer->glyf_table.size();
            } else if (table_entry.tag == OpenType::Tag("loca")) {
                // FIXME: Handle loca table coming before glyf table in input?
                VERIFY(glyf_and_loca_buffer.has_value());
                if (font_buffer.size() < (font_buffer_offset + glyf_and_loca_buffer->loca_table.size()))
                    TRY(font_buffer.try_resize(font_buffer_offset + glyf_and_loca_buffer->loca_table.size()));

                OpenType::TableRecord table_record {
                    .table_tag = table_entry.tag,
                    .checksum = 0, // FIXME: WOFF2 does not give us the original checksum.
                    .offset = font_buffer_offset,
                    .length = glyf_and_loca_buffer->loca_table.size(),
                };
                font_buffer.overwrite(table_directory_offset, &table_record, sizeof(table_record));

                font_buffer.overwrite(font_buffer_offset, glyf_and_loca_buffer->loca_table.data(), glyf_and_loca_buffer->loca_table.size());
                font_buffer_offset += glyf_and_loca_buffer->loca_table.size();
            } else if (table_entry.tag == OpenType::Tag("hmtx")) {
                return Error::from_string_literal("Decoding transformed hmtx table not yet supported");
            } else {
                return Error::from_string_literal("Unknown transformation");
            }
        } else {
            OpenType::TableRecord table_record {
                .table_tag = table_entry.tag,
                .checksum = 0, // FIXME: WOFF2 does not give us the original checksum.
                .offset = font_buffer_offset,
                .length = length_to_read,
            };
            font_buffer.overwrite(table_directory_offset, &table_record, sizeof(table_record));

            if (font_buffer.size() < (font_buffer_offset + length_to_read))
                TRY(font_buffer.try_resize(font_buffer_offset + length_to_read));
            font_buffer.overwrite(font_buffer_offset, table_buffer.data(), length_to_read);

            font_buffer_offset += length_to_read;
        }
    }

    auto input_font = TRY(OpenType::Font::try_load_from_externally_owned_memory(font_buffer.bytes()));
    return adopt_ref(*new Font(input_font, move(font_buffer)));
}

}