C++字体库开发之特性解析十三

2024-12-10

本文作者原创，首发在本博客；CSDN 上的同名文章已标注为转载并回链到本页：https://blog.csdn.net/qq_30220519/article/details/144373482

Freetype

#include "freetype/freetype.h"
#include "freetype/tttables.h"
#include <memory>
#include <set>

namespace {
struct _Script_Lang {
    FT_Tag script;
    FT_Tag language;
};

#define SCRIPT_kana  FT_MAKE_TAG('k', 'a', 'n', 'a')
#define SCRIPT_hani  FT_MAKE_TAG('h', 'a', 'n', 'i')
#define SCRIPT_hang  FT_MAKE_TAG('h', 'a', 'n', 'g')

#define LANGUAGE_JAN FT_MAKE_TAG('J', 'A', 'N', ' ')
#define LANGUAGE_CHN FT_MAKE_TAG('C', 'H', 'N', ' ')
#define LANGUAGE_KOR FT_MAKE_TAG('K', 'O', 'R', ' ')

const struct _Script_Lang Script_Lang[] = {% raw %}{{SCRIPT_kana, LANGUAGE_JAN},{% endraw %}
                                           {SCRIPT_hani, LANGUAGE_CHN},
                                           {SCRIPT_hang, LANGUAGE_KOR}};
#define num_Script_Lang (sizeof(Script_Lang) / sizeof(Script_Lang[0]))
}  // namespace

class TagsParse
{
public:
    typedef struct {
        FT_UShort  req;
        FT_UShort  count;
        FT_UShort *list;
    } LangSys_Item;

    typedef struct {
        FT_Tag        tag;
        FT_ULong      ptr;
        LangSys_Item *entry;
    } LangSys_Record;

    typedef struct {
        FT_ULong        ptr;
        LangSys_Item   *entry;
        FT_UShort       count;
        LangSys_Record *list;
    } Script_Item;

    typedef struct {
        FT_Tag       tag, ltag;
        FT_ULong     ptr;
        Script_Item *entry;
    } Script_Record;

    typedef struct {
        FT_UShort  count;
        FT_UShort *list;
    } Feature_Item;

    typedef struct {
        FT_Tag        tag;
        FT_ULong      ptr;
        Feature_Item *entry;
    } Feature_Record;

    tagsParse(FT_Face f) : face(f) {}
    ~tagsParse() { reset(); }

    void reset()
    {
        if (Table || TABLE_length || TABLE_ptr) {
            free(Table);
            Table  = nullptr;
            TABLE_length = 0;
            TABLE_ptr    = 0;
        }

        if (Script_List || Script_Count) {
            free(Script_List);
            Script_List  = nullptr;
            Script_Count = 0;
        }

        if (Feature_List || Feature_Count) {
            free(Feature_List);
            Feature_List  = nullptr;
            Feature_Count = 0;
        }
    }

    inline void need(FT_ULong needed)
    {
        if (TABLE_ptr + needed > TABLE_length)
            printf("GSUB: Unexpected end of table.");
    }

    inline FT_Byte get_Byte(void) { return Table[TABLE_ptr++]; }

    inline signed char get_SByte(void) { return (signed char)Table[TABLE_ptr++]; }

    FT_UShort get_UShort(void)
    {
        unsigned int cc;
        cc = get_Byte() << 8;
        cc |= get_Byte();
        return (FT_UShort)cc;
    }

    FT_Short get_Short(void)
    {
        int cc;
        cc = get_SByte() << 8;
        cc |= get_Byte();
        return (FT_Short)cc;
    }

    FT_ULong get_ULong(void)
    {
        unsigned int cc;
        cc = get_Byte() << 24;
        cc |= get_Byte() << 16;
        cc |= get_Byte() << 8;
        cc |= get_Byte();
        return (FT_ULong)cc;
    }

    void *mymalloc(size_t len)
    {
        void *p;

#ifdef SMALLMALLOC
        if (len > 65500L)
            printf("Cannot allocate more than 64kByte.");
#endif

        if (len)
            p = malloc(len);
        else
            p = malloc(1);

        if (p == NULL)
            printf("Out of memory.");

        return p;
    }

    void *mycalloc(size_t nmemb, size_t len)
    {
        void *p;

        p = calloc(nmemb ? nmemb : 1, len ? len : 1);

        if (p == NULL)
            printf("Out of memory.");

        return p;
    }

    void gsub(void)
    {
        reset();
        FT_Error error;
        /*
         *   Fetch GSUB table
         */
        if ((error = FT_Load_Sfnt_Table(face, FT_MAKE_TAG('G', 'S', 'U', 'B'), 0, NULL, &TABLE_length))) {
#ifdef DEBUG
            warning("No GSUB data available for vertical glyph presentation forms.");
#endif
            return;
        }
        Table = (FT_Byte *)mymalloc(TABLE_length);
        // std::shared_ptr<void> finally(nullptr, [Table](void *p) { free(Table); });  // 退出时自动销毁缓存
        if ((error = FT_Load_Sfnt_Table(face, FT_MAKE_TAG('G', 'S', 'U', 'B'), 0, Table, &TABLE_length))) {
            printf("Cannot load GSUB table (error code = 0x%x).", error);
            return;
        }
        fetch_table(Table, TABLE_length);
    }

