gaming/godot
gaming/godot
1
0
Fork 0
mirror of https://github.com/godotengine/godot synced 2024-07-20 09:36:13 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Merge pull request #79273 from bruvzg/ft2131

Browse source 
FreeType: Update to version 2.13.1
This commit is contained in:
Yuri Sizov 2023-07-12 21:03:07 +02:00
parent 30e951603c 008d3de1e9
commit a55e714b56
132 changed files with 3845 additions and 3902 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
core/SCsub
View file

@ -97,7 +97,6 @@ if env["builtin_zlib"]:
"compress.c",
"crc32.c",
"deflate.c",
"infback.c",
"inffast.c",
"inflate.c",
"inftrees.c",

1
modules/text_server_adv/gdextension_build/SConstruct
View file

@ -227,7 +227,6 @@ if env["freetype_enabled"]:
"compress.c",
"crc32.c",
"deflate.c",
"infback.c",
"inffast.c",
"inflate.c",
"inftrees.c",

1
modules/text_server_fb/gdextension_build/SConstruct
View file

@ -222,7 +222,6 @@ if env["freetype_enabled"]:
"compress.c",
"crc32.c",
"deflate.c",
"infback.c",
"inffast.c",
"inflate.c",
"inftrees.c",

2
thirdparty/README.md vendored
View file

@ -178,7 +178,7 @@ Files extracted from upstream source:
## freetype
- Upstream: https://www.freetype.org
- Version: 2.13.0 (de8b92dd7ec634e9e2b25ef534c54a3537555c11, 2023)
- Version: 2.13.1 (e4586d960f339cf75e2e0b34aee30a0ed8353c0d, 2023)
- License: FreeType License (BSD-like)
Files extracted from upstream source:

47
thirdparty/freetype/include/freetype/config/ftoption.h vendored
View file

@ -661,36 +661,12 @@ FT_BEGIN_HEADER
* not) instructions in a certain way so that all TrueType fonts look like
* they do in a Windows ClearType (DirectWrite) environment. See [1] for a
* technical overview on what this means. See `ttinterp.h` for more
* details on the LEAN option.
* details on this option.
*
* There are three possible values.
*
* Value 1:
* This value is associated with the 'Infinality' moniker, contributed by
* an individual nicknamed Infinality with the goal of making TrueType
* fonts render better than on Windows. A high amount of configurability
* and flexibility, down to rules for single glyphs in fonts, but also
* very slow. Its experimental and slow nature and the original
* developer losing interest meant that this option was never enabled in
* default builds.
*
* The corresponding interpreter version is v38.
*
* Value 2:
* The new default mode for the TrueType driver. The Infinality code
* base was stripped to the bare minimum and all configurability removed
* in the name of speed and simplicity. The configurability was mainly
* aimed at legacy fonts like 'Arial', 'Times New Roman', or 'Courier'.
* Legacy fonts are fonts that modify vertical stems to achieve clean
* black-and-white bitmaps. The new mode focuses on applying a minimal
* set of rules to all fonts indiscriminately so that modern and web
* fonts render well while legacy fonts render okay.
*
* The corresponding interpreter version is v40.
*
* Value 3:
* Compile both, making both v38 and v40 available (the latter is the
* default).
* The new default mode focuses on applying a minimal set of rules to all
* fonts indiscriminately so that modern and web fonts render well while
* legacy fonts render okay. The corresponding interpreter version is v40.
* The so-called Infinality mode (v38) is no longer available in FreeType.
*
* By undefining these, you get rendering behavior like on Windows without
* ClearType, i.e., Windows XP without ClearType enabled and Win9x
@ -705,9 +681,7 @@ FT_BEGIN_HEADER
* [1]
* https://www.microsoft.com/typography/cleartype/truetypecleartype.aspx
*/
/* #define TT_CONFIG_OPTION_SUBPIXEL_HINTING 1 */
#define TT_CONFIG_OPTION_SUBPIXEL_HINTING 2
/* #define TT_CONFIG_OPTION_SUBPIXEL_HINTING ( 1 | 2 ) */
#define TT_CONFIG_OPTION_SUBPIXEL_HINTING
/**************************************************************************
@ -977,21 +951,14 @@ FT_BEGIN_HEADER
/*
* The next three macros are defined if native TrueType hinting is
* The next two macros are defined if native TrueType hinting is
* requested by the definitions above. Don't change this.
*/
#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
#define TT_USE_BYTECODE_INTERPRETER
#ifdef TT_CONFIG_OPTION_SUBPIXEL_HINTING
#if TT_CONFIG_OPTION_SUBPIXEL_HINTING & 1
#define TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY
#endif
#if TT_CONFIG_OPTION_SUBPIXEL_HINTING & 2
#define TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL
#endif
#endif
#endif

14
thirdparty/freetype/include/freetype/config/ftstdlib.h vendored
View file

@ -111,13 +111,13 @@
#include <stdio.h>
#define FT_FILE FILE
#define ft_fclose fclose
#define ft_fopen fopen
#define ft_fread fread
#define ft_fseek fseek
#define ft_ftell ftell
#define ft_sprintf sprintf
#define FT_FILE FILE
#define ft_fclose fclose
#define ft_fopen fopen
#define ft_fread fread
#define ft_fseek fseek
#define ft_ftell ftell
#define ft_snprintf snprintf
/**************************************************************************

565
thirdparty/freetype/include/freetype/freetype.h vendored
View file

@ -102,61 +102,25 @@ FT_BEGIN_HEADER
*/
/*************************************************************************/
/*************************************************************************/
/* */
/* B A S I C T Y P E S */
/* */
/*************************************************************************/
/*************************************************************************/
/**************************************************************************
*
* @section:
* base_interface
* font_testing_macros
*
* @title:
* Base Interface
* Font Testing Macros
*
* @abstract:
* The FreeType~2 base font interface.
* Macros to test various properties of fonts.
*
* @description:
* This section describes the most important public high-level API
* functions of FreeType~2.
* Macros to test the most important font properties.
*
* It is recommended to use these high-level macros instead of directly
* testing the corresponding flags, which are scattered over various
* structures.
*
* @order:
* FT_Library
* FT_Face
* FT_Size
* FT_GlyphSlot
* FT_CharMap
* FT_Encoding
* FT_ENC_TAG
*
* FT_FaceRec
*
* FT_FACE_FLAG_SCALABLE
* FT_FACE_FLAG_FIXED_SIZES
* FT_FACE_FLAG_FIXED_WIDTH
* FT_FACE_FLAG_HORIZONTAL
* FT_FACE_FLAG_VERTICAL
* FT_FACE_FLAG_COLOR
* FT_FACE_FLAG_SFNT
* FT_FACE_FLAG_CID_KEYED
* FT_FACE_FLAG_TRICKY
* FT_FACE_FLAG_KERNING
* FT_FACE_FLAG_MULTIPLE_MASTERS
* FT_FACE_FLAG_VARIATION
* FT_FACE_FLAG_GLYPH_NAMES
* FT_FACE_FLAG_EXTERNAL_STREAM
* FT_FACE_FLAG_HINTER
* FT_FACE_FLAG_SVG
* FT_FACE_FLAG_SBIX
* FT_FACE_FLAG_SBIX_OVERLAY
*
* FT_HAS_HORIZONTAL
* FT_HAS_VERTICAL
* FT_HAS_KERNING
@ -176,21 +140,59 @@ FT_BEGIN_HEADER
* FT_IS_NAMED_INSTANCE
* FT_IS_VARIATION
*
* FT_STYLE_FLAG_BOLD
* FT_STYLE_FLAG_ITALIC
*/
/**************************************************************************
*
* FT_SizeRec
* FT_Size_Metrics
* @section:
* library_setup
*
* FT_GlyphSlotRec
* FT_Glyph_Metrics
* FT_SubGlyph
* @title:
* Library Setup
*
* FT_Bitmap_Size
* @abstract:
* Functions to start and end the usage of the FreeType library.
*
* @description:
* Functions to start and end the usage of the FreeType library.
*
* Note that @FT_Library_Version and @FREETYPE_XXX are of limited use
* because even a new release of FreeType with only documentation
* changes increases the version number.
*
* @order:
* FT_Library
* FT_Init_FreeType
* FT_Done_FreeType
*
* FT_Library_Version
* FREETYPE_XXX
*
*/
/**************************************************************************
*
* @section:
* face_creation
*
* @title:
* Face Creation
*
* @abstract:
* Functions to manage fonts.
*
* @description:
* The functions and structures collected in this section operate on
* fonts globally.
*
* @order:
* FT_Face
* FT_FaceRec
* FT_FACE_FLAG_XXX
* FT_STYLE_FLAG_XXX
*
* FT_New_Face
* FT_Done_Face
* FT_Reference_Face
@ -198,10 +200,36 @@ FT_BEGIN_HEADER
* FT_Face_Properties
* FT_Open_Face
* FT_Open_Args
* FT_OPEN_XXX
* FT_Parameter
* FT_Attach_File
* FT_Attach_Stream
*
*/
/**************************************************************************
*
* @section:
* sizing_and_scaling
*
* @title:
* Sizing and Scaling
*
* @abstract:
* Functions to manage font sizes.
*
* @description:
* The functions and structures collected in this section are related to
* selecting and manipulating the size of a font globally.
*
* @order:
* FT_Size
* FT_SizeRec
* FT_Size_Metrics
*
* FT_Bitmap_Size
*
* FT_Set_Char_Size
* FT_Set_Pixel_Sizes
* FT_Request_Size
@ -209,44 +237,37 @@ FT_BEGIN_HEADER
* FT_Size_Request_Type
* FT_Size_RequestRec
* FT_Size_Request
*
* FT_Set_Transform
* FT_Get_Transform
*
*/
/**************************************************************************
*
* @section:
* glyph_retrieval
*
* @title:
* Glyph Retrieval
*
* @abstract:
* Functions to manage glyphs.
*
* @description:
* The functions and structures collected in this section operate on
* single glyphs, of which @FT_Load_Glyph is most important.
*
* @order:
* FT_GlyphSlot
* FT_GlyphSlotRec
* FT_Glyph_Metrics
*
* FT_Load_Glyph
* FT_Get_Char_Index
* FT_Get_First_Char
* FT_Get_Next_Char
* FT_Load_Char
*
* FT_OPEN_MEMORY
* FT_OPEN_STREAM
* FT_OPEN_PATHNAME
* FT_OPEN_DRIVER
* FT_OPEN_PARAMS
*
* FT_LOAD_DEFAULT
* FT_LOAD_RENDER
* FT_LOAD_MONOCHROME
* FT_LOAD_LINEAR_DESIGN
* FT_LOAD_NO_SCALE
* FT_LOAD_NO_HINTING
* FT_LOAD_NO_BITMAP
* FT_LOAD_SBITS_ONLY
* FT_LOAD_NO_AUTOHINT
* FT_LOAD_COLOR
*
* FT_LOAD_VERTICAL_LAYOUT
* FT_LOAD_IGNORE_TRANSFORM
* FT_LOAD_FORCE_AUTOHINT
* FT_LOAD_NO_RECURSE
* FT_LOAD_PEDANTIC
*
* FT_LOAD_TARGET_NORMAL
* FT_LOAD_TARGET_LIGHT
* FT_LOAD_TARGET_MONO
* FT_LOAD_TARGET_LCD
* FT_LOAD_TARGET_LCD_V
*
* FT_LOAD_XXX
* FT_LOAD_TARGET_MODE
* FT_LOAD_TARGET_XXX
*
* FT_Render_Glyph
* FT_Render_Mode
@ -254,34 +275,121 @@ FT_BEGIN_HEADER
* FT_Kerning_Mode
* FT_Get_Track_Kerning
*
*/
/**************************************************************************
*
* @section:
* character_mapping
*
* @title:
* Character Mapping
*
* @abstract:
* Functions to manage character-to-glyph maps.
*
* @description:
* This section holds functions and structures that are related to
* mapping character input codes to glyph indices.
*
* Note that for many scripts the simplistic approach used by FreeType
* of mapping a single character to a single glyph is not valid or
* possible! In general, a higher-level library like HarfBuzz or ICU
* should be used for handling text strings.
*
* @order:
* FT_CharMap
* FT_CharMapRec
* FT_Encoding
* FT_ENC_TAG
*
* FT_Select_Charmap
* FT_Set_Charmap
* FT_Get_Charmap_Index
*
* FT_Get_Char_Index
* FT_Get_First_Char
* FT_Get_Next_Char
* FT_Load_Char
*
*/
/**************************************************************************
*
* @section:
* information_retrieval
*
* @title:
* Information Retrieval
*
* @abstract:
* Functions to retrieve font and glyph information.
*
* @description:
* Functions to retrieve font and glyph information. Only some very
* basic data is covered; see also the chapter on the format-specific
* API for more.
*
*
* @order:
* FT_Get_Name_Index
* FT_Get_Glyph_Name
* FT_Get_Postscript_Name
* FT_Get_FSType_Flags
* FT_FSTYPE_XXX
* FT_Get_SubGlyph_Info
* FT_SUBGLYPH_FLAG_XXX
*
*/
/**************************************************************************
*
* @section:
* other_api_data
*
* @title:
* Other API Data
*
* @abstract:
* Other structures, enumerations, and macros.
*
* @description:
* Other structures, enumerations, and macros. Deprecated functions are
* also listed here.
*
* @order:
* FT_Face_Internal
* FT_Size_Internal
* FT_Slot_Internal
*
* FT_FACE_FLAG_XXX
* FT_STYLE_FLAG_XXX
* FT_OPEN_XXX
* FT_LOAD_XXX
* FT_LOAD_TARGET_XXX
* FT_SUBGLYPH_FLAG_XXX
* FT_FSTYPE_XXX
* FT_SubGlyph
*
* FT_HAS_FAST_GLYPHS
* FT_Face_CheckTrueTypePatents
* FT_Face_SetUnpatentedHinting
*
*/
/*************************************************************************/
/*************************************************************************/
/* */
/* B A S I C T Y P E S */
/* */
/*************************************************************************/
/*************************************************************************/
/**************************************************************************
*
* @section:
* glyph_retrieval
*
*/
/**************************************************************************
*
* @struct:
@ -349,6 +457,13 @@ FT_BEGIN_HEADER
} FT_Glyph_Metrics;
/**************************************************************************
*
* @section:
* sizing_and_scaling
*
*/
/**************************************************************************
*
* @struct:
@ -409,6 +524,13 @@ FT_BEGIN_HEADER
/*************************************************************************/
/*************************************************************************/
/**************************************************************************
*
* @section:
* library_setup
*
*/
/**************************************************************************
*
* @type:
@ -483,7 +605,7 @@ FT_BEGIN_HEADER
/**************************************************************************
*
* @section:
* base_interface
* face_creation
*
*/
@ -519,6 +641,13 @@ FT_BEGIN_HEADER
typedef struct FT_FaceRec_* FT_Face;
/**************************************************************************
*
* @section:
* sizing_and_scaling
*
*/
/**************************************************************************
*
* @type:
@ -551,6 +680,13 @@ FT_BEGIN_HEADER
typedef struct FT_SizeRec_* FT_Size;
/**************************************************************************
*
* @section:
* glyph_retrieval
*
*/
/**************************************************************************
*
* @type:
@ -570,6 +706,13 @@ FT_BEGIN_HEADER
typedef struct FT_GlyphSlotRec_* FT_GlyphSlot;
/**************************************************************************
*
* @section:
* character_mapping
*
*/
/**************************************************************************
*
* @type:
@ -877,6 +1020,13 @@ FT_BEGIN_HEADER
/*************************************************************************/
/**************************************************************************
*
* @section:
* other_api_data
*
*/
/**************************************************************************
*
* @type:
@ -892,6 +1042,13 @@ FT_BEGIN_HEADER
typedef struct FT_Face_InternalRec_* FT_Face_Internal;
/**************************************************************************
*
* @section:
* face_creation
*
*/
/**************************************************************************
*
* @struct:
@ -918,7 +1075,7 @@ FT_BEGIN_HEADER
* If we have the third named instance of face~4, say, `face_index` is
* set to 0x00030004.
*
* Bit 31 is always zero (this is, `face_index` is always a positive
* Bit 31 is always zero (that is, `face_index` is always a positive
* value).
*
* [Since 2.9] Changing the design coordinates with
@ -936,7 +1093,7 @@ FT_BEGIN_HEADER
*
* [Since 2.6.1] Bits 16-30 hold the number of named instances
* available for the current face if we have a GX or OpenType variation
* (sub)font. Bit 31 is always zero (this is, `style_flags` is always
* (sub)font. Bit 31 is always zero (that is, `style_flags` is always
* a positive value). Note that a variation font has always at least
* one named instance, namely the default instance.
*
@ -1002,7 +1159,7 @@ FT_BEGIN_HEADER
* Note that the bounding box might be off by (at least) one pixel for
* hinted fonts. See @FT_Size_Metrics for further discussion.
*
* Note that the bounding box does not vary in OpenType variable fonts
* Note that the bounding box does not vary in OpenType variation fonts
* and should only be used in relation to the default instance.
*
* units_per_EM ::
@ -1090,9 +1247,9 @@ FT_BEGIN_HEADER
FT_Generic generic;
/*# The following member variables (down to `underline_thickness`) */
/*# are only relevant to scalable outlines; cf. @FT_Bitmap_Size */
/*# for bitmap fonts. */
/* The following member variables (down to `underline_thickness`) */
/* are only relevant to scalable outlines; cf. @FT_Bitmap_Size */
/* for bitmap fonts. */
FT_BBox bbox;
FT_UShort units_per_EM;
@ -1110,7 +1267,7 @@ FT_BEGIN_HEADER
FT_Size size;
FT_CharMap charmap;
/*@private begin */
/* private fields, internal to FreeType */
FT_Driver driver;
FT_Memory memory;
@ -1123,8 +1280,6 @@ FT_BEGIN_HEADER
FT_Face_Internal internal;
/*@private end */
} FT_FaceRec;
@ -1207,13 +1362,13 @@ FT_BEGIN_HEADER
* successfully; in all other cases you get an
* `FT_Err_Invalid_Argument` error.
*
* Note that CID-keyed fonts that are in an SFNT wrapper (this is, all
* Note that CID-keyed fonts that are in an SFNT wrapper (that is, all
* OpenType/CFF fonts) don't have this flag set since the glyphs are
* accessed in the normal way (using contiguous indices); the
* 'CID-ness' isn't visible to the application.
*
* FT_FACE_FLAG_TRICKY ::
* The face is 'tricky', this is, it always needs the font format's
* The face is 'tricky', that is, it always needs the font format's
* native hinting engine to get a reasonable result. A typical example
* is the old Chinese font `mingli.ttf` (but not `mingliu.ttc`) that
* uses TrueType bytecode instructions to move and scale all of its
@ -1235,8 +1390,8 @@ FT_BEGIN_HEADER
* FT_FACE_FLAG_VARIATION ::
* [Since 2.9] Set if the current face (or named instance) has been
* altered with @FT_Set_MM_Design_Coordinates,
* @FT_Set_Var_Design_Coordinates, or @FT_Set_Var_Blend_Coordinates.
* This flag is unset by a call to @FT_Set_Named_Instance.
* @FT_Set_Var_Design_Coordinates, @FT_Set_Var_Blend_Coordinates, or
* @FT_Set_MM_WeightVector to select a non-default instance.
*
* FT_FACE_FLAG_SVG ::
* [Since 2.12] The face has an 'SVG~' OpenType table.
@ -1272,6 +1427,13 @@ FT_BEGIN_HEADER
#define FT_FACE_FLAG_SBIX_OVERLAY ( 1L << 18 )
/**************************************************************************
*
* @section:
* font_testing_macros
*
*/
/**************************************************************************
*
* @macro:
@ -1381,6 +1543,13 @@ FT_BEGIN_HEADER
( !!( (face)->face_flags & FT_FACE_FLAG_FIXED_SIZES ) )
/**************************************************************************
*
* @section:
* other_api_data
*
*/
/**************************************************************************
*
* @macro:
@ -1393,6 +1562,13 @@ FT_BEGIN_HEADER
#define FT_HAS_FAST_GLYPHS( face ) 0
/**************************************************************************
*
* @section:
* font_testing_macros
*
*/
/**************************************************************************
*
* @macro:
@ -1451,8 +1627,8 @@ FT_BEGIN_HEADER
*
* @description:
* A macro that returns true whenever a face object has been altered by
* @FT_Set_MM_Design_Coordinates, @FT_Set_Var_Design_Coordinates, or
* @FT_Set_Var_Blend_Coordinates.
* @FT_Set_MM_Design_Coordinates, @FT_Set_Var_Design_Coordinates,
* @FT_Set_Var_Blend_Coordinates, or @FT_Set_MM_WeightVector.
*
* @since:
* 2.9
@ -1628,6 +1804,13 @@ FT_BEGIN_HEADER
( !!( (face)->face_flags & FT_FACE_FLAG_SBIX_OVERLAY ) )
/**************************************************************************
*
* @section:
* face_creation
*
*/
/**************************************************************************
*
* @enum:
@ -1654,6 +1837,13 @@ FT_BEGIN_HEADER
#define FT_STYLE_FLAG_BOLD ( 1 << 1 )
/**************************************************************************
*
* @section:
* other_api_data
*
*/
/**************************************************************************
*
* @type:
@ -1666,6 +1856,13 @@ FT_BEGIN_HEADER
typedef struct FT_Size_InternalRec_* FT_Size_Internal;
/**************************************************************************
*
* @section:
* sizing_and_scaling
*
*/
/**************************************************************************
*
* @struct:
@ -1817,6 +2014,13 @@ FT_BEGIN_HEADER
} FT_SizeRec;
/**************************************************************************
*
* @section:
* other_api_data
*
*/
/**************************************************************************
*
* @struct:
@ -1848,6 +2052,13 @@ FT_BEGIN_HEADER
typedef struct FT_Slot_InternalRec_* FT_Slot_Internal;
/**************************************************************************
*
* @section:
* glyph_retrieval
*
*/
/**************************************************************************
*
* @struct:
@ -2092,6 +2303,13 @@ FT_BEGIN_HEADER
/*************************************************************************/
/**************************************************************************
*
* @section:
* library_setup
*
*/
/**************************************************************************
*
* @function:
@ -2149,6 +2367,13 @@ FT_BEGIN_HEADER
FT_Done_FreeType( FT_Library library );
/**************************************************************************
*
* @section:
* face_creation
*
*/
/**************************************************************************
*
* @enum:
@ -2451,7 +2676,7 @@ FT_BEGIN_HEADER
* Each new face object created with this function also owns a default
* @FT_Size object, accessible as `face->size`.
*
* One @FT_Library instance can have multiple face objects, this is,
* One @FT_Library instance can have multiple face objects, that is,
* @FT_Open_Face and its siblings can be called multiple times using the
* same `library` argument.
*
@ -2650,6 +2875,13 @@ FT_BEGIN_HEADER
FT_Done_Face( FT_Face face );
/**************************************************************************
*
* @section:
* sizing_and_scaling
*
*/
/**************************************************************************
*
* @function:
@ -2679,7 +2911,7 @@ FT_BEGIN_HEADER
* silently uses outlines if there is no bitmap for a given glyph index.
*
* For GX and OpenType variation fonts, a bitmap strike makes sense only
* if the default instance is active (this is, no glyph variation takes
* if the default instance is active (that is, no glyph variation takes
* place); otherwise, FreeType simply ignores bitmap strikes. The same
* is true for all named instances that are different from the default
* instance.
@ -2942,6 +3174,13 @@ FT_BEGIN_HEADER
FT_UInt pixel_height );
/**************************************************************************
*
* @section:
* glyph_retrieval
*
*/
/**************************************************************************
*
* @function:
@ -2976,7 +3215,7 @@ FT_BEGIN_HEADER
* glyph may be transformed. See @FT_Set_Transform for the details.
*
* For subsetted CID-keyed fonts, `FT_Err_Invalid_Argument` is returned
* for invalid CID values (this is, for CID values that don't have a
* for invalid CID values (that is, for CID values that don't have a
* corresponding glyph in the font). See the discussion of the
* @FT_FACE_FLAG_CID_KEYED flag for more details.
*
@ -2990,6 +3229,13 @@ FT_BEGIN_HEADER
FT_Int32 load_flags );
/**************************************************************************
*
* @section:
* character_mapping
*
*/
/**************************************************************************
*
* @function:
@ -3033,6 +3279,13 @@ FT_BEGIN_HEADER
FT_Int32 load_flags );
/**************************************************************************
*
* @section:
* glyph_retrieval
*
*/
/**************************************************************************
*
* @enum:
@ -3172,10 +3425,11 @@ FT_BEGIN_HEADER
*
* [Since 2.12] If the glyph index maps to an entry in the face's
* 'SVG~' table, load the associated SVG document from this table and
* set the `format` field of @FT_GlyphSlotRec to @FT_GLYPH_FORMAT_SVG.
* Note that FreeType itself can't render SVG documents; however, the
* library provides hooks to seamlessly integrate an external renderer.
* See sections @ot_svg_driver and @svg_fonts for more.
* set the `format` field of @FT_GlyphSlotRec to @FT_GLYPH_FORMAT_SVG
* ([since 2.13.1] provided @FT_LOAD_NO_SVG is not set). Note that
* FreeType itself can't render SVG documents; however, the library
* provides hooks to seamlessly integrate an external renderer. See
* sections @ot_svg_driver and @svg_fonts for more.
*
* [Since 2.10, experimental] If the glyph index maps to an entry in
* the face's 'COLR' table with a 'CPAL' palette table (as defined in
@ -3189,6 +3443,9 @@ FT_BEGIN_HEADER
* @FT_Palette_Select instead of setting @FT_LOAD_COLOR for rendering
* so that the client application can handle blending by itself.
*
* FT_LOAD_NO_SVG ::
* [Since 2.13.1] Ignore SVG glyph data when loading.
*
* FT_LOAD_COMPUTE_METRICS ::
* [Since 2.6.1] Compute glyph metrics from the glyph data, without the
* use of bundled metrics tables (for example, the 'hdmx' table in
@ -3254,6 +3511,7 @@ FT_BEGIN_HEADER
#define FT_LOAD_COLOR ( 1L << 20 )
#define FT_LOAD_COMPUTE_METRICS ( 1L << 21 )
#define FT_LOAD_BITMAP_METRICS_ONLY ( 1L << 22 )
#define FT_LOAD_NO_SVG ( 1L << 24 )
/* */
@ -3372,6 +3630,13 @@ FT_BEGIN_HEADER
FT_STATIC_CAST( FT_Render_Mode, ( (x) >> 16 ) & 15 )
/**************************************************************************
*
* @section:
* sizing_and_scaling
*
*/
/**************************************************************************
*
* @function:
@ -3447,6 +3712,13 @@ FT_BEGIN_HEADER
FT_Vector* delta );
/**************************************************************************
*
* @section:
* glyph_retrieval
*
*/
/**************************************************************************
*
* @enum:
@ -3841,6 +4113,13 @@ FT_BEGIN_HEADER
FT_Fixed* akerning );
/**************************************************************************
*
* @section:
* character_mapping
*
*/
/**************************************************************************
*
* @function:
@ -4057,6 +4336,13 @@ FT_BEGIN_HEADER
FT_UInt *agindex );
/**************************************************************************
*
* @section:
* face_creation
*
*/
/**************************************************************************
*
* @function:
@ -4155,6 +4441,13 @@ FT_BEGIN_HEADER
FT_Parameter* properties );
/**************************************************************************
*
* @section:
* information_retrieval
*
*/
/**************************************************************************
*
* @function:
@ -4266,9 +4559,10 @@ FT_BEGIN_HEADER
*
* [Since 2.9] Special PostScript names for named instances are only
* returned if the named instance is set with @FT_Set_Named_Instance (and
* the font has corresponding entries in its 'fvar' table). If
* @FT_IS_VARIATION returns true, the algorithmically derived PostScript
* name is provided, not looking up special entries for named instances.
* the font has corresponding entries in its 'fvar' table or is the
* default named instance). If @FT_IS_VARIATION returns true, the
* algorithmically derived PostScript name is provided, not looking up
* special entries for named instances.
*/
FT_EXPORT( const char* )
FT_Get_Postscript_Name( FT_Face face );
@ -4900,32 +5194,10 @@ FT_BEGIN_HEADER
/**************************************************************************
*
* @section:
* version
*
* @title:
* FreeType Version
*
* @abstract:
* Functions and macros related to FreeType versions.
*
* @description:
* Note that those functions and macros are of limited use because even a
* new release of FreeType with only documentation changes increases the
* version number.
*
* @order:
* FT_Library_Version
*
* FREETYPE_MAJOR
* FREETYPE_MINOR
* FREETYPE_PATCH
*
* FT_Face_CheckTrueTypePatents
* FT_Face_SetUnpatentedHinting
* library_setup
*
*/
/**************************************************************************
*
* @enum:
@ -4950,7 +5222,7 @@ FT_BEGIN_HEADER
*/
#define FREETYPE_MAJOR 2
#define FREETYPE_MINOR 13
#define FREETYPE_PATCH 0
#define FREETYPE_PATCH 1
/**************************************************************************
@ -4992,6 +5264,13 @@ FT_BEGIN_HEADER
FT_Int *apatch );
/**************************************************************************
*
* @section:
* other_api_data
*
*/
/**************************************************************************
*
* @function:

74
thirdparty/freetype/include/freetype/ftcache.h vendored
View file

@ -43,61 +43,61 @@ FT_BEGIN_HEADER
* objects, as well as caching information like character maps and glyph
* images while limiting their maximum memory usage.
*
* Note that all types and functions begin with the `FTC_` prefix.
* Note that all types and functions begin with the `FTC_` prefix rather
* than the usual `FT_` prefix in the rest of FreeType.
*
* The cache is highly portable and thus doesn't know anything about the
* fonts installed on your system, or how to access them. This implies
* the following scheme:
* The cache is highly portable and, thus, doesn't know anything about
* the fonts installed on your system, or how to access them. Therefore,
* it requires the following.
*
* First, available or installed font faces are uniquely identified by
* @FTC_FaceID values, provided to the cache by the client. Note that
* the cache only stores and compares these values, and doesn't try to
* interpret them in any way.
* * @FTC_FaceID, an arbitrary non-zero value that uniquely identifies
* available or installed font faces, has to be provided to the
* cache by the client. Note that the cache only stores and compares
* these values and doesn't try to interpret them in any way, but they
* have to be persistent on the client side.
*
* Second, the cache calls, only when needed, a client-provided function
* to convert an @FTC_FaceID into a new @FT_Face object. The latter is
* then completely managed by the cache, including its termination
* through @FT_Done_Face. To monitor termination of face objects, the
* finalizer callback in the `generic` field of the @FT_Face object can
* be used, which might also be used to store the @FTC_FaceID of the
* face.
* * @FTC_Face_Requester, a method to convert an @FTC_FaceID into a new
* @FT_Face object when necessary, has to be provided to the cache by
* the client. The @FT_Face object is completely managed by the cache,
* including its termination through @FT_Done_Face. To monitor
* termination of face objects, the finalizer callback in the `generic`
* field of the @FT_Face object can be used, which might also be used
* to store the @FTC_FaceID of the face.
*
* Clients are free to map face IDs to anything else. The most simple
* usage is to associate them to a (pathname,face_index) pair that is
* used to call @FT_New_Face. However, more complex schemes are also
* possible.
* Clients are free to map face IDs to anything useful. The most simple
* usage is, for example, to associate them to a `{pathname,face_index}`
* pair that is then used by @FTC_Face_Requester to call @FT_New_Face.
* However, more complex schemes are also possible.
*
* Note that for the cache to work correctly, the face ID values must be
* **persistent**, which means that the contents they point to should not
* change at runtime, or that their value should not become invalid.
*
* If this is unavoidable (e.g., when a font is uninstalled at runtime),
* you should call @FTC_Manager_RemoveFaceID as soon as possible, to let
* you should call @FTC_Manager_RemoveFaceID as soon as possible to let
* the cache get rid of any references to the old @FTC_FaceID it may keep
* internally. Failure to do so will lead to incorrect behaviour or even
* crashes.
* crashes in @FTC_Face_Requester.
*
* To use the cache, start with calling @FTC_Manager_New to create a new
* @FTC_Manager object, which models a single cache instance. You can
* then look up @FT_Face and @FT_Size objects with
* @FTC_Manager_LookupFace and @FTC_Manager_LookupSize, respectively.
* @FTC_Manager_LookupFace and @FTC_Manager_LookupSize, respectively, and
* use them in any FreeType work stream. You can also cache other
* FreeType objects as follows.
*
* If you want to use the charmap caching, call @FTC_CMapCache_New, then
* later use @FTC_CMapCache_Lookup to perform the equivalent of
* @FT_Get_Char_Index, only much faster.
* * If you want to use the charmap caching, call @FTC_CMapCache_New,
* then later use @FTC_CMapCache_Lookup to perform the equivalent of
* @FT_Get_Char_Index, only much faster.
*
* If you want to use the @FT_Glyph caching, call @FTC_ImageCache_New,
* then later use @FTC_ImageCache_Lookup to retrieve the corresponding
* @FT_Glyph objects from the cache.
*
* If you need lots of small bitmaps, it is much more memory efficient to
* call @FTC_SBitCache_New followed by @FTC_SBitCache_Lookup. This
* returns @FTC_SBitRec structures, which are used to store small bitmaps
* directly. (A small bitmap is one whose metrics and dimensions all fit
* into 8-bit integers).
*
* We hope to also provide a kerning cache in the near future.
* * If you want to use the @FT_Glyph caching, call @FTC_ImageCache_New,
* then later use @FTC_ImageCache_Lookup to retrieve the corresponding
* @FT_Glyph objects from the cache.
*
* * If you need lots of small bitmaps, it is much more memory-efficient
* to call @FTC_SBitCache_New followed by @FTC_SBitCache_Lookup. This
* returns @FTC_SBitRec structures, which are used to store small
* bitmaps directly. (A small bitmap is one whose metrics and
* dimensions all fit into 8-bit integers).
*
* @order:
* FTC_Manager

23
thirdparty/freetype/include/freetype/ftchapters.h vendored
View file

@ -31,9 +31,28 @@
* Core API
*
* @sections:
* version
* basic_types
* base_interface
* library_setup
* face_creation
* font_testing_macros
* sizing_and_scaling
* glyph_retrieval
* character_mapping
* information_retrieval
* other_api_data
*
*/
/**************************************************************************
*
* @chapter:
* extended_api
*
* @title:
* Extended API
*
* @sections:
* glyph_variants
* color_management
* layer_management

11
thirdparty/freetype/include/freetype/ftdriver.h vendored
View file

@ -134,7 +134,7 @@ FT_BEGIN_HEADER
* each being rounded to the nearest pixel edge, taking care of overshoot
* suppression at small sizes, stem darkening, and scaling.
*
* Hstems (this is, hint values defined in the font to help align
* Hstems (that is, hint values defined in the font to help align
* horizontal features) that fall within a blue zone are said to be
* 'captured' and are aligned to that zone. Uncaptured stems are moved
* in one of four ways, top edge up or down, bottom edge up or down.
@ -446,7 +446,7 @@ FT_BEGIN_HEADER
* at smaller sizes.
*
* For the auto-hinter, stem-darkening is experimental currently and thus
* switched off by default (this is, `no-stem-darkening` is set to TRUE
* switched off by default (that is, `no-stem-darkening` is set to TRUE
* by default). Total consistency with the CFF driver is not achieved
* right now because the emboldening method differs and glyphs must be
* scaled down on the Y-axis to keep outline points inside their
@ -651,11 +651,8 @@ FT_BEGIN_HEADER
* Windows~98; only grayscale and B/W rasterizing is supported.
*
* TT_INTERPRETER_VERSION_38 ::
* Version~38 corresponds to MS rasterizer v.1.9; it is roughly
* equivalent to the hinting provided by DirectWrite ClearType (as can
* be found, for example, in the Internet Explorer~9 running on
* Windows~7). It is used in FreeType to select the 'Infinality'
* subpixel hinting code. The code may be removed in a future version.
* Version~38 is the same Version~40. The original 'Infinality' code is
* no longer available.
*
* TT_INTERPRETER_VERSION_40 ::
* Version~40 corresponds to MS rasterizer v.2.1; it is roughly

10
thirdparty/freetype/include/freetype/ftimage.h vendored
View file

@ -19,7 +19,7 @@
/**************************************************************************
*
* Note: A 'raster' is simply a scan-line converter, used to render
* FT_Outlines into FT_Bitmaps.
* `FT_Outline`s into `FT_Bitmap`s.
*
*/
@ -256,6 +256,12 @@ FT_BEGIN_HEADER
* palette ::
* A typeless pointer to the bitmap palette; this field is intended for
* paletted pixel modes. Not used currently.
*
* @note:
* `width` and `rows` refer to the *physical* size of the bitmap, not the
* *logical* one. For example, if @FT_Pixel_Mode is set to
* `FT_PIXEL_MODE_LCD`, the logical width is a just a third of the
* physical one.
*/
typedef struct FT_Bitmap_
{
@ -856,7 +862,7 @@ FT_BEGIN_HEADER
* @FT_SpanFunc that takes the y~coordinate of the span as a parameter.
*
* The anti-aliased rasterizer produces coverage values from 0 to 255,
* this is, from completely transparent to completely opaque.
* that is, from completely transparent to completely opaque.
*/
typedef struct FT_Span_
{

2
thirdparty/freetype/include/freetype/ftlogging.h vendored
View file

@ -62,7 +62,7 @@ FT_BEGIN_HEADER
* component.
*
* ```
* FT_Trace_Set_Level( "any:7 memory:0 );
* FT_Trace_Set_Level( "any:7 memory:0" );
* ```
*
* @note:

57
thirdparty/freetype/include/freetype/ftmm.h vendored
View file

@ -153,7 +153,7 @@ FT_BEGIN_HEADER
* @note:
* The fields `minimum`, `def`, and `maximum` are 16.16 fractional values
* for TrueType GX and OpenType variation fonts. For Adobe MM fonts, the
* values are integers.
* values are whole numbers (i.e., the fractional part is zero).
*/
typedef struct FT_Var_Axis_
{
@ -399,8 +399,8 @@ FT_BEGIN_HEADER
*
* @note:
* The design coordinates are 16.16 fractional values for TrueType GX and
* OpenType variation fonts. For Adobe MM fonts, the values are
* integers.
* OpenType variation fonts. For Adobe MM fonts, the values are supposed
* to be whole numbers (i.e., the fractional part is zero).
*
* [Since 2.8.1] To reset all axes to the default values, call the
* function with `num_coords` set to zero and `coords` set to `NULL`.
@ -446,8 +446,8 @@ FT_BEGIN_HEADER
*
* @note:
* The design coordinates are 16.16 fractional values for TrueType GX and
* OpenType variation fonts. For Adobe MM fonts, the values are
* integers.
* OpenType variation fonts. For Adobe MM fonts, the values are whole
* numbers (i.e., the fractional part is zero).
*
* @since:
* 2.7.1
@ -602,10 +602,12 @@ FT_BEGIN_HEADER
*
* @note:
* Adobe Multiple Master fonts limit the number of designs, and thus the
* length of the weight vector to~16.
* length of the weight vector to 16~elements.
*
* If `len` is zero and `weightvector` is `NULL`, the weight vector array
* is reset to the default values.
* If `len` is larger than zero, this function sets the
* @FT_FACE_FLAG_VARIATION bit in @FT_Face's `face_flags` field (i.e.,
* @FT_IS_VARIATION will return true). If `len` is zero, this bit flag
* is unset and the weight vector array is reset to the default values.
*
* The Adobe documentation also states that the values in the
* WeightVector array must total 1.0 +/-~0.001. In practice this does
@ -753,6 +755,45 @@ FT_BEGIN_HEADER
FT_Set_Named_Instance( FT_Face face,
FT_UInt instance_index );
/**************************************************************************
*
* @function:
* FT_Get_Default_Named_Instance
*
* @description:
* Retrieve the index of the default named instance, to be used with
* @FT_Set_Named_Instance.
*
* The default instance of a variation font is that instance for which
* the nth axis coordinate is equal to `axis[n].def` (as specified in the
* @FT_MM_Var structure), with~n covering all axes.
*
* FreeType synthesizes a named instance for the default instance if the
* font does not contain such an entry.
*
* @input:
* face ::
* A handle to the source face.
*
* @output:
* instance_index ::
* The index of the default named instance.
*
* @return:
* FreeType error code. 0~means success.
*
* @note:
* For Adobe MM fonts (which don't have named instances) this function
* always returns zero for `instance_index`.
*
* @since:
* 2.13.1
*/
FT_EXPORT( FT_Error )
FT_Get_Default_Named_Instance( FT_Face face,
FT_UInt *instance_index );
/* */

2
thirdparty/freetype/include/freetype/ftoutln.h vendored
View file

@ -118,7 +118,7 @@ FT_BEGIN_HEADER
* attachement.
*
* Similarly, the function returns success for an empty outline also
* (doing nothing, this is, not calling any emitter); if necessary, you
* (doing nothing, that is, not calling any emitter); if necessary, you
* should filter this out, too.
*/
FT_EXPORT( FT_Error )

2
thirdparty/freetype/include/freetype/ftrender.h vendored
View file

@ -158,7 +158,7 @@ FT_BEGIN_HEADER
FT_Renderer_GetCBoxFunc get_glyph_cbox;
FT_Renderer_SetModeFunc set_mode;
FT_Raster_Funcs* raster_class;
const FT_Raster_Funcs* raster_class;
} FT_Renderer_Class;

12
thirdparty/freetype/include/freetype/ftsynth.h vendored
View file

@ -68,6 +68,18 @@ FT_BEGIN_HEADER
FT_EXPORT( void )
FT_GlyphSlot_Embolden( FT_GlyphSlot slot );
/* Precisely adjust the glyph weight either horizontally or vertically. */
/* The `xdelta` and `ydelta` values are fractions of the face Em size */
/* (in fixed-point format). Considering that a regular face would have */
/* stem widths on the order of 0.1 Em, a delta of 0.05 (0x0CCC) should */
/* be very noticeable. To increase or decrease the weight, use positive */
/* or negative values, respectively. */
FT_EXPORT( void )
FT_GlyphSlot_AdjustWeight( FT_GlyphSlot slot,
FT_Fixed xdelta,
FT_Fixed ydelta );
/* Slant an outline glyph to the right by about 12 degrees. */
FT_EXPORT( void )
FT_GlyphSlot_Oblique( FT_GlyphSlot slot );

16
thirdparty/freetype/include/freetype/ftsystem.h vendored
View file

@ -229,8 +229,7 @@ FT_BEGIN_HEADER
* A handle to the source stream.
*
* offset ::
* The offset from the start of the stream to seek to if this is a seek
* operation (see note).
* The offset from the start of the stream to seek to.
*
* buffer ::
* The address of the read buffer.
@ -239,16 +238,9 @@ FT_BEGIN_HEADER
* The number of bytes to read from the stream.
*
* @return:
* The number of bytes effectively read by the stream.
*
* @note:
* This function performs a seek *or* a read operation depending on the
* argument values. If `count` is zero, the operation is a seek to
* `offset` bytes. If `count` is >~0, the operation is a read of `count`
* bytes from the current position in the stream, and the `offset` value
* should be ignored.
*
* For seek operations, a non-zero return value indicates an error.
* If count >~0, return the number of bytes effectively read by the
* stream (after seeking to `offset`). If count ==~0, return the status
* of the seek operation (non-zero indicates an error).
*
*/
typedef unsigned long

7
thirdparty/freetype/include/freetype/internal/compiler-macros.h vendored
View file

@ -41,8 +41,11 @@ FT_BEGIN_HEADER
# if ( defined( __STDC_VERSION__ ) && __STDC_VERSION__ > 201710L ) || \
( defined( __cplusplus ) && __cplusplus > 201402L )
# define FALL_THROUGH [[__fallthrough__]]
# elif ( defined( __GNUC__ ) && __GNUC__ >= 7 ) || \
( defined( __clang__ ) && __clang_major__ >= 10 )
# elif ( defined( __GNUC__ ) && __GNUC__ >= 7 ) || \
( defined( __clang__ ) && \
( defined( __apple_build_version__ ) \
? __apple_build_version__ >= 12000000 \
: __clang_major__ >= 10 ) )
# define FALL_THROUGH __attribute__(( __fallthrough__ ))
# else
# define FALL_THROUGH ( (void)0 )

1
thirdparty/freetype/include/freetype/internal/ftdrv.h vendored
View file

@ -157,6 +157,7 @@ FT_BEGIN_HEADER
* A handle to a function used to select a new fixed size. It is used
* only if @FT_FACE_FLAG_FIXED_SIZES is set. Can be set to 0 if the
* scaling done in the base layer suffices.
*
* @note:
* Most function pointers, with the exception of `load_glyph`, can be set
* to 0 to indicate a default behaviour.

20
thirdparty/freetype/include/freetype/internal/ftmmtypes.h vendored
View file

@ -28,13 +28,19 @@ FT_BEGIN_HEADER
typedef struct GX_ItemVarDataRec_
{
FT_UInt itemCount; /* number of delta sets per item */
FT_UInt regionIdxCount; /* number of region indices */
FT_UInt* regionIndices; /* array of `regionCount' indices; */
/* these index `varRegionList' */
FT_ItemVarDelta* deltaSet; /* array of `itemCount' deltas */
/* use `innerIndex' for this array */
FT_UInt itemCount; /* Number of delta sets per item. */
FT_UInt regionIdxCount; /* Number of region indices. */
FT_UInt* regionIndices; /* Array of `regionCount` indices; */
/* these index `varRegionList`. */
FT_Byte* deltaSet; /* Array of `itemCount` deltas; */
/* use `innerIndex` for this array. */
FT_UShort wordDeltaCount; /* Number of the first 32-bit ints */
/* or 16-bit ints of `deltaSet` */
/* depending on `longWords`. */
FT_Bool longWords; /* If true, `deltaSet` is a 32-bit */
/* array followed by a 16-bit */
/* array, otherwise a 16-bit array */
/* followed by an 8-bit array. */
} GX_ItemVarDataRec, *GX_ItemVarData;

10
thirdparty/freetype/include/freetype/internal/services/svmetric.h vendored
View file

@ -77,6 +77,9 @@ FT_BEGIN_HEADER
typedef void
(*FT_Metrics_Adjust_Func)( FT_Face face );
typedef FT_Error
(*FT_Size_Reset_Func)( FT_Size size );
FT_DEFINE_SERVICE( MetricsVariations )
{
@ -90,6 +93,7 @@ FT_BEGIN_HEADER
FT_VOrg_Adjust_Func vorg_adjust;
FT_Metrics_Adjust_Func metrics_adjust;
FT_Size_Reset_Func size_reset;
};
@ -101,7 +105,8 @@ FT_BEGIN_HEADER
tsb_adjust_, \
bsb_adjust_, \
vorg_adjust_, \
metrics_adjust_ ) \
metrics_adjust_, \
size_reset_ ) \
static const FT_Service_MetricsVariationsRec class_ = \
{ \
hadvance_adjust_, \
@ -111,7 +116,8 @@ FT_BEGIN_HEADER
tsb_adjust_, \
bsb_adjust_, \
vorg_adjust_, \
metrics_adjust_ \
metrics_adjust_, \
size_reset_ \
};
/* */

