/*
* 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)));
}
}
