LibTTF: Split up Font.h into smaller internal header files.

Libraries/LibTTF/Cmap.cpp

@@ -24,7 +24,8 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "Font.h"
+#include "Cmap.h"
+#include <AK/Optional.h>
 
 namespace TTF {
 
@@ -32,7 +33,7 @@ extern u16 be_u16(const u8* ptr);
 extern u32 be_u32(const u8* ptr);
 extern i16 be_i16(const u8* ptr);
 
-Font::Cmap::Subtable::Platform Font::Cmap::Subtable::platform_id() const
+Cmap::Subtable::Platform Cmap::Subtable::platform_id() const
 {
     switch (m_raw_platform_id) {
     case 0:  return Platform::Unicode;
@@ -43,7 +44,7 @@ Font::Cmap::Subtable::Platform Font::Cmap::Subtable::platform_id() const
     }
 }
 
-Font::Cmap::Subtable::Format Font::Cmap::Subtable::format() const
+Cmap::Subtable::Format Cmap::Subtable::format() const
 {
     switch (be_u16(m_slice.offset_pointer(0))) {
         case 0:  return Format::ByteEncoding;
@@ -59,12 +60,12 @@ Font::Cmap::Subtable::Format Font::Cmap::Subtable::format() const
     }
 }
 
-u32 Font::Cmap::num_subtables() const
+u32 Cmap::num_subtables() const
 {
     return be_u16(m_slice.offset_pointer((u32) Offsets::NumTables));
 }
 
-Optional<Font::Cmap::Subtable> Font::Cmap::subtable(u32 index) const
+Optional<Cmap::Subtable> Cmap::subtable(u32 index) const
 {
     if (index >= num_subtables()) {
         return {};
@@ -79,7 +80,7 @@ Optional<Font::Cmap::Subtable> Font::Cmap::subtable(u32 index) const
 }
 
 // FIXME: This only handles formats 4 (SegmentToDelta) and 12 (SegmentedCoverage) for now.
-u32 Font::Cmap::Subtable::glyph_id_for_codepoint(u32 codepoint) const
+u32 Cmap::Subtable::glyph_id_for_codepoint(u32 codepoint) const
 {
     switch (format()) {
     case Format::SegmentToDelta:
@@ -91,7 +92,7 @@ u32 Font::Cmap::Subtable::glyph_id_for_codepoint(u32 codepoint) const
     }
 }
 
-u32 Font::Cmap::Subtable::glyph_id_for_codepoint_table_4(u32 codepoint) const
+u32 Cmap::Subtable::glyph_id_for_codepoint_table_4(u32 codepoint) 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) {
@@ -118,7 +119,7 @@ u32 Font::Cmap::Subtable::glyph_id_for_codepoint_table_4(u32 codepoint) const
     return 0;
 }
 
-u32 Font::Cmap::Subtable::glyph_id_for_codepoint_table_12(u32 codepoint) const
+u32 Cmap::Subtable::glyph_id_for_codepoint_table_12(u32 codepoint) const
 {
     u32 num_groups = be_u32(m_slice.offset_pointer((u32) Table12Offsets::NumGroups));
     ASSERT(m_slice.size() >= (u32) Table12Sizes::Header + (u32) Table12Sizes::Record * num_groups);
@@ -137,7 +138,7 @@ u32 Font::Cmap::Subtable::glyph_id_for_codepoint_table_12(u32 codepoint) const
     return 0;
 }
 
-u32 Font::Cmap::glyph_id_for_codepoint(u32 codepoint) const
+u32 Cmap::glyph_id_for_codepoint(u32 codepoint) const
 {
     auto opt_subtable = subtable(m_active_index);
     if (!opt_subtable.has_value()) {

Libraries/LibTTF/Cmap.h

@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) 2020, Srimanta Barua <srimanta.barua1@gmail.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <AK/ByteBuffer.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(const ByteBuffer& 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_codepoint(u32 codepoint) const;
+        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_codepoint_table_4(u32 codepoint) const;
+        u32 glyph_id_for_codepoint_table_12(u32 codepoint) const;
+
+        ByteBuffer m_slice;
+        u16 m_raw_platform_id;
+        u16 m_encoding_id;
+    };
+
+    Cmap() {}
+    Cmap(const ByteBuffer& slice)
+        : m_slice(slice)
+    {
+        ASSERT(m_slice.size() > (size_t) Sizes::TableHeader);
+    }
+
+    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_codepoint(u32 codepoint) const;
+
+private:
+    enum class Offsets {
+        NumTables = 2,
+        EncodingRecord_EncodingID = 2,
+        EncodingRecord_Offset = 4,
+    };
+    enum class Sizes {
+        TableHeader = 4,
+        EncodingRecord = 8,
+    };
+
+    ByteBuffer m_slice;
+    u32 m_active_index { UINT32_MAX };
+};
+
+}

