lib/tatypes.h

   1 /* tatypes.h */
   2
   3 /*
   4  * Copyright (C) 2011-2022 by Werner Lemberg.
   5  *
   6  * This file is part of the ttfautohint library, and may only be used,
   7  * modified, and distributed under the terms given in `COPYING'.  By
   8  * continuing to use, modify, or distribute this file you indicate that you
   9  * have read `COPYING' and understand and accept it fully.
  10  *
  11  * The file `COPYING' mentioned in the previous paragraph is distributed
  12  * with the ttfautohint library.
  13  */
  14
  15
  16 /* originally file `aftypes.h' (2011-Mar-30) from FreeType */
  17
  18 /* heavily modified 2011 by Werner Lemberg <wl@gnu.org> */
  19
  20 #ifndef TATYPES_H_
  21 #define TATYPES_H_
  22
  23 #include <ft2build.h>
  24
  25 #include FT_FREETYPE_H
  26 #include FT_OUTLINE_H
  27
  28 #include "tablue.h"
  29
  30 #ifdef __cplusplus
  31 extern "C" {
  32 #endif
  33
  34
  35 /* enable one of the following three definitions for debugging */
  36 /* #define TA_DEBUG */
  37 /* #define TA_DEBUG_HORZ */
  38 #define TA_DEBUG_VERT
  39
  40 #if defined TA_DEBUG_HORZ
  41 #  define TA_DEBUG_STARTDIM TA_DIMENSION_HORZ
  42 #  define TA_DEBUG_ENDDIM TA_DIMENSION_HORZ
  43 #  define TA_DEBUG
  44 #elif defined TA_DEBUG_VERT
  45 #  define TA_DEBUG_STARTDIM TA_DIMENSION_VERT
  46 #  define TA_DEBUG_ENDDIM TA_DIMENSION_VERT
  47 #  define TA_DEBUG
  48 #elif defined TA_DEBUG
  49 #  define TA_DEBUG_STARTDIM TA_DIMENSION_VERT
  50 #  define TA_DEBUG_ENDDIM TA_DIMENSION_HORZ
  51 #endif
  52
  53 #ifdef TA_DEBUG
  54
  55 #define TA_LOG(x) \
  56   do \
  57   { \
  58     if (_ta_debug) \
  59       _ta_message x; \
  60   } while (0)
  61
  62 #define TA_LOG_GLOBAL(x) \
  63   do \
  64   { \
  65     if (_ta_debug_global) \
  66       _ta_message x; \
  67   } while (0)
  68
  69 void
  70 _ta_message(const char* format,
  71             ...);
  72
  73 extern int _ta_debug;
  74 extern int _ta_debug_global;
  75 extern int _ta_debug_disable_horz_hints;
  76 extern int _ta_debug_disable_vert_hints;
  77 extern int _ta_debug_disable_blue_hints;
  78 extern void* _ta_debug_hints;
  79
  80 #else /* !TA_DEBUG */
  81
  82 #define TA_LOG(x) \
  83   do { } while (0) /* nothing */
  84
  85 #define TA_LOG_GLOBAL(x) \
  86   do { } while (0) /* nothing */
  87
  88 #endif /* !TA_DEBUG */
  89
  90
  91 #define TA_MIN(a, b) ((a) < (b) ? (a) : (b))
  92 #define TA_MAX(a, b) ((a) > (b) ? (a) : (b))
  93
  94 #define TA_ABS(a) ((a) < 0 ? -(a) : (a))
  95
  96 /* from file `ftconfig.h' (2015-03-02) from FreeType */
  97 /* typeof condition taken from gnulib's `intprops.h' header file */
  98 #if (__GNUC__ >= 2 \
  99      ||  defined(__IBM__TYPEOF__) \
 100      || (__SUNPRO_C >= 0x5110 && !__STDC__))
 101 #define TYPEOF(type) (__typeof__ (type))
 102 #else
 103 #define TYPEOF(type) /* empty */
 104 #endif
 105
 106 /* from file `ftobjs.h' from FreeType */
 107 /* we use the TYPEOF macro to suppress signedness compilation warnings */
 108 #define TA_PAD_FLOOR(x, n) ((x) & ~TYPEOF(x)((n) - 1))
 109 #define TA_PAD_ROUND(x, n) TA_PAD_FLOOR((x) + ((n) / 2), n)
 110 #define TA_PAD_CEIL(x, n) TA_PAD_FLOOR((x) + ((n) - 1), n)
 111
 112 #define TA_PIX_FLOOR(x) ((x) & ~TYPEOF(x)63)
 113 #define TA_PIX_ROUND(x) TA_PIX_FLOOR((x) + 32)
 114 #define TA_PIX_CEIL(x) TA_PIX_FLOOR((x) + 63)
 115
 116
 117 typedef struct TA_WidthRec_
 118 {
 119   FT_Pos org; /* original position/width in font units */
 120   FT_Pos cur; /* current/scaled position/width in device subpixels */
 121   FT_Pos fit; /* current/fitted position/width in device subpixels */
 122 } TA_WidthRec, *TA_Width;
 123
 124
 125 /* the auto-hinter doesn't need a very high angular accuracy */
 126 typedef FT_Int TA_Angle;
 127
 128 #define TA_ANGLE_PI 256
 129 #define TA_ANGLE_2PI (TA_ANGLE_PI * 2)
 130 #define TA_ANGLE_PI2 (TA_ANGLE_PI / 2)
 131 #define TA_ANGLE_PI4 (TA_ANGLE_PI / 4)
 132
 133 #define TA_ANGLE_DIFF(result, angle1, angle2) \
 134           do \
 135           { \
 136             TA_Angle _delta = (angle2) - (angle1); \
 137 \
 138 \
 139             while (_delta <= -TA_ANGLE_PI) \
 140               _delta += TA_ANGLE_2PI; \
 141 \
 142             if (_delta > TA_ANGLE_PI) \
 143               _delta -= TA_ANGLE_2PI; \
 144 \
 145             result = _delta; \
 146           } while (0)
 147
 148
 149 /* opaque handle to glyph-specific hints -- */
 150 /* see `tahints.h' for more details */
 151 typedef struct TA_GlyphHintsRec_* TA_GlyphHints;
 152
 153
 154 /* a scaler models the target pixel device that will receive */
 155 /* the auto-hinted glyph image */
 156 #define TA_SCALER_FLAG_NO_HORIZONTAL 0x01U /* disable horizontal hinting */
 157 #define TA_SCALER_FLAG_NO_VERTICAL 0x02U /* disable vertical hinting */
 158 #define TA_SCALER_FLAG_NO_ADVANCE 0x04U /* disable advance hinting */
 159 #define TA_SCALER_FLAG_NO_WARPER 0x08U /* disable warper */
 160
 161
 162 typedef struct TA_ScalerRec_
 163 {
 164   FT_Face face; /* source font face */
 165   FT_Fixed x_scale; /* from font units to 1/64 device pixels */
 166   FT_Fixed y_scale; /* from font units to 1/64 device pixels */
 167   FT_Pos x_delta; /* in 1/64 device pixels */
 168   FT_Pos y_delta; /* in 1/64 device pixels */
 169   FT_Render_Mode render_mode; /* monochrome, anti-aliased, LCD, etc.*/
 170   FT_UInt32 flags; /* additional control flags, see above */
 171 } TA_ScalerRec, *TA_Scaler;
 172
 173 #define TA_SCALER_EQUAL_SCALES(a, b) \
 174           ((a)->x_scale == (b)->x_scale \
 175            && (a)->y_scale == (b)->y_scale \
 176            && (a)->x_delta == (b)->x_delta \
 177            && (a)->y_delta == (b)->y_delta)
 178
 179
 180 typedef struct TA_StyleMetricsRec_* TA_StyleMetrics;
 181
 182 /* this function parses an FT_Face to compute global metrics */
 183 /* for a specific style, optionally using another FT_Face to */
 184 /* derive blue zones                                         */
 185 typedef FT_Error
 186 (*TA_WritingSystem_InitMetricsFunc)(TA_StyleMetrics metrics,
 187                                     FT_Face face,
 188                                     FT_Face reference);
 189 typedef void
 190 (*TA_WritingSystem_ScaleMetricsFunc)(TA_StyleMetrics metrics,
 191                                      TA_Scaler scaler);
 192 typedef void
 193 (*TA_WritingSystem_DoneMetricsFunc)(TA_StyleMetrics metrics);
 194 typedef FT_Error
 195 (*TA_WritingSystem_InitHintsFunc)(TA_GlyphHints hints,
 196                                   TA_StyleMetrics metrics);
 197 typedef FT_Error
 198 (*TA_WritingSystem_ApplyHintsFunc)(FT_UInt glyph_index,
 199                                    TA_GlyphHints hints,
 200                                    FT_Outline* outline,
 201                                    TA_StyleMetrics metrics);
 202
 203
 204 /*
 205  * For the auto-hinter, a writing system consists of multiple scripts that
 206  * can be handled similarly *in a typographical way*; the relationship is
 207  * not based on history.  For example, both the Greek and the unrelated
 208  * Armenian scripts share the same features like ascender, descender,
 209  * x-height, etc.  Essentially, a writing system is covered by a
 210  * submodule of the auto-fitter; it contains
 211  *
 212  * - a specific global analyzer that computes global metrics specific to
 213  *   the script (based on script-specific characters to identify ascender
 214  *   height, x-height, etc.),
 215  *
 216  * - a specific glyph analyzer that computes segments and edges for each
 217  *   glyph covered by the script,
 218  *
 219  * - a specific grid-fitting algorithm that distorts the scaled glyph
 220  *   outline according to the results of the glyph analyzer.
 221  */
 222
 223 #define TAWRTSYS_H_ /* don't load header files */
 224 #undef WRITING_SYSTEM
 225 #define WRITING_SYSTEM(ws, WS) \
 226           TA_WRITING_SYSTEM_ ## WS,
 227
 228 /* The list of known writing systems. */
 229 typedef enum TA_WritingSystem_
 230 {
 231 #include "tawrtsys.h"
 232
 233   TA_WRITING_SYSTEM_MAX /* do not remove */
 234 } TA_WritingSystem;
 235
 236 #undef TAWRTSYS_H_
 237
 238
 239 typedef struct TA_WritingSystemClassRec_
 240 {
 241   TA_WritingSystem writing_system;
 242
 243   FT_Offset style_metrics_size;
 244   TA_WritingSystem_InitMetricsFunc style_metrics_init;
 245   TA_WritingSystem_ScaleMetricsFunc style_metrics_scale;
 246   TA_WritingSystem_DoneMetricsFunc style_metrics_done;
 247
 248   TA_WritingSystem_InitHintsFunc style_hints_init;
 249   TA_WritingSystem_ApplyHintsFunc style_hints_apply;
 250 } TA_WritingSystemClassRec;
 251
 252 typedef const TA_WritingSystemClassRec* TA_WritingSystemClass;
 253
 254
 255 /*
 256  * Each script is associated with two sets of Unicode ranges to test
 257  * whether the font face supports the script, and which base characters
 258  * the script contains.
 259  *
 260  * We use four-letter script tags from the OpenType specification,
 261  * extended by `NONE', which indicates `no script'.
 262  */
 263
 264 #undef SCRIPT
 265 #define SCRIPT(s, S, d, h, H, ss) \
 266           TA_SCRIPT_ ## S,
 267
 268 /* The list of known scripts. */
 269 typedef enum TA_Script_
 270 {
 271 #include <ttfautohint-scripts.h>
 272
 273   TA_SCRIPT_MAX /* do not remove */
 274 } TA_Script;
 275
 276
 277 typedef struct TA_Script_UniRangeRec_
 278 {
 279   FT_UInt32 first;
 280   FT_UInt32 last;
 281 } TA_Script_UniRangeRec;
 282
 283 #define TA_UNIRANGE_REC(a, b) \
 284           { (FT_UInt32)(a), (FT_UInt32)(b) }
 285
 286 #define TA_HINTING_BOTTOM_TO_TOP 0
 287 #define TA_HINTING_TOP_TO_BOTTOM 1
 288
 289 typedef const TA_Script_UniRangeRec* TA_Script_UniRange;
 290
 291 typedef struct TA_ScriptClassRec_
 292 {
 293   TA_Script script;
 294
 295   /* last element in the ranges must be { 0, 0 } */
 296   TA_Script_UniRange script_uni_ranges;
 297   TA_Script_UniRange script_uni_nonbase_ranges;
 298
 299   FT_Bool top_to_bottom_hinting;
 300
 301   const char* standard_charstring; /* for default width and height */
 302 } TA_ScriptClassRec;
 303
 304 typedef const TA_ScriptClassRec* TA_ScriptClass;
 305
 306
 307 /*
 308  * Usually, a font contains more glyphs than can be addressed by its
 309  * character map.
 310  *
 311  * In the PostScript font world, encoding vectors specific to a given
 312  * task are used to select such glyphs, and these glyphs can be often
 313  * recognized by having a suffix in its glyph names.  For example, a
 314  * superscript glyph `A' might be called `A.sup'.  Unfortunately, this
 315  * naming scheme is not standardized and thus unusable for us.
 316  *
 317  * In the OpenType world, a better solution was invented, namely
 318  * `features', which cleanly separate a character's input encoding from
 319  * the corresponding glyph's appearance, and which don't use glyph names
 320  * at all.  For our purposes, and slightly generalized, an OpenType
 321  * feature is a name of a mapping that maps character codes to
 322  * non-standard glyph indices (features get used for other things also).
 323  * For example, the `sups' feature provides superscript glyphs, thus
 324  * mapping character codes like `A' or `B' to superscript glyph
 325  * representation forms.  How this mapping happens is completely
 326  * uninteresting to us.
 327  *
 328  * For the auto-hinter, a `coverage' represents all glyphs of an OpenType
 329  * feature collected in a set (as listed below) that can be hinted
 330  * together.  To continue the above example, superscript glyphs must not
 331  * be hinted together with normal glyphs because the blue zones
 332  * completely differ.
 333  *
 334  * To compute coverages, we use the HarfBuzz library, which has many
 335  * functions exactly for this purpose.
 336  *
 337  * TA_COVERAGE_DEFAULT is special: It should cover everything that isn't
 338  * listed separately (including the glyphs addressable by the character
 339  * map).
 340  */
 341
 342 #undef COVERAGE
 343 #define COVERAGE(name, NAME, description, \
 344                  tag, tag1, tag2, tag3, tag4) \
 345           TA_COVERAGE_ ## NAME,
 346
 347 typedef enum TA_Coverage_
 348 {
 349 #include "ttfautohint-coverages.h"
 350
 351   TA_COVERAGE_DEFAULT
 352 } TA_Coverage;
 353
 354
 355 /*
 356  * The topmost structure for modelling the auto-hinter glyph input data
 357  * is a `style class', grouping everything together.
 358  */
 359
 360 #undef STYLE
 361 #define STYLE(s, S, d, ws, sc, ss, c) \
 362           TA_STYLE_ ## S,
 363
 364 /* The list of known styles. */
 365 typedef enum TA_Style_
 366 {
 367 #include "tastyles.h"
 368
 369   TA_STYLE_MAX /* do not remove */
 370 } TA_Style;
 371
 372
 373 typedef struct TA_StyleClassRec_
 374 {
 375   TA_Style style;
 376
 377   TA_WritingSystem writing_system;
 378   TA_Script script;
 379   TA_Blue_Stringset blue_stringset;
 380   TA_Coverage coverage;
 381 } TA_StyleClassRec;
 382
 383 typedef const TA_StyleClassRec* TA_StyleClass;
 384
 385
 386 typedef struct TA_FaceGlobalsRec_* TA_FaceGlobals;
 387
 388 /* This is the main structure that combines everything.  Autofit modules */
 389 /* specific to writing systems derive their structures from it, for      */
 390 /* example `TA_LatinMetrics'.                                            */
 391
 392 typedef struct TA_StyleMetricsRec_
 393 {
 394   TA_StyleClass style_class;
 395   TA_ScalerRec scaler;
 396   FT_Bool digits_have_same_width;
 397
 398   TA_FaceGlobals globals; /* to access properties */
 399 } TA_StyleMetricsRec;
 400
 401 #ifdef __cplusplus
 402 } /* extern "C" */
 403 #endif
 404
 405 #endif /* TATYPES_H_ */
 406
 407 /* end of tatypes.h */