font.h

Go to the documentation of this file.

// Copyright (C) 2004-2025 Artifex Software, Inc.
//
// This file is part of MuPDF.
//
// MuPDF is free software: you can redistribute it and/or modify it under the
// terms of the GNU Affero General Public License as published by the Free
// Software Foundation, either version 3 of the License, or (at your option)
// any later version.
//
// MuPDF is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
// details.
//
// You should have received a copy of the GNU Affero General Public License
// along with MuPDF. If not, see <https://www.gnu.org/licenses/agpl-3.0.en.html>
//
// Alternative licensing terms are available from the licensor.
// For commercial licensing, see <https://www.artifex.com/> or contact
// Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco,
// CA 94129, USA, for further information.
 
#ifndef MUPDF_FITZ_FONT_H
#define MUPDF_FITZ_FONT_H
 
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/geometry.h"
#include "mupdf/fitz/buffer.h"
#include "mupdf/fitz/color.h"
 
/* forward declaration for circular dependency */
struct fz_device;
 
/* Various font encoding tables and lookup functions */
 
FZ_DATA extern const char *fz_glyph_name_from_adobe_standard[256];
FZ_DATA extern const char *fz_glyph_name_from_iso8859_7[256];
FZ_DATA extern const char *fz_glyph_name_from_koi8u[256];
FZ_DATA extern const char *fz_glyph_name_from_mac_expert[256];
FZ_DATA extern const char *fz_glyph_name_from_mac_roman[256];
FZ_DATA extern const char *fz_glyph_name_from_win_ansi[256];
FZ_DATA extern const char *fz_glyph_name_from_windows_1252[256];
 
FZ_DATA extern const unsigned short fz_unicode_from_iso8859_1[256];
FZ_DATA extern const unsigned short fz_unicode_from_iso8859_7[256];
FZ_DATA extern const unsigned short fz_unicode_from_koi8u[256];
FZ_DATA extern const unsigned short fz_unicode_from_pdf_doc_encoding[256];
FZ_DATA extern const unsigned short fz_unicode_from_windows_1250[256];
FZ_DATA extern const unsigned short fz_unicode_from_windows_1251[256];
FZ_DATA extern const unsigned short fz_unicode_from_windows_1252[256];
 
int fz_iso8859_1_from_unicode(int u);
int fz_iso8859_7_from_unicode(int u);
int fz_koi8u_from_unicode(int u);
int fz_windows_1250_from_unicode(int u);
int fz_windows_1251_from_unicode(int u);
int fz_windows_1252_from_unicode(int u);
 
int fz_unicode_from_glyph_name(const char *name);
int fz_unicode_from_glyph_name_strict(const char *name);
const char **fz_duplicate_glyph_names_from_unicode(int unicode);
const char *fz_glyph_name_from_unicode_sc(int unicode);

typedef struct fz_text_decoder fz_text_decoder;
 
struct fz_text_decoder {
    // get maximum size estimate of converted text (fast)
    int (*decode_bound)(fz_text_decoder *dec, unsigned char *input, int n);
 
    // get exact size of converted text (slow)
    int (*decode_size)(fz_text_decoder *dec, unsigned char *input, int n);
 
    // convert text into output buffer
    void (*decode)(fz_text_decoder *dec, char *output, unsigned char *input, int n);
 
    // for internal use only; do not touch!
    void *table1;
    void *table2;
};
 
/* Initialize a text decoder using an IANA encoding name.
 * See source/fitz/text-decoder.c for the exact list of supported encodings.
 * Will throw an exception if the requested encoding is not available.
 *
 * The following is a subset of the supported encodings (see source/fitz/text-decoder.c for the full list):
 *   iso-8859-1
 *   iso-8859-7
 *   koi8-r
 *   euc-jp
 *   shift_jis
 *   euc-kr
 *   euc-cn
 *   gb18030
 *   euc-tw
 *   big5
 */
void fz_init_text_decoder(fz_context *ctx, fz_text_decoder *dec, const char *encoding);

typedef struct fz_font fz_font;


void *fz_font_ft_face(fz_context *ctx, fz_font *font);

fz_buffer **fz_font_t3_procs(fz_context *ctx, fz_font *font);
 
/* common CJK font collections */
enum { FZ_ADOBE_CNS, FZ_ADOBE_GB, FZ_ADOBE_JAPAN, FZ_ADOBE_KOREA };

typedef struct
{
    unsigned int is_mono : 1;
    unsigned int is_serif : 1;
    unsigned int is_bold : 1;
    unsigned int is_italic : 1;
    unsigned int ft_substitute : 1; /* use substitute metrics */
    unsigned int ft_stretch : 1; /* stretch to match PDF metrics */
 
    unsigned int fake_bold : 1; /* synthesize bold */
    unsigned int fake_italic : 1; /* synthesize italic */
    unsigned int has_opentype : 1; /* has opentype shaping tables */
    unsigned int invalid_bbox : 1;
 
    unsigned int cjk : 1;
    unsigned int cjk_lang : 2; /* CNS, GB, JAPAN, or KOREA */
 
    unsigned int embed : 1;
    unsigned int never_embed : 1;
} fz_font_flags_t;