Libraries/LibTTF/Font.cpp

@@ -24,7 +24,10 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+#include "Cmap.h"
 #include "Font.h"
+#include "Glyf.h"
+#include "Tables.h"
 #include <AK/LogStream.h>
 #include <AK/Utf8View.h>
 #include <AK/Utf32View.h>
@@ -59,37 +62,37 @@ u32 tag_from_str(const char *str)
     return be_u32((const u8*) str);
 }
 
-u16 Font::Head::units_per_em() const
+u16 Head::units_per_em() const
 {
     return be_u16(m_slice.offset_pointer((u32) Offsets::UnitsPerEM));
 }
 
-i16 Font::Head::xmin() const
+i16 Head::xmin() const
 {
     return be_i16(m_slice.offset_pointer((u32) Offsets::XMin));
 }
 
-i16 Font::Head::ymin() const
+i16 Head::ymin() const
 {
     return be_i16(m_slice.offset_pointer((u32) Offsets::YMin));
 }
 
-i16 Font::Head::xmax() const
+i16 Head::xmax() const
 {
     return be_i16(m_slice.offset_pointer((u32) Offsets::XMax));
 }
 
-i16 Font::Head::ymax() const
+i16 Head::ymax() const
 {
     return be_i16(m_slice.offset_pointer((u32) Offsets::YMax));
 }
 
-u16 Font::Head::lowest_recommended_ppem() const
+u16 Head::lowest_recommended_ppem() const
 {
     return be_u16(m_slice.offset_pointer((u32) Offsets::LowestRecPPEM));
 }
 
-Font::IndexToLocFormat Font::Head::index_to_loc_format() const
+IndexToLocFormat Head::index_to_loc_format() const
 {
     i16 raw = be_i16(m_slice.offset_pointer((u32) Offsets::IndexToLocFormat));
     switch (raw) {
@@ -102,32 +105,32 @@ Font::IndexToLocFormat Font::Head::index_to_loc_format() const
     }
 }
 
-i16 Font::Hhea::ascender() const
+i16 Hhea::ascender() const
 {
     return be_i16(m_slice.offset_pointer((u32) Offsets::Ascender));
 }
 
-i16 Font::Hhea::descender() const
+i16 Hhea::descender() const
 {
     return be_i16(m_slice.offset_pointer((u32) Offsets::Descender));
 }
 
-i16 Font::Hhea::line_gap() const
+i16 Hhea::line_gap() const
 {
     return be_i16(m_slice.offset_pointer((u32) Offsets::LineGap));
 }
 
-u16 Font::Hhea::advance_width_max() const
+u16 Hhea::advance_width_max() const
 {
     return be_u16(m_slice.offset_pointer((u32) Offsets::AdvanceWidthMax));
 }
 
-u16 Font::Hhea::number_of_h_metrics() const
+u16 Hhea::number_of_h_metrics() const
 {
     return be_u16(m_slice.offset_pointer((u32) Offsets::NumberOfHMetrics));
 }
 