109
thirdparty/freetype/include/freetype/internal/services/svmm.h vendored
View file

@ -60,9 +60,9 @@ FT_BEGIN_HEADER
/* use return value -1 to indicate that the new coordinates */
/* are equal to the current ones; no changes are thus needed */
typedef FT_Error
(*FT_Set_MM_Blend_Func)( FT_Face face,
FT_UInt num_coords,
FT_Long* coords );
(*FT_Set_MM_Blend_Func)( FT_Face face,
FT_UInt num_coords,
FT_Fixed* coords );
typedef FT_Error
(*FT_Get_Var_Design_Func)( FT_Face face,
@ -70,13 +70,17 @@ FT_BEGIN_HEADER
FT_Fixed* coords );
typedef FT_Error
(*FT_Set_Instance_Func)( FT_Face face,
FT_UInt instance_index );
(*FT_Set_Named_Instance_Func)( FT_Face face,
FT_UInt instance_index );
typedef FT_Error
(*FT_Get_MM_Blend_Func)( FT_Face face,
FT_UInt num_coords,
FT_Long* coords );
(*FT_Get_Default_Named_Instance_Func)( FT_Face face,
FT_UInt *instance_index );
typedef FT_Error
(*FT_Get_MM_Blend_Func)( FT_Face face,
FT_UInt num_coords,
FT_Fixed* coords );
typedef FT_Error
(*FT_Get_Var_Blend_Func)( FT_Face face,
@ -86,7 +90,7 @@ FT_BEGIN_HEADER
FT_MM_Var* *mm_var );
typedef void
(*FT_Done_Blend_Func)( FT_Face );
(*FT_Done_Blend_Func)( FT_Face face );
typedef FT_Error
(*FT_Set_MM_WeightVector_Func)( FT_Face face,
@ -98,6 +102,9 @@ FT_BEGIN_HEADER
FT_UInt* len,
FT_Fixed* weight_vector );
typedef void
(*FT_Construct_PS_Name_Func)( FT_Face face );
typedef FT_Error
(*FT_Var_Load_Delta_Set_Idx_Map_Func)( FT_Face face,
FT_ULong offset,
@ -134,11 +141,13 @@ FT_BEGIN_HEADER
FT_Get_MM_Var_Func get_mm_var;
FT_Set_Var_Design_Func set_var_design;
FT_Get_Var_Design_Func get_var_design;
FT_Set_Instance_Func set_instance;
FT_Set_Named_Instance_Func set_named_instance;
FT_Get_Default_Named_Instance_Func get_default_named_instance;
FT_Set_MM_WeightVector_Func set_mm_weightvector;
FT_Get_MM_WeightVector_Func get_mm_weightvector;
/* for internal use; only needed for code sharing between modules */
FT_Construct_PS_Name_Func construct_ps_name;
FT_Var_Load_Delta_Set_Idx_Map_Func load_delta_set_idx_map;
FT_Var_Load_Item_Var_Store_Func load_item_var_store;
FT_Var_Get_Item_Delta_Func get_item_delta;
@ -149,43 +158,49 @@ FT_BEGIN_HEADER
};
#define FT_DEFINE_SERVICE_MULTIMASTERSREC( class_, \
get_mm_, \
set_mm_design_, \
set_mm_blend_, \
get_mm_blend_, \
get_mm_var_, \
set_var_design_, \
get_var_design_, \
set_instance_, \
set_weightvector_, \
get_weightvector_, \
load_delta_set_idx_map_, \
load_item_var_store_, \
get_item_delta_, \
done_item_var_store_, \
done_delta_set_idx_map_, \
get_var_blend_, \
done_blend_ ) \
static const FT_Service_MultiMastersRec class_ = \
{ \
get_mm_, \
set_mm_design_, \
set_mm_blend_, \
get_mm_blend_, \
get_mm_var_, \
set_var_design_, \
get_var_design_, \
set_instance_, \
set_weightvector_, \
get_weightvector_, \
load_delta_set_idx_map_, \
load_item_var_store_, \
get_item_delta_, \
done_item_var_store_, \
done_delta_set_idx_map_, \
get_var_blend_, \
done_blend_ \
#define FT_DEFINE_SERVICE_MULTIMASTERSREC( class_, \
get_mm_, \
set_mm_design_, \
set_mm_blend_, \
get_mm_blend_, \
get_mm_var_, \
set_var_design_, \
get_var_design_, \
set_named_instance_, \
get_default_named_instance_, \
set_mm_weightvector_, \
get_mm_weightvector_, \
\
construct_ps_name_, \
load_delta_set_idx_map_, \
load_item_var_store_, \
get_item_delta_, \
done_item_var_store_, \
done_delta_set_idx_map_, \
get_var_blend_, \
done_blend_ ) \
static const FT_Service_MultiMastersRec class_ = \
{ \
get_mm_, \
set_mm_design_, \
set_mm_blend_, \
get_mm_blend_, \
get_mm_var_, \
set_var_design_, \
get_var_design_, \
set_named_instance_, \
get_default_named_instance_, \
set_mm_weightvector_, \
get_mm_weightvector_, \
\
construct_ps_name_, \
load_delta_set_idx_map_, \
load_item_var_store_, \
get_item_delta_, \
done_item_var_store_, \
done_delta_set_idx_map_, \
get_var_blend_, \
done_blend_ \
};
/* */

2
thirdparty/freetype/include/freetype/internal/services/svpscmap.h vendored
View file

@ -97,7 +97,7 @@ FT_BEGIN_HEADER
(*PS_Unicodes_CharIndexFunc)( PS_Unicodes unicodes,
FT_UInt32 unicode );
typedef FT_UInt32
typedef FT_UInt
(*PS_Unicodes_CharNextFunc)( PS_Unicodes unicodes,
FT_UInt32 *unicode );

26
thirdparty/freetype/include/freetype/internal/t1types.h vendored
View file

@ -201,30 +201,30 @@ FT_BEGIN_HEADER
typedef struct T1_FaceRec_
{
FT_FaceRec root;
T1_FontRec type1;
const void* psnames;
const void* psaux;
const void* afm_data;
FT_CharMapRec charmaprecs[2];
FT_CharMap charmaps[2];
FT_FaceRec root;
T1_FontRec type1;
const void* psnames;
const void* psaux;
const void* afm_data;
FT_CharMapRec charmaprecs[2];
FT_CharMap charmaps[2];
/* support for Multiple Masters fonts */
PS_Blend blend;
PS_Blend blend;
/* undocumented, optional: indices of subroutines that express */
/* the NormalizeDesignVector and the ConvertDesignVector procedure, */
/* respectively, as Type 2 charstrings; -1 if keywords not present */
FT_Int ndv_idx;
FT_Int cdv_idx;
FT_Int ndv_idx;
FT_Int cdv_idx;
/* undocumented, optional: has the same meaning as len_buildchar */
/* for Type 2 fonts; manipulated by othersubrs 19, 24, and 25 */
FT_UInt len_buildchar;
FT_Long* buildchar;
FT_UInt len_buildchar;
FT_Long* buildchar;
/* since version 2.1 - interface to PostScript hinter */
const void* pshinter;
const void* pshinter;
} T1_FaceRec;

122
thirdparty/freetype/include/freetype/internal/tttypes.h vendored
View file