fz_font_flags_t *fz_font_flags(fz_font *font);

typedef struct
{
    void *shaper_handle;
    void (*destroy)(fz_context *ctx, void *); /* Destructor for shape_handle */
} fz_shaper_data_t;

fz_shaper_data_t *fz_font_shaper_data(fz_context *ctx, fz_font *font);

const char *fz_font_name(fz_context *ctx, fz_font *font);

int fz_font_is_bold(fz_context *ctx, fz_font *font);

int fz_font_is_italic(fz_context *ctx, fz_font *font);

int fz_font_is_serif(fz_context *ctx, fz_font *font);

int fz_font_is_monospaced(fz_context *ctx, fz_font *font);

fz_rect fz_font_bbox(fz_context *ctx, fz_font *font);

typedef fz_font *(fz_load_system_font_fn)(fz_context *ctx, const char *name, int bold, int italic, int needs_exact_metrics);

typedef fz_font *(fz_load_system_cjk_font_fn)(fz_context *ctx, const char *name, int ordering, int serif);

typedef fz_font *(fz_load_system_fallback_font_fn)(fz_context *ctx, int script, int language, int serif, int bold, int italic);

void fz_install_load_system_font_funcs(fz_context *ctx,
    fz_load_system_font_fn *f,
    fz_load_system_cjk_font_fn *f_cjk,
    fz_load_system_fallback_font_fn *f_fallback);

fz_font *fz_load_system_font(fz_context *ctx, const char *name, int bold, int italic, int needs_exact_metrics);

fz_font *fz_load_system_cjk_font(fz_context *ctx, const char *name, int ordering, int serif);

const unsigned char *fz_lookup_builtin_font(fz_context *ctx, const char *name, int bold, int italic, int *len);

const unsigned char *fz_lookup_base14_font(fz_context *ctx, const char *name, int *len);

const unsigned char *fz_lookup_cjk_font(fz_context *ctx, int ordering, int *len, int *index);

const unsigned char *fz_lookup_cjk_font_by_language(fz_context *ctx, const char *lang, int *len, int *subfont);

int fz_lookup_cjk_ordering_by_language(const char *name);

const unsigned char *fz_lookup_noto_font(fz_context *ctx, int script, int lang, int *len, int *subfont);

const unsigned char *fz_lookup_noto_math_font(fz_context *ctx, int *len);
const unsigned char *fz_lookup_noto_music_font(fz_context *ctx, int *len);
const unsigned char *fz_lookup_noto_symbol1_font(fz_context *ctx, int *len);
const unsigned char *fz_lookup_noto_symbol2_font(fz_context *ctx, int *len);
const unsigned char *fz_lookup_noto_emoji_font(fz_context *ctx, int *len);
const unsigned char *fz_lookup_noto_boxes_font(fz_context *ctx, int *len);

const char *fz_lookup_noto_stem_from_script(fz_context *ctx, int script, int language);
const char *fz_lookup_script_name(fz_context *ctx, int script, int language);

fz_font *fz_load_fallback_font(fz_context *ctx, int script, int language, int serif, int bold, int italic);

fz_font *fz_new_type3_font(fz_context *ctx, const char *name, fz_matrix matrix);

fz_font *fz_new_font_from_memory(fz_context *ctx, const char *name, const unsigned char *data, int len, int index, int use_glyph_bbox);

fz_font *fz_new_font_from_buffer(fz_context *ctx, const char *name, fz_buffer *buffer, int index, int use_glyph_bbox);

fz_font *fz_new_font_from_file(fz_context *ctx, const char *name, const char *path, int index, int use_glyph_bbox);

fz_font *fz_new_base14_font(fz_context *ctx, const char *name);
fz_font *fz_new_cjk_font(fz_context *ctx, int ordering);
fz_font *fz_new_builtin_font(fz_context *ctx, const char *name, int is_bold, int is_italic);

void fz_set_font_embedding(fz_context *ctx, fz_font *font, int embed);

fz_font *fz_keep_font(fz_context *ctx, fz_font *font);

void fz_drop_font(fz_context *ctx, fz_font *font);

void fz_set_font_bbox(fz_context *ctx, fz_font *font, float xmin, float ymin, float xmax, float ymax);

fz_rect fz_bound_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm);

int fz_glyph_cacheable(fz_context *ctx, fz_font *font, int gid);

void fz_run_t3_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm, struct fz_device *dev);

float fz_advance_glyph(fz_context *ctx, fz_font *font, int glyph, int wmode);

int fz_encode_character(fz_context *ctx, fz_font *font, int unicode);