-Font::GlyphHorizontalMetrics Font::Hmtx::get_glyph_horizontal_metrics(u32 glyph_id) const
+GlyphHorizontalMetrics Hmtx::get_glyph_horizontal_metrics(u32 glyph_id) const
 {
     ASSERT(glyph_id < m_num_glyphs);
     if (glyph_id < m_number_of_h_metrics) {
@@ -148,7 +151,7 @@ Font::GlyphHorizontalMetrics Font::Hmtx::get_glyph_horizontal_metrics(u32 glyph_
     };
 }
 
-u16 Font::Maxp::num_glyphs() const
+u16 Maxp::num_glyphs() const
 {
     return be_u16(m_slice.offset_pointer((u32) Offsets::NumGlyphs));
 }
@@ -244,13 +247,14 @@ Font::Font(ByteBuffer&& buffer, u32 offset)
     ASSERT(glyf_slice.has_value());
 
     // Load the tables.
-    m_head = Head(head_slice.value());
+    m_head_slice = head_slice.value();
-    m_hhea = Hhea(hhea_slice.value());
+    m_hhea_slice = hhea_slice.value();
-    m_maxp = Maxp(maxp_slice.value());
+    m_maxp_slice = maxp_slice.value();
-    m_hmtx = Hmtx(hmtx_slice.value(), m_maxp.num_glyphs(), m_hhea.number_of_h_metrics());
+    m_hmtx_slice = hmtx_slice.value();
+    m_loca_slice = loca_slice.value();
+    m_glyf_slice = glyf_slice.value();
+
     m_cmap = Cmap(cmap_slice.value());
-    m_loca = Loca(loca_slice.value(), m_maxp.num_glyphs(), m_head.index_to_loc_format());
-    m_glyf = Glyf(glyf_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"
@@ -275,10 +279,11 @@ Font::Font(ByteBuffer&& buffer, u32 offset)
 
 ScaledFontMetrics Font::metrics(float x_scale, float y_scale) const
 {
-    auto ascender = m_hhea.ascender() * y_scale;
+    Hhea hhea(m_hhea_slice);
-    auto descender = m_hhea.descender() * y_scale;
+    auto ascender = hhea.ascender() * y_scale;
-    auto line_gap = m_hhea.line_gap() * y_scale;
+    auto descender = hhea.descender() * y_scale;
-    auto advance_width_max = m_hhea.advance_width_max() * x_scale;
+    auto line_gap = hhea.line_gap() * y_scale;
+    auto advance_width_max = hhea.advance_width_max() * x_scale;
     return ScaledFontMetrics {
         .ascender = (int) roundf(ascender),
         .descender = (int) roundf(descender),
@@ -287,14 +292,22 @@ ScaledFontMetrics Font::metrics(float x_scale, float y_scale) const
     };
 }
 
+// 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 >= m_maxp.num_glyphs()) {
+    u32 num_glyphs = glyph_count();
+    u16 number_of_h_metrics = Hhea(m_hhea_slice).number_of_h_metrics();
+    auto index_to_loc_format = Head(m_head_slice).index_to_loc_format();
+    Hmtx hmtx(m_hmtx_slice, num_glyphs, number_of_h_metrics);
+    Loca loca(m_loca_slice, num_glyphs, index_to_loc_format);
+    Glyf glyf(m_glyf_slice);
+
+    if (glyph_id >= num_glyphs) {
         glyph_id = 0;
     }
-    auto horizontal_metrics = m_hmtx.get_glyph_horizontal_metrics(glyph_id);
+    auto horizontal_metrics = hmtx.get_glyph_horizontal_metrics(glyph_id);
-    auto glyph_offset = m_loca.get_glyph_offset(glyph_id);
+    auto glyph_offset = loca.get_glyph_offset(glyph_id);
-    auto glyph = m_glyf.glyph(glyph_offset);
+    auto glyph = glyf.glyph(glyph_offset);
     int ascender = glyph.ascender();
     int descender = glyph.descender();
     return ScaledGlyphMetrics {
@@ -308,20 +321,35 @@ ScaledGlyphMetrics Font::glyph_metrics(u32 glyph_id, float x_scale, float y_scal
 // FIXME: "loca" and "glyf" are not available for CFF fonts.
 RefPtr<Gfx::Bitmap> Font::raster_glyph(u32 glyph_id, float x_scale, float y_scale) const
 {
-    if (glyph_id >= m_maxp.num_glyphs()) {
+    u32 num_glyphs = glyph_count();
+    auto index_to_loc_format = Head(m_head_slice).index_to_loc_format();
+    Loca loca(m_loca_slice, num_glyphs, index_to_loc_format);
+    Glyf glyf(m_glyf_slice);
+
+    if (glyph_id >= num_glyphs) {
         glyph_id = 0;
     }
-    auto glyph_offset = m_loca.get_glyph_offset(glyph_id);
+    auto glyph_offset = loca.get_glyph_offset(glyph_id);
-    auto glyph = m_glyf.glyph(glyph_offset);
+    auto glyph = glyf.glyph(glyph_offset);
     return glyph.raster(x_scale, y_scale, [&](u16 glyph_id) {
-        if (glyph_id >= m_maxp.num_glyphs()) {
+        if (glyph_id >= num_glyphs) {
             glyph_id = 0;
         }
-        auto glyph_offset = m_loca.get_glyph_offset(glyph_id);
+        auto glyph_offset = loca.get_glyph_offset(glyph_id);
-        return m_glyf.glyph(glyph_offset);
+        return glyf.glyph(glyph_offset);
     });
 }
 
+u32 Font::glyph_count() const
+{
+    return Maxp(m_maxp_slice).num_glyphs();
+}
+
+u16 Font::units_per_em() const
+{
+    return Head(m_head_slice).units_per_em();
+}
+
 int ScaledFont::width(const StringView& string) const
 {
     Utf8View utf8 { string };

Libraries/LibTTF/Font.h

@@ -26,16 +26,13 @@
 
 #pragma once
 
+#include "Cmap.h"
 #include <AK/ByteBuffer.h>
-#include <AK/FixedArray.h>
 #include <AK/Noncopyable.h>
-#include <AK/Optional.h>
 #include <AK/RefCounted.h>
 #include <AK/StringView.h>
-#include <LibGfx/AffineTransform.h>
 #include <LibGfx/Bitmap.h>
 #include <LibGfx/Size.h>
-#include <math.h>
 
 #define POINTS_PER_INCH 72.0f
 #define DEFAULT_DPI     96
@@ -85,376 +82,20 @@ private:
     ScaledFontMetrics metrics(float x_scale, float y_scale) const;
     ScaledGlyphMetrics glyph_metrics(u32 glyph_id, float x_scale, float y_scale) const;
     RefPtr<Gfx::Bitmap> raster_glyph(u32 glyph_id, float x_scale, float y_scale) const;
-    u32 glyph_count() const { return m_maxp.num_glyphs(); }
+    u32 glyph_count() const;
-
+    u16 units_per_em() const;
-    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;
-        FixedArray<float> m_data;
-    };
-
-    enum class IndexToLocFormat {
-        Offset16,
-        Offset32,
-    };
-
-    class Head {
-    public:
-        Head() {}
-        Head(const ByteBuffer& slice)
-            : m_slice(slice)
-        {
-            ASSERT(m_slice.size() >= (size_t) Sizes::Table);
-        }
-        u16 units_per_em() const;
-        i16 xmin() const;
-        i16 ymin() const;
-        i16 xmax() const;
-        i16 ymax() 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,
-            LowestRecPPEM = 46,
-            IndexToLocFormat = 50,
-        };
-        enum class Sizes {
-            Table = 54,
-        };
-
-        ByteBuffer m_slice;
-    };
-
-    class Hhea {
-    public:
-        Hhea() {}
-        Hhea(const ByteBuffer& slice)
-            : m_slice(slice)
-        {
-            ASSERT(m_slice.size() >= (size_t) Sizes::Table);
-        }
-        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,
-        };
-
-        ByteBuffer m_slice;
-    };
-
-    class Maxp {
-    public:
-        Maxp() {}
-        Maxp(const ByteBuffer& slice)
-            : m_slice(slice)
-        {
-            ASSERT(m_slice.size() >= (size_t) Sizes::TableV0p5);
-        }
-        u16 num_glyphs() const;
-
-    private:
-        enum class Offsets {
-            NumGlyphs = 4
-        };
-        enum class Sizes {
-            TableV0p5 = 6,
-        };
-
-        ByteBuffer m_slice;
-    };
-
-    struct GlyphHorizontalMetrics {
-        u16 advance_width;
-        i16 left_side_bearing;
-    };
-
-    class Hmtx {
-    public:
-        Hmtx() {}
-        Hmtx(const ByteBuffer& 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)
-        {
-            ASSERT(m_slice.size() >= number_of_h_metrics * (u32) Sizes::LongHorMetric + (num_glyphs - number_of_h_metrics) * (u32) Sizes::LeftSideBearing);
-        }
-        GlyphHorizontalMetrics get_glyph_horizontal_metrics(u32 glyph_id) const;
-
-    private:
-        enum class Sizes {
-            LongHorMetric = 4,
-            LeftSideBearing = 2
-        };
-
-        ByteBuffer m_slice;
-        u32 m_num_glyphs;
-        u32 m_number_of_h_metrics;
-    };
-
-    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(const ByteBuffer& 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_codepoint(u32 codepoint) const;
-            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_codepoint_table_4(u32 codepoint) const;
-            u32 glyph_id_for_codepoint_table_12(u32 codepoint) const;
-
-            ByteBuffer m_slice;
-            u16 m_raw_platform_id;
-            u16 m_encoding_id;
-        };
-
-        Cmap() {}
-        Cmap(const ByteBuffer& slice)
-            : m_slice(slice)
-        {
-            ASSERT(m_slice.size() > (size_t) Sizes::TableHeader);
-        }
-
-        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_codepoint(u32 codepoint) const;
-
-    private:
-        enum class Offsets {
-            NumTables = 2,
-            EncodingRecord_EncodingID = 2,
-            EncodingRecord_Offset = 4,
-        };
-        enum class Sizes {
-            TableHeader = 4,
-            EncodingRecord = 8,
-        };
-
-        ByteBuffer m_slice;
-        u32 m_active_index { UINT32_MAX };
-    };
-
-    class Loca {
-    public:
-        Loca() {}
-        Loca(const ByteBuffer& 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)
-        {
-            switch (m_index_to_loc_format) {
-            case IndexToLocFormat::Offset16:
-                ASSERT(m_slice.size() >= m_num_glyphs * 2);
-                break;
-            case IndexToLocFormat::Offset32:
-                ASSERT(m_slice.size() >= m_num_glyphs * 4);
-                break;
-            }
-        }
-        u32 get_glyph_offset(u32 glyph_id) const;
-
-    private:
-        ByteBuffer m_slice;
-        u32 m_num_glyphs;
-        IndexToLocFormat m_index_to_loc_format;
-    };
-
-    class Glyf {
-    public:
-        class Glyph {
-        public:
-            Glyph(const ByteBuffer& 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(move(slice))
-            {
-                if (m_num_contours >= 0) {
-                    m_type = Type::Simple;
-                }
-            }
-            template <typename GlyphCb>
-            RefPtr<Gfx::Bitmap> raster(float x_scale, float y_scale, GlyphCb glyph_callback) const
-            {
-                switch (m_type) {
-                case Type::Simple:
-                    return raster_simple(x_scale, y_scale);
-                case Type::Composite:
-                    return raster_composite(x_scale, y_scale, glyph_callback);
-                }
-                ASSERT_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(const ByteBuffer& slice)
-                    : m_slice(slice)
-                {
-                }
-                Optional<Item> next();
-
-            private:
-                ByteBuffer m_slice;
-                bool m_has_more { true };
-                u32 m_offset { 0 };
-            };
-
-            void raster_inner(Rasterizer&, Gfx::AffineTransform&) const;
-            RefPtr<Gfx::Bitmap> raster_simple(float x_scale, float y_scale) const;
-            template <typename GlyphCb>
-            RefPtr<Gfx::Bitmap> raster_composite(float x_scale, float y_scale, GlyphCb glyph_callback) const
-            {
-                u32 width = (u32) (ceil((m_xmax - m_xmin) * x_scale)) + 1;
-                u32 height = (u32) (ceil((m_ymax - m_ymin) * y_scale)) + 1;
-                Rasterizer rasterizer(Gfx::IntSize(width, height));
-                auto affine = Gfx::AffineTransform().scale(x_scale, -y_scale).translate(-m_xmin, -m_ymax);
-                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 * item.affine;
-                    auto glyph = glyph_callback(item.glyph_id);
-                    glyph.raster_inner(rasterizer, affine_here);
-                }
-                return rasterizer.accumulate();
-            }
-
-            Type m_type { Type::Composite };
-            i16 m_xmin;
-            i16 m_ymin;
-            i16 m_xmax;
-            i16 m_ymax;
-            i16 m_num_contours { -1 };
-            ByteBuffer m_slice;
-        };
-
-        Glyf() {}
-        Glyf(const ByteBuffer& slice)
-            : m_slice(move(slice))
-        {
-        }
-        Glyph glyph(u32 offset) const;
-
-    private:
-        enum class Offsets {
-            XMin = 2,
-            YMin = 4,
-            XMax = 6,
-            YMax = 8,
-        };
-        enum class Sizes {
-            GlyphHeader = 10,
-        };
-
-        ByteBuffer m_slice;
-    };
 
+    // This owns the font data
     ByteBuffer m_buffer;
-    Head m_head;
+    // These are all non-owning slices
-    Hhea m_hhea;
+    ByteBuffer m_head_slice;
-    Maxp m_maxp;
+    ByteBuffer m_hhea_slice;
-    Hmtx m_hmtx;
+    ByteBuffer m_maxp_slice;
+    ByteBuffer m_hmtx_slice;
+    ByteBuffer m_loca_slice;
+    ByteBuffer m_glyf_slice;
+    // These are stateful wrappers around tables
     Cmap m_cmap;
-    Loca m_loca;
-    Glyf m_glyf;
 
     friend ScaledFont;
 };
@@ -464,7 +105,7 @@ public:
     ScaledFont(RefPtr<Font> font, float point_width, float point_height, unsigned dpi_x = DEFAULT_DPI, unsigned dpi_y = DEFAULT_DPI)
         : m_font(font)
     {
-        float units_per_em = m_font->m_head.units_per_em();
+        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);
     }

Libraries/LibTTF/Glyf.cpp

@@ -24,7 +24,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "Font.h"
+#include "Glyf.h"
 #include <LibGfx/FloatPoint.h>
 #include <LibGfx/Path.h>
 
@@ -147,7 +147,7 @@ private:
     Gfx::AffineTransform m_affine;
 };
 