@ -779,13 +779,15 @@ FT_BEGIN_HEADER
/**************************************************************************
*
* @struct:
* TT_Post_20Rec
* TT_Post_NamesRec
*
* @description:
* Postscript names sub-table, format 2.0. Stores the PS name of each
* glyph in the font face.
* Postscript names table, either format 2.0 or 2.5.
*
* @fields:
* loaded ::
* A flag to indicate whether the PS names are loaded.
*
* num_glyphs ::
* The number of named glyphs in the table.
*
@ -798,68 +800,13 @@ FT_BEGIN_HEADER
* glyph_names ::
* The PS names not in Mac Encoding.
*/
typedef struct TT_Post_20Rec_
typedef struct TT_Post_NamesRec_
{
FT_Bool loaded;
FT_UShort num_glyphs;
FT_UShort num_names;
FT_UShort* glyph_indices;
FT_Char** glyph_names;
} TT_Post_20Rec, *TT_Post_20;
/**************************************************************************
*
* @struct:
* TT_Post_25Rec
*
* @description:
* Postscript names sub-table, format 2.5. Stores the PS name of each
* glyph in the font face.
*
* @fields:
* num_glyphs ::
* The number of glyphs in the table.
*
* offsets ::
* An array of signed offsets in a normal Mac Postscript name encoding.
*/
typedef struct TT_Post_25_
{
FT_UShort num_glyphs;
FT_Char* offsets;
} TT_Post_25Rec, *TT_Post_25;
/**************************************************************************
*
* @struct:
* TT_Post_NamesRec
*
* @description:
* Postscript names table, either format 2.0 or 2.5.
*
* @fields:
* loaded ::
* A flag to indicate whether the PS names are loaded.
*
* format_20 ::
* The sub-table used for format 2.0.
*
* format_25 ::
* The sub-table used for format 2.5.
*/
typedef struct TT_Post_NamesRec_
{
FT_Bool loaded;
union
{
TT_Post_20Rec format_20;
TT_Post_25Rec format_25;
} names;
FT_Byte** glyph_names;
} TT_Post_NamesRec, *TT_Post_Names;
@ -1253,12 +1200,16 @@ FT_BEGIN_HEADER
* mm ::
* A pointer to the Multiple Masters service.
*
* var ::
* A pointer to the Metrics Variations service.
* tt_var ::
* A pointer to the Metrics Variations service for the "truetype"
* driver.
*
* hdmx ::
* The face's horizontal device metrics ('hdmx' table). This table is
* optional in TrueType/OpenType fonts.
* face_var ::
* A pointer to the Metrics Variations service for this `TT_Face`'s
* driver.
*
* psaux ::
* A pointer to the PostScript Auxiliary service.
*
* gasp ::
* The grid-fitting and scaling properties table ('gasp'). This table
@ -1364,6 +1315,12 @@ FT_BEGIN_HEADER
* var_postscript_prefix_len ::
* The length of the `var_postscript_prefix` string.
*
* var_default_named_instance ::
* The index of the default named instance.
*
* non_var_style_name ::
* The non-variation style name, used as a backup.
*
* horz_metrics_size ::
* The size of the 'hmtx' table.
*
@ -1410,14 +1367,6 @@ FT_BEGIN_HEADER
* A mapping between the strike indices exposed by the API and the
* indices used in the font's sbit table.
*
* cpal ::
* A pointer to data related to the 'CPAL' table. `NULL` if the table
* is not available.
*
* colr ::
* A pointer to data related to the 'COLR' table. `NULL` if the table
* is not available.
*
* kern_table ::
* A pointer to the 'kern' table.
*
@ -1458,6 +1407,18 @@ FT_BEGIN_HEADER
*
* ebdt_size ::
* The size of the sbit data table.
*
* cpal ::
* A pointer to data related to the 'CPAL' table. `NULL` if the table
* is not available.
*
* colr ::
* A pointer to data related to the 'COLR' table. `NULL` if the table
* is not available.
*
* svg ::
* A pointer to data related to the 'SVG' table. `NULL` if the table
* is not available.
*/
typedef struct TT_FaceRec_
{
@ -1508,8 +1469,14 @@ FT_BEGIN_HEADER
void* mm;
/* a typeless pointer to the FT_Service_MetricsVariationsRec table */
/* used to handle the HVAR, VVAR, and MVAR OpenType tables */
void* var;
/* used to handle the HVAR, VVAR, and MVAR OpenType tables by the */
/* "truetype" driver */
void* tt_var;
/* a typeless pointer to the FT_Service_MetricsVariationsRec table */
/* used to handle the HVAR, VVAR, and MVAR OpenType tables by this */
/* TT_Face's driver */
void* face_var; /* since 2.13.1 */
#endif
/* a typeless pointer to the PostScript Aux service */
@ -1591,6 +1558,9 @@ FT_BEGIN_HEADER
const char* var_postscript_prefix; /* since 2.7.2 */
FT_UInt var_postscript_prefix_len; /* since 2.7.2 */
FT_UInt var_default_named_instance; /* since 2.13.1 */
const char* non_var_style_name; /* since 2.13.1 */
#endif
/* since version 2.2 */

56
thirdparty/freetype/src/autofit/afcjk.c vendored
View file

@ -417,16 +417,14 @@
{
FT_Int nn;
FT_Int first = 0;
FT_Int last = -1;
FT_Int pp, first, last;
for ( nn = 0; nn < outline.n_contours; first = last + 1, nn++ )
last = -1;
for ( nn = 0; nn < outline.n_contours; nn++ )
{
FT_Int pp;
last = outline.contours[nn];
first = last + 1;
last = outline.contours[nn];
/* Avoid single-point contours since they are never rasterized. */
/* In some fonts, they correspond to mark attachment points */
@ -569,8 +567,8 @@
af_cjk_metrics_check_digits( AF_CJKMetrics metrics,
FT_Face face )
{
FT_Bool started = 0, same_width = 1;
FT_Fixed advance = 0, old_advance = 0;
FT_Bool started = 0, same_width = 1;
FT_Long advance = 0, old_advance = 0;
/* If HarfBuzz is not available, we need a pointer to a single */
/* unsigned long value. */
@ -635,10 +633,11 @@
/* Initialize global metrics. */
FT_LOCAL_DEF( FT_Error )
af_cjk_metrics_init( AF_CJKMetrics metrics,
FT_Face face )
af_cjk_metrics_init( AF_StyleMetrics metrics_, /* AF_CJKMetrics */
FT_Face face )
{
FT_CharMap oldmap = face->charmap;
AF_CJKMetrics metrics = (AF_CJKMetrics)metrics_;
FT_CharMap oldmap = face->charmap;
metrics->units_per_em = face->units_per_EM;
@ -756,9 +755,12 @@
/* Scale global values in both directions. */
FT_LOCAL_DEF( void )
af_cjk_metrics_scale( AF_CJKMetrics metrics,
AF_Scaler scaler )
af_cjk_metrics_scale( AF_StyleMetrics metrics_, /* AF_CJKMetrics */
AF_Scaler scaler )
{
AF_CJKMetrics metrics = (AF_CJKMetrics)metrics_;
/* we copy the whole structure since the x and y scaling values */
/* are not modified, contrary to e.g. the `latin' auto-hinter */
metrics->root.scaler = *scaler;
@ -771,11 +773,14 @@
/* Extract standard_width from writing system/script specific */
/* metrics class. */
FT_LOCAL_DEF( void )
af_cjk_get_standard_widths( AF_CJKMetrics metrics,
FT_Pos* stdHW,
FT_Pos* stdVW )
FT_CALLBACK_DEF( void )
af_cjk_get_standard_widths( AF_StyleMetrics metrics_, /* AF_CJKMetrics */
FT_Pos* stdHW,
FT_Pos* stdVW )
{
AF_CJKMetrics metrics = (AF_CJKMetrics)metrics_;
if ( stdHW )
*stdHW = metrics->axis[AF_DIMENSION_VERT].standard_width;
@ -1376,9 +1381,10 @@
/* Initalize hinting engine. */
FT_LOCAL_DEF( FT_Error )
af_cjk_hints_init( AF_GlyphHints hints,
AF_CJKMetrics metrics )
af_cjk_hints_init( AF_GlyphHints hints,
AF_StyleMetrics metrics_ ) /* AF_CJKMetrics */
{
AF_CJKMetrics metrics = (AF_CJKMetrics)metrics_;
FT_Render_Mode mode;
FT_UInt32 scaler_flags, other_flags;
@ -2268,11 +2274,13 @@
/* Apply the complete hinting algorithm to a CJK glyph. */
FT_LOCAL_DEF( FT_Error )
af_cjk_hints_apply( FT_UInt glyph_index,
AF_GlyphHints hints,
FT_Outline* outline,
AF_CJKMetrics metrics )
af_cjk_hints_apply( FT_UInt glyph_index,
AF_GlyphHints hints,
FT_Outline* outline,
AF_StyleMetrics metrics_ ) /* AF_CJKMetrics */
{
AF_CJKMetrics metrics = (AF_CJKMetrics)metrics_;
FT_Error error;
int dim;

20
thirdparty/freetype/src/autofit/afcjk.h vendored
View file

@ -103,22 +103,22 @@ FT_BEGIN_HEADER
#ifdef AF_CONFIG_OPTION_CJK
FT_LOCAL( FT_Error )
af_cjk_metrics_init( AF_CJKMetrics metrics,
FT_Face face );
af_cjk_metrics_init( AF_StyleMetrics metrics,
FT_Face face );
FT_LOCAL( void )
af_cjk_metrics_scale( AF_CJKMetrics metrics,
AF_Scaler scaler );
af_cjk_metrics_scale( AF_StyleMetrics metrics,
AF_Scaler scaler );
FT_LOCAL( FT_Error )
af_cjk_hints_init( AF_GlyphHints hints,
AF_CJKMetrics metrics );
af_cjk_hints_init( AF_GlyphHints hints,
AF_StyleMetrics metrics );
FT_LOCAL( FT_Error )
af_cjk_hints_apply( FT_UInt glyph_index,
AF_GlyphHints hints,
FT_Outline* outline,
AF_CJKMetrics metrics );
af_cjk_hints_apply( FT_UInt glyph_index,
AF_GlyphHints hints,
FT_Outline* outline,
AF_StyleMetrics metrics );
/* shared; called from afindic.c */
FT_LOCAL( void )

5
thirdparty/freetype/src/autofit/afglobal.c vendored
View file

@ -376,8 +376,11 @@
FT_LOCAL_DEF( void )
af_face_globals_free( AF_FaceGlobals globals )
af_face_globals_free( void* globals_ )
{
AF_FaceGlobals globals = (AF_FaceGlobals)globals_;
if ( globals )
{
FT_Memory memory = globals->face->memory;

2
thirdparty/freetype/src/autofit/afglobal.h vendored
View file

@ -156,7 +156,7 @@ FT_BEGIN_HEADER
AF_StyleMetrics *ametrics );
FT_LOCAL( void )
af_face_globals_free( AF_FaceGlobals globals );
af_face_globals_free( void* globals );
FT_LOCAL( FT_Bool )
af_face_globals_is_digit( AF_FaceGlobals globals,

58
thirdparty/freetype/src/autofit/afhints.c vendored
View file

@ -320,8 +320,9 @@
static char*
af_print_idx( char* p,
int idx )
af_print_idx( char* p,
size_t n,
int idx )
{
if ( idx == -1 )
{
@ -330,7 +331,7 @@
p[2] = '\0';
}
else
ft_sprintf( p, "%d", idx );
ft_snprintf( p, n, "%d", idx );
return p;
}
@ -457,12 +458,12 @@
" %5d %5d %7.2f %7.2f %7.2f %7.2f"
" %5s %5s %5s %5s\n",
point_idx,
af_print_idx( buf1,
af_print_idx( buf1, 16,
af_get_edge_index( hints, segment_idx_1, 1 ) ),
af_print_idx( buf2, segment_idx_1 ),
af_print_idx( buf3,
af_print_idx( buf2, 16, segment_idx_1 ),
af_print_idx( buf3, 16,
af_get_edge_index( hints, segment_idx_0, 0 ) ),
af_print_idx( buf4, segment_idx_0 ),
af_print_idx( buf4, 16, segment_idx_0 ),
( point->flags & AF_FLAG_NEAR )
? " near "
: ( point->flags & AF_FLAG_WEAK_INTERPOLATION )
@ -476,18 +477,22 @@
(double)point->x / 64,
(double)point->y / 64,
af_print_idx( buf5, af_get_strong_edge_index( hints,
point->before,
1 ) ),
af_print_idx( buf6, af_get_strong_edge_index( hints,
point->after,
1 ) ),
af_print_idx( buf7, af_get_strong_edge_index( hints,
point->before,
0 ) ),
af_print_idx( buf8, af_get_strong_edge_index( hints,
point->after,
0 ) ) ));
af_print_idx( buf5, 16,
af_get_strong_edge_index( hints,
point->before,
1 ) ),
af_print_idx( buf6, 16,
af_get_strong_edge_index( hints,
point->after,
1 ) ),
af_print_idx( buf7, 16,
af_get_strong_edge_index( hints,
point->before,
0 ) ),
af_print_idx( buf8, 16,
af_get_strong_edge_index( hints,
point->after,
0 ) ) ));
}
AF_DUMP(( "\n" ));
}
@ -574,9 +579,12 @@
AF_INDEX_NUM( seg->first, points ),
AF_INDEX_NUM( seg->last, points ),
af_print_idx( buf1, AF_INDEX_NUM( seg->link, segments ) ),
af_print_idx( buf2, AF_INDEX_NUM( seg->serif, segments ) ),
af_print_idx( buf3, AF_INDEX_NUM( seg->edge, edges ) ),
af_print_idx( buf1, 16,
AF_INDEX_NUM( seg->link, segments ) ),
af_print_idx( buf2, 16,
AF_INDEX_NUM( seg->serif, segments ) ),
af_print_idx( buf3, 16,
AF_INDEX_NUM( seg->edge, edges ) ),
seg->height,
seg->height - ( seg->max_coord - seg->min_coord ),
@ -716,8 +724,10 @@
AF_INDEX_NUM( edge, edges ),
(double)(int)edge->opos / 64,
af_dir_str( (AF_Direction)edge->dir ),
af_print_idx( buf1, AF_INDEX_NUM( edge->link, edges ) ),
af_print_idx( buf2, AF_INDEX_NUM( edge->serif, edges ) ),
af_print_idx( buf1, 16,
AF_INDEX_NUM( edge->link, edges ) ),
af_print_idx( buf2, 16,
AF_INDEX_NUM( edge->serif, edges ) ),
edge->blue_edge ? 'y' : 'n',
(double)edge->opos / 64,

32
thirdparty/freetype/src/autofit/afindic.c vendored
View file

@ -28,9 +28,12 @@
static FT_Error
af_indic_metrics_init( AF_CJKMetrics metrics,
FT_Face face )
af_indic_metrics_init( AF_StyleMetrics metrics_, /* AF_CJKMetrics */
FT_Face face )
{
AF_CJKMetrics metrics = (AF_CJKMetrics)metrics_;
/* skip blue zone init in CJK routines */
FT_CharMap oldmap = face->charmap;
@ -55,8 +58,8 @@
static void
af_indic_metrics_scale( AF_CJKMetrics metrics,
AF_Scaler scaler )
af_indic_metrics_scale( AF_StyleMetrics metrics,
AF_Scaler scaler )
{
/* use CJK routines */
af_cjk_metrics_scale( metrics, scaler );
@ -64,8 +67,8 @@
static FT_Error
af_indic_hints_init( AF_GlyphHints hints,
AF_CJKMetrics metrics )
af_indic_hints_init( AF_GlyphHints hints,
AF_StyleMetrics metrics )
{
/* use CJK routines */
return af_cjk_hints_init( hints, metrics );
@ -73,10 +76,10 @@
static FT_Error
af_indic_hints_apply( FT_UInt glyph_index,
AF_GlyphHints hints,
FT_Outline* outline,
AF_CJKMetrics metrics )
af_indic_hints_apply( FT_UInt glyph_index,
AF_GlyphHints hints,
FT_Outline* outline,
AF_StyleMetrics metrics )
{
/* use CJK routines */
return af_cjk_hints_apply( glyph_index, hints, outline, metrics );
@ -87,10 +90,13 @@
/* metrics class. */
static void
af_indic_get_standard_widths( AF_CJKMetrics metrics,
FT_Pos* stdHW,
FT_Pos* stdVW )
af_indic_get_standard_widths( AF_StyleMetrics metrics_, /* AF_CJKMetrics */
FT_Pos* stdHW,
FT_Pos* stdVW )
{
AF_CJKMetrics metrics = (AF_CJKMetrics)metrics_;
if ( stdHW )
*stdHW = metrics->axis[AF_DIMENSION_VERT].standard_width;

49
thirdparty/freetype/src/autofit/aflatin.c vendored
View file

@ -496,23 +496,20 @@
/* now compute min or max point indices and coordinates */
points = outline.points;
best_point = -1;
best_contour_first = -1;
best_contour_last = -1;
best_y = 0; /* make compiler happy */
best_contour_first = 0; /* ditto */
best_contour_last = 0; /* ditto */
{
FT_Int nn;
FT_Int first = 0;
FT_Int last = -1;
FT_Int pp, first, last;
for ( nn = 0; nn < outline.n_contours; first = last + 1, nn++ )
last = -1;
for ( nn = 0; nn < outline.n_contours; nn++ )
{
FT_Int old_best_point = best_point;
FT_Int pp;
last = outline.contours[nn];
first = last + 1;
last = outline.contours[nn];
/* Avoid single-point contours since they are never */
/* rasterized. In some fonts, they correspond to mark */
@ -551,7 +548,7 @@
}
}
if ( best_point != old_best_point )
if ( best_point > best_contour_last )
{
best_contour_first = first;
best_contour_last = last;
@ -1068,8 +1065,8 @@
af_latin_metrics_check_digits( AF_LatinMetrics metrics,
FT_Face face )
{
FT_Bool started = 0, same_width = 1;
FT_Fixed advance = 0, old_advance = 0;
FT_Bool started = 0, same_width = 1;
FT_Long advance = 0, old_advance = 0;
/* If HarfBuzz is not available, we need a pointer to a single */
/* unsigned long value. */
@ -1134,9 +1131,11 @@
/* Initialize global metrics. */
FT_LOCAL_DEF( FT_Error )
af_latin_metrics_init( AF_LatinMetrics metrics,
af_latin_metrics_init( AF_StyleMetrics metrics_, /* AF_LatinMetrics */
FT_Face face )
{
AF_LatinMetrics metrics = (AF_LatinMetrics)metrics_;
FT_Error error = FT_Err_Ok;
FT_CharMap oldmap = face->charmap;
@ -1489,9 +1488,12 @@
/* Scale global values in both directions. */
FT_LOCAL_DEF( void )
af_latin_metrics_scale( AF_LatinMetrics metrics,
af_latin_metrics_scale( AF_StyleMetrics metrics_, /* AF_LatinMetrics */
AF_Scaler scaler )
{
AF_LatinMetrics metrics = (AF_LatinMetrics)metrics_;
metrics->root.scaler.render_mode = scaler->render_mode;
metrics->root.scaler.face = scaler->face;
metrics->root.scaler.flags = scaler->flags;
@ -1504,11 +1506,14 @@
/* Extract standard_width from writing system/script specific */
/* metrics class. */
FT_LOCAL_DEF( void )
af_latin_get_standard_widths( AF_LatinMetrics metrics,
FT_CALLBACK_DEF( void )
af_latin_get_standard_widths( AF_StyleMetrics metrics_, /* AF_LatinMetrics */
FT_Pos* stdHW,
FT_Pos* stdVW )
{
AF_LatinMetrics metrics = (AF_LatinMetrics)metrics_;
if ( stdHW )
*stdHW = metrics->axis[AF_DIMENSION_VERT].standard_width;
@ -2041,7 +2046,7 @@
max = seg2->max_coord;
/* compute maximum coordinate difference of the two segments */
/* (this is, how much they overlap) */
/* (that is, how much they overlap) */
len = max - min;
if ( len >= len_threshold )
{
@ -2610,8 +2615,10 @@
static FT_Error
af_latin_hints_init( AF_GlyphHints hints,
AF_LatinMetrics metrics )
AF_StyleMetrics metrics_ ) /* AF_LatinMetrics */
{
AF_LatinMetrics metrics = (AF_LatinMetrics)metrics_;
FT_Render_Mode mode;
FT_UInt32 scaler_flags, other_flags;
FT_Face face = metrics->root.scaler.face;
@ -3547,8 +3554,10 @@
af_latin_hints_apply( FT_UInt glyph_index,
AF_GlyphHints hints,
FT_Outline* outline,
AF_LatinMetrics metrics )
AF_StyleMetrics metrics_ ) /* AF_LatinMetrics */
{
AF_LatinMetrics metrics = (AF_LatinMetrics)metrics_;
FT_Error error;
int dim;

4
thirdparty/freetype/src/autofit/aflatin.h vendored
View file

@ -116,11 +116,11 @@ FT_BEGIN_HEADER
FT_LOCAL( FT_Error )
af_latin_metrics_init( AF_LatinMetrics metrics,
af_latin_metrics_init( AF_StyleMetrics metrics,
FT_Face face );
FT_LOCAL( void )
af_latin_metrics_scale( AF_LatinMetrics metrics,
af_latin_metrics_scale( AF_StyleMetrics metrics,
AF_Scaler scaler );
FT_LOCAL( void )

6
thirdparty/freetype/src/autofit/afloader.c vendored
View file

@ -55,10 +55,8 @@
error = af_face_globals_new( face, &loader->globals, module );
if ( !error )
{
face->autohint.data =
(FT_Pointer)loader->globals;
face->autohint.finalizer =
(FT_Generic_Finalizer)af_face_globals_free;
face->autohint.data = (FT_Pointer)loader->globals;
face->autohint.finalizer = af_face_globals_free;
}
}

37
thirdparty/freetype/src/autofit/afmodule.c vendored
View file

@ -89,10 +89,8 @@
error = af_face_globals_new( face, &globals, module );
if ( !error )
{
face->autohint.data =
(FT_Pointer)globals;
face->autohint.finalizer =
(FT_Generic_Finalizer)af_face_globals_free;
face->autohint.data = (FT_Pointer)globals;
face->autohint.finalizer = af_face_globals_free;
}
}
@ -374,8 +372,9 @@
FT_DEFINE_SERVICE_PROPERTIESREC(
af_service_properties,
(FT_Properties_SetFunc)af_property_set, /* set_property */
(FT_Properties_GetFunc)af_property_get ) /* get_property */
af_property_set, /* FT_Properties_SetFunc set_property */
af_property_get /* FT_Properties_GetFunc get_property */
)
FT_DEFINE_SERVICEDESCREC1(
@ -430,12 +429,14 @@
FT_CALLBACK_DEF( FT_Error )
af_autofitter_load_glyph( AF_Module module,
FT_GlyphSlot slot,
FT_Size size,
FT_UInt glyph_index,
FT_Int32 load_flags )
af_autofitter_load_glyph( FT_AutoHinter module_,
FT_GlyphSlot slot,
FT_Size size,
FT_UInt glyph_index,
FT_Int32 load_flags )
{
AF_Module module = (AF_Module)module_;
FT_Error error = FT_Err_Ok;
FT_Memory memory = module->root.library->memory;
@ -499,10 +500,10 @@
FT_DEFINE_AUTOHINTER_INTERFACE(
af_autofitter_interface,
NULL, /* reset_face */
NULL, /* get_global_hints */
NULL, /* done_global_hints */
(FT_AutoHinter_GlyphLoadFunc)af_autofitter_load_glyph /* load_glyph */
NULL, /* FT_AutoHinter_GlobalResetFunc reset_face */
NULL, /* FT_AutoHinter_GlobalGetFunc get_global_hints */
NULL, /* FT_AutoHinter_GlobalDoneFunc done_global_hints */
af_autofitter_load_glyph /* FT_AutoHinter_GlyphLoadFunc load_glyph */
)
FT_DEFINE_MODULE(
@ -517,9 +518,9 @@
(const void*)&af_autofitter_interface,
(FT_Module_Constructor)af_autofitter_init, /* module_init */
(FT_Module_Destructor) af_autofitter_done, /* module_done */
(FT_Module_Requester) af_get_interface /* get_interface */
af_autofitter_init, /* FT_Module_Constructor module_init */
af_autofitter_done, /* FT_Module_Destructor module_done */
af_get_interface /* FT_Module_Requester get_interface */
)

6
thirdparty/freetype/src/autofit/afshaper.c vendored
View file

@ -258,7 +258,7 @@
/*
* We now check whether we can construct blue zones, using glyphs
* covered by the feature only. In case there is not a single zone
* (this is, not a single character is covered), we skip this coverage.
* (that is, not a single character is covered), we skip this coverage.
*
*/
if ( style_class->coverage != AF_COVERAGE_DEFAULT )
@ -313,9 +313,9 @@
* hinted and usually rendered glyph.
*
* Consider the superscript feature of font `pala.ttf': Some of the
* glyphs are `real', this is, they have a zero vertical offset, but
* glyphs are `real', that is, they have a zero vertical offset, but
* most of them are small caps glyphs shifted up to the superscript
* position (this is, the `sups' feature is present in both the GSUB and
* position (that is, the `sups' feature is present in both the GSUB and
* GPOS tables). The code for blue zones computation actually uses a
* feature's y offset so that the `real' glyphs get correct hints. But
* later on it is impossible to decide whether a glyph index belongs to,

2
thirdparty/freetype/src/autofit/ft-hb.c vendored
View file

@ -108,7 +108,7 @@ hb_ft_font_create_ (FT_Face ft_face,
#else /* !FT_CONFIG_OPTION_USE_HARFBUZZ */
/* ANSI C doesn't like empty source files */
typedef int _ft_hb_dummy;
typedef int ft_hb_dummy_;
#endif /* !FT_CONFIG_OPTION_USE_HARFBUZZ */

42
thirdparty/freetype/src/base/ftbbox.c vendored
View file

@ -82,10 +82,13 @@
* @Return:
* Always 0. Needed for the interface only.
*/
static int
BBox_Move_To( FT_Vector* to,
TBBox_Rec* user )
FT_CALLBACK_DEF( int )
BBox_Move_To( const FT_Vector* to,
void* user_ )
{
TBBox_Rec* user = (TBBox_Rec*)user_;
FT_UPDATE_BBOX( to, user->bbox );
user->last = *to;
@ -116,10 +119,13 @@
* @Return:
* Always 0. Needed for the interface only.
*/
static int
BBox_Line_To( FT_Vector* to,
TBBox_Rec* user )
FT_CALLBACK_DEF( int )
BBox_Line_To( const FT_Vector* to,
void* user_ )
{
TBBox_Rec* user = (TBBox_Rec*)user_;
user->last = *to;
return 0;
@ -205,11 +211,14 @@
* In the case of a non-monotonous arc, we compute directly the
* extremum coordinates, as it is sufficiently fast.
*/
static int
BBox_Conic_To( FT_Vector* control,
FT_Vector* to,
TBBox_Rec* user )
FT_CALLBACK_DEF( int )
BBox_Conic_To( const FT_Vector* control,
const FT_Vector* to,
void* user_ )
{
TBBox_Rec* user = (TBBox_Rec*)user_;
/* in case `to' is implicit and not included in bbox yet */
FT_UPDATE_BBOX( to, user->bbox );
@ -410,12 +419,15 @@
* In the case of a non-monotonous arc, we don't compute directly
* extremum coordinates, we subdivide instead.
*/
static int
BBox_Cubic_To( FT_Vector* control1,
FT_Vector* control2,
FT_Vector* to,
TBBox_Rec* user )
FT_CALLBACK_DEF( int )
BBox_Cubic_To( const FT_Vector* control1,
const FT_Vector* control2,
const FT_Vector* to,
void* user_ )
{
TBBox_Rec* user = (TBBox_Rec*)user_;
/* We don't need to check `to' since it is always an on-point, */
/* thus within the bbox. Only segments with an off-point outside */
/* the bbox can possibly reach new extreme values. */

4
thirdparty/freetype/src/base/ftcalc.c vendored
View file

@ -1061,7 +1061,7 @@
/* */
/* This approach has the advantage that the angle between */
/* `in' and `out' is not checked. In case one of the two */
/* vectors is `dominant', this is, much larger than the */
/* vectors is `dominant', that is, much larger than the */
/* other vector, we thus always have a flat corner. */
/* */
/* hypotenuse */
@ -1103,7 +1103,7 @@
for ( i = 0; i < count; ++i )
temp += (FT_Int64)s[i] * f[i];
return ( temp + 0x8000 ) >> 16;
return (FT_Int32)( ( temp + 0x8000 ) >> 16 );
#else
temp.hi = 0;
temp.lo = 0;

2
thirdparty/freetype/src/base/ftdbgmem.c vendored
View file

@ -963,7 +963,7 @@
#else /* !FT_DEBUG_MEMORY */
/* ANSI C doesn't like empty source files */
typedef int _debug_mem_dummy;
typedef int debug_mem_dummy_;
#endif /* !FT_DEBUG_MEMORY */

2
thirdparty/freetype/src/base/ftmac.c vendored
View file

@ -1082,7 +1082,7 @@
#else /* !FT_MACINTOSH */
/* ANSI C doesn't like empty source files */
typedef int _ft_mac_dummy;
typedef int ft_mac_dummy_;
#endif /* !FT_MACINTOSH */

146
thirdparty/freetype/src/base/ftmm.c vendored
View file

@ -185,6 +185,14 @@
error = FT_ERR( Invalid_Argument );
if ( service->set_mm_design )
error = service->set_mm_design( face, num_coords, coords );
if ( !error )
{
if ( num_coords )
face->face_flags |= FT_FACE_FLAG_VARIATION;
else
face->face_flags &= ~FT_FACE_FLAG_VARIATION;
}
}
/* enforce recomputation of auto-hinting data */
@ -220,6 +228,14 @@
error = FT_ERR( Invalid_Argument );
if ( service->set_mm_weightvector )
error = service->set_mm_weightvector( face, len, weightvector );
if ( !error )
{
if ( len )
face->face_flags |= FT_FACE_FLAG_VARIATION;
else
face->face_flags &= ~FT_FACE_FLAG_VARIATION;
}
}
/* enforce recomputation of auto-hinting data */
@ -283,6 +299,30 @@
if ( service_mm->set_var_design )
error = service_mm->set_var_design( face, num_coords, coords );
if ( !error || error == -1 )
{
FT_Bool is_variation_old = FT_IS_VARIATION( face );
if ( num_coords )
face->face_flags |= FT_FACE_FLAG_VARIATION;
else
face->face_flags &= ~FT_FACE_FLAG_VARIATION;
if ( service_mm->construct_ps_name )
{
if ( error == -1 )
{
/* The PS name of a named instance and a non-named instance */
/* usually differs, even if the axis values are identical. */
if ( is_variation_old != FT_IS_VARIATION( face ) )
service_mm->construct_ps_name( face );
}
else
service_mm->construct_ps_name( face );
}
}
/* internal error code -1 means `no change'; we can exit immediately */
if ( error == -1 )
return FT_Err_Ok;
@ -359,6 +399,30 @@
if ( service_mm->set_mm_blend )
error = service_mm->set_mm_blend( face, num_coords, coords );
if ( !error || error == -1 )
{
FT_Bool is_variation_old = FT_IS_VARIATION( face );
if ( num_coords )
face->face_flags |= FT_FACE_FLAG_VARIATION;
else
face->face_flags &= ~FT_FACE_FLAG_VARIATION;
if ( service_mm->construct_ps_name )
{
if ( error == -1 )
{
/* The PS name of a named instance and a non-named instance */
/* usually differs, even if the axis values are identical. */
if ( is_variation_old != FT_IS_VARIATION( face ) )
service_mm->construct_ps_name( face );
}
else
service_mm->construct_ps_name( face );
}
}
/* internal error code -1 means `no change'; we can exit immediately */
if ( error == -1 )
return FT_Err_Ok;
@ -410,6 +474,30 @@
if ( service_mm->set_mm_blend )
error = service_mm->set_mm_blend( face, num_coords, coords );
if ( !error || error == -1 )
{
FT_Bool is_variation_old = FT_IS_VARIATION( face );
if ( num_coords )
face->face_flags |= FT_FACE_FLAG_VARIATION;
else
face->face_flags &= ~FT_FACE_FLAG_VARIATION;
if ( service_mm->construct_ps_name )
{
if ( error == -1 )
{
/* The PS name of a named instance and a non-named instance */
/* usually differs, even if the axis values are identical. */
if ( is_variation_old != FT_IS_VARIATION( face ) )
service_mm->construct_ps_name( face );
}
else
service_mm->construct_ps_name( face );
}
}
/* internal error code -1 means `no change'; we can exit immediately */
if ( error == -1 )
return FT_Err_Ok;
@ -535,8 +623,35 @@
if ( !error )
{
error = FT_ERR( Invalid_Argument );
if ( service_mm->set_instance )
error = service_mm->set_instance( face, instance_index );
if ( service_mm->set_named_instance )
error = service_mm->set_named_instance( face, instance_index );
if ( !error || error == -1 )
{
FT_Bool is_variation_old = FT_IS_VARIATION( face );
face->face_flags &= ~FT_FACE_FLAG_VARIATION;
face->face_index = ( instance_index << 16 ) |
( face->face_index & 0xFFFFL );
if ( service_mm->construct_ps_name )
{
if ( error == -1 )
{
/* The PS name of a named instance and a non-named instance */
/* usually differs, even if the axis values are identical. */
if ( is_variation_old != FT_IS_VARIATION( face ) )
service_mm->construct_ps_name( face );
}
else
service_mm->construct_ps_name( face );
}
}
/* internal error code -1 means `no change'; we can exit immediately */
if ( error == -1 )
return FT_Err_Ok;
}
if ( !error )
@ -554,11 +669,32 @@
face->autohint.data = NULL;
}
return error;
}
/* documentation is in ftmm.h */
FT_EXPORT_DEF( FT_Error )
FT_Get_Default_Named_Instance( FT_Face face,
FT_UInt *instance_index )
{
FT_Error error;
FT_Service_MultiMasters service_mm = NULL;
/* check of `face' delayed to `ft_face_get_mm_service' */
error = ft_face_get_mm_service( face, &service_mm );
if ( !error )
{
face->face_index = ( instance_index << 16 ) |
( face->face_index & 0xFFFFL );
face->face_flags &= ~FT_FACE_FLAG_VARIATION;
/* no error if `get_default_named_instance` is not available */
if ( service_mm->get_default_named_instance )
error = service_mm->get_default_named_instance( face,
instance_index );
else
error = FT_Err_Ok;
}
return error;

23
thirdparty/freetype/src/base/ftobjs.c vendored
View file

@ -1019,7 +1019,8 @@
/* elegant. */
/* try to load SVG documents if available */
if ( FT_HAS_SVG( face ) )
if ( ( load_flags & FT_LOAD_NO_SVG ) == 0 &&
FT_HAS_SVG( face ) )
{
error = driver->clazz->load_glyph( slot, face->size,
glyph_index,
@ -1245,9 +1246,13 @@
/* destructor for sizes list */
static void
destroy_size( FT_Memory memory,
FT_Size size,
FT_Driver driver )
void* size_,
void* driver_ )
{
FT_Size size = (FT_Size)size_;
FT_Driver driver = (FT_Driver)driver_;
/* finalize client-specific data */
if ( size->generic.finalizer )
size->generic.finalizer( size );
@ -1293,10 +1298,12 @@
/* destructor for faces list */
static void
destroy_face( FT_Memory memory,
FT_Face face,
FT_Driver driver )
void* face_,
void* driver_ )
{
FT_Driver_Class clazz = driver->clazz;
FT_Face face = (FT_Face)face_;
FT_Driver driver = (FT_Driver)driver_;
FT_Driver_Class clazz = driver->clazz;
/* discard auto-hinting data */
@ -1310,7 +1317,7 @@
/* discard all sizes for this face */
FT_List_Finalize( &face->sizes_list,
(FT_List_Destructor)destroy_size,
destroy_size,
memory,
driver );
face->size = NULL;
@ -1346,7 +1353,7 @@
Destroy_Driver( FT_Driver driver )
{
FT_List_Finalize( &driver->faces_list,
(FT_List_Destructor)destroy_face,
destroy_face,
driver->root.memory,
driver );
}

52
thirdparty/freetype/src/base/ftoutln.c vendored
View file

@ -58,7 +58,9 @@
FT_Error error;
FT_Int n; /* index of contour in outline */
FT_UInt first; /* index of first point in contour */
FT_Int first; /* index of first point in contour */
FT_Int last; /* index of last point in contour */
FT_Int tag; /* current point's state */
FT_Int shift;
@ -73,18 +75,17 @@
shift = func_interface->shift;
delta = func_interface->delta;
first = 0;
last = -1;
for ( n = 0; n < outline->n_contours; n++ )
{
FT_Int last; /* index of last point in contour */
FT_TRACE5(( "FT_Outline_Decompose: Contour %d\n", n ));
FT_TRACE5(( "FT_Outline_Decompose: Outline %d\n", n ));
last = outline->contours[n];
if ( last < 0 )
first = last + 1;
last = outline->contours[n];
if ( last < first )
goto Invalid_Outline;
limit = outline->points + last;
v_start = outline->points[first];
@ -282,8 +283,6 @@
Close:
if ( error )
goto Exit;
first = (FT_UInt)last + 1;
}
FT_TRACE5(( "FT_Outline_Decompose: Done\n" ));
@ -368,7 +367,7 @@
if ( n_points <= 0 || n_contours <= 0 )
goto Bad;
end0 = end = -1;
end0 = -1;
for ( n = 0; n < n_contours; n++ )
{
end = outline->contours[n];
@ -380,7 +379,7 @@
end0 = end;
}
if ( end != n_points - 1 )
if ( end0 != n_points - 1 )
goto Bad;
/* XXX: check the tags array */
@ -388,7 +387,7 @@
}
Bad:
return FT_THROW( Invalid_Argument );
return FT_THROW( Invalid_Outline );
}
@ -550,10 +549,12 @@
if ( !outline )
return;
first = 0;
last = -1;
for ( n = 0; n < outline->n_contours; n++ )
{
/* keep the first contour point as is and swap points around it */
/* to guarantee that the cubic arches stay valid after reverse */
first = last + 2;
last = outline->contours[n];
/* reverse point table */
@ -591,8 +592,6 @@
q--;
}
}
first = last + 1;
}
outline->flags ^= FT_OUTLINE_REVERSE_FILL;
@ -941,7 +940,7 @@
points = outline->points;
first = 0;
last = -1;
for ( c = 0; c < outline->n_contours; c++ )
{
FT_Vector in, out, anchor, shift;
@ -949,8 +948,9 @@
FT_Int i, j, k;
l_in = 0;
last = outline->contours[c];
first = last + 1;
last = outline->contours[c];
l_in = 0;
/* pacify compiler */
in.x = in.y = anchor.x = anchor.y = 0;
@ -1037,8 +1037,6 @@
in = out;
l_in = l_out;
}
first = last + 1;
}
return FT_Err_Ok;
@ -1054,7 +1052,7 @@
FT_Int xshift, yshift;
FT_Vector* points;
FT_Vector v_prev, v_cur;
FT_Int c, n, first;
FT_Int c, n, first, last;
FT_Pos area = 0;
@ -1086,11 +1084,11 @@
points = outline->points;
first = 0;
last = -1;
for ( c = 0; c < outline->n_contours; c++ )
{
FT_Int last = outline->contours[c];
first = last + 1;
last = outline->contours[c];
v_prev.x = points[last].x >> xshift;
v_prev.y = points[last].y >> yshift;
@ -1106,8 +1104,6 @@
v_prev = v_cur;
}
first = last + 1;
}
if ( area > 0 )

21
thirdparty/freetype/src/base/ftstroke.c vendored
View file

@ -2055,7 +2055,9 @@
FT_Error error;
FT_Int n; /* index of contour in outline */
FT_UInt first; /* index of first point in contour */
FT_Int first; /* index of first point in contour */
FT_Int last; /* index of last point in contour */
FT_Int tag; /* current point's state */
@ -2067,22 +2069,17 @@
FT_Stroker_Rewind( stroker );
first = 0;
last = -1;
for ( n = 0; n < outline->n_contours; n++ )
{
FT_UInt last; /* index of last point in contour */
last = (FT_UInt)outline->contours[n];
limit = outline->points + last;
first = last + 1;
last = outline->contours[n];
/* skip empty points; we don't stroke these */
if ( last <= first )
{
first = last + 1;
continue;
}
limit = outline->points + last;
v_start = outline->points[first];
v_last = outline->points[last];
@ -2231,8 +2228,6 @@
if ( error )
goto Exit;
}
first = last + 1;
}
return FT_Err_Ok;

20
thirdparty/freetype/src/base/ftsynth.c vendored
View file

@ -97,9 +97,18 @@
FT_EXPORT_DEF( void )
FT_GlyphSlot_Embolden( FT_GlyphSlot slot )
{
FT_GlyphSlot_AdjustWeight( slot, 0x0AAA, 0x0AAA );
}
FT_EXPORT_DEF( void )
FT_GlyphSlot_AdjustWeight( FT_GlyphSlot slot,
FT_Fixed xdelta,
FT_Fixed ydelta )
{
FT_Library library;
FT_Face face;
FT_Size size;
FT_Error error;
FT_Pos xstr, ystr;
@ -108,16 +117,15 @@
return;
library = slot->library;
face = slot->face;
size = slot->face->size;
if ( slot->format != FT_GLYPH_FORMAT_OUTLINE &&
slot->format != FT_GLYPH_FORMAT_BITMAP )
return;
/* some reasonable strength */
xstr = FT_MulFix( face->units_per_EM,
face->size->metrics.y_scale ) / 24;
ystr = xstr;
/* express deltas in pixels in 26.6 format */
xstr = (FT_Pos)size->metrics.x_ppem * xdelta / 1024;
ystr = (FT_Pos)size->metrics.y_ppem * ydelta / 1024;
if ( slot->format == FT_GLYPH_FORMAT_OUTLINE )
FT_Outline_EmboldenXY( &slot->outline, xstr, ystr );

9
thirdparty/freetype/src/base/ftsystem.c vendored
View file

@ -206,7 +206,7 @@
* The number of bytes to read from the stream.
*
* @Return:
* The number of bytes actually read. If `count' is zero (this is,
* The number of bytes actually read. If `count' is zero (that is,
* the function is used for seeking), a non-zero return value
* indicates an error.
*/
@ -219,7 +219,7 @@
FT_FILE* file;
if ( !count && offset > stream->size )
if ( offset > stream->size && !count )
return 1;
file = STREAM_FILE( stream );
@ -227,6 +227,11 @@
if ( stream->pos != offset )
ft_fseek( file, (long)offset, SEEK_SET );
/* Avoid calling `fread` with `buffer=NULL` and `count=0`, */
/* which is undefined behaviour. */
if ( !count )
return 0;
return (unsigned long)ft_fread( buffer, 1, count, file );
}

4
thirdparty/freetype/src/bdf/bdf.h vendored
View file

@ -239,10 +239,6 @@ FT_BEGIN_HEADER
FT_LOCAL( void )
bdf_free_font( bdf_font_t* font );
FT_LOCAL( bdf_property_t * )
bdf_get_property( char* name,
bdf_font_t* font );
FT_LOCAL( bdf_property_t * )
bdf_get_font_property( bdf_font_t* font,
const char* name );

116
thirdparty/freetype/src/bdf/bdfdrivr.c vendored
View file

@ -311,9 +311,9 @@ THE SOFTWARE.
FT_CALLBACK_DEF( void )
BDF_Face_Done( FT_Face bdfface ) /* BDF_Face */
BDF_Face_Done( FT_Face face ) /* BDF_Face */
{
BDF_Face face = (BDF_Face)bdfface;
BDF_Face bdfface = (BDF_Face)face;
FT_Memory memory;
@ -322,31 +322,31 @@ THE SOFTWARE.
memory = FT_FACE_MEMORY( face );
bdf_free_font( face->bdffont );
bdf_free_font( bdfface->bdffont );
FT_FREE( face->en_table );
FT_FREE( bdfface->en_table );
FT_FREE( face->charset_encoding );
FT_FREE( face->charset_registry );
FT_FREE( bdfface->family_name );
FT_FREE( bdfface->style_name );
FT_FREE( bdfface->charset_encoding );
FT_FREE( bdfface->charset_registry );
FT_FREE( face->family_name );
FT_FREE( face->style_name );
FT_FREE( bdfface->available_sizes );
FT_FREE( face->available_sizes );
FT_FREE( face->bdffont );
FT_FREE( bdfface->bdffont );
}
FT_CALLBACK_DEF( FT_Error )
BDF_Face_Init( FT_Stream stream,
FT_Face bdfface, /* BDF_Face */
FT_Face face, /* BDF_Face */
FT_Int face_index,
FT_Int num_params,
FT_Parameter* params )
{
FT_Error error = FT_Err_Ok;
BDF_Face face = (BDF_Face)bdfface;
FT_Memory memory = FT_FACE_MEMORY( face );
FT_Error error = FT_Err_Ok;
BDF_Face bdfface = (BDF_Face)face;
FT_Memory memory = FT_FACE_MEMORY( face );
bdf_font_t* font = NULL;
bdf_options_t options;
@ -375,7 +375,7 @@ THE SOFTWARE.
goto Exit;
/* we have a bdf font: let's construct the face object */
face->bdffont = font;
bdfface->bdffont = font;
/* BDF cannot have multiple faces in a single font file.
* XXX: non-zero face_index is already invalid argument, but
@ -386,7 +386,7 @@ THE SOFTWARE.
if ( face_index > 0 && ( face_index & 0xFFFF ) > 0 )
{
FT_ERROR(( "BDF_Face_Init: invalid face index\n" ));
BDF_Face_Done( bdfface );
BDF_Face_Done( face );
return FT_THROW( Invalid_Argument );
}
@ -401,18 +401,18 @@ THE SOFTWARE.
font->unencoded_size,
font->unencoded_used ));
bdfface->num_faces = 1;
bdfface->face_index = 0;
face->num_faces = 1;
face->face_index = 0;
bdfface->face_flags |= FT_FACE_FLAG_FIXED_SIZES |
FT_FACE_FLAG_HORIZONTAL;
face->face_flags |= FT_FACE_FLAG_FIXED_SIZES |
FT_FACE_FLAG_HORIZONTAL;
prop = bdf_get_font_property( font, "SPACING" );
if ( prop && prop->format == BDF_ATOM &&
prop->value.atom &&
( *(prop->value.atom) == 'M' || *(prop->value.atom) == 'm' ||
*(prop->value.atom) == 'C' || *(prop->value.atom) == 'c' ) )
bdfface->face_flags |= FT_FACE_FLAG_FIXED_WIDTH;
face->face_flags |= FT_FACE_FLAG_FIXED_WIDTH;
/* FZ XXX: TO DO: FT_FACE_FLAGS_VERTICAL */
/* FZ XXX: I need a font to implement this */
@ -420,26 +420,27 @@ THE SOFTWARE.
prop = bdf_get_font_property( font, "FAMILY_NAME" );
if ( prop && prop->value.atom )
{
if ( FT_STRDUP( bdfface->family_name, prop->value.atom ) )
if ( FT_STRDUP( face->family_name, prop->value.atom ) )
goto Exit;
}
else
bdfface->family_name = NULL;
face->family_name = NULL;
if ( FT_SET_ERROR( bdf_interpret_style( face ) ) )
if ( FT_SET_ERROR( bdf_interpret_style( bdfface ) ) )
goto Exit;
/* the number of glyphs (with one slot for the undefined glyph */
/* at position 0 and all unencoded glyphs) */
bdfface->num_glyphs = (FT_Long)( font->glyphs_size + 1 );
face->num_glyphs = (FT_Long)( font->glyphs_size + 1 );
bdfface->num_fixed_sizes = 1;
if ( FT_NEW( bdfface->available_sizes ) )
face->num_fixed_sizes = 1;
if ( FT_NEW( face->available_sizes ) )
goto Exit;
{
FT_Bitmap_Size* bsize = bdfface->available_sizes;
FT_Short resolution_x = 0, resolution_y = 0;
FT_Bitmap_Size* bsize = face->available_sizes;
FT_Short resolution_x = 0;
FT_Short resolution_y = 0;
long value;
@ -598,20 +599,20 @@ THE SOFTWARE.
unsigned long n;
if ( FT_QNEW_ARRAY( face->en_table, font->glyphs_size ) )
if ( FT_QNEW_ARRAY( bdfface->en_table, font->glyphs_size ) )
goto Exit;
face->default_glyph = 0;
bdfface->default_glyph = 0;
for ( n = 0; n < font->glyphs_size; n++ )
{
(face->en_table[n]).enc = cur[n].encoding;
(bdfface->en_table[n]).enc = cur[n].encoding;
FT_TRACE4(( " idx %ld, val 0x%lX\n", n, cur[n].encoding ));
(face->en_table[n]).glyph = (FT_UShort)n;
(bdfface->en_table[n]).glyph = (FT_UShort)n;
if ( cur[n].encoding == font->default_char )
{
if ( n < FT_UINT_MAX )
face->default_glyph = (FT_UInt)n;
bdfface->default_glyph = (FT_UInt)n;
else
FT_TRACE1(( "BDF_Face_Init:"
" idx %ld is too large for this system\n", n ));
@ -639,27 +640,27 @@ THE SOFTWARE.
const char* s;
if ( FT_STRDUP( face->charset_encoding,
if ( FT_STRDUP( bdfface->charset_encoding,
charset_encoding->value.atom ) ||
FT_STRDUP( face->charset_registry,
FT_STRDUP( bdfface->charset_registry,
charset_registry->value.atom ) )
goto Exit;
/* Uh, oh, compare first letters manually to avoid dependency */
/* on locales. */
s = face->charset_registry;
s = bdfface->charset_registry;
if ( ( s[0] == 'i' || s[0] == 'I' ) &&
( s[1] == 's' || s[1] == 'S' ) &&
( s[2] == 'o' || s[2] == 'O' ) )
{
s += 3;
if ( !ft_strcmp( s, "10646" ) ||
( !ft_strcmp( s, "8859" ) &&
!ft_strcmp( face->charset_encoding, "1" ) ) )
if ( !ft_strcmp( s, "10646" ) ||
( !ft_strcmp( s, "8859" ) &&
!ft_strcmp( bdfface->charset_encoding, "1" ) ) )
unicode_charmap = 1;
/* another name for ASCII */
else if ( !ft_strcmp( s, "646.1991" ) &&
!ft_strcmp( face->charset_encoding, "IRV" ) )
else if ( !ft_strcmp( s, "646.1991" ) &&
!ft_strcmp( bdfface->charset_encoding, "IRV" ) )
unicode_charmap = 1;
}
@ -667,7 +668,7 @@ THE SOFTWARE.
FT_CharMapRec charmap;
charmap.face = FT_FACE( face );
charmap.face = face;
charmap.encoding = FT_ENCODING_NONE;
/* initial platform/encoding should indicate unset status? */
charmap.platform_id = TT_PLATFORM_APPLE_UNICODE;
@ -693,7 +694,7 @@ THE SOFTWARE.
FT_CharMapRec charmap;
charmap.face = FT_FACE( face );
charmap.face = face;
charmap.encoding = FT_ENCODING_ADOBE_STANDARD;
charmap.platform_id = TT_PLATFORM_ADOBE;
charmap.encoding_id = TT_ADOBE_ID_STANDARD;
@ -701,8 +702,8 @@ THE SOFTWARE.
error = FT_CMap_New( &bdf_cmap_class, NULL, &charmap, NULL );
/* Select default charmap */
if ( bdfface->num_charmaps )
bdfface->charmap = bdfface->charmaps[0];
if ( face->num_charmaps )
face->charmap = face->charmaps[0];
}
}
}
@ -711,7 +712,7 @@ THE SOFTWARE.
return error;
Fail:
BDF_Face_Done( bdfface );
BDF_Face_Done( face );
return FT_THROW( Unknown_File_Format );
}
@ -868,17 +869,18 @@ THE SOFTWARE.
*
*/
static FT_Error
bdf_get_bdf_property( BDF_Face face,
FT_CALLBACK_DEF( FT_Error )
bdf_get_bdf_property( FT_Face face, /* BDF_Face */
const char* prop_name,
BDF_PropertyRec *aproperty )
{
BDF_Face bdfface = (BDF_Face)face;
bdf_property_t* prop;
FT_ASSERT( face && face->bdffont );
FT_ASSERT( bdfface && bdfface->bdffont );
prop = bdf_get_font_property( face->bdffont, prop_name );
prop = bdf_get_font_property( bdfface->bdffont, prop_name );
if ( prop )
{
switch ( prop->format )
@ -921,13 +923,16 @@ THE SOFTWARE.
}
static FT_Error
bdf_get_charset_id( BDF_Face face,
FT_CALLBACK_DEF( FT_Error )
bdf_get_charset_id( FT_Face face, /* BDF_Face */
const char* *acharset_encoding,
const char* *acharset_registry )
{
*acharset_encoding = face->charset_encoding;
*acharset_registry = face->charset_registry;
BDF_Face bdfface = (BDF_Face)face;
*acharset_encoding = bdfface->charset_encoding;
*acharset_registry = bdfface->charset_registry;
return 0;
}
@ -964,7 +969,6 @@ THE SOFTWARE.
}
FT_CALLBACK_TABLE_DEF
const FT_Driver_ClassRec bdf_driver_class =
{

67
thirdparty/freetype/src/bdf/bdflib.c vendored
View file

@ -51,6 +51,9 @@
#define FT_COMPONENT bdflib
#define BUFSIZE 128
/**************************************************************************
*
* Default BDF font options.
@ -378,7 +381,7 @@
*alen = 0;
if ( list == NULL || list->used == 0 )
return 0;
return NULL;
dp = list->field[0];
for ( i = j = 0; i < list->used; i++ )
@ -887,18 +890,18 @@
}
FT_LOCAL_DEF( bdf_property_t* )
bdf_get_property( char* name,
static bdf_property_t*
bdf_get_property( const char* name,
bdf_font_t* font )
{
size_t* propid;
if ( name == NULL || *name == 0 )
return 0;
return NULL;
if ( ( propid = ft_hash_str_lookup( name, &(font->proptbl) ) ) == NULL )
return 0;
return NULL;
if ( *propid >= num_bdf_properties_ )
return font->user_props + ( *propid - num_bdf_properties_ );
@ -944,7 +947,7 @@
static FT_Error
bdf_add_comment_( bdf_font_t* font,
char* comment,
const char* comment,
unsigned long len )
{
char* cp;
@ -1053,27 +1056,24 @@
bdf_property_t* p;
*name = sp = ep = line;
sp = ep = line;
while ( *ep && *ep != ' ' && *ep != '\t' )
ep++;
hold = -1;
if ( *ep )
{
hold = *ep;
*ep = 0;
}
hold = *ep;
*ep = '\0';
p = bdf_get_property( sp, font );
/* Restore the character that was saved before any return can happen. */
if ( hold != -1 )
*ep = (char)hold;
/* If the property exists and is not an atom, just return here. */
if ( p && p->format != BDF_ATOM )
{
*ep = (char)hold; /* Undo NUL-termination. */
return 0;
}
*name = sp;
/* The property is an atom. Trim all leading and trailing whitespace */
/* and double quotes for the atom value. */
@ -1081,25 +1081,26 @@
ep = line + linelen;
/* Trim the leading whitespace if it exists. */
if ( *sp )
*sp++ = 0;
while ( *sp &&
( *sp == ' ' || *sp == '\t' ) )
sp++;
if ( sp < ep )
do
sp++;
while ( *sp == ' ' || *sp == '\t' );
/* Trim the leading double quote if it exists. */
if ( *sp == '"' )
sp++;
*value = sp;
/* Trim the trailing whitespace if it exists. */
while ( ep > sp &&
( *( ep - 1 ) == ' ' || *( ep - 1 ) == '\t' ) )
*--ep = 0;
if ( sp < ep )
do
*ep-- = '\0';
while ( *ep == ' ' || *ep == '\t' );
/* Trim the trailing double quote if it exists. */
if ( ep > sp && *( ep - 1 ) == '"' )
*--ep = 0;
if ( *ep == '"' )
*ep = '\0';
return 1;
}
@ -1775,7 +1776,7 @@
bdf_parse_t_* p;
char* name;
char* value;
char nbuf[128];
char nbuf[BUFSIZE];
FT_Error error = FT_Err_Ok;
FT_UNUSED( lineno );
@ -1796,7 +1797,7 @@
if ( bdf_get_font_property( p->font, "FONT_ASCENT" ) == 0 )
{
p->font->font_ascent = p->font->bbx.ascent;
ft_sprintf( nbuf, "%hd", p->font->bbx.ascent );
ft_snprintf( nbuf, BUFSIZE, "%hd", p->font->bbx.ascent );
error = bdf_add_property_( p->font, "FONT_ASCENT",
nbuf, lineno );
if ( error )
@ -1808,7 +1809,7 @@
if ( bdf_get_font_property( p->font, "FONT_DESCENT" ) == 0 )
{
p->font->font_descent = p->font->bbx.descent;
ft_sprintf( nbuf, "%hd", p->font->bbx.descent );
ft_snprintf( nbuf, BUFSIZE, "%hd", p->font->bbx.descent );
error = bdf_add_property_( p->font, "FONT_DESCENT",
nbuf, lineno );
if ( error )
@ -2116,7 +2117,7 @@
/* Check for the CHARS field -- font properties are optional */
if ( _bdf_strncmp( line, "CHARS", 5 ) == 0 )
{
char nbuf[128];
char nbuf[BUFSIZE];
if ( !( p->flags & BDF_FONT_BBX_ ) )
@ -2130,7 +2131,7 @@
/* Add the two standard X11 properties which are required */
/* for compiling fonts. */
p->font->font_ascent = p->font->bbx.ascent;
ft_sprintf( nbuf, "%hd", p->font->bbx.ascent );
ft_snprintf( nbuf, BUFSIZE, "%hd", p->font->bbx.ascent );
error = bdf_add_property_( p->font, "FONT_ASCENT",
nbuf, lineno );
if ( error )
@ -2138,7 +2139,7 @@
FT_TRACE2(( "bdf_parse_properties_: " ACMSG1, p->font->bbx.ascent ));
p->font->font_descent = p->font->bbx.descent;
ft_sprintf( nbuf, "%hd", p->font->bbx.descent );
ft_snprintf( nbuf, BUFSIZE, "%hd", p->font->bbx.descent );
error = bdf_add_property_( p->font, "FONT_DESCENT",
nbuf, lineno );
if ( error )

19
thirdparty/freetype/src/bzip2/ftbzip2.c vendored
View file

@ -62,10 +62,12 @@
static void*
ft_bzip2_alloc( FT_Memory memory,
int items,
int size )
ft_bzip2_alloc( void* memory_, /* FT_Memory */
int items,
int size )
{
FT_Memory memory = (FT_Memory)memory_;
FT_ULong sz = (FT_ULong)size * (FT_ULong)items;
FT_Error error;
FT_Pointer p = NULL;
@ -77,9 +79,12 @@
static void
ft_bzip2_free( FT_Memory memory,
void* address )
ft_bzip2_free( void* memory_, /* FT_Memory */
void* address )
{
FT_Memory memory = (FT_Memory)memory_;
FT_MEM_FREE( address );
}
@ -170,8 +175,8 @@
}
/* initialize bzlib */
bzstream->bzalloc = (alloc_func)ft_bzip2_alloc;
bzstream->bzfree = (free_func) ft_bzip2_free;
bzstream->bzalloc = ft_bzip2_alloc;
bzstream->bzfree = ft_bzip2_free;
bzstream->opaque = zip->memory;
bzstream->avail_in = 0;

8
thirdparty/freetype/src/cache/ftcbasic.c vendored
View file

@ -337,7 +337,7 @@
#if 1 /* inlining is about 50% faster! */
FTC_GCACHE_LOOKUP_CMP( cache,
ftc_basic_family_compare,
FTC_GNode_Compare,
ftc_gnode_compare,
hash, gindex,
&query,
node,
@ -411,7 +411,7 @@
FTC_GCACHE_LOOKUP_CMP( cache,
ftc_basic_family_compare,
FTC_GNode_Compare,
ftc_gnode_compare,
hash, gindex,
&query,
node,
@ -537,7 +537,7 @@
#if 1 /* inlining is about 50% faster! */
FTC_GCACHE_LOOKUP_CMP( cache,
ftc_basic_family_compare,
FTC_SNode_Compare,
ftc_snode_compare,
hash, gindex,
&query,
node,
@ -613,7 +613,7 @@
FTC_GCACHE_LOOKUP_CMP( cache,
ftc_basic_family_compare,
FTC_SNode_Compare,
ftc_snode_compare,
hash, gindex,
&query,
node,

125
thirdparty/freetype/src/cache/ftccache.c vendored
View file

@ -94,8 +94,8 @@
idx = hash & cache->mask;
if ( idx < cache->p )
idx = hash & ( 2 * cache->mask + 1 );
if ( idx >= cache->p )
idx = hash & ( cache->mask >> 1 );
return cache->buckets + idx;
}
@ -113,9 +113,9 @@
for (;;)
{
FTC_Node node, *pnode;
FT_UFast p = cache->p;
FT_UFast mask = cache->mask;
FT_UFast count = mask + p + 1; /* number of buckets */
FT_UFast p = cache->p;
FT_UFast size = cache->mask + 1; /* available size */
FT_UFast half = size >> 1;
/* do we need to expand the buckets array? */
@ -127,20 +127,22 @@
/* try to expand the buckets array _before_ splitting
* the bucket lists
*/
if ( p >= mask )
if ( p == size )
{
FT_Memory memory = cache->memory;
FT_Error error;
/* if we can't expand the array, leave immediately */
if ( FT_RENEW_ARRAY( cache->buckets,
( mask + 1 ) * 2, ( mask + 1 ) * 4 ) )
if ( FT_QRENEW_ARRAY( cache->buckets, size, size * 2 ) )
break;
cache->mask = 2 * size - 1;
half = size;
}
/* split a single bucket */
pnode = cache->buckets + p;
/* the bucket to split */
pnode = cache->buckets + p - half;
for (;;)
{
@ -148,7 +150,7 @@
if ( !node )
break;
if ( node->hash & ( mask + 1 ) )
if ( node->hash & half )
{
*pnode = node->link;
node->link = new_list;
@ -158,56 +160,50 @@
pnode = &node->link;
}
cache->buckets[p + mask + 1] = new_list;
cache->buckets[p] = new_list;
cache->slack += FTC_HASH_MAX_LOAD;
cache->p = p + 1;
if ( p >= mask )
{
cache->mask = 2 * mask + 1;
cache->p = 0;
}
else
cache->p = p + 1;
FT_TRACE2(( "ftc_cache_resize: cache %u increased to %u hashes\n",
cache->index, cache->p ));
}
/* do we need to shrink the buckets array? */
else if ( cache->slack > (FT_Long)count * FTC_HASH_SUB_LOAD )
else if ( cache->slack > (FT_Long)p * FTC_HASH_SUB_LOAD )
{
FT_UFast old_index = p + mask;
FTC_Node* pold;
FTC_Node old_list = cache->buckets[--p];
if ( old_index + 1 <= FTC_HASH_INITIAL_SIZE )
if ( p < FTC_HASH_INITIAL_SIZE )
break;
if ( p == 0 )
if ( p == half )
{
FT_Memory memory = cache->memory;
FT_Error error;
/* if we can't shrink the array, leave immediately */
if ( FT_QRENEW_ARRAY( cache->buckets,
( mask + 1 ) * 2, mask + 1 ) )
if ( FT_QRENEW_ARRAY( cache->buckets, size, half ) )
break;
cache->mask >>= 1;
p = cache->mask;
cache->mask = half - 1;
}
else
p--;
pnode = cache->buckets + p;
/* the bucket to merge */
pnode = cache->buckets + p - half;
while ( *pnode )
pnode = &(*pnode)->link;
pold = cache->buckets + old_index;
*pnode = *pold;
*pold = NULL;
*pnode = old_list;
cache->slack -= FTC_HASH_MAX_LOAD;
cache->p = p;
FT_TRACE2(( "ftc_cache_resize: cache %u decreased to %u hashes\n",
cache->index, cache->p ));
}
/* otherwise, the hash table is balanced */
@ -239,7 +235,7 @@
if ( node == node0 )
break;
pnode = &(*pnode)->link;
pnode = &node->link;
}
*pnode = node0->link;
@ -322,13 +318,6 @@
/*************************************************************************/
FT_LOCAL_DEF( FT_Error )
FTC_Cache_Init( FTC_Cache cache )
{
return ftc_cache_init( cache );
}
FT_LOCAL_DEF( FT_Error )
ftc_cache_init( FTC_Cache cache )
{
@ -336,27 +325,35 @@
FT_Error error;
cache->p = 0;
cache->p = FTC_HASH_INITIAL_SIZE;
cache->mask = FTC_HASH_INITIAL_SIZE - 1;
cache->slack = FTC_HASH_INITIAL_SIZE * FTC_HASH_MAX_LOAD;
FT_MEM_NEW_ARRAY( cache->buckets, FTC_HASH_INITIAL_SIZE * 2 );
FT_MEM_NEW_ARRAY( cache->buckets, FTC_HASH_INITIAL_SIZE );
return error;
}
static void
FTC_Cache_Clear( FTC_Cache cache )
FT_LOCAL_DEF( FT_Error )
FTC_Cache_Init( FTC_Cache cache )
{
if ( cache && cache->buckets )
return ftc_cache_init( cache );
}
FT_LOCAL_DEF( void )
ftc_cache_done( FTC_Cache cache )
{
FT_Memory memory = cache->memory;
if ( cache->buckets )
{
FTC_Manager manager = cache->manager;
FT_UFast count = cache->p;
FT_UFast i;
FT_UFast count;
count = cache->p + cache->mask + 1;
for ( i = 0; i < count; i++ )
{
FTC_Node node = cache->buckets[i], next;
@ -376,30 +373,14 @@
cache->clazz.node_free( node, cache );
node = next;
}
cache->buckets[i] = NULL;
}
ftc_cache_resize( cache );
}
}
FT_FREE( cache->buckets );
FT_LOCAL_DEF( void )
ftc_cache_done( FTC_Cache cache )
{
if ( cache->memory )
{
FT_Memory memory = cache->memory;
FTC_Cache_Clear( cache );
FT_FREE( cache->buckets );
cache->mask = 0;
cache->p = 0;
cache->slack = 0;
cache->memory = NULL;
}
cache->p = 0;
cache->mask = 0;
cache->slack = 0;
}
@ -562,12 +543,12 @@
FTC_Cache_RemoveFaceID( FTC_Cache cache,
FTC_FaceID face_id )
{
FT_UFast i, count;
FTC_Manager manager = cache->manager;
FTC_Node frees = NULL;
FT_UFast count = cache->p;
FT_UFast i;
count = cache->p + cache->mask + 1;
for ( i = 0; i < count; i++ )
{
FTC_Node* pnode = cache->buckets + i;

17
thirdparty/freetype/src/cache/ftccache.h vendored
View file

@ -72,11 +72,12 @@ FT_BEGIN_HEADER
#define FTC_NODE_NEXT( x ) FTC_NODE( (x)->mru.next )
#define FTC_NODE_PREV( x ) FTC_NODE( (x)->mru.prev )
/* address the hash table entries */
#ifdef FTC_INLINE
#define FTC_NODE_TOP_FOR_HASH( cache, hash ) \
( ( cache )->buckets + \
( ( ( ( hash ) & ( cache )->mask ) < ( cache )->p ) \
? ( ( hash ) & ( ( cache )->mask * 2 + 1 ) ) \
#define FTC_NODE_TOP_FOR_HASH( cache, hash ) \
( ( cache )->buckets + \
( ( ( ( hash ) & ( cache )->mask ) >= ( cache )->p ) \
? ( ( hash ) & ( ( cache )->mask >> 1 ) ) \
: ( ( hash ) & ( cache )->mask ) ) )
#else
FT_LOCAL( FTC_Node* )
@ -139,11 +140,13 @@ FT_BEGIN_HEADER
} FTC_CacheClassRec;
/* each cache really implements a dynamic hash table to manage its nodes */
/* each cache really implements a hash table to manage its nodes */
/* the number of the table entries (buckets) can change dynamically */
/* each bucket contains a linked lists of nodes for a given hash */
typedef struct FTC_CacheRec_
{
FT_UFast p;
FT_UFast mask;
FT_UFast p; /* hash table counter */
FT_UFast mask; /* hash table index range */
FT_Long slack;
FTC_Node* buckets;

46
thirdparty/freetype/src/cache/ftcglyph.c vendored
View file

@ -79,20 +79,6 @@
}
#ifdef FTC_INLINE
FT_LOCAL_DEF( FT_Bool )
FTC_GNode_Compare( FTC_GNode gnode,
FTC_GQuery gquery,
FTC_Cache cache,
FT_Bool* list_changed )
{
return ftc_gnode_compare( FTC_NODE( gnode ), gquery,
cache, list_changed );
}
#endif
/*************************************************************************/
/*************************************************************************/
/***** *****/
@ -115,22 +101,22 @@
FT_LOCAL_DEF( FT_Error )
ftc_gcache_init( FTC_Cache ftccache )
ftc_gcache_init( FTC_Cache cache )
{
FTC_GCache cache = (FTC_GCache)ftccache;
FTC_GCache gcache = (FTC_GCache)cache;
FT_Error error;
error = FTC_Cache_Init( FTC_CACHE( cache ) );
error = FTC_Cache_Init( cache );
if ( !error )
{
FTC_GCacheClass clazz = (FTC_GCacheClass)FTC_CACHE( cache )->org_class;
FTC_GCacheClass clazz = (FTC_GCacheClass)cache->org_class;
FTC_MruList_Init( &cache->families,
FTC_MruList_Init( &gcache->families,
clazz->family_class,
0, /* no maximum here! */
cache,
FTC_CACHE( cache )->memory );
cache->memory );
}
return error;
@ -140,31 +126,31 @@
#if 0
FT_LOCAL_DEF( FT_Error )
FTC_GCache_Init( FTC_GCache cache )
FTC_GCache_Init( FTC_GCache gcache )
{
return ftc_gcache_init( FTC_CACHE( cache ) );
return ftc_gcache_init( FTC_CACHE( gcache ) );
}
#endif /* 0 */
FT_LOCAL_DEF( void )
ftc_gcache_done( FTC_Cache ftccache )
ftc_gcache_done( FTC_Cache cache )
{
FTC_GCache cache = (FTC_GCache)ftccache;
FTC_GCache gcache = (FTC_GCache)cache;
FTC_Cache_Done( (FTC_Cache)cache );
FTC_MruList_Done( &cache->families );
FTC_Cache_Done( cache );
FTC_MruList_Done( &gcache->families );
}
#if 0
FT_LOCAL_DEF( void )
FTC_GCache_Done( FTC_GCache cache )
FTC_GCache_Done( FTC_GCache gcache )
{
ftc_gcache_done( FTC_CACHE( cache ) );
ftc_gcache_done( FTC_CACHE( gcache ) );
}
#endif /* 0 */
@ -183,7 +169,7 @@
#ifndef FTC_INLINE
FT_LOCAL_DEF( FT_Error )
FTC_GCache_Lookup( FTC_GCache cache,
FTC_GCache_Lookup( FTC_GCache gcache,
FT_Offset hash,
FT_UInt gindex,
FTC_GQuery query,
@ -204,7 +190,7 @@
/* out-of-memory condition occurs during glyph node initialization. */
family->num_nodes++;
error = FTC_Cache_Lookup( FTC_CACHE( cache ), hash, query, anode );
error = FTC_Cache_Lookup( FTC_CACHE( gcache ), hash, query, anode );
if ( --family->num_nodes == 0 )
FTC_FAMILY_FREE( family, cache );

15
thirdparty/freetype/src/cache/ftcglyph.h vendored
View file

@ -58,7 +58,7 @@
* - FTC_GNode sub-class, e.g. MyNode, with relevant methods:
* my_node_new (must call FTC_GNode_Init)
* my_node_free (must call FTC_GNode_Done)
* my_node_compare (must call FTC_GNode_Compare)
* my_node_compare (must call ftc_gnode_compare)
* my_node_remove_faceid (must call ftc_gnode_unselect in case
* of match)
*
@ -179,19 +179,6 @@ FT_BEGIN_HEADER
FT_UInt gindex, /* glyph index for node */
FTC_Family family );
#ifdef FTC_INLINE
/* returns TRUE iff the query's glyph index correspond to the node; */
/* this assumes that the `family' and `hash' fields of the query are */
/* already correctly set */
FT_LOCAL( FT_Bool )
FTC_GNode_Compare( FTC_GNode gnode,
FTC_GQuery gquery,
FTC_Cache cache,
FT_Bool* list_changed );
#endif
/* call this function to clear a node's family -- this is necessary */
/* to implement the `node_remove_faceid' cache method correctly */
FT_LOCAL( void )

42
thirdparty/freetype/src/cache/ftcmanag.c vendored
View file

@ -426,7 +426,7 @@
memory = manager->memory;
/* now discard all caches */
for (idx = manager->num_caches; idx-- > 0; )
for ( idx = manager->num_caches; idx-- > 0; )
{
FTC_Cache cache = manager->caches[idx];
@ -537,7 +537,7 @@
FT_LOCAL_DEF( void )
FTC_Manager_Compress( FTC_Manager manager )
{
FTC_Node node, first;
FTC_Node node, prev, first;
if ( !manager )
@ -557,20 +557,16 @@
return;
/* go to last node -- it's a circular list */
node = FTC_NODE_PREV( first );
prev = FTC_NODE_PREV( first );
do
{
FTC_Node prev;
prev = ( node == first ) ? NULL : FTC_NODE_PREV( node );
node = prev;
prev = FTC_NODE_PREV( node );
if ( node->ref_count <= 0 )
ftc_node_destroy( node, manager );
node = prev;
} while ( node && manager->cur_weight > manager->max_weight );
} while ( node != first && manager->cur_weight > manager->max_weight );
}
@ -633,20 +629,20 @@
FT_UInt count )
{
FTC_Node first = manager->nodes_list;
FTC_Node node;
FT_UInt result;
FTC_Node prev, node;
FT_UInt result = 0;
/* try to remove `count' nodes from the list */
if ( !first ) /* empty list! */
return 0;
if ( !first || !count )
return result;
/* go to last node - it's a circular list */
node = FTC_NODE_PREV(first);
for ( result = 0; result < count; )
/* go to last node -- it's a circular list */
prev = FTC_NODE_PREV( first );
do
{
FTC_Node prev = FTC_NODE_PREV( node );
node = prev;
prev = FTC_NODE_PREV( node );
/* don't touch locked nodes */
if ( node->ref_count <= 0 )
@ -654,13 +650,9 @@
ftc_node_destroy( node, manager );
result++;
}
} while ( node != first && result < count );
if ( node == first )
break;
node = prev;
}
return result;
return result;
}

30
thirdparty/freetype/src/cache/ftcmru.c vendored
View file

@ -329,29 +329,23 @@
FTC_MruNode_CompareFunc selection,
FT_Pointer key )
{
FTC_MruNode first, node, next;
FTC_MruNode first = list->nodes;
FTC_MruNode prev, node;
first = list->nodes;
while ( first && ( !selection || selection( first, key ) ) )
if ( !first || !selection )
return;
prev = first->prev;
do
{
FTC_MruList_Remove( list, first );
first = list->nodes;
}
node = prev;
prev = node->prev;
if ( first )
{
node = first->next;
while ( node != first )
{
next = node->next;
if ( selection( node, key ) )
FTC_MruList_Remove( list, node );
if ( selection( node, key ) )
FTC_MruList_Remove( list, node );
node = next;
}
}
} while ( node != first );
}

17
thirdparty/freetype/src/cache/ftcsbits.c vendored
View file

@ -342,7 +342,7 @@
FT_Bool result;
if (list_changed)
if ( list_changed )
*list_changed = FALSE;
result = FT_BOOL( gnode->family == gquery->family &&
gindex - gnode->gindex < snode->count );
@ -411,19 +411,4 @@
return result;
}
#ifdef FTC_INLINE
FT_LOCAL_DEF( FT_Bool )
FTC_SNode_Compare( FTC_SNode snode,
FTC_GQuery gquery,
FTC_Cache cache,
FT_Bool* list_changed )
{
return ftc_snode_compare( FTC_NODE( snode ), gquery,
cache, list_changed );
}
#endif
/* END */

11
thirdparty/freetype/src/cache/ftcsbits.h vendored
View file

@ -81,17 +81,6 @@ FT_BEGIN_HEADER
FTC_SNode_Weight( FTC_SNode inode );
#endif
#ifdef FTC_INLINE
FT_LOCAL( FT_Bool )
FTC_SNode_Compare( FTC_SNode snode,
FTC_GQuery gquery,
FTC_Cache cache,
FT_Bool* list_changed);
#endif
/* */
FT_END_HEADER

107
thirdparty/freetype/src/cff/cffcmap.c vendored
View file

@ -32,9 +32,10 @@
/*************************************************************************/
FT_CALLBACK_DEF( FT_Error )
cff_cmap_encoding_init( CFF_CMapStd cmap,
FT_Pointer pointer )
cff_cmap_encoding_init( FT_CMap cmap,
FT_Pointer pointer )
{
CFF_CMapStd cffcmap = (CFF_CMapStd)cmap;
TT_Face face = (TT_Face)FT_CMAP_FACE( cmap );
CFF_Font cff = (CFF_Font)face->extra.data;
CFF_Encoding encoding = &cff->encoding;
@ -42,63 +43,56 @@
FT_UNUSED( pointer );
cmap->gids = encoding->codes;
cffcmap->gids = encoding->codes;
return 0;
}
FT_CALLBACK_DEF( void )
cff_cmap_encoding_done( CFF_CMapStd cmap )
cff_cmap_encoding_done( FT_CMap cmap )
{
cmap->gids = NULL;
CFF_CMapStd cffcmap = (CFF_CMapStd)cmap;
cffcmap->gids = NULL;
}
FT_CALLBACK_DEF( FT_UInt )
cff_cmap_encoding_char_index( CFF_CMapStd cmap,
FT_UInt32 char_code )
cff_cmap_encoding_char_index( FT_CMap cmap,
FT_UInt32 char_code )
{
FT_UInt result = 0;
CFF_CMapStd cffcmap = (CFF_CMapStd)cmap;
FT_UInt result = 0;
if ( char_code < 256 )
result = cmap->gids[char_code];
result = cffcmap->gids[char_code];
return result;
}
FT_CALLBACK_DEF( FT_UInt32 )
cff_cmap_encoding_char_next( CFF_CMapStd cmap,
FT_UInt32 *pchar_code )
FT_CALLBACK_DEF( FT_UInt )
cff_cmap_encoding_char_next( FT_CMap cmap,
FT_UInt32 *pchar_code )
{
FT_UInt result = 0;
FT_UInt32 char_code = *pchar_code;
CFF_CMapStd cffcmap = (CFF_CMapStd)cmap;
FT_UInt result = 0;
FT_UInt32 char_code = *pchar_code;
*pchar_code = 0;
if ( char_code < 255 )
while ( char_code < 255 )
{
FT_UInt code = (FT_UInt)( char_code + 1 );
for (;;)
result = cffcmap->gids[++char_code];
if ( result )
{
if ( code >= 256 )
break;
result = cmap->gids[code];
if ( result != 0 )
{
*pchar_code = code;
break;
}
code++;
*pchar_code = char_code;
break;
}
}
return result;
}
@ -130,9 +124,10 @@
/*************************************************************************/
FT_CALLBACK_DEF( const char* )
cff_sid_to_glyph_name( TT_Face face,
cff_sid_to_glyph_name( void* face_, /* TT_Face */
FT_UInt idx )
{
TT_Face face = (TT_Face)face_;
CFF_Font cff = (CFF_Font)face->extra.data;
CFF_Charset charset = &cff->charset;
FT_UInt sid = charset->sids[idx];
@ -143,14 +138,15 @@
FT_CALLBACK_DEF( FT_Error )
cff_cmap_unicode_init( PS_Unicodes unicodes,
cff_cmap_unicode_init( FT_CMap cmap, /* PS_Unicodes */
FT_Pointer pointer )
{
TT_Face face = (TT_Face)FT_CMAP_FACE( unicodes );
FT_Memory memory = FT_FACE_MEMORY( face );
CFF_Font cff = (CFF_Font)face->extra.data;
CFF_Charset charset = &cff->charset;
FT_Service_PsCMaps psnames = (FT_Service_PsCMaps)cff->psnames;
PS_Unicodes unicodes = (PS_Unicodes)cmap;
TT_Face face = (TT_Face)FT_CMAP_FACE( cmap );
FT_Memory memory = FT_FACE_MEMORY( face );
CFF_Font cff = (CFF_Font)face->extra.data;
CFF_Charset charset = &cff->charset;
FT_Service_PsCMaps psnames = (FT_Service_PsCMaps)cff->psnames;
FT_UNUSED( pointer );
@ -166,17 +162,18 @@
return psnames->unicodes_init( memory,
unicodes,
cff->num_glyphs,
(PS_GetGlyphNameFunc)&cff_sid_to_glyph_name,
&cff_sid_to_glyph_name,
(PS_FreeGlyphNameFunc)NULL,
(FT_Pointer)face );
}
FT_CALLBACK_DEF( void )
cff_cmap_unicode_done( PS_Unicodes unicodes )
cff_cmap_unicode_done( FT_CMap cmap ) /* PS_Unicodes */
{
FT_Face face = FT_CMAP_FACE( unicodes );
FT_Memory memory = FT_FACE_MEMORY( face );
PS_Unicodes unicodes = (PS_Unicodes)cmap;
FT_Face face = FT_CMAP_FACE( cmap );
FT_Memory memory = FT_FACE_MEMORY( face );
FT_FREE( unicodes->maps );
@ -185,25 +182,27 @@
FT_CALLBACK_DEF( FT_UInt )
cff_cmap_unicode_char_index( PS_Unicodes unicodes,
FT_UInt32 char_code )
cff_cmap_unicode_char_index( FT_CMap cmap, /* PS_Unicodes */
FT_UInt32 char_code )
{
TT_Face face = (TT_Face)FT_CMAP_FACE( unicodes );
CFF_Font cff = (CFF_Font)face->extra.data;
FT_Service_PsCMaps psnames = (FT_Service_PsCMaps)cff->psnames;
PS_Unicodes unicodes = (PS_Unicodes)cmap;
TT_Face face = (TT_Face)FT_CMAP_FACE( cmap );
CFF_Font cff = (CFF_Font)face->extra.data;
FT_Service_PsCMaps psnames = (FT_Service_PsCMaps)cff->psnames;
return psnames->unicodes_char_index( unicodes, char_code );
}
FT_CALLBACK_DEF( FT_UInt32 )
cff_cmap_unicode_char_next( PS_Unicodes unicodes,
FT_UInt32 *pchar_code )
FT_CALLBACK_DEF( FT_UInt )
cff_cmap_unicode_char_next( FT_CMap cmap, /* PS_Unicodes */
FT_UInt32 *pchar_code )
{
TT_Face face = (TT_Face)FT_CMAP_FACE( unicodes );
CFF_Font cff = (CFF_Font)face->extra.data;
FT_Service_PsCMaps psnames = (FT_Service_PsCMaps)cff->psnames;
PS_Unicodes unicodes = (PS_Unicodes)cmap;
TT_Face face = (TT_Face)FT_CMAP_FACE( cmap );
CFF_Font cff = (CFF_Font)face->extra.data;
FT_Service_PsCMaps psnames = (FT_Service_PsCMaps)cff->psnames;
return psnames->unicodes_char_next( unicodes, pchar_code );

443
thirdparty/freetype/src/cff/cffdrivr.c vendored
View file

@ -108,20 +108,20 @@
* They can be implemented by format-specific interfaces.
*/
FT_CALLBACK_DEF( FT_Error )
cff_get_kerning( FT_Face ttface, /* TT_Face */
cff_get_kerning( FT_Face face, /* CFF_Face */
FT_UInt left_glyph,
FT_UInt right_glyph,
FT_Vector* kerning )
{
TT_Face face = (TT_Face)ttface;
SFNT_Service sfnt = (SFNT_Service)face->sfnt;
CFF_Face cffface = (CFF_Face)face;
SFNT_Service sfnt = (SFNT_Service)cffface->sfnt;
kerning->x = 0;
kerning->y = 0;
if ( sfnt )
kerning->x = sfnt->get_kerning( face, left_glyph, right_glyph );
kerning->x = sfnt->get_kerning( cffface, left_glyph, right_glyph );
return FT_Err_Ok;
}
@ -158,23 +158,23 @@
* FreeType error code. 0 means success.
*/
FT_CALLBACK_DEF( FT_Error )
cff_glyph_load( FT_GlyphSlot cffslot, /* CFF_GlyphSlot */
FT_Size cffsize, /* CFF_Size */
cff_glyph_load( FT_GlyphSlot slot, /* CFF_GlyphSlot */
FT_Size size, /* CFF_Size */
FT_UInt glyph_index,
FT_Int32 load_flags )
{
FT_Error error;
CFF_GlyphSlot slot = (CFF_GlyphSlot)cffslot;
CFF_Size size = (CFF_Size)cffsize;
CFF_GlyphSlot cffslot = (CFF_GlyphSlot)slot;
CFF_Size cffsize = (CFF_Size)size;
if ( !slot )
if ( !cffslot )
return FT_THROW( Invalid_Slot_Handle );
FT_TRACE1(( "cff_glyph_load: glyph index %d\n", glyph_index ));
/* check whether we want a scaled outline or bitmap */
if ( !size )
if ( !cffsize )
load_flags |= FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;
/* reset the size object if necessary */
@ -184,12 +184,12 @@
if ( size )
{
/* these two objects must have the same parent */
if ( cffsize->face != cffslot->face )
if ( size->face != slot->face )
return FT_THROW( Invalid_Face_Handle );
}
/* now load the glyph outline if necessary */
error = cff_slot_load( slot, size, glyph_index, load_flags );
error = cff_slot_load( cffslot, cffsize, glyph_index, load_flags );
/* force drop-out mode to 2 - irrelevant now */
/* slot->outline.dropout_mode = 2; */
@ -216,7 +216,7 @@
/* it is no longer necessary that those values are identical to */
/* the values in the `CFF' table */
TT_Face ttface = (TT_Face)face;
CFF_Face cffface = (CFF_Face)face;
FT_Short dummy;
@ -225,7 +225,7 @@
#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
/* no fast retrieval for blended MM fonts without VVAR table */
if ( ( FT_IS_NAMED_INSTANCE( face ) || FT_IS_VARIATION( face ) ) &&
!( ttface->variation_support & TT_FACE_FLAG_VAR_VADVANCE ) )
!( cffface->variation_support & TT_FACE_FLAG_VAR_VADVANCE ) )
return FT_THROW( Unimplemented_Feature );
#endif
@ -233,7 +233,7 @@
/* otherwise we extract the info from the CFF glyphstrings */
/* (instead of synthesizing a global value using the `OS/2' */
/* table) */
if ( !ttface->vertical_info )
if ( !cffface->vertical_info )
goto Missing_Table;
for ( nn = 0; nn < count; nn++ )
@ -241,11 +241,11 @@
FT_UShort ah;
( (SFNT_Service)ttface->sfnt )->get_metrics( ttface,
1,
start + nn,
&dummy,
&ah );
( (SFNT_Service)cffface->sfnt )->get_metrics( cffface,
1,
start + nn,
&dummy,
&ah );
FT_TRACE5(( " idx %d: advance height %d font unit%s\n",
start + nn,
@ -259,12 +259,12 @@
#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
/* no fast retrieval for blended MM fonts without HVAR table */
if ( ( FT_IS_NAMED_INSTANCE( face ) || FT_IS_VARIATION( face ) ) &&
!( ttface->variation_support & TT_FACE_FLAG_VAR_HADVANCE ) )
!( cffface->variation_support & TT_FACE_FLAG_VAR_HADVANCE ) )
return FT_THROW( Unimplemented_Feature );
#endif
/* check whether we have data from the `hmtx' table at all */
if ( !ttface->horizontal.number_Of_HMetrics )
if ( !cffface->horizontal.number_Of_HMetrics )
goto Missing_Table;
for ( nn = 0; nn < count; nn++ )
@ -272,11 +272,11 @@
FT_UShort aw;
( (SFNT_Service)ttface->sfnt )->get_metrics( ttface,
0,
start + nn,
&dummy,
&aw );
( (SFNT_Service)cffface->sfnt )->get_metrics( cffface,
0,
start + nn,
&dummy,
&aw );
FT_TRACE5(( " idx %d: advance width %d font unit%s\n",
start + nn,
@ -312,13 +312,14 @@
*
*/
static FT_Error
cff_get_glyph_name( CFF_Face face,
FT_CALLBACK_DEF( FT_Error )
cff_get_glyph_name( FT_Face face, /* CFF_Face */
FT_UInt glyph_index,
FT_Pointer buffer,
FT_UInt buffer_max )
{
CFF_Font font = (CFF_Font)face->extra.data;
CFF_Face cffface = (CFF_Face)face;
CFF_Font font = (CFF_Font)cffface->extra.data;
FT_String* gname;
FT_UShort sid;
FT_Error error;
@ -338,10 +339,7 @@
if ( service && service->get_name )
return service->get_name( FT_FACE( face ),
glyph_index,
buffer,
buffer_max );
return service->get_name( face, glyph_index, buffer, buffer_max );
else
{
FT_ERROR(( "cff_get_glyph_name:"
@ -366,7 +364,7 @@
/* first, locate the sid in the charset table */
sid = font->charset.sids[glyph_index];
/* now, lookup the name itself */
/* now, look up the name itself */
gname = cff_index_get_sid_string( font, sid );
if ( gname )
@ -379,21 +377,19 @@
}
static FT_UInt
cff_get_name_index( CFF_Face face,
FT_CALLBACK_DEF( FT_UInt )
cff_get_name_index( FT_Face face, /* CFF_Face */
const FT_String* glyph_name )
{
CFF_Font cff;
CFF_Charset charset;
CFF_Face cffface = (CFF_Face)face;
CFF_Font cff = (CFF_Font)cffface->extra.data;
CFF_Charset charset = &cff->charset;
FT_Service_PsCMaps psnames;
FT_String* name;
FT_UShort sid;
FT_UInt i;
cff = (CFF_FontRec *)face->extra.data;
charset = &cff->charset;
/* CFF2 table does not have glyph names; */
/* we need to use `post' table method */
if ( cff->version_major == 2 )
@ -408,7 +404,7 @@
if ( service && service->name_index )
return service->name_index( FT_FACE( face ), glyph_name );
return service->name_index( face, glyph_name );
else
{
FT_ERROR(( "cff_get_name_index:"
@ -446,8 +442,8 @@
FT_DEFINE_SERVICE_GLYPHDICTREC(
cff_service_glyph_dict,
(FT_GlyphDict_GetNameFunc) cff_get_glyph_name, /* get_name */
(FT_GlyphDict_NameIndexFunc)cff_get_name_index /* name_index */
cff_get_glyph_name, /* FT_GlyphDict_GetNameFunc get_name */
cff_get_name_index /* FT_GlyphDict_NameIndexFunc name_index */
)
@ -456,25 +452,32 @@
*
*/
static FT_Int
FT_CALLBACK_DEF( FT_Int )
cff_ps_has_glyph_names( FT_Face face )
{
return ( face->face_flags & FT_FACE_FLAG_GLYPH_NAMES ) > 0;
}
static FT_Error
cff_ps_get_font_info( CFF_Face face,
FT_CALLBACK_DEF( FT_Error )
cff_ps_get_font_info( FT_Face face, /* CFF_Face */
PS_FontInfoRec* afont_info )
{
CFF_Font cff = (CFF_Font)face->extra.data;
FT_Error error = FT_Err_Ok;
CFF_Face cffface = (CFF_Face)face;
CFF_Font cff = (CFF_Font)cffface->extra.data;
FT_Error error = FT_Err_Ok;
if ( cffface->is_cff2 )
{
error = FT_THROW( Invalid_Argument );
goto Fail;
}
if ( cff && !cff->font_info )
{
CFF_FontRecDict dict = &cff->top_font.font_dict;
FT_Memory memory = face->root.memory;
FT_Memory memory = FT_FACE_MEMORY( face );
PS_FontInfoRec* font_info = NULL;
@ -507,18 +510,19 @@
}
static FT_Error
cff_ps_get_font_extra( CFF_Face face,
FT_CALLBACK_DEF( FT_Error )
cff_ps_get_font_extra( FT_Face face, /* CFF_Face */
PS_FontExtraRec* afont_extra )
{
CFF_Font cff = (CFF_Font)face->extra.data;
FT_Error error = FT_Err_Ok;
CFF_Face cffface = (CFF_Face)face;
CFF_Font cff = (CFF_Font)cffface->extra.data;
FT_Error error = FT_Err_Ok;
if ( cff && !cff->font_extra )
{
CFF_FontRecDict dict = &cff->top_font.font_dict;
FT_Memory memory = face->root.memory;
FT_Memory memory = FT_FACE_MEMORY( face );
PS_FontExtraRec* font_extra = NULL;
FT_String* embedded_postscript;
@ -588,13 +592,13 @@
FT_DEFINE_SERVICE_PSINFOREC(
cff_service_ps_info,
(PS_GetFontInfoFunc) cff_ps_get_font_info, /* ps_get_font_info */
(PS_GetFontExtraFunc) cff_ps_get_font_extra, /* ps_get_font_extra */
(PS_HasGlyphNamesFunc) cff_ps_has_glyph_names, /* ps_has_glyph_names */
cff_ps_get_font_info, /* PS_GetFontInfoFunc ps_get_font_info */
cff_ps_get_font_extra, /* PS_GetFontExtraFunc ps_get_font_extra */
cff_ps_has_glyph_names, /* PS_HasGlyphNamesFunc ps_has_glyph_names */
/* unsupported with CFF fonts */
(PS_GetFontPrivateFunc)NULL, /* ps_get_font_private */
NULL, /* PS_GetFontPrivateFunc ps_get_font_private */
/* not implemented */
(PS_GetFontValueFunc) NULL /* ps_get_font_value */
NULL /* PS_GetFontValueFunc ps_get_font_value */
)
@ -603,17 +607,18 @@
*
*/
static const char*
cff_get_ps_name( CFF_Face face )
FT_CALLBACK_DEF( const char* )
cff_get_ps_name( FT_Face face ) /* CFF_Face */
{
CFF_Font cff = (CFF_Font)face->extra.data;
SFNT_Service sfnt = (SFNT_Service)face->sfnt;
CFF_Face cffface = (CFF_Face)face;
CFF_Font cff = (CFF_Font)cffface->extra.data;
SFNT_Service sfnt = (SFNT_Service)cffface->sfnt;
/* following the OpenType specification 1.7, we return the name stored */
/* in the `name' table for a CFF wrapped into an SFNT container */
if ( FT_IS_SFNT( FT_FACE( face ) ) && sfnt )
if ( FT_IS_SFNT( face ) && sfnt )
{
FT_Library library = FT_FACE_LIBRARY( face );
FT_Module sfnt_module = FT_Get_Module( library, "sfnt" );
@ -625,17 +630,17 @@
if ( service && service->get_ps_font_name )
return service->get_ps_font_name( FT_FACE( face ) );
return service->get_ps_font_name( face );
}
return (const char*)cff->font_name;
return cff ? (const char*)cff->font_name : NULL;
}
FT_DEFINE_SERVICE_PSFONTNAMEREC(
cff_service_ps_name,
(FT_PsName_GetFunc)cff_get_ps_name /* get_ps_font_name */
cff_get_ps_name /* FT_PsName_GetFunc get_ps_font_name */
)
@ -649,7 +654,7 @@
* Otherwise call the service function in the sfnt module.
*
*/
static FT_Error
FT_CALLBACK_DEF( FT_Error )
cff_get_cmap_info( FT_CharMap charmap,
TT_CMapInfo *cmap_info )
{
@ -683,7 +688,7 @@
FT_DEFINE_SERVICE_TTCMAPSREC(
cff_service_get_cmap_info,
(TT_CMap_Info_GetFunc)cff_get_cmap_info /* get_cmap_info */
cff_get_cmap_info /* TT_CMap_Info_GetFunc get_cmap_info */
)
@ -691,14 +696,15 @@
* CID INFO SERVICE
*
*/
static FT_Error
cff_get_ros( CFF_Face face,
FT_CALLBACK_DEF( FT_Error )
cff_get_ros( FT_Face face, /* FT_Face */
const char* *registry,
const char* *ordering,
FT_Int *supplement )
{
FT_Error error = FT_Err_Ok;
CFF_Font cff = (CFF_Font)face->extra.data;
FT_Error error = FT_Err_Ok;
CFF_Face cffface = (CFF_Face)face;
CFF_Font cff = (CFF_Font)cffface->extra.data;
if ( cff )
@ -748,12 +754,13 @@
}
static FT_Error
cff_get_is_cid( CFF_Face face,
FT_CALLBACK_DEF( FT_Error )
cff_get_is_cid( FT_Face face, /* CFF_Face */
FT_Bool *is_cid )
{
FT_Error error = FT_Err_Ok;
CFF_Font cff = (CFF_Font)face->extra.data;
FT_Error error = FT_Err_Ok;
CFF_Face cffface = (CFF_Face)face;
CFF_Font cff = (CFF_Font)cffface->extra.data;
*is_cid = 0;
@ -771,17 +778,16 @@
}
static FT_Error
cff_get_cid_from_glyph_index( CFF_Face face,
FT_CALLBACK_DEF( FT_Error )
cff_get_cid_from_glyph_index( FT_Face face, /* CFF_Face */
FT_UInt glyph_index,
FT_UInt *cid )
{
FT_Error error = FT_Err_Ok;
CFF_Font cff;
FT_Error error = FT_Err_Ok;
CFF_Face cffface = (CFF_Face)face;
CFF_Font cff = (CFF_Font)cffface->extra.data;
cff = (CFF_Font)face->extra.data;
if ( cff )
{
FT_UInt c;
@ -814,12 +820,12 @@
FT_DEFINE_SERVICE_CIDREC(
cff_service_cid_info,
(FT_CID_GetRegistryOrderingSupplementFunc)
cff_get_ros, /* get_ros */
(FT_CID_GetIsInternallyCIDKeyedFunc)
cff_get_is_cid, /* get_is_cid */
(FT_CID_GetCIDFromGlyphIndexFunc)
cff_get_cid_from_glyph_index /* get_cid_from_glyph_index */
cff_get_ros,
/* FT_CID_GetRegistryOrderingSupplementFunc get_ros */
cff_get_is_cid,
/* FT_CID_GetIsInternallyCIDKeyedFunc get_is_cid */
cff_get_cid_from_glyph_index
/* FT_CID_GetCIDFromGlyphIndexFunc get_cid_from_glyph_index */
)
@ -831,9 +837,9 @@
FT_DEFINE_SERVICE_PROPERTIESREC(
cff_service_properties,
(FT_Properties_SetFunc)ps_property_set, /* set_property */
(FT_Properties_GetFunc)ps_property_get ) /* get_property */
ps_property_set, /* FT_Properties_SetFunc set_property */
ps_property_get /* FT_Properties_GetFunc get_property */
)
#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
@ -842,160 +848,195 @@
*
*/
static FT_Error
cff_set_mm_blend( CFF_Face face,
FT_CALLBACK_DEF( FT_Error )
cff_set_mm_blend( FT_Face face, /* CFF_Face */
FT_UInt num_coords,
FT_Fixed* coords )
{
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)face->mm;
CFF_Face cffface = (CFF_Face)face;
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)cffface->mm;
return mm->set_mm_blend( FT_FACE( face ), num_coords, coords );
return mm->set_mm_blend( face, num_coords, coords );
}
static FT_Error
cff_get_mm_blend( CFF_Face face,
FT_CALLBACK_DEF( FT_Error )
cff_get_mm_blend( FT_Face face, /* CFF_Face */
FT_UInt num_coords,
FT_Fixed* coords )
{
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)face->mm;
CFF_Face cffface = (CFF_Face)face;
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)cffface->mm;
return mm->get_mm_blend( FT_FACE( face ), num_coords, coords );
return mm->get_mm_blend( face, num_coords, coords );
}
static FT_Error
cff_set_mm_weightvector( CFF_Face face,
FT_CALLBACK_DEF( FT_Error )
cff_set_mm_weightvector( FT_Face face, /* CFF_Face */
FT_UInt len,
FT_Fixed* weightvector )
{
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)face->mm;
CFF_Face cffface = (CFF_Face)face;
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)cffface->mm;
return mm->set_mm_weightvector( FT_FACE( face ), len, weightvector );
return mm->set_mm_weightvector( face, len, weightvector );
}
static FT_Error
cff_get_mm_weightvector( CFF_Face face,
FT_CALLBACK_DEF( FT_Error )
cff_get_mm_weightvector( FT_Face face, /* CFF_Face */
FT_UInt* len,
FT_Fixed* weightvector )
{
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)face->mm;
CFF_Face cffface = (CFF_Face)face;
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)cffface->mm;
return mm->get_mm_weightvector( FT_FACE( face ), len, weightvector );
return mm->get_mm_weightvector( face, len, weightvector );
}
static FT_Error
cff_get_mm_var( CFF_Face face,
FT_CALLBACK_DEF( void )
cff_construct_ps_name( FT_Face face ) /* CFF_Face */
{
CFF_Face cffface = (CFF_Face)face;
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)cffface->mm;
mm->construct_ps_name( face );
}
FT_CALLBACK_DEF( FT_Error )
cff_get_mm_var( FT_Face face, /* CFF_Face */
FT_MM_Var* *master )
{
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)face->mm;
CFF_Face cffface = (CFF_Face)face;
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)cffface->mm;
return mm->get_mm_var( FT_FACE( face ), master );
return mm->get_mm_var( face, master );
}
static FT_Error
cff_set_var_design( CFF_Face face,
FT_CALLBACK_DEF( FT_Error )
cff_set_var_design( FT_Face face, /* CFF_Face */
FT_UInt num_coords,
FT_Fixed* coords )
{
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)face->mm;
CFF_Face cffface = (CFF_Face)face;
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)cffface->mm;
return mm->set_var_design( FT_FACE( face ), num_coords, coords );
return mm->set_var_design( face, num_coords, coords );
}
static FT_Error
cff_get_var_design( CFF_Face face,
FT_CALLBACK_DEF( FT_Error )
cff_get_var_design( FT_Face face, /* CFF_Face */
FT_UInt num_coords,
FT_Fixed* coords )
{
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)face->mm;
CFF_Face cffface = (CFF_Face)face;
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)cffface->mm;
return mm->get_var_design( FT_FACE( face ), num_coords, coords );
return mm->get_var_design( face, num_coords, coords );
}
static FT_Error
cff_set_instance( CFF_Face face,
FT_UInt instance_index )
FT_CALLBACK_DEF( FT_Error )
cff_set_named_instance( FT_Face face, /* CFF_Face */
FT_UInt instance_index )
{
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)face->mm;
CFF_Face cffface = (CFF_Face)face;
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)cffface->mm;
return mm->set_instance( FT_FACE( face ), instance_index );
return mm->set_named_instance( face, instance_index );
}
static FT_Error
cff_load_item_variation_store( CFF_Face face,
FT_CALLBACK_DEF( FT_Error )
cff_get_default_named_instance( FT_Face face, /* CFF_Face */
FT_UInt *instance_index )
{
CFF_Face cffface = (CFF_Face)face;
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)cffface->mm;
return mm->get_default_named_instance( face, instance_index );
}
FT_CALLBACK_DEF( FT_Error )
cff_load_item_variation_store( FT_Face face, /* CFF_Face */
FT_ULong offset,
GX_ItemVarStore itemStore )
{
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)face->mm;
CFF_Face cffface = (CFF_Face)face;
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)cffface->mm;
return mm->load_item_var_store( FT_FACE(face), offset, itemStore );
return mm->load_item_var_store( face, offset, itemStore );
}
static FT_Error
cff_load_delta_set_index_mapping( CFF_Face face,
FT_CALLBACK_DEF( FT_Error )
cff_load_delta_set_index_mapping( FT_Face face, /* CFF_Face */
FT_ULong offset,
GX_DeltaSetIdxMap map,
GX_ItemVarStore itemStore,
FT_ULong table_len )
{
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)face->mm;
CFF_Face cffface = (CFF_Face)face;
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)cffface->mm;
return mm->load_delta_set_idx_map( FT_FACE( face ), offset, map,
return mm->load_delta_set_idx_map( face, offset, map,
itemStore, table_len );
}
static FT_Int
cff_get_item_delta( CFF_Face face,
FT_CALLBACK_DEF( FT_Int )
cff_get_item_delta( FT_Face face, /* CFF_Face */
GX_ItemVarStore itemStore,
FT_UInt outerIndex,
FT_UInt innerIndex )
{
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)face->mm;
CFF_Face cffface = (CFF_Face)face;
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)cffface->mm;
return mm->get_item_delta( FT_FACE( face ), itemStore,
outerIndex, innerIndex );
return mm->get_item_delta( face, itemStore, outerIndex, innerIndex );
}
static void
cff_done_item_variation_store( CFF_Face face,
FT_CALLBACK_DEF( void )
cff_done_item_variation_store( FT_Face face, /* CFF_Face */
GX_ItemVarStore itemStore )
{
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)face->mm;
CFF_Face cffface = (CFF_Face)face;
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)cffface->mm;
mm->done_item_var_store( FT_FACE( face ), itemStore );
mm->done_item_var_store( face, itemStore );
}
static void
cff_done_delta_set_index_map( CFF_Face face,
FT_CALLBACK_DEF( void )
cff_done_delta_set_index_map( FT_Face face, /* CFF_Face */
GX_DeltaSetIdxMap deltaSetIdxMap )
{
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)face->mm;
CFF_Face cffface = (CFF_Face)face;
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)cffface->mm;
mm->done_delta_set_idx_map( FT_FACE ( face ), deltaSetIdxMap );
mm->done_delta_set_idx_map( face, deltaSetIdxMap );
}
@ -1003,36 +1044,35 @@
FT_DEFINE_SERVICE_MULTIMASTERSREC(
cff_service_multi_masters,
(FT_Get_MM_Func) NULL, /* get_mm */
(FT_Set_MM_Design_Func) NULL, /* set_mm_design */
(FT_Set_MM_Blend_Func) cff_set_mm_blend, /* set_mm_blend */
(FT_Get_MM_Blend_Func) cff_get_mm_blend, /* get_mm_blend */
(FT_Get_MM_Var_Func) cff_get_mm_var, /* get_mm_var */
(FT_Set_Var_Design_Func)cff_set_var_design, /* set_var_design */
(FT_Get_Var_Design_Func)cff_get_var_design, /* get_var_design */
(FT_Set_Instance_Func) cff_set_instance, /* set_instance */
(FT_Set_MM_WeightVector_Func)
cff_set_mm_weightvector,
/* set_mm_weightvector */
(FT_Get_MM_WeightVector_Func)
cff_get_mm_weightvector,
/* get_mm_weightvector */
(FT_Var_Load_Delta_Set_Idx_Map_Func)
cff_load_delta_set_index_mapping,
/* load_delta_set_idx_map */
(FT_Var_Load_Item_Var_Store_Func)
cff_load_item_variation_store,
/* load_item_variation_store */
(FT_Var_Get_Item_Delta_Func)
cff_get_item_delta, /* get_item_delta */
(FT_Var_Done_Item_Var_Store_Func)
cff_done_item_variation_store,
/* done_item_variation_store */
(FT_Var_Done_Delta_Set_Idx_Map_Func)
cff_done_delta_set_index_map,
/* done_delta_set_index_map */
(FT_Get_Var_Blend_Func) cff_get_var_blend, /* get_var_blend */
(FT_Done_Blend_Func) cff_done_blend /* done_blend */
NULL, /* FT_Get_MM_Func get_mm */
NULL, /* FT_Set_MM_Design_Func set_mm_design */
cff_set_mm_blend, /* FT_Set_MM_Blend_Func set_mm_blend */
cff_get_mm_blend, /* FT_Get_MM_Blend_Func get_mm_blend */
cff_get_mm_var, /* FT_Get_MM_Var_Func get_mm_var */
cff_set_var_design, /* FT_Set_Var_Design_Func set_var_design */
cff_get_var_design, /* FT_Get_Var_Design_Func get_var_design */
cff_set_named_instance,
/* FT_Set_Named_Instance_Func set_named_instance */
cff_get_default_named_instance,
/* FT_Get_Default_Named_Instance_Func get_default_named_instance */
cff_set_mm_weightvector,
/* FT_Set_MM_WeightVector_Func set_mm_weightvector */
cff_get_mm_weightvector,
/* FT_Get_MM_WeightVector_Func get_mm_weightvector */
cff_construct_ps_name,
/* FT_Construct_PS_Name_Func construct_ps_name */
cff_load_delta_set_index_mapping,
/* FT_Var_Load_Delta_Set_Idx_Map_Func load_delta_set_idx_map */
cff_load_item_variation_store,
/* FT_Var_Load_Item_Var_Store_Func load_item_variation_store */
cff_get_item_delta,
/* FT_Var_Get_Item_Delta_Func get_item_delta */
cff_done_item_variation_store,
/* FT_Var_Done_Item_Var_Store_Func done_item_variation_store */
cff_done_delta_set_index_map,
/* FT_Var_Done_Delta_Set_Idx_Map_Func done_delta_set_index_map */
cff_get_var_blend, /* FT_Get_Var_Blend_Func get_var_blend */
cff_done_blend /* FT_Done_Blend_Func done_blend */
)
@ -1041,41 +1081,46 @@
*
*/
static FT_Error
cff_hadvance_adjust( CFF_Face face,
FT_CALLBACK_DEF( FT_Error )
cff_hadvance_adjust( FT_Face face, /* CFF_Face */
FT_UInt gindex,
FT_Int *avalue )
{
FT_Service_MetricsVariations var = (FT_Service_MetricsVariations)face->var;
CFF_Face cffface = (CFF_Face)face;
FT_Service_MetricsVariations
var = (FT_Service_MetricsVariations)cffface->tt_var;
return var->hadvance_adjust( FT_FACE( face ), gindex, avalue );
return var->hadvance_adjust( face, gindex, avalue );
}
static void
cff_metrics_adjust( CFF_Face face )
FT_CALLBACK_DEF( void )
cff_metrics_adjust( FT_Face face ) /* CFF_Face */
{
FT_Service_MetricsVariations var = (FT_Service_MetricsVariations)face->var;
CFF_Face cffface = (CFF_Face)face;
FT_Service_MetricsVariations
var = (FT_Service_MetricsVariations)cffface->tt_var;
var->metrics_adjust( FT_FACE( face ) );
var->metrics_adjust( face );
}
FT_DEFINE_SERVICE_METRICSVARIATIONSREC(
cff_service_metrics_variations,
(FT_HAdvance_Adjust_Func)cff_hadvance_adjust, /* hadvance_adjust */
(FT_LSB_Adjust_Func) NULL, /* lsb_adjust */
(FT_RSB_Adjust_Func) NULL, /* rsb_adjust */
cff_hadvance_adjust, /* FT_HAdvance_Adjust_Func hadvance_adjust */
NULL, /* FT_LSB_Adjust_Func lsb_adjust */
NULL, /* FT_RSB_Adjust_Func rsb_adjust */
(FT_VAdvance_Adjust_Func)NULL, /* vadvance_adjust */
(FT_TSB_Adjust_Func) NULL, /* tsb_adjust */
(FT_BSB_Adjust_Func) NULL, /* bsb_adjust */
(FT_VOrg_Adjust_Func) NULL, /* vorg_adjust */
NULL, /* FT_VAdvance_Adjust_Func vadvance_adjust */
NULL, /* FT_TSB_Adjust_Func tsb_adjust */
NULL, /* FT_BSB_Adjust_Func bsb_adjust */
NULL, /* FT_VOrg_Adjust_Func vorg_adjust */
(FT_Metrics_Adjust_Func) cff_metrics_adjust /* metrics_adjust */
cff_metrics_adjust, /* FT_Metrics_Adjust_Func metrics_adjust */
NULL /* FT_Size_Reset_Func size_reset */
)
#endif
@ -1088,11 +1133,11 @@
FT_DEFINE_SERVICE_CFFLOADREC(
cff_service_cff_load,
(FT_Get_Standard_Encoding_Func)cff_get_standard_encoding,
(FT_Load_Private_Dict_Func) cff_load_private_dict,
(FT_FD_Select_Get_Func) cff_fd_select_get,
(FT_Blend_Check_Vector_Func) cff_blend_check_vector,
(FT_Blend_Build_Vector_Func) cff_blend_build_vector
cff_get_standard_encoding, /* FT_Get_Standard_Encoding_Func get_standard_encoding */
cff_load_private_dict, /* FT_Load_Private_Dict_Func load_private_dict */
cff_fd_select_get, /* FT_FD_Select_Get_Func fd_select_get */
cff_blend_check_vector, /* FT_Blend_Check_Vector_Func blend_check_vector */
cff_blend_build_vector /* FT_Blend_Build_Vector_Func blend_build_vector */
)

6
thirdparty/freetype/src/cff/cffgload.c vendored
View file

@ -356,14 +356,16 @@
#ifdef FT_CONFIG_OPTION_SVG
/* check for OT-SVG */
if ( ( load_flags & FT_LOAD_COLOR ) && face->svg )
if ( ( load_flags & FT_LOAD_NO_SVG ) == 0 &&
( load_flags & FT_LOAD_COLOR ) &&
face->svg )
{
/*
* We load the SVG document and try to grab the advances from the
* table. For the bearings we rely on the presetting hook to do that.
*/
SFNT_Service sfnt = (SFNT_Service)face->sfnt;
SFNT_Service sfnt = (SFNT_Service)face->sfnt;
if ( size && (size->root.metrics.x_ppem < 1 ||

31
thirdparty/freetype/src/cff/cffload.c vendored
View file

@ -400,7 +400,7 @@
/* Allocate a table containing pointers to an index's elements. */
/* The `pool' argument makes this function convert the index */
/* entries to C-style strings (this is, null-terminated). */
/* entries to C-style strings (that is, null-terminated). */
static FT_Error
cff_index_get_pointers( CFF_Index idx,
FT_Byte*** table,
@ -1589,16 +1589,17 @@
#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
FT_LOCAL_DEF( FT_Error )
cff_get_var_blend( CFF_Face face,
cff_get_var_blend( FT_Face face, /* CFF_Face */
FT_UInt *num_coords,
FT_Fixed* *coords,
FT_Fixed* *normalizedcoords,
FT_MM_Var* *mm_var )
{
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)face->mm;
CFF_Face cffface = (CFF_Face)face;
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)cffface->mm;
return mm->get_var_blend( FT_FACE( face ),
return mm->get_var_blend( face,
num_coords,
coords,
normalizedcoords,
@ -1607,13 +1608,14 @@
FT_LOCAL_DEF( void )
cff_done_blend( CFF_Face face )
cff_done_blend( FT_Face face ) /* CFF_Face */
{
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)face->mm;
CFF_Face cffface = (CFF_Face)face;
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)cffface->mm;
if (mm)
mm->done_blend( FT_FACE( face ) );
if ( mm )
mm->done_blend( face );
}
#endif /* TT_CONFIG_OPTION_GX_VAR_SUPPORT */
@ -1650,13 +1652,6 @@
goto Exit;
}
/* Zero out the code to gid/sid mappings. */
for ( j = 0; j < 256; j++ )
{
encoding->sids [j] = 0;
encoding->codes[j] = 0;
}
/* Note: The encoding table in a CFF font is indexed by glyph index; */
/* the first encoded glyph index is 1. Hence, we read the character */
/* code (`glyph_code') at index j and make the assignment: */
@ -1671,6 +1666,10 @@
if ( offset > 1 )
{
/* Zero out the code to gid/sid mappings. */
FT_ARRAY_ZERO( encoding->sids, 256 );
FT_ARRAY_ZERO( encoding->codes, 256 );
encoding->offset = base_offset + offset;
/* we need to parse the table to determine its size */
@ -2012,7 +2011,7 @@
/* Top and Font DICTs are not allowed to have blend operators. */
error = cff_parser_init( &parser,
code,
&subfont->font_dict,
top,
font->library,
stackSize,
0,

4
thirdparty/freetype/src/cff/cffload.h vendored
View file

@ -105,14 +105,14 @@ FT_BEGIN_HEADER
#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
FT_LOCAL( FT_Error )
cff_get_var_blend( CFF_Face face,
cff_get_var_blend( FT_Face face,
FT_UInt *num_coords,
FT_Fixed* *coords,
FT_Fixed* *normalizedcoords,
FT_MM_Var* *mm_var );
FT_LOCAL( void )
cff_done_blend( CFF_Face face );
cff_done_blend( FT_Face face );
#endif

24
thirdparty/freetype/src/cff/cffobjs.c vendored
View file

@ -69,8 +69,8 @@
FT_Module module;
module = FT_Get_Module( size->root.face->driver->root.library,
"pshinter" );
module = FT_Get_Module( font->library, "pshinter" );
return ( module && pshinter && pshinter->get_globals_funcs )
? pshinter->get_globals_funcs( module )
: 0;
@ -182,8 +182,7 @@
goto Exit;
cff_make_private_dict( &font->top_font, &priv );
error = funcs->create( cffsize->face->memory, &priv,
&internal->topfont );
error = funcs->create( memory, &priv, &internal->topfont );
if ( error )
goto Exit;
@ -193,8 +192,7 @@
cff_make_private_dict( sub, &priv );
error = funcs->create( cffsize->face->memory, &priv,
&internal->subfonts[i - 1] );
error = funcs->create( memory, &priv, &internal->subfonts[i - 1] );
if ( error )
goto Exit;
}
@ -381,8 +379,7 @@
FT_Module module;
module = FT_Get_Module( slot->face->driver->root.library,
"pshinter" );
module = FT_Get_Module( slot->library, "pshinter" );
if ( module )
{
T2_Hints_Funcs funcs;
@ -722,22 +719,15 @@
#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
{
FT_Service_MultiMasters mm = (FT_Service_MultiMasters)face->mm;
FT_Service_MetricsVariations var = (FT_Service_MetricsVariations)face->var;
FT_UInt instance_index = (FT_UInt)face_index >> 16;
if ( FT_HAS_MULTIPLE_MASTERS( cffface ) &&
mm &&
instance_index > 0 )
{
error = mm->set_instance( cffface, instance_index );
error = FT_Set_Named_Instance( cffface, instance_index );
if ( error )
goto Exit;
if ( var )
var->metrics_adjust( cffface );
}
}
#endif /* TT_CONFIG_OPTION_GX_VAR_SUPPORT */
@ -1160,7 +1150,7 @@
}
#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
cff_done_blend( face );
cff_done_blend( cffface );
face->blend = NULL;
#endif
}

228
thirdparty/freetype/src/cff/cffparse.c vendored
View file

@ -63,10 +63,7 @@
/* allocate the stack buffer */
if ( FT_QNEW_ARRAY( parser->stack, stackSize ) )
{
FT_FREE( parser->stack );
goto Exit;
}
parser->stackSize = stackSize;
parser->top = parser->stack; /* empty stack */
@ -76,23 +73,6 @@
}
#ifdef CFF_CONFIG_OPTION_OLD_ENGINE
static void
finalize_t2_strings( FT_Memory memory,
void* data,
void* user )
{
CFF_T2_String t2 = (CFF_T2_String)data;
FT_UNUSED( user );
memory->free( memory, t2->start );
memory->free( memory, data );
}
#endif /* CFF_CONFIG_OPTION_OLD_ENGINE */
FT_LOCAL_DEF( void )
cff_parser_done( CFF_Parser parser )
{
@ -102,63 +82,19 @@
FT_FREE( parser->stack );
#ifdef CFF_CONFIG_OPTION_OLD_ENGINE
FT_List_Finalize( &parser->t2_strings,
finalize_t2_strings,
memory,
NULL );
FT_List_Finalize( &parser->t2_strings, NULL, memory, NULL );
#endif
}
/* Assuming `first >= last'. */
static FT_Error
cff_parser_within_limits( CFF_Parser parser,
FT_Byte* first,
FT_Byte* last )
{
#ifndef CFF_CONFIG_OPTION_OLD_ENGINE
/* Fast path for regular FreeType builds with the "new" engine; */
/* `first >= parser->start' can be assumed. */
FT_UNUSED( first );
return last < parser->limit ? FT_Err_Ok : FT_THROW( Invalid_Argument );
#else /* CFF_CONFIG_OPTION_OLD_ENGINE */
FT_ListNode node;
if ( first >= parser->start &&
last < parser->limit )
return FT_Err_Ok;
node = parser->t2_strings.head;
while ( node )
{
CFF_T2_String t2 = (CFF_T2_String)node->data;
if ( first >= t2->start &&
last < t2->limit )
return FT_Err_Ok;
node = node->next;
}
return FT_THROW( Invalid_Argument );
#endif /* CFF_CONFIG_OPTION_OLD_ENGINE */
}
/* The parser limit checks in the next two functions are supposed */
/* to detect the immediate crossing of the stream boundary. They */
/* shall not be triggered from the distant t2_strings buffers. */
/* read an integer */
static FT_Long
cff_parse_integer( CFF_Parser parser,
FT_Byte* start )
cff_parse_integer( FT_Byte* start,
FT_Byte* limit )
{
FT_Byte* p = start;
FT_Int v = *p++;
@ -167,14 +103,14 @@
if ( v == 28 )
{
if ( cff_parser_within_limits( parser, p, p + 1 ) )
if ( p + 2 > limit && limit >= p )
goto Bad;
val = (FT_Short)( ( (FT_UShort)p[0] << 8 ) | p[1] );
}
else if ( v == 29 )
{
if ( cff_parser_within_limits( parser, p, p + 3 ) )
if ( p + 4 > limit && limit >= p )
goto Bad;
val = (FT_Long)( ( (FT_ULong)p[0] << 24 ) |
@ -188,14 +124,14 @@
}
else if ( v < 251 )
{
if ( cff_parser_within_limits( parser, p, p ) )
if ( p + 1 > limit && limit >= p )
goto Bad;
val = ( v - 247 ) * 256 + p[0] + 108;
}
else
{
if ( cff_parser_within_limits( parser, p, p ) )
if ( p + 1 > limit && limit >= p )
goto Bad;
val = -( v - 251 ) * 256 - p[0] - 108;
@ -244,10 +180,10 @@
/* read a real */
static FT_Fixed
cff_parse_real( CFF_Parser parser,
FT_Byte* start,
FT_Long power_ten,
FT_Long* scaling )
cff_parse_real( FT_Byte* start,
FT_Byte* limit,
FT_Long power_ten,
FT_Long* scaling )
{
FT_Byte* p = start;
FT_Int nib;
@ -282,7 +218,7 @@
p++;
/* Make sure we don't read past the end. */
if ( cff_parser_within_limits( parser, p, p ) )
if ( p + 1 > limit && limit >= p )
goto Bad;
}
@ -319,7 +255,7 @@
p++;
/* Make sure we don't read past the end. */
if ( cff_parser_within_limits( parser, p, p ) )
if ( p + 1 > limit && limit >= p )
goto Bad;
}
@ -358,7 +294,7 @@
p++;
/* Make sure we don't read past the end. */
if ( cff_parser_within_limits( parser, p, p ) )
if ( p + 1 > limit && limit >= p )
goto Bad;
}
@ -525,7 +461,7 @@
if ( **d == 30 )
{
/* binary-coded decimal is truncated to integer */
return cff_parse_real( parser, *d, 0, NULL ) >> 16;
return cff_parse_real( *d, parser->limit, 0, NULL ) >> 16;
}
else if ( **d == 255 )
@ -551,7 +487,7 @@
}
else
return cff_parse_integer( parser, *d );
return cff_parse_integer( *d, parser->limit );
}
@ -562,10 +498,10 @@
FT_Long scaling )
{
if ( **d == 30 )
return cff_parse_real( parser, *d, scaling, NULL );
return cff_parse_real( *d, parser->limit, scaling, NULL );
else
{
FT_Long val = cff_parse_integer( parser, *d );
FT_Long val = cff_parse_integer( *d, parser->limit );
if ( scaling )
@ -630,14 +566,14 @@
FT_ASSERT( scaling );
if ( **d == 30 )
return cff_parse_real( parser, *d, 0, scaling );
return cff_parse_real( *d, parser->limit, 0, scaling );
else
{
FT_Long number;
FT_Int integer_length;
number = cff_parse_integer( parser, d[0] );
number = cff_parse_integer( *d, parser->limit );
if ( number > 0x7FFFL )
{
@ -686,7 +622,7 @@
dict->has_font_matrix = TRUE;
/* We expect a well-formed font matrix, this is, the matrix elements */
/* We expect a well-formed font matrix, that is, the matrix elements */
/* `xx' and `yy' are of approximately the same magnitude. To avoid */
/* loss of precision, we use the magnitude of the largest matrix */
/* element to scale all other elements. The scaling factor is then */
@ -1264,11 +1200,8 @@
FT_Byte* charstring_base;
FT_ULong charstring_len;
FT_Fixed* stack;
FT_ListNode node;
CFF_T2_String t2;
FT_Fixed t2_size;
FT_Byte* q;
FT_Fixed* stack;
FT_Byte* q = NULL;
charstring_base = ++p;
@ -1309,39 +1242,18 @@
/* Now copy the stack data in the temporary decoder object, */
/* converting it back to charstring number representations */
/* (this is ugly, I know). */
/* The maximum required size is 5 bytes per stack element. */
if ( FT_QALLOC( q, (FT_Long)( 2 * sizeof ( FT_ListNode ) ) +
5 * ( decoder.top - decoder.stack ) ) )
goto Exit;
node = (FT_ListNode)memory->alloc( memory,
sizeof ( FT_ListNodeRec ) );
if ( !node )
goto Out_Of_Memory_Error;
FT_List_Add( &parser->t2_strings, (FT_ListNode)q );
FT_List_Add( &parser->t2_strings, node );
q += 2 * sizeof ( FT_ListNode );
t2 = (CFF_T2_String)memory->alloc( memory,
sizeof ( CFF_T2_StringRec ) );
if ( !t2 )
goto Out_Of_Memory_Error;
node->data = t2;
/* `5' is the conservative upper bound of required bytes per stack */
/* element. */
t2_size = 5 * ( decoder.top - decoder.stack );
q = (FT_Byte*)memory->alloc( memory, t2_size );
if ( !q )
goto Out_Of_Memory_Error;
t2->start = q;
t2->limit = q + t2_size;
stack = decoder.stack;
while ( stack < decoder.top )
for ( stack = decoder.stack; stack < decoder.top; stack++ )
{
FT_ULong num;
FT_Bool neg;
FT_Long num = *stack;
if ( (FT_UInt)( parser->top - parser->stack ) >= parser->stackSize )
@ -1349,69 +1261,37 @@
*parser->top++ = q;
if ( *stack < 0 )
{
num = (FT_ULong)NEG_LONG( *stack );
neg = 1;
}
else
{
num = (FT_ULong)*stack;
neg = 0;
}
if ( num & 0xFFFFU )
{
if ( neg )
num = (FT_ULong)-num;
*q++ = 255;
*q++ = ( num & 0xFF000000U ) >> 24;
*q++ = ( num & 0x00FF0000U ) >> 16;
*q++ = ( num & 0x0000FF00U ) >> 8;
*q++ = num & 0x000000FFU;
*q++ = (FT_Byte)( ( num >> 24 ) & 0xFF );
*q++ = (FT_Byte)( ( num >> 16 ) & 0xFF );
*q++ = (FT_Byte)( ( num >> 8 ) & 0xFF );
*q++ = (FT_Byte)( ( num ) & 0xFF );
}
else
{
num >>= 16;
if ( neg )
if ( -107 <= num && num <= 107 )
*q++ = (FT_Byte)( num + 139 );
else if ( 108 <= num && num <= 1131 )
{
if ( num <= 107 )
*q++ = (FT_Byte)( 139 - num );
else if ( num <= 1131 )
{
*q++ = (FT_Byte)( ( ( num - 108 ) >> 8 ) + 251 );
*q++ = (FT_Byte)( ( num - 108 ) & 0xFF );
}
else
{
num = (FT_ULong)-num;
*q++ = 28;
*q++ = (FT_Byte)( num >> 8 );
*q++ = (FT_Byte)( num & 0xFF );
}
*q++ = (FT_Byte)( ( ( num - 108 ) >> 8 ) + 247 );
*q++ = (FT_Byte)( ( num - 108 ) & 0xFF );
}
else if ( -1131 <= num && num <= -108 )
{
*q++ = (FT_Byte)( ( ( -num - 108 ) >> 8 ) + 251 );
*q++ = (FT_Byte)( ( -num - 108) & 0xFF );
}
else
{
if ( num <= 107 )
*q++ = (FT_Byte)( num + 139 );
else if ( num <= 1131 )
{
*q++ = (FT_Byte)( ( ( num - 108 ) >> 8 ) + 247 );
*q++ = (FT_Byte)( ( num - 108 ) & 0xFF );
}
else
{
*q++ = 28;
*q++ = (FT_Byte)( num >> 8 );
*q++ = (FT_Byte)( num & 0xFF );
}
*q++ = 28;
*q++ = (FT_Byte)( num >> 8 );
*q++ = (FT_Byte)( num & 0xFF );
}
}
stack++;
}
}
#endif /* CFF_CONFIG_OPTION_OLD_ENGINE */
@ -1598,12 +1478,6 @@
Exit:
return error;
#ifdef CFF_CONFIG_OPTION_OLD_ENGINE
Out_Of_Memory_Error:
error = FT_THROW( Out_Of_Memory );
goto Exit;
#endif
Stack_Overflow:
error = FT_THROW( Invalid_Argument );
goto Exit;

9
thirdparty/freetype/src/cff/cffparse.h vendored
View file

@ -133,15 +133,6 @@ FT_BEGIN_HEADER
FT_END_HEADER
#ifdef CFF_CONFIG_OPTION_OLD_ENGINE
typedef struct CFF_T2_String_
{
FT_Byte* start;
FT_Byte* limit;
} CFF_T2_StringRec, *CFF_T2_String;
#endif /* CFF_CONFIG_OPTION_OLD_ENGINE */
#endif /* CFFPARSE_H_ */

141
thirdparty/freetype/src/cid/cidgload.c vendored
View file

@ -40,6 +40,117 @@
#define FT_COMPONENT cidgload
/*
* A helper function to compute FD number (`fd_select`), the offset to the
* head of the glyph data (`off1`), and the offset to the and of the glyph
* data (`off2`).
*
* The number how many times `cid_get_offset` is invoked can be controlled
* by the number of non-NULL arguments. If `fd_select` is non-NULL but
* `off1` and `off2` are NULL, `cid_get_offset` is invoked only for
* `fd_select`; `off1` and `off2` are not validated.
*
*/
FT_LOCAL_DEF( FT_Error )
cid_compute_fd_and_offsets( CID_Face face,
FT_UInt glyph_index,
FT_ULong* fd_select_p,
FT_ULong* off1_p,
FT_ULong* off2_p )
{
FT_Error error = FT_Err_Ok;
CID_FaceInfo cid = &face->cid;
FT_Stream stream = face->cid_stream;
FT_UInt entry_len = cid->fd_bytes + cid->gd_bytes;
FT_Byte* p;
FT_Bool need_frame_exit = 0;
FT_ULong fd_select, off1, off2;
/* For ordinary fonts, read the CID font dictionary index */
/* and charstring offset from the CIDMap. */
if ( FT_STREAM_SEEK( cid->data_offset + cid->cidmap_offset +
glyph_index * entry_len ) ||
FT_FRAME_ENTER( 2 * entry_len ) )
goto Exit;
need_frame_exit = 1;
p = (FT_Byte*)stream->cursor;
fd_select = cid_get_offset( &p, cid->fd_bytes );
off1 = cid_get_offset( &p, cid->gd_bytes );
p += cid->fd_bytes;
off2 = cid_get_offset( &p, cid->gd_bytes );
if ( fd_select_p )
*fd_select_p = fd_select;
if ( off1_p )
*off1_p = off1;
if ( off2_p )
*off2_p = off2;
if ( fd_select >= cid->num_dicts )
{
/*
* fd_select == 0xFF is often used to indicate that the CID
* has no charstring to be rendered, similar to GID = 0xFFFF
* in TrueType fonts.
*/
if ( ( cid->fd_bytes == 1 && fd_select == 0xFFU ) ||
( cid->fd_bytes == 2 && fd_select == 0xFFFFU ) )
{
FT_TRACE1(( "cid_load_glyph: fail for glyph index %d:\n",
glyph_index ));
FT_TRACE1(( " FD number %ld is the maximum\n",
fd_select ));
FT_TRACE1(( " integer fitting into %d byte%s\n",
cid->fd_bytes, cid->fd_bytes == 1 ? "" : "s" ));
}
else
{
FT_TRACE0(( "cid_load_glyph: fail for glyph index %d:\n",
glyph_index ));
FT_TRACE0(( " FD number %ld is larger\n",
fd_select ));
FT_TRACE0(( " than number of dictionaries (%d)\n",
cid->num_dicts ));
}
error = FT_THROW( Invalid_Offset );
goto Exit;
}
else if ( off2 > stream->size )
{
FT_TRACE0(( "cid_load_glyph: fail for glyph index %d:\n",
glyph_index ));
FT_TRACE0(( " end of the glyph data\n" ));
FT_TRACE0(( " is beyond the data stream\n" ));
error = FT_THROW( Invalid_Offset );
goto Exit;
}
else if ( off1 > off2 )
{
FT_TRACE0(( "cid_load_glyph: fail for glyph index %d:\n",
glyph_index ));
FT_TRACE0(( " the end position of glyph data\n" ));
FT_TRACE0(( " is set before the start position\n" ));
error = FT_THROW( Invalid_Offset );
}
Exit:
if ( need_frame_exit )
FT_FRAME_EXIT();
return error;
}
FT_CALLBACK_DEF( FT_Error )
cid_load_glyph( T1_Decoder decoder,
FT_UInt glyph_index )
@ -97,35 +208,15 @@
else
#endif /* FT_CONFIG_OPTION_INCREMENTAL */
/* For ordinary fonts read the CID font dictionary index */
/* and charstring offset from the CIDMap. */
{
FT_UInt entry_len = cid->fd_bytes + cid->gd_bytes;
FT_ULong off1, off2;
if ( FT_STREAM_SEEK( cid->data_offset + cid->cidmap_offset +
glyph_index * entry_len ) ||
FT_FRAME_ENTER( 2 * entry_len ) )
error = cid_compute_fd_and_offsets( face, glyph_index,
&fd_select, &off1, &off2 );
if ( error )
goto Exit;
p = (FT_Byte*)stream->cursor;
fd_select = cid_get_offset( &p, cid->fd_bytes );
off1 = cid_get_offset( &p, cid->gd_bytes );
p += cid->fd_bytes;
off2 = cid_get_offset( &p, cid->gd_bytes );
FT_FRAME_EXIT();
if ( fd_select >= cid->num_dicts ||
off2 > stream->size ||
off1 > off2 )
{
FT_TRACE0(( "cid_load_glyph: invalid glyph stream offsets\n" ));
error = FT_THROW( Invalid_Offset );
goto Exit;
}
glyph_length = off2 - off1;
if ( glyph_length == 0 ||
@ -161,7 +252,9 @@
cs_offset = decoder->lenIV >= 0 ? (FT_UInt)decoder->lenIV : 0;
if ( cs_offset > glyph_length )
{
FT_TRACE0(( "cid_load_glyph: invalid glyph stream offsets\n" ));
FT_TRACE0(( "cid_load_glyph: fail for glyph_index=%d, "
"offset to the charstring is beyond glyph length\n",
glyph_index ));
error = FT_THROW( Invalid_Offset );
goto Exit;
}

8
thirdparty/freetype/src/cid/cidgload.h vendored
View file

@ -42,6 +42,14 @@ FT_BEGIN_HEADER
FT_Int32 load_flags );
FT_LOCAL( FT_Error )
cid_compute_fd_and_offsets( CID_Face face,
FT_UInt glyph_index,
FT_ULong* fd_select_p,
FT_ULong* off1_p,
FT_ULong* off2_p );
FT_END_HEADER
#endif /* CIDGLOAD_H_ */

51
thirdparty/freetype/src/cid/cidload.c vendored
View file

@ -155,23 +155,24 @@
FT_CALLBACK_DEF( void )
cid_parse_font_matrix( CID_Face face,
CID_Parser* parser )
cid_parse_font_matrix( FT_Face face, /* CID_Face */
void* parser_ )
{
CID_Face cidface = (CID_Face)face;
CID_Parser* parser = (CID_Parser*)parser_;
CID_FaceDict dict;
FT_Face root = (FT_Face)&face->root;
FT_Fixed temp[6];
FT_Fixed temp_scale;
if ( parser->num_dict < face->cid.num_dicts )
if ( parser->num_dict < cidface->cid.num_dicts )
{
FT_Matrix* matrix;
FT_Vector* offset;
FT_Int result;
dict = face->cid.font_dicts + parser->num_dict;
dict = cidface->cid.font_dicts + parser->num_dict;
matrix = &dict->font_matrix;
offset = &dict->font_offset;
@ -204,7 +205,7 @@
if ( temp_scale != 0x10000L )
{
/* set units per EM based on FontMatrix values */
root->units_per_EM = (FT_UShort)FT_DivFix( 1000, temp_scale );
face->units_per_EM = (FT_UShort)FT_DivFix( 1000, temp_scale );
temp[0] = FT_DivFix( temp[0], temp_scale );
temp[1] = FT_DivFix( temp[1], temp_scale );
@ -237,13 +238,15 @@
FT_CALLBACK_DEF( void )
parse_fd_array( CID_Face face,
CID_Parser* parser )
parse_fd_array( FT_Face face, /* CID_Face */
void* parser_ )
{
CID_FaceInfo cid = &face->cid;
FT_Memory memory = face->root.memory;
FT_Stream stream = parser->stream;
FT_Error error = FT_Err_Ok;
CID_Face cidface = (CID_Face)face;
CID_Parser* parser = (CID_Parser*)parser_;
CID_FaceInfo cid = &cidface->cid;
FT_Memory memory = FT_FACE_MEMORY( face );
FT_Stream stream = parser->stream;
FT_Error error = FT_Err_Ok;
FT_Long num_dicts, max_dicts;
@ -313,18 +316,20 @@
/* By mistake, `expansion_factor' appears both in PS_PrivateRec */
/* and CID_FaceDictRec (both are public header files and can't */
/* changed). We simply copy the value. */
/* be thus changed). We simply copy the value. */
FT_CALLBACK_DEF( void )
parse_expansion_factor( CID_Face face,
CID_Parser* parser )
parse_expansion_factor( FT_Face face, /* CID_Face */
void* parser_ )
{
CID_Face cidface = (CID_Face)face;
CID_Parser* parser = (CID_Parser*)parser_;
CID_FaceDict dict;
if ( parser->num_dict < face->cid.num_dicts )
if ( parser->num_dict < cidface->cid.num_dicts )
{
dict = face->cid.font_dicts + parser->num_dict;
dict = cidface->cid.font_dicts + parser->num_dict;
dict->expansion_factor = cid_parser_to_fixed( parser, 0 );
dict->private_dict.expansion_factor = dict->expansion_factor;
@ -341,11 +346,15 @@
/* to catch it for producing better trace output. */
FT_CALLBACK_DEF( void )
parse_font_name( CID_Face face,
CID_Parser* parser )
parse_font_name( FT_Face face, /* CID_Face */
void* parser_ )
{
#ifdef FT_DEBUG_LEVEL_TRACE
if ( parser->num_dict < face->cid.num_dicts )
CID_Face cidface = (CID_Face)face;
CID_Parser* parser = (CID_Parser*)parser_;
if ( parser->num_dict < cidface->cid.num_dicts )
{
T1_TokenRec token;
FT_UInt len;
@ -361,7 +370,7 @@
}
#else
FT_UNUSED( face );
FT_UNUSED( parser );
FT_UNUSED( parser_ );
#endif
return;

14
thirdparty/freetype/src/cid/cidobjs.c vendored
View file

@ -69,8 +69,7 @@
FT_Module module;
module = FT_Get_Module( slot->face->driver->root.library,
"pshinter" );
module = FT_Get_Module( slot->library, "pshinter" );
if ( module )
{
T1_Hints_Funcs funcs;
@ -268,7 +267,8 @@
*
* @Input:
* stream ::
* The source font stream.
* Dummy argument for compatibility with the `FT_Face_InitFunc` API.
* Ignored. The stream should be passed through `face->root.stream`.
*
* face_index ::
* The index of the font face in the resource.
@ -375,6 +375,14 @@
if ( info->is_fixed_pitch )
cidface->face_flags |= FT_FACE_FLAG_FIXED_WIDTH;
/*
* For the sfnt-wrapped CID fonts for MacOS, currently,
* its `cmap' tables are ignored, and the content in
* its `CID ' table is treated the same as naked CID-keyed
* font. See ft_lookup_PS_in_sfnt_stream().
*/
cidface->face_flags |= FT_FACE_FLAG_CID_KEYED;
/* XXX: TODO: add kerning with .afm support */
/* get style name -- be careful, some broken fonts only */

18
thirdparty/freetype/src/cid/cidparse.c vendored
View file

@ -214,18 +214,24 @@
cur <= limit - STARTDATA_LEN &&
ft_strncmp( (char*)cur, STARTDATA, STARTDATA_LEN ) == 0 )
{
if ( ft_strncmp( (char*)arg1, "(Hex)", 5 ) == 0 )
T1_TokenRec type_token;
FT_Long binary_length;
parser->root.cursor = arg1;
cid_parser_to_token( parser, &type_token );
if ( type_token.limit - type_token.start == 5 &&
ft_memcmp( (char*)type_token.start, "(Hex)", 5 ) == 0 )
{
FT_Long tmp = ft_strtol( (const char *)arg2, NULL, 10 );
if ( tmp < 0 )
parser->root.cursor = arg2;
binary_length = cid_parser_to_int( parser );
if ( binary_length < 0 )
{
FT_ERROR(( "cid_parser_new: invalid length of hex data\n" ));
error = FT_THROW( Invalid_File_Format );
}
else
parser->binary_length = (FT_ULong)tmp;
parser->binary_length = (FT_ULong)binary_length;
}
goto Exit;

93
thirdparty/freetype/src/cid/cidriver.c vendored
View file

@ -48,10 +48,11 @@
*
*/
static const char*
cid_get_postscript_name( CID_Face face )
FT_CALLBACK_DEF( const char* )
cid_get_postscript_name( FT_Face face ) /* CID_Face */
{
const char* result = face->cid.cid_font_name;
CID_Face cidface = (CID_Face)face;
const char* result = cidface->cid.cid_font_name;
if ( result && result[0] == '/' )
@ -72,34 +73,36 @@
*
*/
static FT_Error
cid_ps_get_font_info( FT_Face face,
FT_CALLBACK_DEF( FT_Error )
cid_ps_get_font_info( FT_Face face, /* CID_Face */
PS_FontInfoRec* afont_info )
{
*afont_info = ((CID_Face)face)->cid.font_info;
*afont_info = ( (CID_Face)face )->cid.font_info;
return FT_Err_Ok;
}
static FT_Error
cid_ps_get_font_extra( FT_Face face,
PS_FontExtraRec* afont_extra )
FT_CALLBACK_DEF( FT_Error )
cid_ps_get_font_extra( FT_Face face, /* CID_Face */
PS_FontExtraRec* afont_extra )
{
*afont_extra = ((CID_Face)face)->font_extra;
*afont_extra = ( (CID_Face)face )->font_extra;
return FT_Err_Ok;
}
static const FT_Service_PsInfoRec cid_service_ps_info =
{
(PS_GetFontInfoFunc) cid_ps_get_font_info, /* ps_get_font_info */
(PS_GetFontExtraFunc) cid_ps_get_font_extra, /* ps_get_font_extra */
cid_ps_get_font_info, /* PS_GetFontInfoFunc ps_get_font_info */
cid_ps_get_font_extra, /* PS_GetFontExtraFunc ps_get_font_extra */
/* unsupported with CID fonts */
(PS_HasGlyphNamesFunc) NULL, /* ps_has_glyph_names */
NULL, /* PS_HasGlyphNamesFunc ps_has_glyph_names */
/* unsupported */
(PS_GetFontPrivateFunc)NULL, /* ps_get_font_private */
NULL, /* PS_GetFontPrivateFunc ps_get_font_private */
/* not implemented */
(PS_GetFontValueFunc) NULL /* ps_get_font_value */
NULL /* PS_GetFontValueFunc ps_get_font_value */
};
@ -107,13 +110,14 @@
* CID INFO SERVICE
*
*/
static FT_Error
cid_get_ros( CID_Face face,
FT_CALLBACK_DEF( FT_Error )
cid_get_ros( FT_Face face, /* CID_Face */
const char* *registry,
const char* *ordering,
FT_Int *supplement )
{
CID_FaceInfo cid = &face->cid;
CID_Face cidface = (CID_Face)face;
CID_FaceInfo cid = &cidface->cid;
if ( registry )
@ -129,32 +133,48 @@
}
static FT_Error
cid_get_is_cid( CID_Face face,
FT_CALLBACK_DEF( FT_Error )
cid_get_is_cid( FT_Face face, /* CID_Face */
FT_Bool *is_cid )
{
FT_Error error = FT_Err_Ok;
FT_UNUSED( face );
/*
* XXX: If the ROS is Adobe-Identity-H or -V,
* the font has no reliable information about
* its glyph collection. Should we not set
* *is_cid in such cases?
*/
if ( is_cid )
*is_cid = 1; /* cid driver is only used for CID keyed fonts */
*is_cid = 1;
return error;
}
static FT_Error
cid_get_cid_from_glyph_index( CID_Face face,
FT_CALLBACK_DEF( FT_Error )
cid_get_cid_from_glyph_index( FT_Face face, /* CID_Face */
FT_UInt glyph_index,
FT_UInt *cid )
{
FT_Error error = FT_Err_Ok;
FT_UNUSED( face );
FT_Error error = FT_Err_Ok;
CID_Face cidface = (CID_Face)face;
if ( cid )
*cid = glyph_index; /* identity mapping */
/*
* Currently, FreeType does not support incrementally-defined, CID-keyed
* fonts that store the glyph description data in a `/GlyphDirectory`
* array or dictionary. Fonts loaded by the incremental loading feature
* are thus not handled here.
*/
error = cid_compute_fd_and_offsets( cidface, glyph_index,
NULL, NULL, NULL );
if ( error )
*cid = 0;
else
*cid = glyph_index;
return error;
}
@ -162,12 +182,12 @@
static const FT_Service_CIDRec cid_service_cid_info =
{
(FT_CID_GetRegistryOrderingSupplementFunc)
cid_get_ros, /* get_ros */
(FT_CID_GetIsInternallyCIDKeyedFunc)
cid_get_is_cid, /* get_is_cid */
(FT_CID_GetCIDFromGlyphIndexFunc)
cid_get_cid_from_glyph_index /* get_cid_from_glyph_index */
cid_get_ros,
/* FT_CID_GetRegistryOrderingSupplementFunc get_ros */
cid_get_is_cid,
/* FT_CID_GetIsInternallyCIDKeyedFunc get_is_cid */
cid_get_cid_from_glyph_index
/* FT_CID_GetCIDFromGlyphIndexFunc get_cid_from_glyph_index */
};
@ -179,9 +199,9 @@
FT_DEFINE_SERVICE_PROPERTIESREC(
cid_service_properties,
(FT_Properties_SetFunc)ps_property_set, /* set_property */
(FT_Properties_GetFunc)ps_property_get ) /* get_property */
ps_property_set, /* FT_Properties_SetFunc set_property */
ps_property_get /* FT_Properties_GetFunc get_property */
)
/*
* SERVICE LIST
@ -209,7 +229,6 @@
}
FT_CALLBACK_TABLE_DEF
const FT_Driver_ClassRec t1cid_driver_class =
{

3
thirdparty/freetype/src/gxvalid/gxvfgen.c vendored
View file

@ -97,7 +97,8 @@
#define EMPTYFEAT {0, 0, {NULL}}
static GX_Feature_RegistryRec featreg_table[] = {
static GX_Feature_RegistryRec featreg_table[] =
{
{ /* 0 */
"All Typographic Features",
0,

5
thirdparty/freetype/src/gzip/ftgzip.c vendored
View file

@ -70,10 +70,9 @@
/* so that configuration with `FT_CONFIG_OPTION_SYSTEM_ZLIB' might */
/* include the wrong `zconf.h' file, leading to errors. */
#if defined( __GNUC__ ) || defined( __clang__ )
#define ZEXPORT
#define ZEXTERN static
#endif
/* prevent zlib functions from being visible outside their object files */
#define ZEXTERN static
#define HAVE_MEMCPY 1
#define Z_SOLO 1

644
thirdparty/freetype/src/gzip/infback.c vendored
View file

@ -1,644 +0,0 @@
/* infback.c -- inflate using a call-back interface
* Copyright (C) 1995-2022 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/*
This code is largely copied from inflate.c. Normally either infback.o or
inflate.o would be linked into an application--not both. The interface
with inffast.c is retained so that optimized assembler-coded versions of
inflate_fast() can be used with either inflate.c or infback.c.
*/
#include "zutil.h"
#include "inftrees.h"
#include "inflate.h"
#include "inffast.h"
/* function prototypes */
local void fixedtables OF((struct inflate_state FAR *state));
/*
strm provides memory allocation functions in zalloc and zfree, or
Z_NULL to use the library memory allocation functions.
windowBits is in the range 8..15, and window is a user-supplied
window and output buffer that is 2**windowBits bytes.
*/
int ZEXPORT inflateBackInit_(
z_streamp strm,
int windowBits,
unsigned char FAR *window,
const char *version,
int stream_size)
{
struct inflate_state FAR *state;
if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
stream_size != (int)(sizeof(z_stream)))
return Z_VERSION_ERROR;
if (strm == Z_NULL || window == Z_NULL ||
windowBits < 8 || windowBits > 15)
return Z_STREAM_ERROR;
strm->msg = Z_NULL; /* in case we return an error */
if (strm->zalloc == (alloc_func)0) {
#ifdef Z_SOLO
return Z_STREAM_ERROR;
#else
strm->zalloc = zcalloc;
strm->opaque = (voidpf)0;
#endif
}
if (strm->zfree == (free_func)0)
#ifdef Z_SOLO
return Z_STREAM_ERROR;
#else
strm->zfree = zcfree;
#endif
state = (struct inflate_state FAR *)ZALLOC(strm, 1,
sizeof(struct inflate_state));
if (state == Z_NULL) return Z_MEM_ERROR;
Tracev((stderr, "inflate: allocated\n"));
strm->state = (struct internal_state FAR *)state;
state->dmax = 32768U;
state->wbits = (uInt)windowBits;
state->wsize = 1U << windowBits;
state->window = window;
state->wnext = 0;
state->whave = 0;
state->sane = 1;
return Z_OK;
}
/*
Return state with length and distance decoding tables and index sizes set to
fixed code decoding. Normally this returns fixed tables from inffixed.h.
If BUILDFIXED is defined, then instead this routine builds the tables the
first time it's called, and returns those tables the first time and
thereafter. This reduces the size of the code by about 2K bytes, in
exchange for a little execution time. However, BUILDFIXED should not be
used for threaded applications, since the rewriting of the tables and virgin
may not be thread-safe.
*/
local void fixedtables(
struct inflate_state FAR *state)
{
#ifdef BUILDFIXED
static int virgin = 1;
static code *lenfix, *distfix;
static code fixed[544];
/* build fixed huffman tables if first call (may not be thread safe) */
if (virgin) {
unsigned sym, bits;
static code *next;
/* literal/length table */
sym = 0;
while (sym < 144) state->lens[sym++] = 8;
while (sym < 256) state->lens[sym++] = 9;
while (sym < 280) state->lens[sym++] = 7;
while (sym < 288) state->lens[sym++] = 8;
next = fixed;
lenfix = next;
bits = 9;
inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
/* distance table */
sym = 0;
while (sym < 32) state->lens[sym++] = 5;
distfix = next;
bits = 5;
inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
/* do this just once */
virgin = 0;
}
#else /* !BUILDFIXED */
# include "inffixed.h"
#endif /* BUILDFIXED */
state->lencode = lenfix;
state->lenbits = 9;
state->distcode = distfix;
state->distbits = 5;
}
/* Macros for inflateBack(): */
/* Load returned state from inflate_fast() */
#define LOAD() \
do { \
put = strm->next_out; \
left = strm->avail_out; \
next = strm->next_in; \
have = strm->avail_in; \
hold = state->hold; \
bits = state->bits; \
} while (0)
/* Set state from registers for inflate_fast() */
#define RESTORE() \
do { \
strm->next_out = put; \
strm->avail_out = left; \
strm->next_in = next; \
strm->avail_in = have; \
state->hold = hold; \
state->bits = bits; \
} while (0)
/* Clear the input bit accumulator */
#define INITBITS() \
do { \
hold = 0; \
bits = 0; \
} while (0)
/* Assure that some input is available. If input is requested, but denied,
then return a Z_BUF_ERROR from inflateBack(). */
#define PULL() \
do { \
if (have == 0) { \
have = in(in_desc, &next); \
if (have == 0) { \
next = Z_NULL; \
ret = Z_BUF_ERROR; \
goto inf_leave; \
} \
} \
} while (0)
/* Get a byte of input into the bit accumulator, or return from inflateBack()
with an error if there is no input available. */
#define PULLBYTE() \
do { \
PULL(); \
have--; \
hold += (unsigned long)(*next++) << bits; \
bits += 8; \
} while (0)
/* Assure that there are at least n bits in the bit accumulator. If there is
not enough available input to do that, then return from inflateBack() with
an error. */
#define NEEDBITS(n) \
do { \
while (bits < (unsigned)(n)) \
PULLBYTE(); \
} while (0)
/* Return the low n bits of the bit accumulator (n < 16) */
#define BITS(n) \
((unsigned)hold & ((1U << (n)) - 1))
/* Remove n bits from the bit accumulator */
#define DROPBITS(n) \
do { \
hold >>= (n); \
bits -= (unsigned)(n); \
} while (0)
/* Remove zero to seven bits as needed to go to a byte boundary */
#define BYTEBITS() \
do { \
hold >>= bits & 7; \
bits -= bits & 7; \
} while (0)
/* Assure that some output space is available, by writing out the window
if it's full. If the write fails, return from inflateBack() with a
Z_BUF_ERROR. */
#define ROOM() \
do { \
if (left == 0) { \
put = state->window; \
left = state->wsize; \
state->whave = left; \
if (out(out_desc, put, left)) { \
ret = Z_BUF_ERROR; \
goto inf_leave; \
} \
} \
} while (0)
/*
strm provides the memory allocation functions and window buffer on input,
and provides information on the unused input on return. For Z_DATA_ERROR
returns, strm will also provide an error message.
in() and out() are the call-back input and output functions. When
inflateBack() needs more input, it calls in(). When inflateBack() has
filled the window with output, or when it completes with data in the
window, it calls out() to write out the data. The application must not
change the provided input until in() is called again or inflateBack()
returns. The application must not change the window/output buffer until
inflateBack() returns.
in() and out() are called with a descriptor parameter provided in the
inflateBack() call. This parameter can be a structure that provides the
information required to do the read or write, as well as accumulated
information on the input and output such as totals and check values.
in() should return zero on failure. out() should return non-zero on
failure. If either in() or out() fails, than inflateBack() returns a
Z_BUF_ERROR. strm->next_in can be checked for Z_NULL to see whether it
was in() or out() that caused in the error. Otherwise, inflateBack()
returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format
error, or Z_MEM_ERROR if it could not allocate memory for the state.
inflateBack() can also return Z_STREAM_ERROR if the input parameters
are not correct, i.e. strm is Z_NULL or the state was not initialized.
*/
int ZEXPORT inflateBack(
z_streamp strm,
in_func in,
void FAR *in_desc,
out_func out,
void FAR *out_desc)
{
struct inflate_state FAR *state;
z_const unsigned char FAR *next; /* next input */
unsigned char FAR *put; /* next output */
unsigned have, left; /* available input and output */
unsigned long hold; /* bit buffer */
unsigned bits; /* bits in bit buffer */
unsigned copy; /* number of stored or match bytes to copy */
unsigned char FAR *from; /* where to copy match bytes from */
code here; /* current decoding table entry */
code last; /* parent table entry */
unsigned len; /* length to copy for repeats, bits to drop */
int ret; /* return code */
static const unsigned short order[19] = /* permutation of code lengths */
{16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
/* Check that the strm exists and that the state was initialized */
if (strm == Z_NULL || strm->state == Z_NULL)
return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
/* Reset the state */
strm->msg = Z_NULL;
state->mode = TYPE;
state->last = 0;
state->whave = 0;
next = strm->next_in;
have = next != Z_NULL ? strm->avail_in : 0;
hold = 0;
bits = 0;
put = state->window;
left = state->wsize;
/* Inflate until end of block marked as last */
for (;;)
switch (state->mode) {
case TYPE:
/* determine and dispatch block type */
if (state->last) {
BYTEBITS();
state->mode = DONE;
break;
}
NEEDBITS(3);
state->last = BITS(1);
DROPBITS(1);
switch (BITS(2)) {
case 0: /* stored block */
Tracev((stderr, "inflate: stored block%s\n",
state->last ? " (last)" : ""));
state->mode = STORED;
break;
case 1: /* fixed block */
fixedtables(state);
Tracev((stderr, "inflate: fixed codes block%s\n",
state->last ? " (last)" : ""));
state->mode = LEN; /* decode codes */
break;
case 2: /* dynamic block */
Tracev((stderr, "inflate: dynamic codes block%s\n",
state->last ? " (last)" : ""));
state->mode = TABLE;
break;
case 3:
strm->msg = (char *)"invalid block type";
state->mode = BAD;
}
DROPBITS(2);
break;
case STORED:
/* get and verify stored block length */
BYTEBITS(); /* go to byte boundary */
NEEDBITS(32);
if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
strm->msg = (char *)"invalid stored block lengths";
state->mode = BAD;
break;
}
state->length = (unsigned)hold & 0xffff;
Tracev((stderr, "inflate: stored length %u\n",
state->length));
INITBITS();
/* copy stored block from input to output */
while (state->length != 0) {
copy = state->length;
PULL();
ROOM();
if (copy > have) copy = have;
if (copy > left) copy = left;
zmemcpy(put, next, copy);
have -= copy;
next += copy;
left -= copy;
put += copy;
state->length -= copy;
}
Tracev((stderr, "inflate: stored end\n"));
state->mode = TYPE;
break;
case TABLE:
/* get dynamic table entries descriptor */
NEEDBITS(14);
state->nlen = BITS(5) + 257;
DROPBITS(5);
state->ndist = BITS(5) + 1;
DROPBITS(5);
state->ncode = BITS(4) + 4;
DROPBITS(4);
#ifndef PKZIP_BUG_WORKAROUND
if (state->nlen > 286 || state->ndist > 30) {
strm->msg = (char *)"too many length or distance symbols";
state->mode = BAD;
break;
}
#endif
Tracev((stderr, "inflate: table sizes ok\n"));
/* get code length code lengths (not a typo) */
state->have = 0;
while (state->have < state->ncode) {
NEEDBITS(3);
state->lens[order[state->have++]] = (unsigned short)BITS(3);
DROPBITS(3);
}
while (state->have < 19)
state->lens[order[state->have++]] = 0;
state->next = state->codes;
state->lencode = (code const FAR *)(state->next);
state->lenbits = 7;
ret = inflate_table(CODES, state->lens, 19, &(state->next),
&(state->lenbits), state->work);
if (ret) {
strm->msg = (char *)"invalid code lengths set";
state->mode = BAD;
break;
}
Tracev((stderr, "inflate: code lengths ok\n"));
/* get length and distance code code lengths */
state->have = 0;
while (state->have < state->nlen + state->ndist) {
for (;;) {
here = state->lencode[BITS(state->lenbits)];
if ((unsigned)(here.bits) <= bits) break;
PULLBYTE();
}
if (here.val < 16) {
DROPBITS(here.bits);
state->lens[state->have++] = here.val;
}
else {
if (here.val == 16) {
NEEDBITS(here.bits + 2);
DROPBITS(here.bits);
if (state->have == 0) {
strm->msg = (char *)"invalid bit length repeat";
state->mode = BAD;
break;
}
len = (unsigned)(state->lens[state->have - 1]);
copy = 3 + BITS(2);
DROPBITS(2);
}
else if (here.val == 17) {
NEEDBITS(here.bits + 3);
DROPBITS(here.bits);
len = 0;
copy = 3 + BITS(3);
DROPBITS(3);
}
else {
NEEDBITS(here.bits + 7);
DROPBITS(here.bits);
len = 0;
copy = 11 + BITS(7);
DROPBITS(7);
}
if (state->have + copy > state->nlen + state->ndist) {
strm->msg = (char *)"invalid bit length repeat";
state->mode = BAD;
break;
}
while (copy--)
state->lens[state->have++] = (unsigned short)len;
}
}
/* handle error breaks in while */
if (state->mode == BAD) break;
/* check for end-of-block code (better have one) */
if (state->lens[256] == 0) {
strm->msg = (char *)"invalid code -- missing end-of-block";
state->mode = BAD;
break;
}
/* build code tables -- note: do not change the lenbits or distbits
values here (9 and 6) without reading the comments in inftrees.h
concerning the ENOUGH constants, which depend on those values */
state->next = state->codes;
state->lencode = (code const FAR *)(state->next);
state->lenbits = 9;
ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
&(state->lenbits), state->work);
if (ret) {
strm->msg = (char *)"invalid literal/lengths set";
state->mode = BAD;
break;
}
state->distcode = (code const FAR *)(state->next);
state->distbits = 6;
ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
&(state->next), &(state->distbits), state->work);
if (ret) {
strm->msg = (char *)"invalid distances set";
state->mode = BAD;
break;
}
Tracev((stderr, "inflate: codes ok\n"));
state->mode = LEN;
/* fallthrough */
case LEN:
/* use inflate_fast() if we have enough input and output */
if (have >= 6 && left >= 258) {
RESTORE();
if (state->whave < state->wsize)
state->whave = state->wsize - left;
inflate_fast(strm, state->wsize);
LOAD();
break;
}
/* get a literal, length, or end-of-block code */
for (;;) {
here = state->lencode[BITS(state->lenbits)];
if ((unsigned)(here.bits) <= bits) break;
PULLBYTE();
}
if (here.op && (here.op & 0xf0) == 0) {
last = here;
for (;;) {
here = state->lencode[last.val +
(BITS(last.bits + last.op) >> last.bits)];
if ((unsigned)(last.bits + here.bits) <= bits) break;
PULLBYTE();
}
DROPBITS(last.bits);
}
DROPBITS(here.bits);
state->length = (unsigned)here.val;
/* process literal */
if (here.op == 0) {
Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
"inflate: literal '%c'\n" :
"inflate: literal 0x%02x\n", here.val));
ROOM();
*put++ = (unsigned char)(state->length);
left--;
state->mode = LEN;
break;
}
/* process end of block */
if (here.op & 32) {
Tracevv((stderr, "inflate: end of block\n"));
state->mode = TYPE;
break;
}
/* invalid code */
if (here.op & 64) {
strm->msg = (char *)"invalid literal/length code";
state->mode = BAD;
break;
}
/* length code -- get extra bits, if any */
state->extra = (unsigned)(here.op) & 15;
if (state->extra != 0) {
NEEDBITS(state->extra);
state->length += BITS(state->extra);
DROPBITS(state->extra);
}
Tracevv((stderr, "inflate: length %u\n", state->length));
/* get distance code */
for (;;) {
here = state->distcode[BITS(state->distbits)];
if ((unsigned)(here.bits) <= bits) break;
PULLBYTE();
}
if ((here.op & 0xf0) == 0) {
last = here;
for (;;) {
here = state->distcode[last.val +
(BITS(last.bits + last.op) >> last.bits)];
if ((unsigned)(last.bits + here.bits) <= bits) break;
PULLBYTE();
}
DROPBITS(last.bits);
}
DROPBITS(here.bits);
if (here.op & 64) {
strm->msg = (char *)"invalid distance code";
state->mode = BAD;
break;
}
state->offset = (unsigned)here.val;
/* get distance extra bits, if any */
state->extra = (unsigned)(here.op) & 15;
if (state->extra != 0) {
NEEDBITS(state->extra);
state->offset += BITS(state->extra);
DROPBITS(state->extra);
}
if (state->offset > state->wsize - (state->whave < state->wsize ?
left : 0)) {
strm->msg = (char *)"invalid distance too far back";
state->mode = BAD;
break;
}
Tracevv((stderr, "inflate: distance %u\n", state->offset));
/* copy match from window to output */
do {
ROOM();
copy = state->wsize - state->offset;
if (copy < left) {
from = put + copy;
copy = left - copy;
}
else {
from = put - state->offset;
copy = left;
}
if (copy > state->length) copy = state->length;
state->length -= copy;
left -= copy;
do {
*put++ = *from++;
} while (--copy);
} while (state->length != 0);
break;
case DONE:
/* inflate stream terminated properly */
ret = Z_STREAM_END;
goto inf_leave;
case BAD:
ret = Z_DATA_ERROR;
goto inf_leave;
default:
/* can't happen, but makes compilers happy */
ret = Z_STREAM_ERROR;
goto inf_leave;
}
/* Write leftover output and return unused input */
inf_leave:
if (left < state->wsize) {
if (out(out_desc, state->window, state->wsize - left) &&
ret == Z_STREAM_END)
ret = Z_BUF_ERROR;
}
strm->next_in = next;
strm->avail_in = have;
return ret;
}
int ZEXPORT inflateBackEnd(
z_streamp strm)
{
if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
return Z_STREAM_ERROR;
ZFREE(strm, strm->state);
strm->state = Z_NULL;
Tracev((stderr, "inflate: end\n"));
return Z_OK;
}

122
thirdparty/freetype/src/pcf/pcfdrivr.c vendored
View file

@ -75,36 +75,36 @@ THE SOFTWARE.
FT_CALLBACK_DEF( FT_Error )
pcf_cmap_init( FT_CMap pcfcmap, /* PCF_CMap */
pcf_cmap_init( FT_CMap cmap, /* PCF_CMap */
FT_Pointer init_data )
{
PCF_CMap cmap = (PCF_CMap)pcfcmap;
PCF_Face face = (PCF_Face)FT_CMAP_FACE( pcfcmap );
PCF_CMap pcfcmap = (PCF_CMap)cmap;
PCF_Face face = (PCF_Face)FT_CMAP_FACE( cmap );
FT_UNUSED( init_data );
cmap->enc = &face->enc;
pcfcmap->enc = &face->enc;
return FT_Err_Ok;
}
FT_CALLBACK_DEF( void )
pcf_cmap_done( FT_CMap pcfcmap ) /* PCF_CMap */
pcf_cmap_done( FT_CMap cmap ) /* PCF_CMap */
{
PCF_CMap cmap = (PCF_CMap)pcfcmap;
PCF_CMap pcfcmap = (PCF_CMap)cmap;
cmap->enc = NULL;
pcfcmap->enc = NULL;
}
FT_CALLBACK_DEF( FT_UInt )
pcf_cmap_char_index( FT_CMap pcfcmap, /* PCF_CMap */
pcf_cmap_char_index( FT_CMap cmap, /* PCF_CMap */
FT_UInt32 charcode )
{
PCF_Enc enc = ( (PCF_CMap)pcfcmap )->enc;
PCF_Enc enc = ( (PCF_CMap)cmap )->enc;
FT_UInt32 i = ( charcode >> 8 ) - enc->firstRow;
FT_UInt32 j = ( charcode & 0xFF ) - enc->firstCol;
@ -121,10 +121,10 @@ THE SOFTWARE.
FT_CALLBACK_DEF( FT_UInt )
pcf_cmap_char_next( FT_CMap pcfcmap, /* PCF_CMap */
pcf_cmap_char_next( FT_CMap cmap, /* PCF_CMap */
FT_UInt32 *acharcode )
{
PCF_Enc enc = ( (PCF_CMap)pcfcmap )->enc;
PCF_Enc enc = ( (PCF_CMap)cmap )->enc;
FT_UInt32 charcode = *acharcode + 1;
FT_UInt32 i = ( charcode >> 8 ) - enc->firstRow;
@ -170,9 +170,9 @@ THE SOFTWARE.
FT_CALLBACK_DEF( void )
PCF_Face_Done( FT_Face pcfface ) /* PCF_Face */
PCF_Face_Done( FT_Face face ) /* PCF_Face */
{
PCF_Face face = (PCF_Face)pcfface;
PCF_Face pcfface = (PCF_Face)face;
FT_Memory memory;
@ -181,18 +181,18 @@ THE SOFTWARE.
memory = FT_FACE_MEMORY( face );
FT_FREE( face->metrics );
FT_FREE( face->enc.offset );
FT_FREE( pcfface->metrics );
FT_FREE( pcfface->enc.offset );
/* free properties */
if ( face->properties )
if ( pcfface->properties )
{
FT_Int i;
for ( i = 0; i < face->nprops; i++ )
for ( i = 0; i < pcfface->nprops; i++ )
{
PCF_Property prop = &face->properties[i];
PCF_Property prop = &pcfface->properties[i];
if ( prop )
@ -203,33 +203,33 @@ THE SOFTWARE.
}
}
FT_FREE( face->properties );
FT_FREE( pcfface->properties );
}
FT_FREE( face->toc.tables );
FT_FREE( pcfface->family_name );
FT_FREE( pcfface->style_name );
FT_FREE( pcfface->available_sizes );
FT_FREE( face->charset_encoding );
FT_FREE( face->charset_registry );
FT_FREE( pcfface->toc.tables );
FT_FREE( face->family_name );
FT_FREE( face->style_name );
FT_FREE( face->available_sizes );
FT_FREE( pcfface->charset_encoding );
FT_FREE( pcfface->charset_registry );
/* close compressed stream if any */
if ( pcfface->stream == &face->comp_stream )
if ( face->stream == &pcfface->comp_stream )
{
FT_Stream_Close( &face->comp_stream );
pcfface->stream = face->comp_source;
FT_Stream_Close( &pcfface->comp_stream );
face->stream = pcfface->comp_source;
}
}
FT_CALLBACK_DEF( FT_Error )
PCF_Face_Init( FT_Stream stream,
FT_Face pcfface, /* PCF_Face */
FT_Face face, /* PCF_Face */
FT_Int face_index,
FT_Int num_params,
FT_Parameter* params )
{
PCF_Face face = (PCF_Face)pcfface;
PCF_Face pcfface = (PCF_Face)face;
FT_Error error;
FT_UNUSED( num_params );
@ -238,10 +238,10 @@ THE SOFTWARE.
FT_TRACE2(( "PCF driver\n" ));
error = pcf_load_font( stream, face, face_index );
error = pcf_load_font( stream, pcfface, face_index );
if ( error )
{
PCF_Face_Done( pcfface );
PCF_Face_Done( face );
#if defined( FT_CONFIG_OPTION_USE_ZLIB ) || \
defined( FT_CONFIG_OPTION_USE_LZW ) || \
@ -254,7 +254,7 @@ THE SOFTWARE.
/* this didn't work, try gzip support! */
FT_TRACE2(( " ... try gzip stream\n" ));
error2 = FT_Stream_OpenGzip( &face->comp_stream, stream );
error2 = FT_Stream_OpenGzip( &pcfface->comp_stream, stream );
if ( FT_ERR_EQ( error2, Unimplemented_Feature ) )
goto Fail;
@ -270,7 +270,7 @@ THE SOFTWARE.
/* this didn't work, try LZW support! */
FT_TRACE2(( " ... try LZW stream\n" ));
error3 = FT_Stream_OpenLZW( &face->comp_stream, stream );
error3 = FT_Stream_OpenLZW( &pcfface->comp_stream, stream );
if ( FT_ERR_EQ( error3, Unimplemented_Feature ) )
goto Fail;
@ -286,7 +286,7 @@ THE SOFTWARE.
/* this didn't work, try Bzip2 support! */
FT_TRACE2(( " ... try Bzip2 stream\n" ));
error4 = FT_Stream_OpenBzip2( &face->comp_stream, stream );
error4 = FT_Stream_OpenBzip2( &pcfface->comp_stream, stream );
if ( FT_ERR_EQ( error4, Unimplemented_Feature ) )
goto Fail;
@ -297,12 +297,12 @@ THE SOFTWARE.
if ( error )
goto Fail;
face->comp_source = stream;
pcfface->stream = &face->comp_stream;
pcfface->comp_source = stream;
face->stream = &pcfface->comp_stream;
stream = pcfface->stream;
stream = face->stream;
error = pcf_load_font( stream, face, face_index );
error = pcf_load_font( stream, pcfface, face_index );
if ( error )
goto Fail;
@ -326,14 +326,14 @@ THE SOFTWARE.
else if ( face_index > 0 && ( face_index & 0xFFFF ) > 0 )
{
FT_ERROR(( "PCF_Face_Init: invalid face index\n" ));
PCF_Face_Done( pcfface );
PCF_Face_Done( face );
return FT_THROW( Invalid_Argument );
}
/* set up charmap */
{
FT_String *charset_registry = face->charset_registry;
FT_String *charset_encoding = face->charset_encoding;
FT_String *charset_registry = pcfface->charset_registry;
FT_String *charset_encoding = pcfface->charset_encoding;
FT_Bool unicode_charmap = 0;
@ -349,13 +349,13 @@ THE SOFTWARE.
( s[2] == 'o' || s[2] == 'O' ) )
{
s += 3;
if ( !ft_strcmp( s, "10646" ) ||
( !ft_strcmp( s, "8859" ) &&
!ft_strcmp( face->charset_encoding, "1" ) ) )
if ( !ft_strcmp( s, "10646" ) ||
( !ft_strcmp( s, "8859" ) &&
!ft_strcmp( pcfface->charset_encoding, "1" ) ) )
unicode_charmap = 1;
/* another name for ASCII */
else if ( !ft_strcmp( s, "646.1991" ) &&
!ft_strcmp( face->charset_encoding, "IRV" ) )
else if ( !ft_strcmp( s, "646.1991" ) &&
!ft_strcmp( pcfface->charset_encoding, "IRV" ) )
unicode_charmap = 1;
}
}
@ -364,7 +364,7 @@ THE SOFTWARE.
FT_CharMapRec charmap;
charmap.face = FT_FACE( face );
charmap.face = face;
charmap.encoding = FT_ENCODING_NONE;
/* initial platform/encoding should indicate unset status? */
charmap.platform_id = TT_PLATFORM_APPLE_UNICODE;
@ -386,7 +386,7 @@ THE SOFTWARE.
Fail:
FT_TRACE2(( " not a PCF file\n" ));
PCF_Face_Done( pcfface );
PCF_Face_Done( face );
error = FT_THROW( Unknown_File_Format ); /* error */
goto Exit;
}
@ -569,15 +569,16 @@ THE SOFTWARE.
*
*/
static FT_Error
pcf_get_bdf_property( PCF_Face face,
FT_CALLBACK_DEF( FT_Error )
pcf_get_bdf_property( FT_Face face, /* PCF_Face */
const char* prop_name,
BDF_PropertyRec *aproperty )
{
PCF_Face pcfface = (PCF_Face)face;
PCF_Property prop;
prop = pcf_find_property( face, prop_name );
prop = pcf_find_property( pcfface, prop_name );
if ( prop )
{
if ( prop->isString )
@ -611,13 +612,16 @@ THE SOFTWARE.
}
static FT_Error
pcf_get_charset_id( PCF_Face face,
FT_CALLBACK_DEF( FT_Error )
pcf_get_charset_id( FT_Face face, /* PCF_Face */
const char* *acharset_encoding,
const char* *acharset_registry )
{
*acharset_encoding = face->charset_encoding;
*acharset_registry = face->charset_registry;
PCF_Face pcfface = (PCF_Face)face;
*acharset_encoding = pcfface->charset_encoding;
*acharset_registry = pcfface->charset_registry;
return FT_Err_Ok;
}
@ -634,7 +638,7 @@ THE SOFTWARE.
* PROPERTY SERVICE
*
*/
static FT_Error
FT_CALLBACK_DEF( FT_Error )
pcf_property_set( FT_Module module, /* PCF_Driver */
const char* property_name,
const void* value,
@ -695,10 +699,10 @@ THE SOFTWARE.
}
static FT_Error
FT_CALLBACK_DEF( FT_Error )
pcf_property_get( FT_Module module, /* PCF_Driver */
const char* property_name,
const void* value )
void* value )
{
#ifdef PCF_CONFIG_OPTION_LONG_FAMILY_NAMES

48
thirdparty/freetype/src/pfr/pfrcmap.c vendored
View file

@ -24,17 +24,18 @@
FT_CALLBACK_DEF( FT_Error )
pfr_cmap_init( PFR_CMap cmap,
pfr_cmap_init( FT_CMap cmap, /* PFR_CMap */
FT_Pointer pointer )
{
FT_Error error = FT_Err_Ok;
PFR_Face face = (PFR_Face)FT_CMAP_FACE( cmap );
PFR_CMap pfrcmap = (PFR_CMap)cmap;
FT_Error error = FT_Err_Ok;
PFR_Face face = (PFR_Face)FT_CMAP_FACE( cmap );
FT_UNUSED( pointer );
cmap->num_chars = face->phy_font.num_chars;
cmap->chars = face->phy_font.chars;
pfrcmap->num_chars = face->phy_font.num_chars;
pfrcmap->chars = face->phy_font.chars;
/* just for safety, check that the character entries are correctly */
/* sorted in increasing character code order */
@ -42,9 +43,9 @@
FT_UInt n;
for ( n = 1; n < cmap->num_chars; n++ )
for ( n = 1; n < pfrcmap->num_chars; n++ )
{
if ( cmap->chars[n - 1].char_code >= cmap->chars[n].char_code )
if ( pfrcmap->chars[n - 1].char_code >= pfrcmap->chars[n].char_code )
{
error = FT_THROW( Invalid_Table );
goto Exit;
@ -58,26 +59,30 @@
FT_CALLBACK_DEF( void )
pfr_cmap_done( PFR_CMap cmap )
pfr_cmap_done( FT_CMap cmap ) /* PFR_CMap */
{
cmap->chars = NULL;
cmap->num_chars = 0;
PFR_CMap pfrcmap = (PFR_CMap)cmap;
pfrcmap->chars = NULL;
pfrcmap->num_chars = 0;
}
FT_CALLBACK_DEF( FT_UInt )
pfr_cmap_char_index( PFR_CMap cmap,
pfr_cmap_char_index( FT_CMap cmap, /* PFR_CMap */
FT_UInt32 char_code )
{
FT_UInt min = 0;
FT_UInt max = cmap->num_chars;
FT_UInt mid = min + ( max - min ) / 2;
PFR_CMap pfrcmap = (PFR_CMap)cmap;
FT_UInt min = 0;
FT_UInt max = pfrcmap->num_chars;
FT_UInt mid = min + ( max - min ) / 2;
PFR_Char gchar;
while ( min < max )
{
gchar = cmap->chars + mid;
gchar = pfrcmap->chars + mid;
if ( gchar->char_code == char_code )
return mid + 1;
@ -96,10 +101,11 @@
}
FT_CALLBACK_DEF( FT_UInt32 )
pfr_cmap_char_next( PFR_CMap cmap,
FT_CALLBACK_DEF( FT_UInt )
pfr_cmap_char_next( FT_CMap cmap, /* PFR_CMap */
FT_UInt32 *pchar_code )
{
PFR_CMap pfrcmap = (PFR_CMap)cmap;
FT_UInt result = 0;
FT_UInt32 char_code = *pchar_code + 1;
@ -107,14 +113,14 @@
Restart:
{
FT_UInt min = 0;
FT_UInt max = cmap->num_chars;
FT_UInt max = pfrcmap->num_chars;
FT_UInt mid = min + ( max - min ) / 2;
PFR_Char gchar;
while ( min < max )
{
gchar = cmap->chars + mid;
gchar = pfrcmap->chars + mid;
if ( gchar->char_code == char_code )
{
@ -143,9 +149,9 @@
/* we didn't find it, but we have a pair just above it */
char_code = 0;
if ( min < cmap->num_chars )
if ( min < pfrcmap->num_chars )
{
gchar = cmap->chars + min;
gchar = pfrcmap->chars + min;
result = min;
if ( result != 0 )
{

26
thirdparty/freetype/src/pfr/pfrdrivr.c vendored
View file

@ -27,16 +27,16 @@
FT_CALLBACK_DEF( FT_Error )
pfr_get_kerning( FT_Face pfrface, /* PFR_Face */
pfr_get_kerning( FT_Face face, /* PFR_Face */
FT_UInt left,
FT_UInt right,
FT_Vector *avector )
{
PFR_Face face = (PFR_Face)pfrface;
PFR_PhyFont phys = &face->phy_font;
PFR_Face pfrface = (PFR_Face)face;
PFR_PhyFont phys = &pfrface->phy_font;
(void)pfr_face_get_kerning( pfrface, left, right, avector );
(void)pfr_face_get_kerning( face, left, right, avector );
/* convert from metrics to outline units when necessary */
if ( phys->outline_resolution != phys->metrics_resolution )
@ -62,12 +62,12 @@
*/
FT_CALLBACK_DEF( FT_Error )
pfr_get_advance( FT_Face pfrface, /* PFR_Face */
pfr_get_advance( FT_Face face, /* PFR_Face */
FT_UInt gindex,
FT_Pos *anadvance )
{
PFR_Face face = (PFR_Face)pfrface;
FT_Error error = FT_ERR( Invalid_Argument );
PFR_Face pfrface = (PFR_Face)face;
FT_Error error = FT_ERR( Invalid_Argument );
*anadvance = 0;
@ -77,9 +77,9 @@
gindex--;
if ( face )
if ( pfrface )
{
PFR_PhyFont phys = &face->phy_font;
PFR_PhyFont phys = &pfrface->phy_font;
if ( gindex < phys->num_chars )
@ -95,16 +95,16 @@
FT_CALLBACK_DEF( FT_Error )
pfr_get_metrics( FT_Face pfrface, /* PFR_Face */
pfr_get_metrics( FT_Face face, /* PFR_Face */
FT_UInt *anoutline_resolution,
FT_UInt *ametrics_resolution,
FT_Fixed *ametrics_x_scale,
FT_Fixed *ametrics_y_scale )
{
PFR_Face face = (PFR_Face)pfrface;
PFR_PhyFont phys = &face->phy_font;
PFR_Face pfrface = (PFR_Face)face;
PFR_PhyFont phys = &pfrface->phy_font;
FT_Fixed x_scale, y_scale;
FT_Size size = face->root.size;
FT_Size size = pfrface->root.size;
if ( anoutline_resolution )

3
thirdparty/freetype/src/pfr/pfrgload.c vendored
View file

@ -560,8 +560,7 @@
FT_Byte* limit )
{
FT_Error error = FT_Err_Ok;
FT_GlyphLoader loader = glyph->loader;
FT_Memory memory = loader->memory;
FT_Memory memory = glyph->loader->memory;
PFR_SubGlyph subglyph;
FT_UInt flags, i, count, org_count;
FT_Int x_pos, y_pos;

60
thirdparty/freetype/src/pfr/pfrload.c vendored
View file

@ -449,15 +449,16 @@
/* load bitmap strikes lists */
FT_CALLBACK_DEF( FT_Error )
pfr_extra_item_load_bitmap_info( FT_Byte* p,
FT_Byte* limit,
PFR_PhyFont phy_font )
pfr_extra_item_load_bitmap_info( FT_Byte* p,
FT_Byte* limit,
void* phy_font_ )
{
FT_Memory memory = phy_font->memory;
PFR_Strike strike;
FT_UInt flags0;
FT_UInt n, count, size1;
FT_Error error = FT_Err_Ok;
PFR_PhyFont phy_font = (PFR_PhyFont)phy_font_;
FT_Memory memory = phy_font->memory;
PFR_Strike strike;
FT_UInt flags0;
FT_UInt n, count, size1;
FT_Error error = FT_Err_Ok;
PFR_CHECK( 5 );
@ -549,13 +550,14 @@
* family.
*/
FT_CALLBACK_DEF( FT_Error )
pfr_extra_item_load_font_id( FT_Byte* p,
FT_Byte* limit,
PFR_PhyFont phy_font )
pfr_extra_item_load_font_id( FT_Byte* p,
FT_Byte* limit,
void* phy_font_ )
{
FT_Error error = FT_Err_Ok;
FT_Memory memory = phy_font->memory;
FT_UInt len = (FT_UInt)( limit - p );
PFR_PhyFont phy_font = (PFR_PhyFont)phy_font_;
FT_Error error = FT_Err_Ok;
FT_Memory memory = phy_font->memory;
FT_UInt len = (FT_UInt)( limit - p );
if ( phy_font->font_id )
@ -575,14 +577,15 @@
/* load stem snap tables */
FT_CALLBACK_DEF( FT_Error )
pfr_extra_item_load_stem_snaps( FT_Byte* p,
FT_Byte* limit,
PFR_PhyFont phy_font )
pfr_extra_item_load_stem_snaps( FT_Byte* p,
FT_Byte* limit,
void* phy_font_ )
{
FT_UInt count, num_vert, num_horz;
FT_Int* snaps = NULL;
FT_Error error = FT_Err_Ok;
FT_Memory memory = phy_font->memory;
PFR_PhyFont phy_font = (PFR_PhyFont)phy_font_;
FT_UInt count, num_vert, num_horz;
FT_Int* snaps = NULL;
FT_Error error = FT_Err_Ok;
FT_Memory memory = phy_font->memory;
if ( phy_font->vertical.stem_snaps )
@ -619,10 +622,11 @@
/* load kerning pair data */
FT_CALLBACK_DEF( FT_Error )
pfr_extra_item_load_kerning_pairs( FT_Byte* p,
FT_Byte* limit,
PFR_PhyFont phy_font )
pfr_extra_item_load_kerning_pairs( FT_Byte* p,
FT_Byte* limit,
void* phy_font_ )
{
PFR_PhyFont phy_font = (PFR_PhyFont)phy_font_;
PFR_KernItem item = NULL;
FT_Error error = FT_Err_Ok;
FT_Memory memory = phy_font->memory;
@ -715,10 +719,10 @@
static const PFR_ExtraItemRec pfr_phy_font_extra_items[] =
{
{ 1, (PFR_ExtraItem_ParseFunc)pfr_extra_item_load_bitmap_info },
{ 2, (PFR_ExtraItem_ParseFunc)pfr_extra_item_load_font_id },
{ 3, (PFR_ExtraItem_ParseFunc)pfr_extra_item_load_stem_snaps },
{ 4, (PFR_ExtraItem_ParseFunc)pfr_extra_item_load_kerning_pairs },
{ 1, pfr_extra_item_load_bitmap_info },
{ 2, pfr_extra_item_load_font_id },
{ 3, pfr_extra_item_load_stem_snaps },
{ 4, pfr_extra_item_load_kerning_pairs },
{ 0, NULL }
};

6
thirdparty/freetype/src/pfr/pfrobjs.c vendored
View file

@ -50,14 +50,14 @@
if ( !face )
return;
memory = pfrface->driver->root.memory;
memory = pfrface->memory;
/* we don't want dangling pointers */
pfrface->family_name = NULL;
pfrface->style_name = NULL;
/* finalize the physical font record */
pfr_phy_font_done( &face->phy_font, FT_FACE_MEMORY( face ) );
pfr_phy_font_done( &face->phy_font, memory );
/* no need to finalize the logical font or the header */
FT_FREE( pfrface->available_sizes );
@ -214,7 +214,7 @@
FT_UInt n, count = phy_font->num_strikes;
FT_Bitmap_Size* size;
PFR_Strike strike;
FT_Memory memory = pfrface->stream->memory;
FT_Memory memory = pfrface->memory;
if ( FT_QNEW_ARRAY( pfrface->available_sizes, count ) )

2
thirdparty/freetype/src/psaux/afmparse.c vendored
View file

@ -1086,7 +1086,7 @@
#else /* T1_CONFIG_OPTION_NO_AFM */
/* ANSI C doesn't like empty source files */
typedef int _afm_parse_dummy;
typedef int afm_parse_dummy_;
#endif /* T1_CONFIG_OPTION_NO_AFM */

141
thirdparty/freetype/src/psaux/t1cmap.c vendored
View file

@ -50,8 +50,11 @@
FT_CALLBACK_DEF( void )
t1_cmap_std_done( T1_CMapStd cmap )
t1_cmap_std_done( FT_CMap cmap_ ) /* T1_CMapStd */
{
T1_CMapStd cmap = (T1_CMapStd)cmap_;
cmap->num_glyphs = 0;
cmap->glyph_names = NULL;
cmap->sid_to_string = NULL;
@ -60,10 +63,11 @@
FT_CALLBACK_DEF( FT_UInt )
t1_cmap_std_char_index( T1_CMapStd cmap,
FT_UInt32 char_code )
t1_cmap_std_char_index( FT_CMap cmap, /* T1_CMapStd */
FT_UInt32 char_code )
{
FT_UInt result = 0;
T1_CMapStd t1cmap = (T1_CMapStd)cmap;
FT_UInt result = 0;
if ( char_code < 256 )
@ -73,13 +77,13 @@
/* convert character code to Adobe SID string */
code = cmap->code_to_sid[char_code];
glyph_name = cmap->sid_to_string( code );
code = t1cmap->code_to_sid[char_code];
glyph_name = t1cmap->sid_to_string( code );
/* look for the corresponding glyph name */
for ( n = 0; n < cmap->num_glyphs; n++ )
for ( n = 0; n < t1cmap->num_glyphs; n++ )
{
const char* gname = cmap->glyph_names[n];
const char* gname = t1cmap->glyph_names[n];
if ( gname && gname[0] == glyph_name[0] &&
@ -95,9 +99,9 @@
}
FT_CALLBACK_DEF( FT_UInt32 )
t1_cmap_std_char_next( T1_CMapStd cmap,
FT_UInt32 *pchar_code )
FT_CALLBACK_DEF( FT_UInt )
t1_cmap_std_char_next( FT_CMap cmap,
FT_UInt32 *pchar_code )
{
FT_UInt result = 0;
FT_UInt32 char_code = *pchar_code + 1;
@ -120,13 +124,14 @@
FT_CALLBACK_DEF( FT_Error )
t1_cmap_standard_init( T1_CMapStd cmap,
t1_cmap_standard_init( FT_CMap cmap, /* T1_CMapStd */
FT_Pointer pointer )
{
T1_CMapStd t1cmap = (T1_CMapStd)cmap;
FT_UNUSED( pointer );
t1_cmap_std_init( cmap, 0 );
t1_cmap_std_init( t1cmap, 0 );
return 0;
}
@ -150,13 +155,14 @@
FT_CALLBACK_DEF( FT_Error )
t1_cmap_expert_init( T1_CMapStd cmap,
t1_cmap_expert_init( FT_CMap cmap, /* T1_CMapStd */
FT_Pointer pointer )
{
T1_CMapStd t1cmap = (T1_CMapStd)cmap;
FT_UNUSED( pointer );
t1_cmap_std_init( cmap, 1 );
t1_cmap_std_init( t1cmap, 1 );
return 0;
}
@ -188,20 +194,21 @@
FT_CALLBACK_DEF( FT_Error )
t1_cmap_custom_init( T1_CMapCustom cmap,
FT_Pointer pointer )
t1_cmap_custom_init( FT_CMap cmap, /* T1_CMapCustom */
FT_Pointer pointer )
{
T1_Face face = (T1_Face)FT_CMAP_FACE( cmap );
T1_Encoding encoding = &face->type1.encoding;
T1_CMapCustom t1cmap = (T1_CMapCustom)cmap;
T1_Face face = (T1_Face)FT_CMAP_FACE( cmap );
T1_Encoding encoding = &face->type1.encoding;
FT_UNUSED( pointer );
cmap->first = (FT_UInt)encoding->code_first;
cmap->count = (FT_UInt)encoding->code_last - cmap->first;
cmap->indices = encoding->char_index;
t1cmap->first = (FT_UInt)encoding->code_first;
t1cmap->count = (FT_UInt)encoding->code_last - t1cmap->first;
t1cmap->indices = encoding->char_index;
FT_ASSERT( cmap->indices );
FT_ASSERT( t1cmap->indices );
FT_ASSERT( encoding->code_first <= encoding->code_last );
return 0;
@ -209,45 +216,50 @@
FT_CALLBACK_DEF( void )
t1_cmap_custom_done( T1_CMapCustom cmap )
t1_cmap_custom_done( FT_CMap cmap ) /* T1_CMapCustom */
{
cmap->indices = NULL;
cmap->first = 0;
cmap->count = 0;
T1_CMapCustom t1cmap = (T1_CMapCustom)cmap;
t1cmap->indices = NULL;
t1cmap->first = 0;
t1cmap->count = 0;
}
FT_CALLBACK_DEF( FT_UInt )
t1_cmap_custom_char_index( T1_CMapCustom cmap,
FT_UInt32 char_code )
t1_cmap_custom_char_index( FT_CMap cmap, /* T1_CMapCustom */
FT_UInt32 char_code )
{
FT_UInt result = 0;
T1_CMapCustom t1cmap = (T1_CMapCustom)cmap;
FT_UInt result = 0;
if ( ( char_code >= cmap->first ) &&
( char_code < ( cmap->first + cmap->count ) ) )
result = cmap->indices[char_code];
if ( char_code >= t1cmap->first &&
char_code < ( t1cmap->first + t1cmap->count ) )
result = t1cmap->indices[char_code];
return result;
}
FT_CALLBACK_DEF( FT_UInt32 )
t1_cmap_custom_char_next( T1_CMapCustom cmap,
FT_UInt32 *pchar_code )
FT_CALLBACK_DEF( FT_UInt )
t1_cmap_custom_char_next( FT_CMap cmap, /* T1_CMapCustom */
FT_UInt32 *pchar_code )
{
FT_UInt result = 0;
FT_UInt32 char_code = *pchar_code;
T1_CMapCustom t1cmap = (T1_CMapCustom)cmap;
FT_UInt result = 0;
FT_UInt32 char_code = *pchar_code;
char_code++;
if ( char_code < cmap->first )
char_code = cmap->first;
if ( char_code < t1cmap->first )
char_code = t1cmap->first;
for ( ; char_code < ( cmap->first + cmap->count ); char_code++ )
for ( ; char_code < ( t1cmap->first + t1cmap->count ); char_code++ )
{
result = cmap->indices[char_code];
result = t1cmap->indices[char_code];
if ( result != 0 )
goto Exit;
}
@ -287,20 +299,24 @@
/*************************************************************************/
FT_CALLBACK_DEF( const char * )
psaux_get_glyph_name( T1_Face face,
psaux_get_glyph_name( void* face_,
FT_UInt idx )
{
T1_Face face = (T1_Face)face_;
return face->type1.glyph_names[idx];
}
FT_CALLBACK_DEF( FT_Error )
t1_cmap_unicode_init( PS_Unicodes unicodes,
FT_Pointer pointer )
t1_cmap_unicode_init( FT_CMap cmap, /* PS_Unicodes */
FT_Pointer pointer )
{
T1_Face face = (T1_Face)FT_CMAP_FACE( unicodes );
FT_Memory memory = FT_FACE_MEMORY( face );
FT_Service_PsCMaps psnames = (FT_Service_PsCMaps)face->psnames;
PS_Unicodes unicodes = (PS_Unicodes)cmap;
T1_Face face = (T1_Face)FT_CMAP_FACE( cmap );
FT_Memory memory = FT_FACE_MEMORY( face );
FT_Service_PsCMaps psnames = (FT_Service_PsCMaps)face->psnames;
FT_UNUSED( pointer );
@ -311,17 +327,18 @@
return psnames->unicodes_init( memory,
unicodes,
(FT_UInt)face->type1.num_glyphs,
(PS_GetGlyphNameFunc)&psaux_get_glyph_name,
&psaux_get_glyph_name,
(PS_FreeGlyphNameFunc)NULL,
(FT_Pointer)face );
}
FT_CALLBACK_DEF( void )
t1_cmap_unicode_done( PS_Unicodes unicodes )
t1_cmap_unicode_done( FT_CMap cmap ) /* PS_Unicodes */
{
FT_Face face = FT_CMAP_FACE( unicodes );
FT_Memory memory = FT_FACE_MEMORY( face );
PS_Unicodes unicodes = (PS_Unicodes)cmap;
FT_Face face = FT_CMAP_FACE( cmap );
FT_Memory memory = FT_FACE_MEMORY( face );
FT_FREE( unicodes->maps );
@ -330,23 +347,25 @@
FT_CALLBACK_DEF( FT_UInt )
t1_cmap_unicode_char_index( PS_Unicodes unicodes,
FT_UInt32 char_code )
t1_cmap_unicode_char_index( FT_CMap cmap, /* PS_Unicodes */
FT_UInt32 char_code )
{
T1_Face face = (T1_Face)FT_CMAP_FACE( unicodes );
FT_Service_PsCMaps psnames = (FT_Service_PsCMaps)face->psnames;
PS_Unicodes unicodes = (PS_Unicodes)cmap;
T1_Face face = (T1_Face)FT_CMAP_FACE( cmap );
FT_Service_PsCMaps psnames = (FT_Service_PsCMaps)face->psnames;
return psnames->unicodes_char_index( unicodes, char_code );
}
FT_CALLBACK_DEF( FT_UInt32 )
t1_cmap_unicode_char_next( PS_Unicodes unicodes,
FT_UInt32 *pchar_code )
FT_CALLBACK_DEF( FT_UInt )
t1_cmap_unicode_char_next( FT_CMap cmap, /* PS_Unicodes */
FT_UInt32 *pchar_code )
{
T1_Face face = (T1_Face)FT_CMAP_FACE( unicodes );
FT_Service_PsCMaps psnames = (FT_Service_PsCMaps)face->psnames;
PS_Unicodes unicodes = (PS_Unicodes)cmap;
T1_Face face = (T1_Face)FT_CMAP_FACE( cmap );
FT_Service_PsCMaps psnames = (FT_Service_PsCMaps)face->psnames;
return psnames->unicodes_char_next( unicodes, pchar_code );

2
thirdparty/freetype/src/pshinter/pshalgo.c vendored
View file

@ -516,7 +516,7 @@
if ( !psh_hint_is_fitted( parent ) )
psh_hint_align( parent, globals, dimension, glyph );
/* keep original relation between hints, this is, use the */
/* keep original relation between hints, that is, use the */
/* scaled distance between the centers of the hints to */
/* compute the new position */
par_org_center = parent->org_pos + ( parent->org_len >> 1 );

9
thirdparty/freetype/src/pshinter/pshmod.c vendored
View file

@ -37,8 +37,11 @@
/* finalize module */
FT_CALLBACK_DEF( void )
ps_hinter_done( PS_Hinter_Module module )
ps_hinter_done( FT_Module module_ ) /* PS_Hinter_Module */
{
PS_Hinter_Module module = (PS_Hinter_Module)module_;
module->t1_funcs.hints = NULL;
module->t2_funcs.hints = NULL;
@ -48,8 +51,10 @@
/* initialize module, create hints recorder and the interface */
FT_CALLBACK_DEF( FT_Error )
ps_hinter_init( PS_Hinter_Module module )
ps_hinter_init( FT_Module module_ ) /* PS_Hinter_Module */
{
PS_Hinter_Module module = (PS_Hinter_Module)module_;
FT_Memory memory = module->root.memory;
void* ph = &module->ps_hints;

63
thirdparty/freetype/src/pshinter/pshrec.c vendored
View file

@ -851,10 +851,11 @@
/* add one Type1 counter stem to the current hints table */
static void
ps_hints_t1stem3( PS_Hints hints,
ps_hints_t1stem3( T1_Hints hints_, /* PS_Hints */
FT_UInt dimension,
FT_Fixed* stems )
{
PS_Hints hints = (PS_Hints)hints_;
FT_Error error = FT_Err_Ok;
@ -914,9 +915,10 @@
/* reset hints (only with Type 1 hints) */
static void
ps_hints_t1reset( PS_Hints hints,
ps_hints_t1reset( T1_Hints hints_, /* PS_Hints */
FT_UInt end_point )
{
PS_Hints hints = (PS_Hints)hints_;
FT_Error error = FT_Err_Ok;
@ -953,11 +955,12 @@
/* Type2 "hintmask" operator, add a new hintmask to each direction */
static void
ps_hints_t2mask( PS_Hints hints,
ps_hints_t2mask( T2_Hints hints_, /* PS_Hints */
FT_UInt end_point,
FT_UInt bit_count,
const FT_Byte* bytes )
{
PS_Hints hints = (PS_Hints)hints_;
FT_Error error;
@ -999,10 +1002,11 @@
static void
ps_hints_t2counter( PS_Hints hints,
ps_hints_t2counter( T2_Hints hints_, /* PS_Hints */
FT_UInt bit_count,
const FT_Byte* bytes )
{
PS_Hints hints = (PS_Hints)hints_;
FT_Error error;
@ -1087,6 +1091,13 @@
ps_hints_open( (PS_Hints)hints, PS_HINT_TYPE_1 );
}
static FT_Error
t1_hints_close( T1_Hints hints,
FT_UInt end_point )
{
return ps_hints_close( (PS_Hints)hints, end_point );
}
static void
t1_hints_stem( T1_Hints hints,
FT_UInt dimension,
@ -1102,17 +1113,27 @@
}
static FT_Error
t1_hints_apply( T1_Hints hints,
FT_Outline* outline,
PSH_Globals globals,
FT_Render_Mode hint_mode )
{
return ps_hints_apply( (PS_Hints)hints, outline, globals, hint_mode );
}
FT_LOCAL_DEF( void )
t1_hints_funcs_init( T1_Hints_FuncsRec* funcs )
{
FT_ZERO( funcs );
funcs->open = (T1_Hints_OpenFunc) t1_hints_open;
funcs->close = (T1_Hints_CloseFunc) ps_hints_close;
funcs->close = (T1_Hints_CloseFunc) t1_hints_close;
funcs->stem = (T1_Hints_SetStemFunc) t1_hints_stem;
funcs->stem3 = (T1_Hints_SetStem3Func)ps_hints_t1stem3;
funcs->reset = (T1_Hints_ResetFunc) ps_hints_t1reset;
funcs->apply = (T1_Hints_ApplyFunc) ps_hints_apply;
funcs->apply = (T1_Hints_ApplyFunc) t1_hints_apply;
}
@ -1131,6 +1152,14 @@
}
static FT_Error
t2_hints_close( T2_Hints hints,
FT_UInt end_point )
{
return ps_hints_close( (PS_Hints)hints, end_point );
}
static void
t2_hints_stems( T2_Hints hints,
FT_UInt dimension,
@ -1168,17 +1197,27 @@
}
static FT_Error
t2_hints_apply( T2_Hints hints,
FT_Outline* outline,
PSH_Globals globals,
FT_Render_Mode hint_mode )
{
return ps_hints_apply( (PS_Hints)hints, outline, globals, hint_mode );
}
FT_LOCAL_DEF( void )
t2_hints_funcs_init( T2_Hints_FuncsRec* funcs )
{
FT_ZERO( funcs );
funcs->open = (T2_Hints_OpenFunc) t2_hints_open;
funcs->close = (T2_Hints_CloseFunc) ps_hints_close;
funcs->stems = (T2_Hints_StemsFunc) t2_hints_stems;
funcs->hintmask= (T2_Hints_MaskFunc) ps_hints_t2mask;
funcs->counter = (T2_Hints_CounterFunc)ps_hints_t2counter;
funcs->apply = (T2_Hints_ApplyFunc) ps_hints_apply;
funcs->open = (T2_Hints_OpenFunc) t2_hints_open;
funcs->close = (T2_Hints_CloseFunc) t2_hints_close;
funcs->stems = (T2_Hints_StemsFunc) t2_hints_stems;
funcs->hintmask = (T2_Hints_MaskFunc) ps_hints_t2mask;
funcs->counter = (T2_Hints_CounterFunc)ps_hints_t2counter;
funcs->apply = (T2_Hints_ApplyFunc) t2_hints_apply;
}

42
thirdparty/freetype/src/psnames/psmodule.c vendored
View file

@ -57,7 +57,7 @@
/* the name, as in `A.swash' or `e.final'; in this case, the */
/* VARIANT_BIT is set in the return value. */
/* */
static FT_UInt32
FT_CALLBACK_DEF( FT_UInt32 )
ps_unicode_value( const char* glyph_name )
{
/* If the name begins with `uni', then the glyph name may be a */
@ -309,7 +309,7 @@
/* Build a table that maps Unicode values to glyph indices. */
static FT_Error
FT_CALLBACK_DEF( FT_Error )
ps_unicodes_init( FT_Memory memory,
PS_Unicodes table,
FT_UInt num_glyphs,
@ -408,7 +408,7 @@
}
static FT_UInt
FT_CALLBACK_DEF( FT_UInt )
ps_unicodes_char_index( PS_Unicodes table,
FT_UInt32 unicode )
{
@ -453,7 +453,7 @@
}
static FT_UInt32
FT_CALLBACK_DEF( FT_UInt )
ps_unicodes_char_next( PS_Unicodes table,
FT_UInt32 *unicode )
{
@ -518,7 +518,7 @@
#endif /* FT_CONFIG_OPTION_ADOBE_GLYPH_LIST */
static const char*
FT_CALLBACK_DEF( const char* )
ps_get_macintosh_name( FT_UInt name_index )
{
if ( name_index >= FT_NUM_MAC_NAMES )
@ -528,7 +528,7 @@
}
static const char*
FT_CALLBACK_DEF( const char* )
ps_get_standard_strings( FT_UInt sid )
{
if ( sid >= FT_NUM_SID_NAMES )
@ -543,13 +543,13 @@
FT_DEFINE_SERVICE_PSCMAPSREC(
pscmaps_interface,
(PS_Unicode_ValueFunc) ps_unicode_value, /* unicode_value */
(PS_Unicodes_InitFunc) ps_unicodes_init, /* unicodes_init */
(PS_Unicodes_CharIndexFunc)ps_unicodes_char_index, /* unicodes_char_index */
(PS_Unicodes_CharNextFunc) ps_unicodes_char_next, /* unicodes_char_next */
ps_unicode_value, /* PS_Unicode_ValueFunc unicode_value */
ps_unicodes_init, /* PS_Unicodes_InitFunc unicodes_init */
ps_unicodes_char_index, /* PS_Unicodes_CharIndexFunc unicodes_char_index */
ps_unicodes_char_next, /* PS_Unicodes_CharNextFunc unicodes_char_next */
(PS_Macintosh_NameFunc) ps_get_macintosh_name, /* macintosh_name */
(PS_Adobe_Std_StringsFunc) ps_get_standard_strings, /* adobe_std_strings */
ps_get_macintosh_name, /* PS_Macintosh_NameFunc macintosh_name */
ps_get_standard_strings, /* PS_Adobe_Std_StringsFunc adobe_std_strings */
t1_standard_encoding, /* adobe_std_encoding */
t1_expert_encoding /* adobe_expert_encoding */
@ -560,13 +560,13 @@
FT_DEFINE_SERVICE_PSCMAPSREC(
pscmaps_interface,
NULL, /* unicode_value */
NULL, /* unicodes_init */
NULL, /* unicodes_char_index */
NULL, /* unicodes_char_next */
NULL, /* PS_Unicode_ValueFunc unicode_value */
NULL, /* PS_Unicodes_InitFunc unicodes_init */
NULL, /* PS_Unicodes_CharIndexFunc unicodes_char_index */
NULL, /* PS_Unicodes_CharNextFunc unicodes_char_next */
(PS_Macintosh_NameFunc) ps_get_macintosh_name, /* macintosh_name */
(PS_Adobe_Std_StringsFunc) ps_get_standard_strings, /* adobe_std_strings */
ps_get_macintosh_name, /* PS_Macintosh_NameFunc macintosh_name */
ps_get_standard_strings, /* PS_Adobe_Std_StringsFunc adobe_std_strings */
t1_standard_encoding, /* adobe_std_encoding */
t1_expert_encoding /* adobe_expert_encoding */
@ -612,9 +612,9 @@
PUT_PS_NAMES_SERVICE(
(void*)&pscmaps_interface ), /* module specific interface */
(FT_Module_Constructor)NULL, /* module_init */
(FT_Module_Destructor) NULL, /* module_done */
(FT_Module_Requester) PUT_PS_NAMES_SERVICE( psnames_get_service ) /* get_interface */
NULL, /* FT_Module_Constructor module_init */
NULL, /* FT_Module_Destructor module_done */
PUT_PS_NAMES_SERVICE( psnames_get_service ) /* FT_Module_Requester get_interface */
)

44
thirdparty/freetype/src/raster/ftraster.c vendored
View file

@ -1742,9 +1742,9 @@
* SUCCESS on success, FAILURE on error.
*/
static Bool
Decompose_Curve( RAS_ARGS UShort first,
UShort last,
Int flipped )
Decompose_Curve( RAS_ARGS Int first,
Int last,
Int flipped )
{
FT_Vector v_last;
FT_Vector v_control;
@ -1969,8 +1969,8 @@
static Bool
Convert_Glyph( RAS_ARGS Int flipped )
{
Int i;
UInt start;
Int i;
Int first, last;
ras.fProfile = NULL;
@ -1985,8 +1985,7 @@
ras.cProfile->offset = ras.top;
ras.num_Profs = 0;
start = 0;
last = -1;
for ( i = 0; i < ras.outline.n_contours; i++ )
{
PProfile lastProfile;
@ -1996,12 +1995,11 @@
ras.state = Unknown_State;
ras.gProfile = NULL;
if ( Decompose_Curve( RAS_VARS (UShort)start,
(UShort)ras.outline.contours[i],
flipped ) )
return FAILURE;
first = last + 1;
last = ras.outline.contours[i];
start = (UShort)ras.outline.contours[i] + 1;
if ( Decompose_Curve( RAS_VARS first, last, flipped ) )
return FAILURE;
/* we must now check whether the extreme arcs join or not */
if ( FRAC( ras.lastY ) == 0 &&
@ -3167,9 +3165,12 @@
static int
ft_black_new( FT_Memory memory,
black_PRaster *araster )
ft_black_new( void* memory_, /* FT_Memory */
FT_Raster *araster_ ) /* black_PRaster */
{
FT_Memory memory = (FT_Memory)memory_;
black_PRaster *araster = (black_PRaster*)araster_;
FT_Error error;
black_PRaster raster = NULL;
@ -3184,9 +3185,10 @@
static void
ft_black_done( black_PRaster raster )
ft_black_done( FT_Raster raster_ ) /* black_PRaster */
{
FT_Memory memory = (FT_Memory)raster->memory;
black_PRaster raster = (black_PRaster)raster_;
FT_Memory memory = (FT_Memory)raster->memory;
FT_FREE( raster );
@ -3281,11 +3283,11 @@
FT_GLYPH_FORMAT_OUTLINE,
(FT_Raster_New_Func) ft_black_new, /* raster_new */
(FT_Raster_Reset_Func) ft_black_reset, /* raster_reset */
(FT_Raster_Set_Mode_Func)ft_black_set_mode, /* raster_set_mode */
(FT_Raster_Render_Func) ft_black_render, /* raster_render */
(FT_Raster_Done_Func) ft_black_done /* raster_done */
ft_black_new, /* FT_Raster_New_Func raster_new */
ft_black_reset, /* FT_Raster_Reset_Func raster_reset */
ft_black_set_mode, /* FT_Raster_Set_Mode_Func raster_set_mode */
ft_black_render, /* FT_Raster_Render_Func raster_render */
ft_black_done /* FT_Raster_Done_Func raster_done */
)

21
thirdparty/freetype/src/raster/ftrend1.c vendored
View file

@ -27,8 +27,11 @@
/* initialize renderer -- init its raster */
static FT_Error
ft_raster1_init( FT_Renderer render )
ft_raster1_init( FT_Module module ) /* FT_Renderer */
{
FT_Renderer render = (FT_Renderer)module;
render->clazz->raster_class->raster_reset( render->raster, NULL, 0 );
return FT_Err_Ok;
@ -188,18 +191,18 @@
NULL, /* module specific interface */
(FT_Module_Constructor)ft_raster1_init, /* module_init */
(FT_Module_Destructor) NULL, /* module_done */
(FT_Module_Requester) NULL, /* get_interface */
ft_raster1_init, /* FT_Module_Constructor module_init */
NULL, /* FT_Module_Destructor module_done */
NULL, /* FT_Module_Requester get_interface */
FT_GLYPH_FORMAT_OUTLINE,
(FT_Renderer_RenderFunc) ft_raster1_render, /* render_glyph */
(FT_Renderer_TransformFunc)ft_raster1_transform, /* transform_glyph */
(FT_Renderer_GetCBoxFunc) ft_raster1_get_cbox, /* get_glyph_cbox */
(FT_Renderer_SetModeFunc) ft_raster1_set_mode, /* set_mode */
ft_raster1_render, /* FT_Renderer_RenderFunc render_glyph */
ft_raster1_transform, /* FT_Renderer_TransformFunc transform_glyph */
ft_raster1_get_cbox, /* FT_Renderer_GetCBoxFunc get_glyph_cbox */
ft_raster1_set_mode, /* FT_Renderer_SetModeFunc set_mode */
(FT_Raster_Funcs*)&ft_standard_raster /* raster_class */
&ft_standard_raster /* FT_Raster_Funcs* raster_class */
)

7
thirdparty/freetype/src/sdf/ftbsdf.c vendored
View file

@ -1173,9 +1173,12 @@
/* called when adding a new module through @FT_Add_Module */
static FT_Error
bsdf_raster_new( FT_Memory memory,
BSDF_PRaster* araster )
bsdf_raster_new( void* memory_, /* FT_Memory */
FT_Raster* araster_ ) /* BSDF_PRaster* */
{
FT_Memory memory = (FT_Memory)memory_;
BSDF_PRaster* araster = (BSDF_PRaster*)araster_;
FT_Error error;
BSDF_PRaster raster = NULL;

21
thirdparty/freetype/src/sdf/ftsdf.c vendored
View file

@ -2371,11 +2371,11 @@
* ```
*
* (6) Our task is to find a value of `t` such that the above equation
* `Q(t)` becomes zero, this is, the point-to-curve vector makes
* `Q(t)` becomes zero, that is, the point-to-curve vector makes
* 90~degrees with the curve. We solve this with the Newton-Raphson
* method.
*
* (7) We first assume an arbitary value of factor `t`, which we then
* (7) We first assume an arbitrary value of factor `t`, which we then
* improve.
*
* ```
@ -2684,11 +2684,11 @@
* ```
*
* (6) Our task is to find a value of `t` such that the above equation
* `Q(t)` becomes zero, this is, the point-to-curve vector makes
* `Q(t)` becomes zero, that is, the point-to-curve vector makes
* 90~degree with curve. We solve this with the Newton-Raphson
* method.
*
* (7) We first assume an arbitary value of factor `t`, which we then
* (7) We first assume an arbitrary value of factor `t`, which we then
* improve.
*
* ```
@ -2718,8 +2718,9 @@
FT_Error error = FT_Err_Ok;
FT_26D6_Vec aA, bB, cC, dD; /* A, B, C in the above comment */
FT_16D16_Vec nearest_point; /* point on curve nearest to `point` */
FT_26D6_Vec aA, bB, cC, dD; /* A, B, C, D in the above comment */
FT_16D16_Vec nearest_point = { 0, 0 };
/* point on curve nearest to `point` */
FT_16D16_Vec direction; /* direction of curve at `nearest_point` */
FT_26D6_Vec p0, p1, p2, p3; /* control points of a cubic curve */
@ -3761,9 +3762,13 @@
*/
static FT_Error
sdf_raster_new( FT_Memory memory,
SDF_PRaster* araster )
sdf_raster_new( void* memory_, /* FT_Memory */
FT_Raster* araster_ ) /* SDF_PRaster* */
{
FT_Memory memory = (FT_Memory)memory_;
SDF_PRaster* araster = (SDF_PRaster*)araster_;
FT_Error error;
SDF_PRaster raster = NULL;

35
thirdparty/freetype/src/sdf/ftsdfrend.c vendored
View file

@ -197,10 +197,10 @@
static FT_Module_Interface
ft_sdf_requester( FT_Renderer render,
ft_sdf_requester( FT_Module module,
const char* module_interface )
{
FT_UNUSED( render );
FT_UNUSED( module );
return ft_service_list_lookup( sdf_services, module_interface );
}
@ -221,9 +221,9 @@
*/
static FT_Error
ft_sdf_init( FT_Renderer render )
ft_sdf_init( FT_Module module ) /* SDF_Renderer */
{
SDF_Renderer sdf_render = SDF_RENDERER( render );
SDF_Renderer sdf_render = SDF_RENDERER( module );
sdf_render->spread = DEFAULT_SPREAD;
@ -236,9 +236,9 @@
static void
ft_sdf_done( FT_Renderer render )
ft_sdf_done( FT_Module module )
{
FT_UNUSED( render );
FT_UNUSED( module );
}
@ -300,7 +300,7 @@
/* nothing to render */
if ( !bitmap->rows || !bitmap->pitch )
return FT_Err_Ok;
goto Exit;
/* the padding will simply be equal to the `spread' */
x_pad = sdf_module->spread;
@ -508,6 +508,10 @@
goto Exit;
}
/* nothing to render */
if ( !bitmap->rows || !bitmap->pitch )
goto Exit;
/* Do not generate SDF if the bitmap is not owned by the */
/* glyph: it might be that the source buffer is already freed. */
if ( !( slot->internal->flags & FT_GLYPH_OWN_BITMAP ) )
@ -519,10 +523,6 @@
goto Exit;
}
/* nothing to render */
if ( !bitmap->rows || !bitmap->pitch )
return FT_Err_Ok;
FT_Bitmap_New( &target );
/* padding will simply be equal to `spread` */
@ -557,15 +557,14 @@
{
/* the glyph is successfully converted to a SDF */
if ( slot->internal->flags & FT_GLYPH_OWN_BITMAP )
{
FT_FREE( bitmap->buffer );
slot->internal->flags &= ~FT_GLYPH_OWN_BITMAP;
}
slot->bitmap = target;
slot->bitmap_top += y_pad;
slot->bitmap_left -= x_pad;
slot->internal->flags |= FT_GLYPH_OWN_BITMAP;
slot->bitmap = target;
slot->bitmap_top += y_pad;
slot->bitmap_left -= x_pad;
if ( target.buffer )
slot->internal->flags |= FT_GLYPH_OWN_BITMAP;
}
else if ( target.buffer )
FT_FREE( target.buffer );

7
thirdparty/freetype/src/sfnt/pngshim.c vendored
View file

@ -406,10 +406,7 @@
switch ( color_type )
{
default:
/* Shouldn't happen, but ... */
FALL_THROUGH;
default: /* Shouldn't happen, but ... */
case PNG_COLOR_TYPE_RGB_ALPHA:
png_set_read_user_transform_fn( png, premultiply_data );
break;
@ -457,7 +454,7 @@
#else /* !(TT_CONFIG_OPTION_EMBEDDED_BITMAPS && FT_CONFIG_OPTION_USE_PNG) */
/* ANSI C doesn't like empty source files */
typedef int _pngshim_dummy;
typedef int pngshim_dummy_;
#endif /* !(TT_CONFIG_OPTION_EMBEDDED_BITMAPS && FT_CONFIG_OPTION_USE_PNG) */

143
thirdparty/freetype/src/sfnt/sfdriver.c vendored
View file

@ -79,41 +79,57 @@
*
*/
static void*
get_sfnt_table( TT_Face face,
FT_CALLBACK_DEF( FT_Error )
sfnt_load_table( FT_Face face, /* TT_Face */
FT_ULong tag,
FT_Long offset,
FT_Byte* buffer,
FT_ULong* length )
{
TT_Face ttface = (TT_Face)face;
return tt_face_load_any( ttface, tag, offset, buffer, length );
}
FT_CALLBACK_DEF( void* )
get_sfnt_table( FT_Face face, /* TT_Face */
FT_Sfnt_Tag tag )
{
TT_Face ttface = (TT_Face)face;
void* table;
switch ( tag )
{
case FT_SFNT_HEAD:
table = &face->header;
table = &ttface->header;
break;
case FT_SFNT_HHEA:
table = &face->horizontal;
table = &ttface->horizontal;
break;
case FT_SFNT_VHEA:
table = face->vertical_info ? &face->vertical : NULL;
table = ttface->vertical_info ? &ttface->vertical : NULL;
break;
case FT_SFNT_OS2:
table = ( face->os2.version == 0xFFFFU ) ? NULL : &face->os2;
table = ( ttface->os2.version == 0xFFFFU ) ? NULL : &ttface->os2;
break;
case FT_SFNT_POST:
table = &face->postscript;
table = &ttface->postscript;
break;
case FT_SFNT_MAXP:
table = &face->max_profile;
table = &ttface->max_profile;
break;
case FT_SFNT_PCLT:
table = face->pclt.Version ? &face->pclt : NULL;
table = ttface->pclt.Version ? &ttface->pclt : NULL;
break;
default:
@ -124,26 +140,29 @@
}
static FT_Error
sfnt_table_info( TT_Face face,
FT_CALLBACK_DEF( FT_Error )
sfnt_table_info( FT_Face face, /* TT_Face */
FT_UInt idx,
FT_ULong *tag,
FT_ULong *offset,
FT_ULong *length )
{
TT_Face ttface = (TT_Face)face;
if ( !offset || !length )
return FT_THROW( Invalid_Argument );
if ( !tag )
*length = face->num_tables;
*length = ttface->num_tables;
else
{
if ( idx >= face->num_tables )
if ( idx >= ttface->num_tables )
return FT_THROW( Table_Missing );
*tag = face->dir_tables[idx].Tag;
*offset = face->dir_tables[idx].Offset;
*length = face->dir_tables[idx].Length;
*tag = ttface->dir_tables[idx].Tag;
*offset = ttface->dir_tables[idx].Offset;
*length = ttface->dir_tables[idx].Length;
}
return FT_Err_Ok;
@ -153,9 +172,9 @@
FT_DEFINE_SERVICE_SFNT_TABLEREC(
sfnt_service_sfnt_table,
(FT_SFNT_TableLoadFunc)tt_face_load_any, /* load_table */
(FT_SFNT_TableGetFunc) get_sfnt_table, /* get_table */
(FT_SFNT_TableInfoFunc)sfnt_table_info /* table_info */
sfnt_load_table, /* FT_SFNT_TableLoadFunc load_table */
get_sfnt_table, /* FT_SFNT_TableGetFunc get_table */
sfnt_table_info /* FT_SFNT_TableInfoFunc table_info */
)
@ -166,7 +185,7 @@
*
*/
static FT_Error
FT_CALLBACK_DEF( FT_Error )
sfnt_get_glyph_name( FT_Face face,
FT_UInt glyph_index,
FT_Pointer buffer,
@ -184,7 +203,7 @@
}
static FT_UInt
FT_CALLBACK_DEF( FT_UInt )
sfnt_get_name_index( FT_Face face,
const FT_String* glyph_name )
{
@ -221,8 +240,8 @@
FT_DEFINE_SERVICE_GLYPHDICTREC(
sfnt_service_glyph_dict,
(FT_GlyphDict_GetNameFunc) sfnt_get_glyph_name, /* get_name */
(FT_GlyphDict_NameIndexFunc)sfnt_get_name_index /* name_index */
sfnt_get_glyph_name, /* FT_GlyphDict_GetNameFunc get_name */
sfnt_get_name_index /* FT_GlyphDict_NameIndexFunc name_index */
)
#endif /* TT_CONFIG_OPTION_POSTSCRIPT_NAMES */
@ -523,15 +542,14 @@
FT_TRACE0(( "get_win_string:"
" Character 0x%X invalid in PS name string\n",
((unsigned)p[0])*256 + (unsigned)p[1] ));
break;
continue;
}
}
if ( !len )
*r = '\0';
*r = '\0';
FT_FRAME_EXIT();
if ( !len )
if ( r != result )
return result;
get_win_string_error:
@ -580,15 +598,14 @@
FT_TRACE0(( "get_apple_string:"
" Character `%c' (0x%X) invalid in PS name string\n",
*p, *p ));
break;
continue;
}
}
if ( !len )
*r = '\0';
*r = '\0';
FT_FRAME_EXIT();
if ( !len )
if ( r != result )
return result;
get_apple_string_error:
@ -602,7 +619,7 @@
}
static FT_Bool
FT_CALLBACK_DEF( FT_Bool )
sfnt_get_name_id( TT_Face face,
FT_UShort id,
FT_Int *win,
@ -819,9 +836,9 @@
if ( !found )
{
/* as a last resort we try the family name; note that this is */
/* not in the Adobe TechNote, but GX fonts (which predate the */
/* TechNote) benefit from this behaviour */
/* according to the 'name' documentation in the OpenType */
/* specification the font family name is to be used if the */
/* typographic family name is missing, so let's do that */
found = sfnt_get_name_id( face,
TT_NAME_ID_FONT_FAMILY,
&win,
@ -853,6 +870,10 @@
{
FT_TRACE0(( "sfnt_get_var_ps_name:"
" No valid PS name prefix for font instances found\n" ));
/* XXX It probably makes sense to never let this fail */
/* since an arbitrary prefix should work, too. */
/* On the other hand, it is very unlikely that */
/* we ever reach this code at all. */
return NULL;
}
@ -1041,47 +1062,49 @@
#endif /* TT_CONFIG_OPTION_GX_VAR_SUPPORT */
static const char*
sfnt_get_ps_name( TT_Face face )
FT_CALLBACK_DEF( const char* )
sfnt_get_ps_name( FT_Face face ) /* TT_Face */
{
TT_Face ttface = (TT_Face)face;
FT_Int found, win, apple;
const char* result = NULL;
if ( face->postscript_name )
return face->postscript_name;
if ( ttface->postscript_name )
return ttface->postscript_name;
#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
if ( face->blend &&
( FT_IS_NAMED_INSTANCE( FT_FACE( face ) ) ||
FT_IS_VARIATION( FT_FACE( face ) ) ) )
if ( ttface->blend &&
( FT_IS_NAMED_INSTANCE( face ) ||
FT_IS_VARIATION( face ) ) )
{
face->postscript_name = sfnt_get_var_ps_name( face );
return face->postscript_name;
ttface->postscript_name = sfnt_get_var_ps_name( ttface );
return ttface->postscript_name;
}
#endif
/* scan the name table to see whether we have a Postscript name here, */
/* either in Macintosh or Windows platform encodings */
found = sfnt_get_name_id( face, TT_NAME_ID_PS_NAME, &win, &apple );
found = sfnt_get_name_id( ttface, TT_NAME_ID_PS_NAME, &win, &apple );
if ( !found )
return NULL;
/* prefer Windows entries over Apple */
if ( win != -1 )
result = get_win_string( face->root.memory,
face->name_table.stream,
face->name_table.names + win,
result = get_win_string( FT_FACE_MEMORY( face ),
ttface->name_table.stream,
ttface->name_table.names + win,
sfnt_is_postscript,
1 );
if ( !result && apple != -1 )
result = get_apple_string( face->root.memory,
face->name_table.stream,
face->name_table.names + apple,
result = get_apple_string( FT_FACE_MEMORY( face ),
ttface->name_table.stream,
ttface->name_table.names + apple,
sfnt_is_postscript,
1 );
face->postscript_name = result;
ttface->postscript_name = result;
return result;
}
@ -1090,7 +1113,7 @@
FT_DEFINE_SERVICE_PSFONTNAMEREC(
sfnt_service_ps_name,
(FT_PsName_GetFunc)sfnt_get_ps_name /* get_ps_font_name */
sfnt_get_ps_name /* FT_PsName_GetFunc get_ps_font_name */
)
@ -1100,14 +1123,14 @@
FT_DEFINE_SERVICE_TTCMAPSREC(
tt_service_get_cmap_info,
(TT_CMap_Info_GetFunc)tt_get_cmap_info /* get_cmap_info */
tt_get_cmap_info /* TT_CMap_Info_GetFunc get_cmap_info */
)
#ifdef TT_CONFIG_OPTION_BDF
static FT_Error
sfnt_get_charset_id( TT_Face face,
sfnt_get_charset_id( FT_Face face,
const char* *acharset_encoding,
const char* *acharset_registry )
{
@ -1145,8 +1168,8 @@
FT_DEFINE_SERVICE_BDFRec(
sfnt_service_bdf,
(FT_BDF_GetCharsetIdFunc)sfnt_get_charset_id, /* get_charset_id */
(FT_BDF_GetPropertyFunc) tt_face_find_bdf_prop /* get_property */
sfnt_get_charset_id, /* FT_BDF_GetCharsetIdFunc get_charset_id */
tt_face_find_bdf_prop /* FT_BDF_GetPropertyFunc get_property */
)
@ -1337,9 +1360,9 @@
(const void*)&sfnt_interface, /* module specific interface */
(FT_Module_Constructor)NULL, /* module_init */
(FT_Module_Destructor) NULL, /* module_done */
(FT_Module_Requester) sfnt_get_interface /* get_interface */
NULL, /* FT_Module_Constructor module_init */
NULL, /* FT_Module_Destructor module_done */
sfnt_get_interface /* FT_Module_Requester get_interface */
)

30
thirdparty/freetype/src/sfnt/sfobjs.c vendored
View file

@ -534,17 +534,23 @@
0 );
}
if ( !face->var )
if ( !face->tt_var )
{
/* we want the metrics variations interface */
/* from the `truetype' module only */
FT_Module tt_module = FT_Get_Module( library, "truetype" );
face->var = ft_module_get_service( tt_module,
FT_SERVICE_ID_METRICS_VARIATIONS,
0 );
face->tt_var = ft_module_get_service( tt_module,
FT_SERVICE_ID_METRICS_VARIATIONS,
0 );
}
if ( !face->face_var )
face->face_var = ft_module_get_service(
&face->root.driver->root,
FT_SERVICE_ID_METRICS_VARIATIONS,
0 );
#endif
FT_TRACE2(( "SFNT driver\n" ));
@ -692,6 +698,9 @@
instance_offset += instance_size;
}
/* named instance indices start with value 1 */
face->var_default_named_instance = i + 1;
if ( i == num_instances )
{
/* no default instance in named instance table; */
@ -1054,6 +1063,16 @@
GET_NAME( FONT_SUBFAMILY, &face->root.style_name );
}
#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
{
FT_Memory memory = face->root.memory;
if ( FT_STRDUP( face->non_var_style_name, face->root.style_name ) )
goto Exit;
}
#endif
/* now set up root fields */
{
FT_Face root = &face->root;
@ -1221,7 +1240,7 @@
if ( count > 0 )
{
FT_Memory memory = face->root.stream->memory;
FT_Memory memory = face->root.memory;
FT_UShort em_size = face->header.Units_Per_EM;
FT_Short avgwidth = face->os2.xAvgCharWidth;
FT_Size_Metrics metrics;
@ -1500,6 +1519,7 @@
#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
FT_FREE( face->var_postscript_prefix );
FT_FREE( face->non_var_style_name );
#endif
/* freeing glyph color palette data */

2
thirdparty/freetype/src/sfnt/sfwoff.c vendored
View file

@ -426,7 +426,7 @@
#else /* !FT_CONFIG_OPTION_USE_ZLIB */
/* ANSI C doesn't like empty source files */
typedef int _sfwoff_dummy;
typedef int sfwoff_dummy_;
#endif /* !FT_CONFIG_OPTION_USE_ZLIB */

2
thirdparty/freetype/src/sfnt/sfwoff2.c vendored
View file

@ -2378,7 +2378,7 @@
#else /* !FT_CONFIG_OPTION_USE_BROTLI */
/* ANSI C doesn't like empty source files */
typedef int _sfwoff2_dummy;
typedef int sfwoff2_dummy_;
#endif /* !FT_CONFIG_OPTION_USE_BROTLI */

13
thirdparty/freetype/src/sfnt/ttbdf.c vendored
View file

@ -136,13 +136,14 @@
FT_LOCAL_DEF( FT_Error )
tt_face_find_bdf_prop( TT_Face face,
tt_face_find_bdf_prop( FT_Face face, /* TT_Face */
const char* property_name,
BDF_PropertyRec *aprop )
{
TT_BDF bdf = &face->bdf;
FT_Size size = FT_FACE( face )->size;
FT_Error error = FT_Err_Ok;
TT_Face ttface = (TT_Face)face;
TT_BDF bdf = &ttface->bdf;
FT_Size size = FT_FACE_SIZE( face );
FT_Error error = FT_Err_Ok;
FT_Byte* p;
FT_UInt count;
FT_Byte* strike;
@ -153,7 +154,7 @@
if ( bdf->loaded == 0 )
{
error = tt_face_load_bdf_props( face, FT_FACE( face )->stream );
error = tt_face_load_bdf_props( ttface, FT_FACE_STREAM( face ) );
if ( error )
goto Exit;
}
@ -248,7 +249,7 @@
#else /* !TT_CONFIG_OPTION_BDF */
/* ANSI C doesn't like empty source files */
typedef int _tt_bdf_dummy;
typedef int tt_bdf_dummy_;
#endif /* !TT_CONFIG_OPTION_BDF */

Some files were not shown because too many files have changed in this diff Show more