    void gpos(void)
    {
        reset();
        FT_Error error;
        /*
         *   Fetch GSUB table
         */
        if ((error = FT_Load_Sfnt_Table(face, FT_MAKE_TAG('G', 'P', 'O', 'S'), 0, NULL, &TABLE_length))) {
#ifdef DEBUG
            warning("No GSUB data available for vertical glyph presentation forms.");
#endif
            return;
        }
        Table = (FT_Byte *)mymalloc(TABLE_length);
        // std::shared_ptr<void> finally(nullptr, [Table](void *p) { free(Table); });  // 退出时自动销毁缓存
        if ((error = FT_Load_Sfnt_Table(face, FT_MAKE_TAG('G', 'P', 'O', 'S'), 0, Table, &TABLE_length))) {
            printf("Cannot load GSUB table (error code = 0x%x).", error);
            return;
        }
        fetch_table(Table, TABLE_length);
    }

    void fetch_table(FT_Byte *Table, FT_ULong TABLE_length)
    {
        FT_Error error;
        int      i, j;

        FT_ULong Script_List_ptr, Feature_List_ptr, Lookup_List_ptr;

        /*
         *   Read GSUB header
         */
        need(10);
        if (get_ULong() != 0x00010000)
            printf("GSUB: Bad version.");
        Script_List_ptr  = get_UShort();
        Feature_List_ptr = get_UShort();
        Lookup_List_ptr  = get_UShort();

        /*
         *   Read Script_List
         */
        TABLE_ptr = Script_List_ptr;
        need(2);
        Script_Count = get_UShort();
#ifdef DEBUG
        warning("GSUB: Script List with %d entries at 0x%04x.", Script_Count, Script_List_ptr);
#endif
        Script_List = (Script_Record *)mycalloc(Script_Count, sizeof(Script_Record));

        need(6 * Script_Count);
        for (i = 0; i < Script_Count; i++) {
            FT_Tag   tag = get_ULong();
            FT_ULong ptr = Script_List_ptr + get_UShort();
            for (j = 0; j < num_Script_Lang; j++)
                if (tag == Script_Lang[j].script) {
                    Script_List[i].tag  = tag;
                    Script_List[i].ltag = Script_Lang[j].language;
                    Script_List[i].ptr  = ptr;
                }
        }

        /*
         *   Read Feature_List
         */
        TABLE_ptr = Feature_List_ptr;
        need(2);
        Feature_Count = get_UShort();
#ifdef DEBUG
        warning("GSUB: Feature List with %d entries at 0x%04x.", Feature_Count, Feature_List_ptr);
#endif
        Feature_List = (Feature_Record *)mycalloc(Feature_Count, sizeof(Feature_Record));

        need(6 * Feature_Count);
        for (i = 0; i < Feature_Count; i++) {
            FT_Tag   tag = get_ULong();
            FT_ULong ptr = Feature_List_ptr + get_UShort();
            //            char a = (tag >> 24) & 0xFF;
            //            char b = (tag >> 16) & 0xFF;
            //            char c = (tag >> 8) & 0xFF;
            //            char d = tag & 0xFF;
            tags.insert(tag);
        }
    }

public:
    FT_Face          face             = nullptr;
    FT_ULong         Script_List_ptr  = 0;
    FT_ULong         Feature_List_ptr = 0;
    FT_ULong         Lookup_List_ptr  = 0;
    FT_ULong         TABLE_ptr         = 0;
    Script_Record   *Script_List      = nullptr;
    FT_UShort        Script_Count     = 0;
    Feature_Record  *Feature_List     = nullptr;
    FT_UShort        Feature_Count    = 0;
    FT_ULong         TABLE_length      = 0;
    FT_Byte         *Table       = nullptr;
    std::set<FT_Tag> tags;
};

TagsParse parse(face);
parse.gsub();
parse.gpos();
parse.tags;

Harfbuzz

#include "hb-ft.h"

hb_font_t            *hb_font = hb_ft_font_create(face, NULL);
hb_face_t            *hb_face = hb_ft_face_create_referenced(face);
std::set<std::string> curFeatSet;
for (hb_tag_t table_tag : {HB_OT_TAG_GSUB, HB_OT_TAG_GPOS}) {
	unsigned int feature_count = hb_ot_layout_table_get_feature_tags(hb_face, table_tag, 0, nullptr, nullptr);

	std::vector<hb_tag_t> feature_tags(feature_count);
	hb_ot_layout_table_get_feature_tags(hb_face, table_tag, 0, &feature_count, feature_tags.data());

	for (hb_tag_t feature_tag : feature_tags) {
		char tag_str[5] = {0};
		hb_tag_to_string(feature_tag, tag_str);
		curFeatSet.insert(tag_str);
	}
	curFeatSet.insert(curFeatSet.begin(), curFeatSet.end());
}
hb_face_destroy(face);
hb_font_destroy(hb_font);

输出

"fontFeatures": [
	"aalt",
	"calt",
	"case",
	"ccmp",
	"cpsp",
	"cv01",
	"cv02",
	"cv03",
	"cv04",
	"cv05",
	"cv06",
	"cv07",
	"cv08",
	"cv09",
	"cv10",
	"cv11",
	"dlig",
	"dnom",
	"frac",
	"kern",
	"locl",
	"mark",
	"numr",
	"ordn",
	"pnum",
	"salt",
	"sinf",
	"ss01",
	"ss02",
	"ss03",
	"ss04",
	"subs",
	"sups",
	"tnum",
	"zero"
]