-Optional<Font::Glyf::Glyph::ComponentIterator::Item> Font::Glyf::Glyph::ComponentIterator::next() {
+Optional<Glyf::Glyph::ComponentIterator::Item> Glyf::Glyph::ComponentIterator::next() {
     if (!m_has_more) {
         return {};
     }
@@ -208,7 +208,7 @@ Optional<Font::Glyf::Glyph::ComponentIterator::Item> Font::Glyf::Glyph::Componen
     };
 }
 
-Font::Rasterizer::Rasterizer(Gfx::IntSize size)
+Rasterizer::Rasterizer(Gfx::IntSize size)
     : m_size(size)
     , m_data(m_size.width() * m_size.height())
 {
@@ -217,14 +217,14 @@ Font::Rasterizer::Rasterizer(Gfx::IntSize size)
     }
 }
 
-void Font::Rasterizer::draw_path(Gfx::Path& path)
+void Rasterizer::draw_path(Gfx::Path& path)
 {
     for (auto& line : path.split_lines()) {
         draw_line(line.from, line.to);
     }
 }
 
-RefPtr<Gfx::Bitmap> Font::Rasterizer::accumulate()
+RefPtr<Gfx::Bitmap> Rasterizer::accumulate()
 {
     auto bitmap = Gfx::Bitmap::create(Gfx::BitmapFormat::RGBA32, m_size);
     Color base_color = Color::from_rgb(0xffffff);
@@ -246,7 +246,7 @@ RefPtr<Gfx::Bitmap> Font::Rasterizer::accumulate()
     return bitmap;
 }
 