int fz_encode_character_sc(fz_context *ctx, fz_font *font, int unicode);

int fz_encode_character_by_glyph_name(fz_context *ctx, fz_font *font, const char *glyphname);

int fz_encode_character_with_fallback(fz_context *ctx, fz_font *font, int unicode, int script, int language, fz_font **out_font);

void fz_get_glyph_name(fz_context *ctx, fz_font *font, int glyph, char *buf, int size);

float fz_font_ascender(fz_context *ctx, fz_font *font);

float fz_font_descender(fz_context *ctx, fz_font *font);

void fz_font_digest(fz_context *ctx, fz_font *font, unsigned char digest[16]);
 
/* Implementation details: subject to change. */
 
void fz_decouple_type3_font(fz_context *ctx, fz_font *font, void *t3doc);

const char *ft_error_string(int err);
int ft_char_index(void *face, int cid);
int ft_name_index(void *face, const char *name);


void fz_hb_lock(fz_context *ctx);

void fz_hb_unlock(fz_context *ctx);

typedef void (fz_cmap_callback)(fz_context *ctx, void *opaque, unsigned long ucs, unsigned int gid);

void fz_enumerate_font_cmap(fz_context *ctx, fz_font *font, fz_cmap_callback *cb, void *opaque);

void fz_calculate_font_ascender_descender(fz_context *ctx, fz_font *font);
 
typedef enum
{
    FZ_ASCDESC_FROM_FONT,
    FZ_ASCDESC_DEFAULT,
    FZ_ASCDESC_FROM_BOUNDS
} fz_ascdesc_source;
 
#define FZ_MAX_TRUSTWORTHY_ASCENT 8
#define FZ_MAX_TRUSTWORTHY_DESCENT -3
 
struct fz_font
{
    int refs;
    char name[32];
    char family[32];
    fz_buffer *buffer;
 
    fz_font_flags_t flags;
 
    void *ft_face; /* has an FT_Face if used */
    fz_shaper_data_t shaper_data;
 
    fz_matrix t3matrix;
    void *t3resources;
    fz_buffer **t3procs; /* has 256 entries if used */
    struct fz_display_list **t3lists; /* has 256 entries if used */
    float *t3widths; /* has 256 entries if used */
    unsigned short *t3flags; /* has 256 entries if used */
    void *t3doc; /* a pdf_document for the callback */
    void (*t3run)(fz_context *ctx, void *doc, void *resources, fz_buffer *contents, struct fz_device *dev, fz_matrix ctm, void *gstate, fz_default_colorspaces *default_cs, void *fill_gstate, void *stroke_gstate);
    void (*t3freeres)(fz_context *ctx, void *doc, void *resources);
    int t3loading; /* to detect recursive type3 fonts */
 
    fz_rect bbox;   /* font bbox is used only for t3 fonts */
 
    float ascender;
    float descender;
    fz_ascdesc_source ascdesc_src;
 
    int glyph_count;
 
    /* per glyph bounding box cache. */
    fz_rect **bbox_table;
    int use_glyph_bbox;
 
    /* substitute metrics */
    int width_count;
    short width_default; /* in 1000 units */
    short *width_table; /* in 1000 units */
 
    /* cached glyph metrics */
    float **advance_cache;
 
    /* cached encoding lookup */
    uint16_t *encoding_cache[256];
 
    /* cached md5sum for caching */
    int has_digest;
    unsigned char digest[16];
 
    /* Which font to use in a collection. */
    int subfont;
};
 
void fz_ft_lock(fz_context *ctx);
 
void fz_ft_unlock(fz_context *ctx);
 
/* Internal function. Must be called with FT_ALLOC_LOCK
 * held. Returns 1 if this thread (context!) already holds
 * the freeetype lock. */
int fz_ft_lock_held(fz_context *ctx);
 
/* Internal function: Extract a ttf from the ttc that underlies
 * a given fz_font. Caller takes ownership of the returned
 * buffer.
 */
fz_buffer *fz_extract_ttf_from_ttc(fz_context *ctx, fz_font *font);
 
/* Internal function: Given a ttf in a buffer, create a subset
 * ttf in a new buffer that only provides the required gids.
 * Caller takes ownership of the returned buffer.
 *
 * EXPERIMENTAL AND VERY SUBJECT TO CHANGE.
 */
fz_buffer *fz_subset_ttf_for_gids(fz_context *ctx, fz_buffer *orig, int *gids, int num_gids, int symbolic, int cidfont);
 
/* Internal function: Given a cff in a buffer, create a subset
 * cff in a new buffer that only provides the required gids.
 * Caller takes ownership of the returned buffer.
 *
 * EXPERIMENTAL AND VERY SUBJECT TO CHANGE.
 */
fz_buffer *fz_subset_cff_for_gids(fz_context *ctx, fz_buffer *orig, int *gids, int num_gids, int symbolic, int cidfont);
 
#endif