RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-27 10:07:44 +00:00
Code Issues Activity Actions

LibGfx: Move TTF files from TrueTypeFont/ to Font/TrueType/

Browse source
This commit is contained in:
Simon Wanner 2022-04-09 08:52:59 +02:00 • committed by Andreas Kling
parent e84bbfed44
commit 6f8fd91f22
15 changed files with 36 additions and 36 deletions
Download patch file Download diff file Expand all files Collapse all files

158
Userland/Libraries/LibGfx/Font/TrueType/Cmap.cpp Normal file
View file

@ -0,0 +1,158 @@
/*
* Copyright (c) 2020, Srimanta Barua <srimanta.barua1@gmail.com>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <AK/Optional.h>
#include <LibGfx/Font/TrueType/Cmap.h>
namespace TTF {
extern u16 be_u16(u8 const*);
extern u32 be_u32(u8 const*);
extern i16 be_i16(u8 const*);
Optional<Cmap::Subtable::Platform> Cmap::Subtable::platform_id() const
{
switch (m_raw_platform_id) {
case 0:
return Platform::Unicode;
case 1:
return Platform::Macintosh;
case 3:
return Platform::Windows;
case 4:
return Platform::Custom;
default:
return {};
}
}
Cmap::Subtable::Format Cmap::Subtable::format() const
{
switch (be_u16(m_slice.offset_pointer(0))) {
case 0:
return Format::ByteEncoding;
case 2:
return Format::HighByte;
case 4:
return Format::SegmentToDelta;
case 6:
return Format::TrimmedTable;
case 8:
return Format::Mixed16And32;
case 10:
return Format::TrimmedArray;
case 12:
return Format::SegmentedCoverage;
case 13:
return Format::ManyToOneRange;
case 14:
return Format::UnicodeVariationSequences;
default:
VERIFY_NOT_REACHED();
}
}
u32 Cmap::num_subtables() const
{
return be_u16(m_slice.offset_pointer((u32)Offsets::NumTables));
}
Optional<Cmap::Subtable> Cmap::subtable(u32 index) const
{
if (index >= num_subtables()) {
return {};
}
u32 record_offset = (u32)Sizes::TableHeader + index * (u32)Sizes::EncodingRecord;
u16 platform_id = be_u16(m_slice.offset_pointer(record_offset));
u16 encoding_id = be_u16(m_slice.offset_pointer(record_offset + (u32)Offsets::EncodingRecord_EncodingID));
u32 subtable_offset = be_u32(m_slice.offset_pointer(record_offset + (u32)Offsets::EncodingRecord_Offset));
if (subtable_offset >= m_slice.size())
return {};
auto subtable_slice = ReadonlyBytes(m_slice.offset_pointer(subtable_offset), m_slice.size() - subtable_offset);
return Subtable(subtable_slice, platform_id, encoding_id);
}
// FIXME: This only handles formats 4 (SegmentToDelta) and 12 (SegmentedCoverage) for now.
u32 Cmap::Subtable::glyph_id_for_code_point(u32 code_point) const
{
switch (format()) {
case Format::SegmentToDelta:
return glyph_id_for_code_point_table_4(code_point);
case Format::SegmentedCoverage:
return glyph_id_for_code_point_table_12(code_point);
default:
return 0;
}
}
u32 Cmap::Subtable::glyph_id_for_code_point_table_4(u32 code_point) const
{
u32 segcount_x2 = be_u16(m_slice.offset_pointer((u32)Table4Offsets::SegCountX2));
if (m_slice.size() < segcount_x2 * (u32)Table4Sizes::NonConstMultiplier + (u32)Table4Sizes::Constant)
return 0;
u32 segcount = segcount_x2 / 2;
u32 l = 0, r = segcount - 1;
while (l < r) {
u32 mid = l + (r - l) / 2;
u32 end_code_point_at_mid = be_u16(m_slice.offset_pointer((u32)Table4Offsets::EndConstBase + (mid * 2)));
if (code_point <= end_code_point_at_mid)
r = mid;
else
l = mid + 1;
}
u32 offset = l * 2;
u32 start_code_point = be_u16(m_slice.offset_pointer((u32)Table4Offsets::StartConstBase + segcount_x2 + offset));
if (start_code_point > code_point)
return 0;
u32 delta = be_u16(m_slice.offset_pointer((u32)Table4Offsets::DeltaConstBase + segcount_x2 * 2 + offset));
u32 range = be_u16(m_slice.offset_pointer((u32)Table4Offsets::RangeConstBase + segcount_x2 * 3 + offset));
if (range == 0)
return (code_point + delta) & 0xffff;
u32 glyph_offset = (u32)Table4Offsets::GlyphOffsetConstBase + segcount_x2 * 3 + offset + range + (code_point - start_code_point) * 2;
VERIFY(glyph_offset + 2 <= m_slice.size());
return (be_u16(m_slice.offset_pointer(glyph_offset)) + delta) & 0xffff;
}
u32 Cmap::Subtable::glyph_id_for_code_point_table_12(u32 code_point) const
{
u32 num_groups = be_u32(m_slice.offset_pointer((u32)Table12Offsets::NumGroups));
VERIFY(m_slice.size() >= (u32)Table12Sizes::Header + (u32)Table12Sizes::Record * num_groups);
for (u32 offset = 0; offset < num_groups * (u32)Table12Sizes::Record; offset += (u32)Table12Sizes::Record) {
u32 start_code_point = be_u32(m_slice.offset_pointer((u32)Table12Offsets::Record_StartCode + offset));
if (code_point < start_code_point)
break;
u32 end_code_point = be_u32(m_slice.offset_pointer((u32)Table12Offsets::Record_EndCode + offset));
if (code_point > end_code_point)
continue;
u32 glyph_offset = be_u32(m_slice.offset_pointer((u32)Table12Offsets::Record_StartGlyph + offset));
return code_point - start_code_point + glyph_offset;
}
return 0;
}
u32 Cmap::glyph_id_for_code_point(u32 code_point) const
{
auto opt_subtable = subtable(m_active_index);
if (!opt_subtable.has_value())
return 0;
auto subtable = opt_subtable.value();
return subtable.glyph_id_for_code_point(code_point);
}
Optional<Cmap> Cmap::from_slice(ReadonlyBytes slice)
{
if (slice.size() < (size_t)Sizes::TableHeader)
return {};
return Cmap(slice);
}
}

111
Userland/Libraries/LibGfx/Font/TrueType/Cmap.h Normal file
View file

@ -0,0 +1,111 @@
/*
* Copyright (c) 2020, Srimanta Barua <srimanta.barua1@gmail.com>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/Span.h>
#include <stdint.h>
namespace TTF {
class Cmap {
public:
class Subtable {
public:
enum class Platform {
Unicode = 0,
Macintosh = 1,
Windows = 3,
Custom = 4,
};
enum class Format {
ByteEncoding = 0,
HighByte = 2,
SegmentToDelta = 4,
TrimmedTable = 6,
Mixed16And32 = 8,
TrimmedArray = 10,
SegmentedCoverage = 12,
ManyToOneRange = 13,
UnicodeVariationSequences = 14,
};
enum class WindowsEncoding {
UnicodeBMP = 1,
UnicodeFullRepertoire = 10,
};
Subtable(ReadonlyBytes slice, u16 platform_id, u16 encoding_id)
: m_slice(slice)
, m_raw_platform_id(platform_id)
, m_encoding_id(encoding_id)
{
}
// Returns 0 if glyph not found. This corresponds to the "missing glyph"
u32 glyph_id_for_code_point(u32 code_point) const;
Optional<Platform> platform_id() const;
u16 encoding_id() const { return m_encoding_id; }
Format format() const;
private:
enum class Table4Offsets {
SegCountX2 = 6,
EndConstBase = 14,
StartConstBase = 16,
DeltaConstBase = 16,
RangeConstBase = 16,
GlyphOffsetConstBase = 16,
};
enum class Table4Sizes {
Constant = 16,
NonConstMultiplier = 4,
};
enum class Table12Offsets {
NumGroups = 12,
Record_StartCode = 16,
Record_EndCode = 20,
Record_StartGlyph = 24,
};
enum class Table12Sizes {
Header = 16,
Record = 12,
};
u32 glyph_id_for_code_point_table_4(u32 code_point) const;
u32 glyph_id_for_code_point_table_12(u32 code_point) const;
ReadonlyBytes m_slice;
u16 m_raw_platform_id { 0 };
u16 m_encoding_id { 0 };
};
static Optional<Cmap> from_slice(ReadonlyBytes);
u32 num_subtables() const;
Optional<Subtable> subtable(u32 index) const;
void set_active_index(u32 index) { m_active_index = index; }
// Returns 0 if glyph not found. This corresponds to the "missing glyph"
u32 glyph_id_for_code_point(u32 code_point) const;
private:
enum class Offsets {
NumTables = 2,
EncodingRecord_EncodingID = 2,
EncodingRecord_Offset = 4,
};
enum class Sizes {
TableHeader = 4,
EncodingRecord = 8,
};
Cmap(ReadonlyBytes slice)
: m_slice(slice)
{
}
ReadonlyBytes m_slice;
u32 m_active_index { UINT32_MAX };
};
}

766
Userland/Libraries/LibGfx/Font/TrueType/Font.cpp Normal file
View file

@ -0,0 +1,766 @@
/*
* Copyright (c) 2020, Srimanta Barua <srimanta.barua1@gmail.com>
* Copyright (c) 2021, Andreas Kling <kling@serenityos.org>
* Copyright (c) 2022, Jelle Raaijmakers <jelle@gmta.nl>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <AK/Checked.h>
#include <AK/Try.h>
#include <AK/Utf32View.h>
#include <AK/Utf8View.h>
#include <LibCore/MappedFile.h>
#include <LibGfx/Font/TrueType/Cmap.h>
#include <LibGfx/Font/TrueType/Font.h>
#include <LibGfx/Font/TrueType/Glyf.h>
#include <LibGfx/Font/TrueType/Tables.h>
#include <LibTextCodec/Decoder.h>
#include <math.h>
#include <sys/mman.h>
namespace TTF {
u16 be_u16(u8 const*);
u32 be_u32(u8 const*);
i16 be_i16(u8 const*);
float be_fword(u8 const*);
u32 tag_from_str(char const*);
u16 be_u16(u8 const* ptr)
{
return (((u16)ptr[0]) << 8) | ((u16)ptr[1]);
}
u32 be_u32(u8 const* ptr)
{
return (((u32)ptr[0]) << 24) | (((u32)ptr[1]) << 16) | (((u32)ptr[2]) << 8) | ((u32)ptr[3]);
}
i16 be_i16(u8 const* ptr)
{
return (((i16)ptr[0]) << 8) | ((i16)ptr[1]);
}
float be_fword(u8 const* ptr)
{
return (float)be_i16(ptr) / (float)(1 << 14);
}
u32 tag_from_str(char const* str)
{
return be_u32((u8 const*)str);
}
Optional<Head> Head::from_slice(ReadonlyBytes slice)
{
if (slice.size() < (size_t)Sizes::Table) {
return {};
}
return Head(slice);
}
u16 Head::units_per_em() const
{
return be_u16(m_slice.offset_pointer((u32)Offsets::UnitsPerEM));
}
i16 Head::xmin() const
{
return be_i16(m_slice.offset_pointer((u32)Offsets::XMin));
}
i16 Head::ymin() const
{
return be_i16(m_slice.offset_pointer((u32)Offsets::YMin));
}
i16 Head::xmax() const
{
return be_i16(m_slice.offset_pointer((u32)Offsets::XMax));
}
i16 Head::ymax() const
{
return be_i16(m_slice.offset_pointer((u32)Offsets::YMax));
}
u16 Head::style() const
{
return be_u16(m_slice.offset_pointer((u32)Offsets::Style));
}
u16 Head::lowest_recommended_ppem() const
{
return be_u16(m_slice.offset_pointer((u32)Offsets::LowestRecPPEM));
}
IndexToLocFormat Head::index_to_loc_format() const
{
i16 raw = be_i16(m_slice.offset_pointer((u32)Offsets::IndexToLocFormat));
switch (raw) {
case 0:
return IndexToLocFormat::Offset16;
case 1:
return IndexToLocFormat::Offset32;
default:
VERIFY_NOT_REACHED();
}
}
Optional<Hhea> Hhea::from_slice(ReadonlyBytes slice)
{
if (slice.size() < (size_t)Sizes::Table) {
return {};
}
return Hhea(slice);
}
i16 Hhea::ascender() const
{
return be_i16(m_slice.offset_pointer((u32)Offsets::Ascender));
}
i16 Hhea::descender() const
{
return be_i16(m_slice.offset_pointer((u32)Offsets::Descender));
}
i16 Hhea::line_gap() const
{
return be_i16(m_slice.offset_pointer((u32)Offsets::LineGap));
}
u16 Hhea::advance_width_max() const
{
return be_u16(m_slice.offset_pointer((u32)Offsets::AdvanceWidthMax));
}
u16 Hhea::number_of_h_metrics() const
{
return be_u16(m_slice.offset_pointer((u32)Offsets::NumberOfHMetrics));
}
Optional<Maxp> Maxp::from_slice(ReadonlyBytes slice)
{
if (slice.size() < (size_t)Sizes::TableV0p5) {
return {};
}
return Maxp(slice);
}
u16 Maxp::num_glyphs() const
{
return be_u16(m_slice.offset_pointer((u32)Offsets::NumGlyphs));
}
Optional<Hmtx> Hmtx::from_slice(ReadonlyBytes slice, u32 num_glyphs, u32 number_of_h_metrics)
{
if (slice.size() < number_of_h_metrics * (u32)Sizes::LongHorMetric + (num_glyphs - number_of_h_metrics) * (u32)Sizes::LeftSideBearing) {
return {};
}
return Hmtx(slice, num_glyphs, number_of_h_metrics);
}
Optional<Name> Name::from_slice(ReadonlyBytes slice)
{
return Name(slice);
}
ErrorOr<Kern> Kern::from_slice(ReadonlyBytes slice)
{
if (slice.size() < sizeof(u32))
return Error::from_string_literal("Invalid kern table header"sv);
// We only support the old (2x u16) version of the header
auto version = be_u16(slice.data());
auto number_of_subtables = be_u16(slice.offset(sizeof(u16)));
if (version != 0)
return Error::from_string_literal("Unsupported kern table version"sv);
if (number_of_subtables == 0)
return Error::from_string_literal("Kern table does not contain any subtables"sv);
// Read all subtable offsets
auto subtable_offsets = TRY(FixedArray<size_t>::try_create(number_of_subtables));
size_t offset = 2 * sizeof(u16);
for (size_t i = 0; i < number_of_subtables; ++i) {
if (slice.size() < offset + Sizes::SubtableHeader)
return Error::from_string_literal("Invalid kern subtable header"sv);
subtable_offsets[i] = offset;
auto subtable_size = be_u16(slice.offset(offset + sizeof(u16)));
offset += subtable_size;
}
return Kern(slice, move(subtable_offsets));
}
i16 Kern::get_glyph_kerning(u16 left_glyph_id, u16 right_glyph_id) const
{
VERIFY(left_glyph_id > 0 && right_glyph_id > 0);
i16 glyph_kerning = 0;
for (auto subtable_offset : m_subtable_offsets) {
auto subtable_slice = m_slice.slice(subtable_offset);
auto version = be_u16(subtable_slice.data());
auto length = be_u16(subtable_slice.offset(sizeof(u16)));
auto coverage = be_u16(subtable_slice.offset(2 * sizeof(u16)));
if (version != 0) {
dbgln("TTF::Kern: unsupported subtable version {}", version);
continue;
}
if (subtable_slice.size() < length) {
dbgln("TTF::Kern: subtable has an invalid size {}", length);
continue;
}
auto is_horizontal = (coverage & (1 << 0)) > 0;
auto is_minimum = (coverage & (1 << 1)) > 0;
auto is_cross_stream = (coverage & (1 << 2)) > 0;
auto is_override = (coverage & (1 << 3)) > 0;
auto reserved_bits = (coverage & 0xF0);
auto format = (coverage & 0xFF00) >> 8;
// FIXME: implement support for these features
if (!is_horizontal || is_minimum || is_cross_stream || (reserved_bits > 0)) {
dbgln("TTF::Kern: FIXME: implement missing feature support for subtable");
continue;
}
// FIXME: implement support for subtable formats other than 0
Optional<i16> subtable_kerning;
switch (format) {
case 0:
subtable_kerning = read_glyph_kerning_format0(subtable_slice.slice(Sizes::SubtableHeader), left_glyph_id, right_glyph_id);
break;
default:
dbgln("TTF::Kern: FIXME: subtable format {} is unsupported", format);
continue;
}
if (!subtable_kerning.has_value())
continue;
auto kerning_value = subtable_kerning.release_value();
if (is_override)
glyph_kerning = kerning_value;
else
glyph_kerning += kerning_value;
}
return glyph_kerning;
}
Optional<i16> Kern::read_glyph_kerning_format0(ReadonlyBytes slice, u16 left_glyph_id, u16 right_glyph_id)
{
if (slice.size() < 4 * sizeof(u16))
return {};
u16 number_of_pairs = be_u16(slice.data());
u16 search_range = be_u16(slice.offset_pointer(sizeof(u16)));
u16 entry_selector = be_u16(slice.offset_pointer(2 * sizeof(u16)));
u16 range_shift = be_u16(slice.offset_pointer(3 * sizeof(u16)));
// Sanity checks for this table format
auto pairs_in_search_range = search_range / Sizes::Format0Entry;
if (number_of_pairs == 0)
return {};
if (pairs_in_search_range > number_of_pairs)
return {};
if ((1 << entry_selector) * Sizes::Format0Entry != search_range)
return {};
if ((number_of_pairs - pairs_in_search_range) * Sizes::Format0Entry != range_shift)
return {};
// FIXME: implement a possibly slightly more efficient binary search using the parameters above
auto search_slice = slice.slice(4 * sizeof(u16));
size_t left_idx = 0;
size_t right_idx = number_of_pairs - 1;
for (auto i = 0; i < 16; ++i) {
size_t pivot_idx = (left_idx + right_idx) / 2;
u16 pivot_left_glyph_id = be_u16(search_slice.offset(pivot_idx * Sizes::Format0Entry + 0));
u16 pivot_right_glyph_id = be_u16(search_slice.offset(pivot_idx * Sizes::Format0Entry + 2));
// Match
if (pivot_left_glyph_id == left_glyph_id && pivot_right_glyph_id == right_glyph_id)
return be_i16(search_slice.offset(pivot_idx * Sizes::Format0Entry + 4));
// Narrow search area
if (pivot_left_glyph_id < left_glyph_id || (pivot_left_glyph_id == left_glyph_id && pivot_right_glyph_id < right_glyph_id))
left_idx = pivot_idx + 1;
else if (pivot_idx == left_idx)
break;
else
right_idx = pivot_idx - 1;
}
return 0;
}
String Name::string_for_id(NameId id) const
{
auto num_entries = be_u16(m_slice.offset_pointer(2));
auto string_offset = be_u16(m_slice.offset_pointer(4));
Vector<int> valid_ids;
for (int i = 0; i < num_entries; ++i) {
auto this_id = be_u16(m_slice.offset_pointer(6 + i * 12 + 6));
if (this_id == (u16)id)
valid_ids.append(i);
}
if (valid_ids.is_empty())
return String::empty();
auto it = valid_ids.find_if([this](auto const& i) {
// check if font has naming table for en-US language id
auto platform = be_u16(m_slice.offset_pointer(6 + i * 12 + 0));
auto language_id = be_u16(m_slice.offset_pointer(6 + i * 12 + 4));
return (platform == (u16)Platform::Macintosh && language_id == (u16)MacintoshLanguage::English)
|| (platform == (u16)Platform::Windows && language_id == (u16)WindowsLanguage::EnglishUnitedStates);
});
auto i = it != valid_ids.end() ? *it : valid_ids.first();
auto platform = be_u16(m_slice.offset_pointer(6 + i * 12 + 0));
auto length = be_u16(m_slice.offset_pointer(6 + i * 12 + 8));
auto offset = be_u16(m_slice.offset_pointer(6 + i * 12 + 10));
if (platform == (u16)Platform::Windows) {
static auto& decoder = *TextCodec::decoder_for("utf-16be");
return decoder.to_utf8(StringView { (char const*)m_slice.offset_pointer(string_offset + offset), length });
}
return String((char const*)m_slice.offset_pointer(string_offset + offset), length);
}
GlyphHorizontalMetrics Hmtx::get_glyph_horizontal_metrics(u32 glyph_id) const
{
VERIFY(glyph_id < m_num_glyphs);
if (glyph_id < m_number_of_h_metrics) {
auto offset = glyph_id * (u32)Sizes::LongHorMetric;
u16 advance_width = be_u16(m_slice.offset_pointer(offset));
i16 left_side_bearing = be_i16(m_slice.offset_pointer(offset + 2));
return GlyphHorizontalMetrics {
.advance_width = advance_width,
.left_side_bearing = left_side_bearing,
};
}
auto offset = m_number_of_h_metrics * (u32)Sizes::LongHorMetric + (glyph_id - m_number_of_h_metrics) * (u32)Sizes::LeftSideBearing;
u16 advance_width = be_u16(m_slice.offset_pointer((m_number_of_h_metrics - 1) * (u32)Sizes::LongHorMetric));
i16 left_side_bearing = be_i16(m_slice.offset_pointer(offset));
return GlyphHorizontalMetrics {
.advance_width = advance_width,
.left_side_bearing = left_side_bearing,
};
}
ErrorOr<NonnullRefPtr<Font>> Font::try_load_from_file(String path, unsigned index)
{
auto file = TRY(Core::MappedFile::map(path));
auto font = TRY(try_load_from_externally_owned_memory(file->bytes(), index));
font->m_mapped_file = move(file);
return font;
}
ErrorOr<NonnullRefPtr<Font>> Font::try_load_from_externally_owned_memory(ReadonlyBytes buffer, unsigned index)
{
if (buffer.size() < 4)
return Error::from_string_literal("Font file too small"sv);
u32 tag = be_u32(buffer.data());
if (tag == tag_from_str("ttcf")) {
// It's a font collection
if (buffer.size() < (u32)Sizes::TTCHeaderV1 + sizeof(u32) * (index + 1))
return Error::from_string_literal("Font file too small"sv);
u32 offset = be_u32(buffer.offset_pointer((u32)Sizes::TTCHeaderV1 + sizeof(u32) * index));
return try_load_from_offset(buffer, offset);
}
if (tag == tag_from_str("OTTO"))
return Error::from_string_literal("CFF fonts not supported yet"sv);
if (tag != 0x00010000)
return Error::from_string_literal("Not a valid font"sv);
return try_load_from_offset(buffer, 0);
}
// FIXME: "loca" and "glyf" are not available for CFF fonts.
ErrorOr<NonnullRefPtr<Font>> Font::try_load_from_offset(ReadonlyBytes buffer, u32 offset)
{
if (Checked<u32>::addition_would_overflow(offset, (u32)Sizes::OffsetTable))
return Error::from_string_literal("Invalid offset in font header"sv);
if (buffer.size() < offset + (u32)Sizes::OffsetTable)
return Error::from_string_literal("Font file too small"sv);
Optional<ReadonlyBytes> opt_head_slice = {};
Optional<ReadonlyBytes> opt_name_slice = {};
Optional<ReadonlyBytes> opt_hhea_slice = {};
Optional<ReadonlyBytes> opt_maxp_slice = {};
Optional<ReadonlyBytes> opt_hmtx_slice = {};
Optional<ReadonlyBytes> opt_cmap_slice = {};
Optional<ReadonlyBytes> opt_loca_slice = {};
Optional<ReadonlyBytes> opt_glyf_slice = {};
Optional<ReadonlyBytes> opt_os2_slice = {};
Optional<ReadonlyBytes> opt_kern_slice = {};
Optional<Head> opt_head = {};
Optional<Name> opt_name = {};
Optional<Hhea> opt_hhea = {};
Optional<Maxp> opt_maxp = {};
Optional<Hmtx> opt_hmtx = {};
Optional<Cmap> opt_cmap = {};
Optional<Loca> opt_loca = {};
Optional<OS2> opt_os2 = {};
Optional<Kern> opt_kern = {};
auto num_tables = be_u16(buffer.offset_pointer(offset + (u32)Offsets::NumTables));
if (buffer.size() < offset + (u32)Sizes::OffsetTable + num_tables * (u32)Sizes::TableRecord)
return Error::from_string_literal("Font file too small"sv);
for (auto i = 0; i < num_tables; i++) {
u32 record_offset = offset + (u32)Sizes::OffsetTable + i * (u32)Sizes::TableRecord;
u32 tag = be_u32(buffer.offset_pointer(record_offset));
u32 table_offset = be_u32(buffer.offset_pointer(record_offset + (u32)Offsets::TableRecord_Offset));
u32 table_length = be_u32(buffer.offset_pointer(record_offset + (u32)Offsets::TableRecord_Length));
if (Checked<u32>::addition_would_overflow(table_offset, table_length))
return Error::from_string_literal("Invalid table offset or length in font"sv);
if (buffer.size() < table_offset + table_length)
return Error::from_string_literal("Font file too small"sv);
auto buffer_here = ReadonlyBytes(buffer.offset_pointer(table_offset), table_length);
// Get the table offsets we need.
if (tag == tag_from_str("head")) {
opt_head_slice = buffer_here;
} else if (tag == tag_from_str("name")) {
opt_name_slice = buffer_here;
} else if (tag == tag_from_str("hhea")) {
opt_hhea_slice = buffer_here;
} else if (tag == tag_from_str("maxp")) {
opt_maxp_slice = buffer_here;
} else if (tag == tag_from_str("hmtx")) {
opt_hmtx_slice = buffer_here;
} else if (tag == tag_from_str("cmap")) {
opt_cmap_slice = buffer_here;
} else if (tag == tag_from_str("loca")) {
opt_loca_slice = buffer_here;
} else if (tag == tag_from_str("glyf")) {
opt_glyf_slice = buffer_here;
} else if (tag == tag_from_str("OS/2")) {
opt_os2_slice = buffer_here;
} else if (tag == tag_from_str("kern")) {
opt_kern_slice = buffer_here;
}
}
if (!opt_head_slice.has_value() || !(opt_head = Head::from_slice(opt_head_slice.value())).has_value())
return Error::from_string_literal("Could not load Head"sv);
auto head = opt_head.value();
if (!opt_name_slice.has_value() || !(opt_name = Name::from_slice(opt_name_slice.value())).has_value())
return Error::from_string_literal("Could not load Name"sv);
auto name = opt_name.value();
if (!opt_hhea_slice.has_value() || !(opt_hhea = Hhea::from_slice(opt_hhea_slice.value())).has_value())
return Error::from_string_literal("Could not load Hhea"sv);
auto hhea = opt_hhea.value();
if (!opt_maxp_slice.has_value() || !(opt_maxp = Maxp::from_slice(opt_maxp_slice.value())).has_value())
return Error::from_string_literal("Could not load Maxp"sv);
auto maxp = opt_maxp.value();
if (!opt_hmtx_slice.has_value() || !(opt_hmtx = Hmtx::from_slice(opt_hmtx_slice.value(), maxp.num_glyphs(), hhea.number_of_h_metrics())).has_value())
return Error::from_string_literal("Could not load Hmtx"sv);
auto hmtx = opt_hmtx.value();
if (!opt_cmap_slice.has_value() || !(opt_cmap = Cmap::from_slice(opt_cmap_slice.value())).has_value())
return Error::from_string_literal("Could not load Cmap"sv);
auto cmap = opt_cmap.value();
if (!opt_loca_slice.has_value() || !(opt_loca = Loca::from_slice(opt_loca_slice.value(), maxp.num_glyphs(), head.index_to_loc_format())).has_value())
return Error::from_string_literal("Could not load Loca"sv);
auto loca = opt_loca.value();
if (!opt_glyf_slice.has_value())
return Error::from_string_literal("Could not load Glyf"sv);
auto glyf = Glyf(opt_glyf_slice.value());
if (!opt_os2_slice.has_value())
return Error::from_string_literal("Could not load OS/2"sv);
auto os2 = OS2(opt_os2_slice.value());
Optional<Kern> kern {};
if (opt_kern_slice.has_value())
kern = TRY(Kern::from_slice(opt_kern_slice.value()));
// Select cmap table. FIXME: Do this better. Right now, just looks for platform "Windows"
// and corresponding encoding "Unicode full repertoire", or failing that, "Unicode BMP"
for (u32 i = 0; i < cmap.num_subtables(); i++) {
auto opt_subtable = cmap.subtable(i);
if (!opt_subtable.has_value()) {
continue;
}
auto subtable = opt_subtable.value();
auto platform = subtable.platform_id();
if (!platform.has_value())
return Error::from_string_literal("Invalid Platform ID"sv);
if (platform.value() == Cmap::Subtable::Platform::Windows) {
if (subtable.encoding_id() == (u16)Cmap::Subtable::WindowsEncoding::UnicodeFullRepertoire) {
cmap.set_active_index(i);
break;
}
if (subtable.encoding_id() == (u16)Cmap::Subtable::WindowsEncoding::UnicodeBMP) {
cmap.set_active_index(i);
break;
}
}
}
return adopt_ref(*new Font(move(buffer), move(head), move(name), move(hhea), move(maxp), move(hmtx), move(cmap), move(loca), move(glyf), move(os2), move(kern)));
}
ScaledFontMetrics Font::metrics([[maybe_unused]] float x_scale, float y_scale) const
{
auto ascender = m_hhea.ascender() * y_scale;
auto descender = m_hhea.descender() * y_scale;
auto line_gap = m_hhea.line_gap() * y_scale;
return ScaledFontMetrics {
.ascender = ascender,
.descender = descender,
.line_gap = line_gap,
};
}
// FIXME: "loca" and "glyf" are not available for CFF fonts.
ScaledGlyphMetrics Font::glyph_metrics(u32 glyph_id, float x_scale, float y_scale) const
{
if (glyph_id >= glyph_count()) {
glyph_id = 0;
}
auto horizontal_metrics = m_hmtx.get_glyph_horizontal_metrics(glyph_id);
auto glyph_offset = m_loca.get_glyph_offset(glyph_id);
auto glyph = m_glyf.glyph(glyph_offset);
int ascender = glyph.ascender();
int descender = glyph.descender();
return ScaledGlyphMetrics {
.ascender = (int)roundf(ascender * y_scale),
.descender = (int)roundf(descender * y_scale),
.advance_width = (int)roundf(horizontal_metrics.advance_width * x_scale),
.left_side_bearing = (int)roundf(horizontal_metrics.left_side_bearing * x_scale),
};
}
float Font::glyphs_horizontal_kerning(u32 left_glyph_id, u32 right_glyph_id, float x_scale) const
{
if (!m_kern.has_value())
return 0.f;
return m_kern->get_glyph_kerning(left_glyph_id, right_glyph_id) * x_scale;
}
// FIXME: "loca" and "glyf" are not available for CFF fonts.
RefPtr<Gfx::Bitmap> Font::rasterize_glyph(u32 glyph_id, float x_scale, float y_scale) const
{
if (glyph_id >= glyph_count()) {
glyph_id = 0;
}
auto glyph_offset = m_loca.get_glyph_offset(glyph_id);
auto glyph = m_glyf.glyph(glyph_offset);
return glyph.rasterize(m_hhea.ascender(), m_hhea.descender(), x_scale, y_scale, [&](u16 glyph_id) {
if (glyph_id >= glyph_count()) {
glyph_id = 0;
}
auto glyph_offset = m_loca.get_glyph_offset(glyph_id);
return m_glyf.glyph(glyph_offset);
});
}
u32 Font::glyph_count() const
{
return m_maxp.num_glyphs();
}
u16 Font::units_per_em() const
{
return m_head.units_per_em();
}
String Font::family() const
{
auto string = m_name.typographic_family_name();
if (!string.is_empty())
return string;
return m_name.family_name();
}
String Font::variant() const
{
auto string = m_name.typographic_subfamily_name();
if (!string.is_empty())
return string;
return m_name.subfamily_name();
}
u16 Font::weight() const
{
constexpr u16 bold_bit { 1 };
if (m_os2.weight_class())
return m_os2.weight_class();
if (m_head.style() & bold_bit)
return 700;
return 400;
}
u8 Font::slope() const
{
// https://docs.microsoft.com/en-us/typography/opentype/spec/os2
constexpr u16 italic_selection_bit { 1 };
constexpr u16 oblique_selection_bit { 512 };
// https://docs.microsoft.com/en-us/typography/opentype/spec/head
constexpr u16 italic_style_bit { 2 };
if (m_os2.selection() & oblique_selection_bit)
return 2;
if (m_os2.selection() & italic_selection_bit)
return 1;
if (m_head.style() & italic_style_bit)
return 1;
return 0;
}
bool Font::is_fixed_width() const
{
// FIXME: Read this information from the font file itself.
// FIXME: Although, it appears some application do similar hacks
return glyph_metrics(glyph_id_for_code_point('.'), 1, 1).advance_width == glyph_metrics(glyph_id_for_code_point('X'), 1, 1).advance_width;
}
int ScaledFont::width(StringView view) const { return unicode_view_width(Utf8View(view)); }
int ScaledFont::width(Utf8View const& view) const { return unicode_view_width(view); }
int ScaledFont::width(Utf32View const& view) const { return unicode_view_width(view); }
template<typename T>
ALWAYS_INLINE int ScaledFont::unicode_view_width(T const& view) const
{
if (view.is_empty())
return 0;
int width = 0;
int longest_width = 0;
u32 last_code_point = 0;
for (auto code_point : view) {
if (code_point == '\n' || code_point == '\r') {
longest_width = max(width, longest_width);
width = 0;
last_code_point = code_point;
continue;
}
u32 glyph_id = glyph_id_for_code_point(code_point);
auto kerning = glyphs_horizontal_kerning(last_code_point, code_point);
width += kerning + glyph_metrics(glyph_id).advance_width;
last_code_point = code_point;
}
longest_width = max(width, longest_width);
return longest_width;
}
RefPtr<Gfx::Bitmap> ScaledFont::rasterize_glyph(u32 glyph_id) const
{
auto glyph_iterator = m_cached_glyph_bitmaps.find(glyph_id);
if (glyph_iterator != m_cached_glyph_bitmaps.end())
return glyph_iterator->value;
auto glyph_bitmap = m_font->rasterize_glyph(glyph_id, m_x_scale, m_y_scale);
m_cached_glyph_bitmaps.set(glyph_id, glyph_bitmap);
return glyph_bitmap;
}
Gfx::Glyph ScaledFont::glyph(u32 code_point) const
{
auto id = glyph_id_for_code_point(code_point);
auto bitmap = rasterize_glyph(id);
auto metrics = glyph_metrics(id);
return Gfx::Glyph(bitmap, metrics.left_side_bearing, metrics.advance_width, metrics.ascender);
}
u8 ScaledFont::glyph_width(u32 code_point) const
{
auto id = glyph_id_for_code_point(code_point);
auto metrics = glyph_metrics(id);
return metrics.advance_width;
}
int ScaledFont::glyph_or_emoji_width(u32 code_point) const
{
auto id = glyph_id_for_code_point(code_point);
auto metrics = glyph_metrics(id);
return metrics.advance_width;
}
float ScaledFont::glyphs_horizontal_kerning(u32 left_code_point, u32 right_code_point) const
{
if (left_code_point == 0 || right_code_point == 0)
return 0.f;
auto left_glyph_id = glyph_id_for_code_point(left_code_point);
auto right_glyph_id = glyph_id_for_code_point(right_code_point);
if (left_glyph_id == 0 || right_glyph_id == 0)
return 0.f;
return m_font->glyphs_horizontal_kerning(left_glyph_id, right_glyph_id, m_x_scale);
}
u8 ScaledFont::glyph_fixed_width() const
{
return glyph_metrics(glyph_id_for_code_point(' ')).advance_width;
}
Gfx::FontPixelMetrics ScaledFont::pixel_metrics() const
{
auto metrics = m_font->metrics(m_x_scale, m_y_scale);
return Gfx::FontPixelMetrics {
.size = (float)pixel_size(),
.x_height = (float)x_height(),
.advance_of_ascii_zero = (float)glyph_width('0'),
.glyph_spacing = (float)glyph_spacing(),
.ascent = metrics.ascender,
.descent = -metrics.descender,
.line_gap = metrics.line_gap,
};
}
u16 OS2::weight_class() const
{
return be_u16(m_slice.offset_pointer((u32)Offsets::WeightClass));
}
u16 OS2::selection() const
{
return be_u16(m_slice.offset_pointer((u32)Offsets::Selection));
}
i16 OS2::typographic_ascender() const
{
return be_i16(m_slice.offset_pointer((u32)Offsets::TypographicAscender));
}
i16 OS2::typographic_descender() const
{
return be_i16(m_slice.offset_pointer((u32)Offsets::TypographicDescender));
}
i16 OS2::typographic_line_gap() const
{
return be_i16(m_slice.offset_pointer((u32)Offsets::TypographicLineGap));
}
}

170
Userland/Libraries/LibGfx/Font/TrueType/Font.h Normal file
View file

@ -0,0 +1,170 @@
/*
* Copyright (c) 2020, Srimanta Barua <srimanta.barua1@gmail.com>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/HashMap.h>
#include <AK/Noncopyable.h>
#include <AK/RefCounted.h>
#include <AK/StringView.h>
#include <LibGfx/Bitmap.h>
#include <LibGfx/Font.h>
#include <LibGfx/Size.h>
#include <LibGfx/Font/TrueType/Cmap.h>
#include <LibGfx/Font/TrueType/Glyf.h>
#include <LibGfx/Font/TrueType/Tables.h>
#define POINTS_PER_INCH 72.0f
#define DEFAULT_DPI 96
namespace TTF {
struct ScaledFontMetrics {
float ascender { 0 };
float descender { 0 };
float line_gap { 0 };
int height() const
{
return ascender - descender;
}
};
struct ScaledGlyphMetrics {
int ascender;
int descender;
int advance_width;
int left_side_bearing;
};
class Font : public RefCounted<Font> {
AK_MAKE_NONCOPYABLE(Font);
public:
static ErrorOr<NonnullRefPtr<Font>> try_load_from_file(String path, unsigned index = 0);
static ErrorOr<NonnullRefPtr<Font>> try_load_from_externally_owned_memory(ReadonlyBytes bytes, unsigned index = 0);
ScaledFontMetrics metrics(float x_scale, float y_scale) const;
ScaledGlyphMetrics glyph_metrics(u32 glyph_id, float x_scale, float y_scale) const;
float glyphs_horizontal_kerning(u32 left_glyph_id, u32 right_glyph_id, float x_scale) const;
RefPtr<Gfx::Bitmap> rasterize_glyph(u32 glyph_id, float x_scale, float y_scale) const;
u32 glyph_count() const;
u16 units_per_em() const;
u32 glyph_id_for_code_point(u32 code_point) const { return m_cmap.glyph_id_for_code_point(code_point); }
String family() const;
String variant() const;
u16 weight() const;
u8 slope() const;
bool is_fixed_width() const;
private:
enum class Offsets {
NumTables = 4,
TableRecord_Offset = 8,
TableRecord_Length = 12,
};
enum class Sizes {
TTCHeaderV1 = 12,
OffsetTable = 12,
TableRecord = 16,
};
static ErrorOr<NonnullRefPtr<Font>> try_load_from_offset(ReadonlyBytes, unsigned index = 0);
Font(ReadonlyBytes bytes, Head&& head, Name&& name, Hhea&& hhea, Maxp&& maxp, Hmtx&& hmtx, Cmap&& cmap, Loca&& loca, Glyf&& glyf, OS2&& os2, Optional<Kern>&& kern)
: m_buffer(move(bytes))
, m_head(move(head))
, m_name(move(name))
, m_hhea(move(hhea))
, m_maxp(move(maxp))
, m_hmtx(move(hmtx))
, m_loca(move(loca))
, m_glyf(move(glyf))
, m_cmap(move(cmap))
, m_os2(move(os2))
, m_kern(move(kern))
{
}
RefPtr<Core::MappedFile> m_mapped_file;
ReadonlyBytes m_buffer;
// These are stateful wrappers around non-owning slices
Head m_head;
Name m_name;
Hhea m_hhea;
Maxp m_maxp;
Hmtx m_hmtx;
Loca m_loca;
Glyf m_glyf;
Cmap m_cmap;
OS2 m_os2;
Optional<Kern> m_kern;
};
class ScaledFont : public Gfx::Font {
public:
ScaledFont(NonnullRefPtr<TTF::Font> font, float point_width, float point_height, unsigned dpi_x = DEFAULT_DPI, unsigned dpi_y = DEFAULT_DPI)
: m_font(move(font))
, m_point_width(point_width)
, m_point_height(point_height)
{
float units_per_em = m_font->units_per_em();
m_x_scale = (point_width * dpi_x) / (POINTS_PER_INCH * units_per_em);
m_y_scale = (point_height * dpi_y) / (POINTS_PER_INCH * units_per_em);
}
u32 glyph_id_for_code_point(u32 code_point) const { return m_font->glyph_id_for_code_point(code_point); }
ScaledFontMetrics metrics() const { return m_font->metrics(m_x_scale, m_y_scale); }
ScaledGlyphMetrics glyph_metrics(u32 glyph_id) const { return m_font->glyph_metrics(glyph_id, m_x_scale, m_y_scale); }
RefPtr<Gfx::Bitmap> rasterize_glyph(u32 glyph_id) const;
// ^Gfx::Font
virtual NonnullRefPtr<Font> clone() const override { return *this; } // FIXME: clone() should not need to be implemented
virtual u8 presentation_size() const override { return m_point_height; }
virtual int pixel_size() const override { return m_point_height * 1.33333333f; }
virtual float point_size() const override { return m_point_height; }
virtual Gfx::FontPixelMetrics pixel_metrics() const override;
virtual u8 slope() const override { return m_font->slope(); }
virtual u16 weight() const override { return m_font->weight(); }
virtual Gfx::Glyph glyph(u32 code_point) const override;
virtual bool contains_glyph(u32 code_point) const override { return m_font->glyph_id_for_code_point(code_point) > 0; }
virtual u8 glyph_width(u32 code_point) const override;
virtual int glyph_or_emoji_width(u32 code_point) const override;
virtual float glyphs_horizontal_kerning(u32 left_code_point, u32 right_code_point) const override;
virtual int preferred_line_height() const override { return metrics().height() + metrics().line_gap; }
virtual u8 glyph_height() const override { return m_point_height; }
virtual int x_height() const override { return m_point_height; } // FIXME: Read from font
virtual u8 min_glyph_width() const override { return 1; } // FIXME: Read from font
virtual u8 max_glyph_width() const override { return m_point_width; } // FIXME: Read from font
virtual u8 glyph_fixed_width() const override;
virtual u8 baseline() const override { return m_point_height; } // FIXME: Read from font
virtual u8 mean_line() const override { return m_point_height; } // FIXME: Read from font
virtual int width(StringView) const override;
virtual int width(Utf8View const&) const override;
virtual int width(Utf32View const&) const override;
virtual String name() const override { return String::formatted("{} {}", family(), variant()); }
virtual bool is_fixed_width() const override { return m_font->is_fixed_width(); }
virtual u8 glyph_spacing() const override { return 0; }
virtual size_t glyph_count() const override { return m_font->glyph_count(); }
virtual String family() const override { return m_font->family(); }
virtual String variant() const override { return m_font->variant(); }
virtual String qualified_name() const override { return String::formatted("{} {} {} {}", family(), presentation_size(), weight(), slope()); }
virtual String human_readable_name() const override { return String::formatted("{} {} {}", family(), variant(), presentation_size()); }
private:
NonnullRefPtr<TTF::Font> m_font;
float m_x_scale { 0.0f };
float m_y_scale { 0.0f };
float m_point_width { 0.0f };
float m_point_height { 0.0f };
mutable HashMap<u32, RefPtr<Gfx::Bitmap>> m_cached_glyph_bitmaps;
template<typename T>
int unicode_view_width(T const& view) const;
};
}

504
Userland/Libraries/LibGfx/Font/TrueType/Glyf.cpp Normal file
View file

@ -0,0 +1,504 @@
/*
* Copyright (c) 2020, Srimanta Barua <srimanta.barua1@gmail.com>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <LibGfx/Font/TrueType/Glyf.h>
#include <LibGfx/Path.h>
#include <LibGfx/Point.h>
namespace TTF {
extern u16 be_u16(u8 const* ptr);
extern u32 be_u32(u8 const* ptr);
extern i16 be_i16(u8 const* ptr);
extern float be_fword(u8 const* ptr);
enum class SimpleGlyfFlags {
// From spec.
OnCurve = 0x01,
XShortVector = 0x02,
YShortVector = 0x04,
RepeatFlag = 0x08,
XIsSameOrPositiveXShortVector = 0x10,
YIsSameOrPositiveYShortVector = 0x20,
// Combinations
XMask = 0x12,
YMask = 0x24,
XLongVector = 0x00,
YLongVector = 0x00,
XNegativeShortVector = 0x02,
YNegativeShortVector = 0x04,
XPositiveShortVector = 0x12,
YPositiveShortVector = 0x24,
};
enum class CompositeGlyfFlags {
Arg1AndArg2AreWords = 0x0001,
ArgsAreXYValues = 0x0002,
RoundXYToGrid = 0x0004,
WeHaveAScale = 0x0008,
MoreComponents = 0x0020,
WeHaveAnXAndYScale = 0x0040,
WeHaveATwoByTwo = 0x0080,
WeHaveInstructions = 0x0100,
UseMyMetrics = 0x0200,
OverlapCompound = 0x0400, // Not relevant - can overlap without this set
ScaledComponentOffset = 0x0800,
UnscaledComponentOffset = 0x1000,
};
class PointIterator {
public:
struct Item {
bool on_curve;
Gfx::FloatPoint point;
};
PointIterator(ReadonlyBytes slice, u16 num_points, u32 flags_offset, u32 x_offset, u32 y_offset, Gfx::AffineTransform affine)
: m_slice(slice)
, m_points_remaining(num_points)
, m_flags_offset(flags_offset)
, m_x_offset(x_offset)
, m_y_offset(y_offset)
, m_affine(affine)
{
}
Optional<Item> next()
{
if (m_points_remaining == 0) {
return {};
}
if (m_flags_remaining > 0) {
m_flags_remaining--;
} else {
m_flag = m_slice[m_flags_offset++];
if (m_flag & (u8)SimpleGlyfFlags::RepeatFlag) {
m_flags_remaining = m_slice[m_flags_offset++];
}
}
switch (m_flag & (u8)SimpleGlyfFlags::XMask) {
case (u8)SimpleGlyfFlags::XLongVector:
m_last_point.set_x(m_last_point.x() + be_i16(m_slice.offset_pointer(m_x_offset)));
m_x_offset += 2;
break;
case (u8)SimpleGlyfFlags::XNegativeShortVector:
m_last_point.set_x(m_last_point.x() - m_slice[m_x_offset++]);
break;
case (u8)SimpleGlyfFlags::XPositiveShortVector:
m_last_point.set_x(m_last_point.x() + m_slice[m_x_offset++]);
break;
default:
break;
}
switch (m_flag & (u8)SimpleGlyfFlags::YMask) {
case (u8)SimpleGlyfFlags::YLongVector:
m_last_point.set_y(m_last_point.y() + be_i16(m_slice.offset_pointer(m_y_offset)));
m_y_offset += 2;
break;
case (u8)SimpleGlyfFlags::YNegativeShortVector:
m_last_point.set_y(m_last_point.y() - m_slice[m_y_offset++]);
break;
case (u8)SimpleGlyfFlags::YPositiveShortVector:
m_last_point.set_y(m_last_point.y() + m_slice[m_y_offset++]);
break;
default:
break;
}
m_points_remaining--;
Item ret = {
.on_curve = (m_flag & (u8)SimpleGlyfFlags::OnCurve) != 0,
.point = m_affine.map(m_last_point),
};
return ret;
}
private:
ReadonlyBytes m_slice;
u16 m_points_remaining;
u8 m_flag { 0 };
Gfx::FloatPoint m_last_point = { 0.0f, 0.0f };
u32 m_flags_remaining = { 0 };
u32 m_flags_offset;
u32 m_x_offset;
u32 m_y_offset;
Gfx::AffineTransform m_affine;
};
Optional<Glyf::Glyph::ComponentIterator::Item> Glyf::Glyph::ComponentIterator::next()
{
if (!m_has_more) {
return {};
}
u16 flags = be_u16(m_slice.offset_pointer(m_offset));
m_offset += 2;
u16 glyph_id = be_u16(m_slice.offset_pointer(m_offset));
m_offset += 2;
i16 arg1 = 0, arg2 = 0;
if (flags & (u16)CompositeGlyfFlags::Arg1AndArg2AreWords) {
arg1 = be_i16(m_slice.offset_pointer(m_offset));
m_offset += 2;
arg2 = be_i16(m_slice.offset_pointer(m_offset));
m_offset += 2;
} else {
arg1 = (i8)m_slice[m_offset++];
arg2 = (i8)m_slice[m_offset++];
}
float a = 1.0, b = 0.0, c = 0.0, d = 1.0, e = 0.0, f = 0.0;
if (flags & (u16)CompositeGlyfFlags::WeHaveATwoByTwo) {
a = be_fword(m_slice.offset_pointer(m_offset));
m_offset += 2;
b = be_fword(m_slice.offset_pointer(m_offset));
m_offset += 2;
c = be_fword(m_slice.offset_pointer(m_offset));
m_offset += 2;
d = be_fword(m_slice.offset_pointer(m_offset));
m_offset += 2;
} else if (flags & (u16)CompositeGlyfFlags::WeHaveAnXAndYScale) {
a = be_fword(m_slice.offset_pointer(m_offset));
m_offset += 2;
d = be_fword(m_slice.offset_pointer(m_offset));
m_offset += 2;
} else if (flags & (u16)CompositeGlyfFlags::WeHaveAScale) {
a = be_fword(m_slice.offset_pointer(m_offset));
m_offset += 2;
d = a;
}
// FIXME: Handle UseMyMetrics, ScaledComponentOffset, UnscaledComponentOffset, non-ArgsAreXYValues
if (flags & (u16)CompositeGlyfFlags::ArgsAreXYValues) {
e = arg1;
f = arg2;
} else {
// FIXME: Implement this. There's no TODO() here since many fonts work just fine without this.
}
if (flags & (u16)CompositeGlyfFlags::UseMyMetrics) {
// FIXME: Implement this. There's no TODO() here since many fonts work just fine without this.
}
if (flags & (u16)CompositeGlyfFlags::ScaledComponentOffset) {
// FIXME: Implement this. There's no TODO() here since many fonts work just fine without this.
}
if (flags & (u16)CompositeGlyfFlags::UnscaledComponentOffset) {
// FIXME: Implement this. There's no TODO() here since many fonts work just fine without this.
}
m_has_more = (flags & (u16)CompositeGlyfFlags::MoreComponents);
return Item {
.glyph_id = glyph_id,
.affine = Gfx::AffineTransform(a, b, c, d, e, f),
};
}
Rasterizer::Rasterizer(Gfx::IntSize size)
: m_size(size)
{
m_data.resize(m_size.width() * m_size.height());
for (int i = 0; i < m_size.width() * m_size.height(); i++) {
m_data[i] = 0.0f;
}
}
void Rasterizer::draw_path(Gfx::Path& path)
{
for (auto& line : path.split_lines()) {
draw_line(line.from, line.to);
}
}
RefPtr<Gfx::Bitmap> Rasterizer::accumulate()
{
auto bitmap_or_error = Gfx::Bitmap::try_create(Gfx::BitmapFormat::BGRA8888, m_size);
if (bitmap_or_error.is_error())
return {};
auto bitmap = bitmap_or_error.release_value_but_fixme_should_propagate_errors();
Color base_color = Color::from_rgb(0xffffff);
for (int y = 0; y < m_size.height(); y++) {
float accumulator = 0.0;
for (int x = 0; x < m_size.width(); x++) {
accumulator += m_data[y * m_size.width() + x];
float value = accumulator;
if (value < 0.0f) {
value = -value;
}
if (value > 1.0f) {
value = 1.0;
}
u8 alpha = value * 255.0f;
bitmap->set_pixel(x, y, base_color.with_alpha(alpha));
}
}
return bitmap;
}
void Rasterizer::draw_line(Gfx::FloatPoint p0, Gfx::FloatPoint p1)
{
// FIXME: Shift x and y according to dy/dx
if (p0.x() < 0.0f) {
p0.set_x(roundf(p0.x()));
}
if (p0.y() < 0.0f) {
p0.set_y(roundf(p0.y()));
}
if (p1.x() < 0.0f) {
p1.set_x(roundf(p1.x()));
}
if (p1.y() < 0.0f) {
p1.set_y(roundf(p1.y()));
}
if (!(p0.x() >= 0.0f && p0.y() >= 0.0f && p0.x() <= m_size.width() && p0.y() <= m_size.height())) {
dbgln("!P0({},{})", p0.x(), p0.y());
return;
}
if (!(p1.x() >= 0.0f && p1.y() >= 0.0f && p1.x() <= m_size.width() && p1.y() <= m_size.height())) {
dbgln("!P1({},{})", p1.x(), p1.y());
return;
}
VERIFY(p0.x() >= 0.0f && p0.y() >= 0.0f && p0.x() <= m_size.width() && p0.y() <= m_size.height());
VERIFY(p1.x() >= 0.0f && p1.y() >= 0.0f && p1.x() <= m_size.width() && p1.y() <= m_size.height());
// If we're on the same Y, there's no need to draw
if (p0.y() == p1.y()) {
return;
}
float direction = -1.0;
if (p1.y() < p0.y()) {
direction = 1.0;
auto tmp = p0;
p0 = p1;
p1 = tmp;
}
float dxdy = (p1.x() - p0.x()) / (p1.y() - p0.y());
u32 y0 = floorf(p0.y());
u32 y1 = ceilf(p1.y());
float x_cur = p0.x();
for (u32 y = y0; y < y1; y++) {
u32 line_offset = m_size.width() * y;
float dy = min(y + 1.0f, p1.y()) - max((float)y, p0.y());
float directed_dy = dy * direction;
float x_next = x_cur + dy * dxdy;
if (x_next < 0.0f) {
x_next = 0.0f;
}
float x0 = x_cur;
float x1 = x_next;
if (x1 < x0) {
x1 = x_cur;
x0 = x_next;
}
float x0_floor = floorf(x0);
float x1_ceil = ceilf(x1);
u32 x0i = x0_floor;
if (x1_ceil <= x0_floor + 1.0f) {
// If x0 and x1 are within the same pixel, then area to the right is (1 - (mid(x0, x1) - x0_floor)) * dy
float area = ((x0 + x1) * 0.5f) - x0_floor;
m_data[line_offset + x0i] += directed_dy * (1.0f - area);
m_data[line_offset + x0i + 1] += directed_dy * area;
} else {
float dydx = 1.0f / dxdy;
if (dydx < 0)
dydx = -dydx;
float x0_right = 1.0f - (x0 - x0_floor);
u32 x1_floor_i = floorf(x1);
float area_upto_here = 0.5f * x0_right * x0_right * dydx;
m_data[line_offset + x0i] += direction * area_upto_here;
for (u32 x = x0i + 1; x < x1_floor_i; x++) {
m_data[line_offset + x] += direction * dydx;
area_upto_here += dydx;
}
float remaining_area = (dy - area_upto_here);
m_data[line_offset + x1_floor_i] += direction * remaining_area;
}
x_cur = x_next;
}
}
Optional<Loca> Loca::from_slice(ReadonlyBytes slice, u32 num_glyphs, IndexToLocFormat index_to_loc_format)
{
switch (index_to_loc_format) {
case IndexToLocFormat::Offset16:
if (slice.size() < num_glyphs * 2) {
return {};
}
break;
case IndexToLocFormat::Offset32:
if (slice.size() < num_glyphs * 4) {
return {};
}
break;
}
return Loca(slice, num_glyphs, index_to_loc_format);
}
u32 Loca::get_glyph_offset(u32 glyph_id) const
{
VERIFY(glyph_id < m_num_glyphs);
switch (m_index_to_loc_format) {
case IndexToLocFormat::Offset16:
return ((u32)be_u16(m_slice.offset_pointer(glyph_id * 2))) * 2;
case IndexToLocFormat::Offset32:
return be_u32(m_slice.offset_pointer(glyph_id * 4));
default:
VERIFY_NOT_REACHED();
}
}
static void get_ttglyph_offsets(ReadonlyBytes slice, u32 num_points, u32 flags_offset, u32* x_offset, u32* y_offset)
{
u32 flags_size = 0;
u32 x_size = 0;
u32 repeat_count;
while (num_points > 0) {
u8 flag = slice[flags_offset + flags_size];
if (flag & (u8)SimpleGlyfFlags::RepeatFlag) {
flags_size++;
repeat_count = slice[flags_offset + flags_size] + 1;
} else {
repeat_count = 1;
}
flags_size++;
switch (flag & (u8)SimpleGlyfFlags::XMask) {
case (u8)SimpleGlyfFlags::XLongVector:
x_size += repeat_count * 2;
break;
case (u8)SimpleGlyfFlags::XNegativeShortVector:
case (u8)SimpleGlyfFlags::XPositiveShortVector:
x_size += repeat_count;
break;
default:
break;
}
num_points -= repeat_count;
}
*x_offset = flags_offset + flags_size;
*y_offset = *x_offset + x_size;
}
void Glyf::Glyph::rasterize_impl(Rasterizer& rasterizer, Gfx::AffineTransform const& transform) const
{
// Get offset for flags, x, and y.
u16 num_points = be_u16(m_slice.offset_pointer((m_num_contours - 1) * 2)) + 1;
u16 num_instructions = be_u16(m_slice.offset_pointer(m_num_contours * 2));
u32 flags_offset = m_num_contours * 2 + 2 + num_instructions;
u32 x_offset = 0;
u32 y_offset = 0;
get_ttglyph_offsets(m_slice, num_points, flags_offset, &x_offset, &y_offset);
// Prepare to render glyph.
Gfx::Path path;
PointIterator point_iterator(m_slice, num_points, flags_offset, x_offset, y_offset, transform);
int last_contour_end = -1;
i32 contour_index = 0;
u32 contour_size = 0;
Optional<Gfx::FloatPoint> contour_start = {};
Optional<Gfx::FloatPoint> last_offcurve_point = {};
// Render glyph
while (true) {
if (!contour_start.has_value()) {
if (contour_index >= m_num_contours) {
break;
}
int current_contour_end = be_u16(m_slice.offset_pointer(contour_index++ * 2));
contour_size = current_contour_end - last_contour_end;
last_contour_end = current_contour_end;
auto opt_item = point_iterator.next();
VERIFY(opt_item.has_value());
contour_start = opt_item.value().point;
path.move_to(contour_start.value());
contour_size--;
} else if (!last_offcurve_point.has_value()) {
if (contour_size > 0) {
auto opt_item = point_iterator.next();
// FIXME: Should we draw a line to the first point here?
if (!opt_item.has_value()) {
break;
}
auto item = opt_item.value();
contour_size--;
if (item.on_curve) {
path.line_to(item.point);
} else if (contour_size > 0) {
auto opt_next_item = point_iterator.next();
// FIXME: Should we draw a quadratic bezier to the first point here?
if (!opt_next_item.has_value()) {
break;
}
auto next_item = opt_next_item.value();
contour_size--;
if (next_item.on_curve) {
path.quadratic_bezier_curve_to(item.point, next_item.point);
} else {
auto mid_point = (item.point + next_item.point) * 0.5f;
path.quadratic_bezier_curve_to(item.point, mid_point);
last_offcurve_point = next_item.point;
}
} else {
path.quadratic_bezier_curve_to(item.point, contour_start.value());
contour_start = {};
}
} else {
path.line_to(contour_start.value());
contour_start = {};
}
} else {
auto point0 = last_offcurve_point.value();
last_offcurve_point = {};
if (contour_size > 0) {
auto opt_item = point_iterator.next();
// FIXME: Should we draw a quadratic bezier to the first point here?
if (!opt_item.has_value()) {
break;
}
auto item = opt_item.value();
contour_size--;
if (item.on_curve) {
path.quadratic_bezier_curve_to(point0, item.point);
} else {
auto mid_point = (point0 + item.point) * 0.5f;
path.quadratic_bezier_curve_to(point0, mid_point);
last_offcurve_point = item.point;
}
} else {
path.quadratic_bezier_curve_to(point0, contour_start.value());
contour_start = {};
}
}
}
rasterizer.draw_path(path);
}
RefPtr<Gfx::Bitmap> Glyf::Glyph::rasterize_simple(i16 font_ascender, i16 font_descender, float x_scale, float y_scale) const
{
u32 width = (u32)(ceilf((m_xmax - m_xmin) * x_scale)) + 2;
u32 height = (u32)(ceilf((font_ascender - font_descender) * y_scale)) + 2;
Rasterizer rasterizer(Gfx::IntSize(width, height));
auto affine = Gfx::AffineTransform().scale(x_scale, -y_scale).translate(-m_xmin, -font_ascender);
rasterize_impl(rasterizer, affine);
return rasterizer.accumulate();
}
Glyf::Glyph Glyf::glyph(u32 offset) const
{
VERIFY(m_slice.size() >= offset + (u32)Sizes::GlyphHeader);
i16 num_contours = be_i16(m_slice.offset_pointer(offset));
i16 xmin = be_i16(m_slice.offset_pointer(offset + (u32)Offsets::XMin));
i16 ymin = be_i16(m_slice.offset_pointer(offset + (u32)Offsets::YMin));
i16 xmax = be_i16(m_slice.offset_pointer(offset + (u32)Offsets::XMax));
i16 ymax = be_i16(m_slice.offset_pointer(offset + (u32)Offsets::YMax));
auto slice = ReadonlyBytes(m_slice.offset_pointer(offset + (u32)Sizes::GlyphHeader), m_slice.size() - offset - (u32)Sizes::GlyphHeader);
return Glyph(slice, xmin, ymin, xmax, ymax, num_contours);
}
}

156
Userland/Libraries/LibGfx/Font/TrueType/Glyf.h Normal file
View file

@ -0,0 +1,156 @@
/*
* Copyright (c) 2020, Srimanta Barua <srimanta.barua1@gmail.com>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/Span.h>
#include <AK/Vector.h>
#include <LibGfx/AffineTransform.h>
#include <LibGfx/Bitmap.h>
#include <LibGfx/Font/TrueType/Tables.h>
#include <math.h>
namespace TTF {
class Rasterizer {
public:
Rasterizer(Gfx::IntSize);
void draw_path(Gfx::Path&);
RefPtr<Gfx::Bitmap> accumulate();
private:
void draw_line(Gfx::FloatPoint, Gfx::FloatPoint);
Gfx::IntSize m_size;
Vector<float> m_data;
};
class Loca {
public:
static Optional<Loca> from_slice(ReadonlyBytes, u32 num_glyphs, IndexToLocFormat);
u32 get_glyph_offset(u32 glyph_id) const;
private:
Loca(ReadonlyBytes slice, u32 num_glyphs, IndexToLocFormat index_to_loc_format)
: m_slice(slice)
, m_num_glyphs(num_glyphs)
, m_index_to_loc_format(index_to_loc_format)
{
}
ReadonlyBytes m_slice;
u32 m_num_glyphs { 0 };
IndexToLocFormat m_index_to_loc_format;
};
class Glyf {
public:
class Glyph {
public:
Glyph(ReadonlyBytes slice, i16 xmin, i16 ymin, i16 xmax, i16 ymax, i16 num_contours = -1)
: m_xmin(xmin)
, m_ymin(ymin)
, m_xmax(xmax)
, m_ymax(ymax)
, m_num_contours(num_contours)
, m_slice(slice)
{
if (m_num_contours >= 0) {
m_type = Type::Simple;
}
}
template<typename GlyphCb>
RefPtr<Gfx::Bitmap> rasterize(i16 font_ascender, i16 font_descender, float x_scale, float y_scale, GlyphCb glyph_callback) const
{
switch (m_type) {
case Type::Simple:
return rasterize_simple(font_ascender, font_descender, x_scale, y_scale);
case Type::Composite:
return rasterize_composite(font_ascender, font_descender, x_scale, y_scale, glyph_callback);
}
VERIFY_NOT_REACHED();
}
int ascender() const { return m_ymax; }
int descender() const { return m_ymin; }
private:
enum class Type {
Simple,
Composite,
};
class ComponentIterator {
public:
struct Item {
u16 glyph_id;
Gfx::AffineTransform affine;
};
ComponentIterator(ReadonlyBytes slice)
: m_slice(slice)
{
}
Optional<Item> next();
private:
ReadonlyBytes m_slice;
bool m_has_more { true };
u32 m_offset { 0 };
};
void rasterize_impl(Rasterizer&, Gfx::AffineTransform const&) const;
RefPtr<Gfx::Bitmap> rasterize_simple(i16 ascender, i16 descender, float x_scale, float y_scale) const;
template<typename GlyphCb>
RefPtr<Gfx::Bitmap> rasterize_composite(i16 font_ascender, i16 font_descender, float x_scale, float y_scale, GlyphCb glyph_callback) const
{
u32 width = (u32)(ceilf((m_xmax - m_xmin) * x_scale)) + 1;
u32 height = (u32)(ceilf((font_ascender - font_descender) * y_scale)) + 1;
Rasterizer rasterizer(Gfx::IntSize(width, height));
auto affine = Gfx::AffineTransform().scale(x_scale, -y_scale).translate(-m_xmin, -font_ascender);
ComponentIterator component_iterator(m_slice);
while (true) {
auto opt_item = component_iterator.next();
if (!opt_item.has_value()) {
break;
}
auto item = opt_item.value();
auto affine_here = affine.multiply(item.affine);
auto glyph = glyph_callback(item.glyph_id);
glyph.rasterize_impl(rasterizer, affine_here);
}
return rasterizer.accumulate();
}
Type m_type { Type::Composite };
i16 m_xmin { 0 };
i16 m_ymin { 0 };
i16 m_xmax { 0 };
i16 m_ymax { 0 };
i16 m_num_contours { -1 };
ReadonlyBytes m_slice;
};
Glyf(ReadonlyBytes slice)
: m_slice(slice)
{
}
Glyph glyph(u32 offset) const;
private:
enum class Offsets {
XMin = 2,
YMin = 4,
XMax = 6,
YMax = 8,
};
enum class Sizes {
GlyphHeader = 10,
};
ReadonlyBytes m_slice;
};
}

230
Userland/Libraries/LibGfx/Font/TrueType/Tables.h Normal file
View file

@ -0,0 +1,230 @@
/*
* Copyright (c) 2020, Srimanta Barua <srimanta.barua1@gmail.com>
* Copyright (c) 2022, Jelle Raaijmakers <jelle@gmta.nl>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/Error.h>
#include <AK/FixedArray.h>
#include <AK/Span.h>
#include <AK/String.h>
namespace TTF {
enum class IndexToLocFormat {
Offset16,
Offset32,
};
class Head {
public:
static Optional<Head> from_slice(ReadonlyBytes);
u16 units_per_em() const;
i16 xmin() const;
i16 ymin() const;
i16 xmax() const;
i16 ymax() const;
u16 style() const;
u16 lowest_recommended_ppem() const;
IndexToLocFormat index_to_loc_format() const;
private:
enum class Offsets {
UnitsPerEM = 18,
XMin = 36,
YMin = 38,
XMax = 40,
YMax = 42,
Style = 44,
LowestRecPPEM = 46,
IndexToLocFormat = 50,
};
enum class Sizes {
Table = 54,
};
Head(ReadonlyBytes slice)
: m_slice(slice)
{
}
ReadonlyBytes m_slice;
};
class Hhea {
public:
static Optional<Hhea> from_slice(ReadonlyBytes);
i16 ascender() const;
i16 descender() const;
i16 line_gap() const;
u16 advance_width_max() const;
u16 number_of_h_metrics() const;
private:
enum class Offsets {
Ascender = 4,
Descender = 6,
LineGap = 8,
AdvanceWidthMax = 10,
NumberOfHMetrics = 34,
};
enum class Sizes {
Table = 36,
};
Hhea(ReadonlyBytes slice)
: m_slice(slice)
{
}
ReadonlyBytes m_slice;
};
class Maxp {
public:
static Optional<Maxp> from_slice(ReadonlyBytes);
u16 num_glyphs() const;
private:
enum class Offsets {
NumGlyphs = 4
};
enum class Sizes {
TableV0p5 = 6,
};
Maxp(ReadonlyBytes slice)
: m_slice(slice)
{
}
ReadonlyBytes m_slice;
};
struct GlyphHorizontalMetrics {
u16 advance_width;
i16 left_side_bearing;
};
class Hmtx {
public:
static Optional<Hmtx> from_slice(ReadonlyBytes, u32 num_glyphs, u32 number_of_h_metrics);
GlyphHorizontalMetrics get_glyph_horizontal_metrics(u32 glyph_id) const;
private:
enum class Sizes {
LongHorMetric = 4,
LeftSideBearing = 2
};
Hmtx(ReadonlyBytes slice, u32 num_glyphs, u32 number_of_h_metrics)
: m_slice(slice)
, m_num_glyphs(num_glyphs)
, m_number_of_h_metrics(number_of_h_metrics)
{
}
ReadonlyBytes m_slice;
u32 m_num_glyphs { 0 };
u32 m_number_of_h_metrics { 0 };
};
class OS2 {
public:
enum class Offsets {
WeightClass = 4,
Selection = 62,
TypographicAscender = 68,
TypographicDescender = 70,
TypographicLineGap = 72,
};
u16 weight_class() const;
u16 selection() const;
i16 typographic_ascender() const;
i16 typographic_descender() const;
i16 typographic_line_gap() const;
explicit OS2(ReadonlyBytes slice)
: m_slice(slice)
{
}
private:
ReadonlyBytes m_slice;
};
class Name {
public:
enum class Platform {
Unicode = 0,
Macintosh = 1,
Windows = 3,
};
enum class MacintoshLanguage {
English = 0,
};
enum class WindowsLanguage {
EnglishUnitedStates = 0x0409,
};
static Optional<Name> from_slice(ReadonlyBytes);
String family_name() const { return string_for_id(NameId::FamilyName); }
String subfamily_name() const { return string_for_id(NameId::SubfamilyName); }
String typographic_family_name() const { return string_for_id(NameId::TypographicFamilyName); }
String typographic_subfamily_name() const { return string_for_id(NameId::TypographicSubfamilyName); }
private:
enum class NameId {
Copyright = 0,
FamilyName = 1,
SubfamilyName = 2,
UniqueIdentifier = 3,
FullName = 4,
VersionString = 5,
PostscriptName = 6,
Trademark = 7,
Manufacturer = 8,
Designer = 9,
Description = 10,
TypographicFamilyName = 16,
TypographicSubfamilyName = 17,
};
Name(ReadonlyBytes slice)
: m_slice(slice)
{
}
String string_for_id(NameId id) const;
ReadonlyBytes m_slice;
};
class Kern {
public:
static ErrorOr<Kern> from_slice(ReadonlyBytes);
i16 get_glyph_kerning(u16 left_glyph_id, u16 right_glyph_id) const;
private:
enum Sizes : size_t {
SubtableHeader = 6,
Format0Entry = 6,
};
Kern(ReadonlyBytes slice, FixedArray<size_t> subtable_offsets)
: m_slice(slice)
, m_subtable_offsets(move(subtable_offsets))
{
}
static Optional<i16> read_glyph_kerning_format0(ReadonlyBytes slice, u16 left_glyph_id, u16 right_glyph_id);
ReadonlyBytes m_slice;
FixedArray<size_t> m_subtable_offsets;
};
}