-void Font::Rasterizer::draw_line(Gfx::FloatPoint p0, Gfx::FloatPoint p1)
+void Rasterizer::draw_line(Gfx::FloatPoint p0, Gfx::FloatPoint p1)
 {
     // FIXME: Shift x and y according to dy/dx
     if (p0.x() < 0.0) { p0.set_x(roundf(p0.x())); }
@@ -254,7 +254,6 @@ void Font::Rasterizer::draw_line(Gfx::FloatPoint p0, Gfx::FloatPoint p1)
     if (p1.x() < 0.0) { p1.set_x(roundf(p1.x())); }
     if (p1.y() < 0.0) { p1.set_y(roundf(p1.y())); }
 
-    dbg() << "m_size: " << m_size << " | p0: (" << p0.x() << ", " << p0.y() << ") | p1: (" << p1.x() << ", " << p1.y() << ")";
     ASSERT(p0.x() >= 0.0 && p0.y() >= 0.0 && p0.x() <= m_size.width() && p0.y() <= m_size.height());
     ASSERT(p1.x() >= 0.0 && p1.y() >= 0.0 && p1.x() <= m_size.width() && p1.y() <= m_size.height());
 
@@ -319,7 +318,7 @@ void Font::Rasterizer::draw_line(Gfx::FloatPoint p0, Gfx::FloatPoint p1)
     }
 }
 
-u32 Font::Loca::get_glyph_offset(u32 glyph_id) const
+u32 Loca::get_glyph_offset(u32 glyph_id) const
 {
     ASSERT(glyph_id < m_num_glyphs);
     switch (m_index_to_loc_format) {
@@ -363,7 +362,7 @@ static void get_ttglyph_offsets(const ByteBuffer& slice, u32 num_points, u32 fla
     *y_offset = *x_offset + x_size;
 }
 
-void Font::Glyf::Glyph::raster_inner(Rasterizer& rasterizer, Gfx::AffineTransform& affine) const
+void Glyf::Glyph::raster_inner(Rasterizer& rasterizer, Gfx::AffineTransform& affine) const
 {
     // Get offets for flags, x, and y.
     u16 num_points = be_u16(m_slice.offset_pointer((m_num_contours - 1) * 2)) + 1;
@@ -461,7 +460,7 @@ void Font::Glyf::Glyph::raster_inner(Rasterizer& rasterizer, Gfx::AffineTransfor
     rasterizer.draw_path(path);
 }
 
-RefPtr<Gfx::Bitmap> Font::Glyf::Glyph::raster_simple(float x_scale, float y_scale) const
+RefPtr<Gfx::Bitmap> Glyf::Glyph::raster_simple(float x_scale, float y_scale) const
 {
     u32 width = (u32) (ceil((m_xmax - m_xmin) * x_scale)) + 2;
     u32 height = (u32) (ceil((m_ymax - m_ymin) * y_scale)) + 2;
@@ -471,7 +470,7 @@ RefPtr<Gfx::Bitmap> Font::Glyf::Glyph::raster_simple(float x_scale, float y_scal
     return rasterizer.accumulate();
 }
 
-Font::Glyf::Glyph Font::Glyf::glyph(u32 offset) const
+Glyf::Glyph Glyf::glyph(u32 offset) const
 {
     ASSERT(m_slice.size() >= offset + (u32) Sizes::GlyphHeader);
     i16 num_contours = be_i16(m_slice.offset_pointer(offset));

Libraries/LibTTF/Glyf.h

@@ -0,0 +1,182 @@
+/*
+ * Copyright (c) 2020, Srimanta Barua <srimanta.barua1@gmail.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include "Tables.h"
+#include <AK/ByteBuffer.h>
+#include <AK/FixedArray.h>
+#include <LibGfx/AffineTransform.h>
+#include <LibGfx/Bitmap.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;
+    FixedArray<float> m_data;
+};
+
+class Loca {
+public:
+    Loca(const ByteBuffer& 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)
+    {
+        switch (m_index_to_loc_format) {
+        case IndexToLocFormat::Offset16:
+            ASSERT(m_slice.size() >= m_num_glyphs * 2);
+            break;
+        case IndexToLocFormat::Offset32:
+            ASSERT(m_slice.size() >= m_num_glyphs * 4);
+            break;
+        }
+    }
+    u32 get_glyph_offset(u32 glyph_id) const;
+
+private:
+    ByteBuffer m_slice;
+    u32 m_num_glyphs;
+    IndexToLocFormat m_index_to_loc_format;
+};
+
+class Glyf {
+public:
+    class Glyph {
+    public:
+        Glyph(const ByteBuffer& 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> raster(float x_scale, float y_scale, GlyphCb glyph_callback) const
+        {
+            switch (m_type) {
+            case Type::Simple:
+                return raster_simple(x_scale, y_scale);
+            case Type::Composite:
+                return raster_composite(x_scale, y_scale, glyph_callback);
+            }
+            ASSERT_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(const ByteBuffer& slice)
+                : m_slice(slice)
+            {
+            }
+            Optional<Item> next();
+
+        private:
+            ByteBuffer m_slice;
+            bool m_has_more { true };
+            u32 m_offset { 0 };
+        };
+
+        void raster_inner(Rasterizer&, Gfx::AffineTransform&) const;
+        RefPtr<Gfx::Bitmap> raster_simple(float x_scale, float y_scale) const;
+        template <typename GlyphCb>
+        RefPtr<Gfx::Bitmap> raster_composite(float x_scale, float y_scale, GlyphCb glyph_callback) const
+        {
+            u32 width = (u32) (ceil((m_xmax - m_xmin) * x_scale)) + 1;
+            u32 height = (u32) (ceil((m_ymax - m_ymin) * y_scale)) + 1;
+            Rasterizer rasterizer(Gfx::IntSize(width, height));
+            auto affine = Gfx::AffineTransform().scale(x_scale, -y_scale).translate(-m_xmin, -m_ymax);
+            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 * item.affine;
+                auto glyph = glyph_callback(item.glyph_id);
+                glyph.raster_inner(rasterizer, affine_here);
+            }
+            return rasterizer.accumulate();
+        }
+
+        Type m_type { Type::Composite };
+        i16 m_xmin;
+        i16 m_ymin;
+        i16 m_xmax;
+        i16 m_ymax;
+        i16 m_num_contours { -1 };
+        ByteBuffer m_slice;
+    };
+
+    Glyf(const ByteBuffer& 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,
+    };
+
+    ByteBuffer m_slice;
+};
+
+}

Libraries/LibTTF/Tables.h

@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2020, Srimanta Barua <srimanta.barua1@gmail.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <AK/ByteBuffer.h>
+
+namespace TTF {
+
+enum class IndexToLocFormat {
+    Offset16,
+    Offset32,
+};
+
+class Head {
+public:
+    Head(const ByteBuffer& slice)
+        : m_slice(slice)
+    {
+        ASSERT(m_slice.size() >= (size_t) Sizes::Table);
+    }
+    u16 units_per_em() const;
+    i16 xmin() const;
+    i16 ymin() const;
+    i16 xmax() const;
+    i16 ymax() 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,
+        LowestRecPPEM = 46,
+        IndexToLocFormat = 50,
+    };
+    enum class Sizes {
+        Table = 54,
+    };
+
+    ByteBuffer m_slice;
+};
+
+class Hhea {
+public:
+    Hhea(const ByteBuffer& slice)
+        : m_slice(slice)
+    {
+        ASSERT(m_slice.size() >= (size_t) Sizes::Table);
+    }
+    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,
+    };
+
+    ByteBuffer m_slice;
+};
+
+class Maxp {
+public:
+    Maxp(const ByteBuffer& slice)
+        : m_slice(slice)
+    {
+        ASSERT(m_slice.size() >= (size_t) Sizes::TableV0p5);
+    }
+    u16 num_glyphs() const;
+
+private:
+    enum class Offsets {
+        NumGlyphs = 4
+    };
+    enum class Sizes {
+        TableV0p5 = 6,
+    };
+
+    ByteBuffer m_slice;
+};
+
+struct GlyphHorizontalMetrics {
+    u16 advance_width;
+    i16 left_side_bearing;
+};
+
+class Hmtx {
+public:
+    Hmtx(const ByteBuffer& 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)
+    {
+        ASSERT(m_slice.size() >= number_of_h_metrics * (u32) Sizes::LongHorMetric + (num_glyphs - number_of_h_metrics) * (u32) Sizes::LeftSideBearing);
+    }
+    GlyphHorizontalMetrics get_glyph_horizontal_metrics(u32 glyph_id) const;
+
+private:
+    enum class Sizes {
+        LongHorMetric = 4,
+        LeftSideBearing = 2
+    };
+
+    ByteBuffer m_slice;
+    u32 m_num_glyphs;
+    u32 m_number_of_h_metrics;
+};
+
+}