lib/tatypes.h

   1 /* tatypes.h */
   2
   3 /*
   4  * Copyright (C) 2011-2014 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_ABS(a) ((a) < 0 ? -(a) : (a))
  92
  93 /* from file `ftobjs.h' from FreeType */
  94 #define TA_PAD_FLOOR(x, n) ((x) & ~((n) - 1))
  95 #define TA_PAD_ROUND(x, n) TA_PAD_FLOOR((x) + ((n) / 2), n)
  96 #define TA_PAD_CEIL(x, n) TA_PAD_FLOOR((x) + ((n) - 1), n)
  97
  98 #define TA_PIX_FLOOR(x) ((x) & ~63)
  99 #define TA_PIX_ROUND(x) TA_PIX_FLOOR((x) + 32)
 100 #define TA_PIX_CEIL(x) TA_PIX_FLOOR((x) + 63)
 101
 102
 103 typedef struct TA_WidthRec_
 104 {
 105   FT_Pos org; /* original position/width in font units */
 106   FT_Pos cur; /* current/scaled position/width in device sub-pixels */
 107   FT_Pos fit; /* current/fitted position/width in device sub-pixels */
 108 } TA_WidthRec, *TA_Width;
 109
 110
 111 /* the auto-hinter doesn't need a very high angular accuracy */
 112 typedef FT_Int TA_Angle;
 113
 114 #define TA_ANGLE_PI 256
 115 #define TA_ANGLE_2PI (TA_ANGLE_PI * 2)
 116 #define TA_ANGLE_PI2 (TA_ANGLE_PI / 2)
 117 #define TA_ANGLE_PI4 (TA_ANGLE_PI / 4)
 118
 119 #define TA_ANGLE_DIFF(result, angle1, angle2) \
 120           do \
 121           { \
 122             TA_Angle _delta = (angle2) - (angle1); \
 123 \
 124 \
 125             _delta %= TA_ANGLE_2PI; \
 126             if (_delta < 0) \
 127               _delta += TA_ANGLE_2PI; \
 128 \
 129             if (_delta > TA_ANGLE_PI) \
 130               _delta -= TA_ANGLE_2PI; \
 131 \
 132             result = _delta; \
 133           } while (0)
 134
 135
 136 /* opaque handle to glyph-specific hints -- */
 137 /* see `tahints.h' for more details */
 138 typedef struct TA_GlyphHintsRec_* TA_GlyphHints;
 139
 140
 141 /* a scaler models the target pixel device that will receive */
 142 /* the auto-hinted glyph image */
 143 #define TA_SCALER_FLAG_NO_HORIZONTAL 0x01 /* disable horizontal hinting */
 144 #define TA_SCALER_FLAG_NO_VERTICAL 0x02 /* disable vertical hinting */
 145 #define TA_SCALER_FLAG_NO_ADVANCE 0x04 /* disable advance hinting */
 146
 147 typedef struct TA_ScalerRec_
 148 {
 149   FT_Face face; /* source font face */
 150   FT_Fixed x_scale; /* from font units to 1/64th device pixels */
 151   FT_Fixed y_scale; /* from font units to 1/64th device pixels */
 152   FT_Pos x_delta; /* in 1/64th device pixels */
 153   FT_Pos y_delta; /* in 1/64th device pixels */
 154   FT_Render_Mode render_mode; /* monochrome, anti-aliased, LCD, etc.*/
 155   FT_UInt32 flags; /* additional control flags, see above */
 156 } TA_ScalerRec, *TA_Scaler;
 157
 158 #define TA_SCALER_EQUAL_SCALES(a, b) \
 159           ((a)->x_scale == (b)->x_scale \
 160            && (a)->y_scale == (b)->y_scale \
 161            && (a)->x_delta == (b)->x_delta \
 162            && (a)->y_delta == (b)->y_delta)
 163
 164
 165 typedef struct TA_StyleMetricsRec_* TA_StyleMetrics;
 166
 167 /* this function parses an FT_Face to compute global metrics */
 168 /* for a specific style */
 169 typedef FT_Error
 170 (*TA_WritingSystem_InitMetricsFunc)(TA_StyleMetrics metrics,
 171                                     FT_Face face);
 172 typedef void
 173 (*TA_WritingSystem_ScaleMetricsFunc)(TA_StyleMetrics metrics,
 174                                      TA_Scaler scaler);
 175 typedef void
 176 (*TA_WritingSystem_DoneMetricsFunc)(TA_StyleMetrics metrics);
 177 typedef FT_Error
 178 (*TA_WritingSystem_InitHintsFunc)(TA_GlyphHints hints,
 179                                   TA_StyleMetrics metrics);
 180 typedef void
 181 (*TA_WritingSystem_ApplyHintsFunc)(TA_GlyphHints hints,
 182                                    FT_Outline* outline,
 183                                    TA_StyleMetrics metrics);
 184
 185
 186 /*
 187  * For the auto-hinter, a writing system consists of multiple scripts that
 188  * can be handled similarly *in a typographical way*; the relationship is
 189  * not based on history.  For example, both the Greek and the unrelated
 190  * Armenian scripts share the same features like ascender, descender,
 191  * x-height, etc.  Essentially, a writing system is covered by a
 192  * submodule of the auto-fitter; it contains
 193  *
 194  * - a specific global analyzer that computes global metrics specific to
 195  *   the script (based on script-specific characters to identify ascender
 196  *   height, x-height, etc.),
 197  *
 198  * - a specific glyph analyzer that computes segments and edges for each
 199  *   glyph covered by the script,
 200  *
 201  * - a specific grid-fitting algorithm that distorts the scaled glyph
 202  *   outline according to the results of the glyph analyzer.
 203  */
 204
 205 #define __TAWRTSYS_H__ /* don't load header files */
 206 #undef WRITING_SYSTEM
 207 #define WRITING_SYSTEM(ws, WS) \
 208           TA_WRITING_SYSTEM_ ## WS,
 209
 210 /* The list of known writing systems. */
 211 typedef enum TA_WritingSystem_
 212 {
 213 #include "tawrtsys.h"
 214
 215   TA_WRITING_SYSTEM_MAX /* do not remove */
 216 } TA_WritingSystem;
 217
 218 #undef __TAWRTSYS_H__
 219
 220
 221 typedef struct TA_WritingSystemClassRec_
 222 {
 223   TA_WritingSystem writing_system;
 224
 225   FT_Offset style_metrics_size;
 226   TA_WritingSystem_InitMetricsFunc style_metrics_init;
 227   TA_WritingSystem_ScaleMetricsFunc style_metrics_scale;
 228   TA_WritingSystem_DoneMetricsFunc style_metrics_done;
 229
 230   TA_WritingSystem_InitHintsFunc style_hints_init;
 231   TA_WritingSystem_ApplyHintsFunc style_hints_apply;
 232 } TA_WritingSystemClassRec;
 233
 234 typedef const TA_WritingSystemClassRec* TA_WritingSystemClass;
 235
 236
 237 /*
 238  * Each script is associated with a set of Unicode ranges that gets used
 239  * to test whether the font face supports the script.
 240  *
 241  * We use four-letter script tags from the OpenType specification,
 242  * extended by `NONE', which indicates `no script'.
 243  */
 244
 245 #undef SCRIPT
 246 #define SCRIPT(s, S, d, h, sc1, sc2, sc3) \
 247           TA_SCRIPT_ ## S,
 248
 249 /* The list of known scripts. */
 250 typedef enum TA_Script_
 251 {
 252 #include <ttfautohint-scripts.h>
 253
 254   TA_SCRIPT_MAX /* do not remove */
 255 } TA_Script;
 256
 257
 258 typedef struct TA_Script_UniRangeRec_
 259 {
 260   FT_UInt32 first;
 261   FT_UInt32 last;
 262 } TA_Script_UniRangeRec;
 263
 264 #define TA_UNIRANGE_REC(a, b) \
 265           { (FT_UInt32)(a), (FT_UInt32)(b) }
 266
 267 typedef const TA_Script_UniRangeRec* TA_Script_UniRange;
 268
 269 typedef struct TA_ScriptClassRec_
 270 {
 271   TA_Script script;
 272
 273   TA_Script_UniRange script_uni_ranges; /* last must be { 0, 0 } */
 274
 275   FT_UInt32 standard_char1; /* for default width and height */
 276   FT_UInt32 standard_char2; /* ditto */
 277   FT_UInt32 standard_char3; /* ditto */
 278 } TA_ScriptClassRec;
 279
 280 typedef const TA_ScriptClassRec* TA_ScriptClass;
 281
 282
 283 /*
 284  * Usually, a font contains more glyphs than can be addressed by its
 285  * character map.
 286  *
 287  * In the PostScript font world, encoding vectors specific to a given
 288  * task are used to select such glyphs, and these glyphs can be often
 289  * recognized by having a suffix in its glyph names.  For example, a
 290  * superscript glyph `A' might be called `A.sup'.  Unfortunately, this
 291  * naming scheme is not standardized and thus unusable for us.
 292  *
 293  * In the OpenType world, a better solution was invented, namely
 294  * `features', which cleanly separate a character's input encoding from
 295  * the corresponding glyph's appearance, and which don't use glyph names
 296  * at all.  For our purposes, and slightly generalized, an OpenType
 297  * feature is a name of a mapping that maps character codes to
 298  * non-standard glyph indices (features get used for other things also).
 299  * For example, the `sups' feature provides superscript glyphs, thus
 300  * mapping character codes like `A' or `B' to superscript glyph
 301  * representation forms.  How this mapping happens is completely
 302  * uninteresting to us.
 303  *
 304  * For the auto-hinter, a `coverage' represents all glyphs of an OpenType
 305  * feature collected in a set (as listed below) that can be hinted
 306  * together.  To continue the above example, superscript glyphs must not
 307  * be hinted together with normal glyphs because the blue zones
 308  * completely differ.
 309  *
 310  * To compute coverages, we use the HarfBuzz library, which has many
 311  * functions exactly for this purpose.
 312  *
 313  * TA_COVERAGE_DEFAULT is special: It should cover everything that isn't
 314  * listed separately (including the glyphs addressable by the character
 315  * map).
 316  */
 317
 318 #undef COVERAGE
 319 #define COVERAGE(name, NAME, description, \
 320                  tag1, tag2, tag3, tag4) \
 321           TA_COVERAGE_ ## NAME,
 322
 323 typedef enum TA_Coverage_
 324 {
 325 #include "tacover.h"
 326
 327   TA_COVERAGE_DEFAULT
 328 } TA_Coverage;
 329
 330
 331 /*
 332  * The topmost structure for modelling the auto-hinter glyph input data
 333  * is a `style class', grouping everything together.
 334  */
 335
 336 #undef STYLE
 337 #define STYLE(s, S, d, ws, sc, ss, c) \
 338           TA_STYLE_ ## S,
 339
 340 /* The list of known styles. */
 341 typedef enum TA_Style_
 342 {
 343 #include "tastyles.h"
 344
 345   TA_STYLE_MAX /* do not remove */
 346 } TA_Style;
 347
 348
 349 typedef struct TA_StyleClassRec_
 350 {
 351   TA_Style style;
 352
 353   TA_WritingSystem writing_system;
 354   TA_Script script;
 355   TA_Blue_Stringset blue_stringset;
 356   TA_Coverage coverage;
 357 } TA_StyleClassRec;
 358
 359 typedef const TA_StyleClassRec* TA_StyleClass;
 360
 361
 362 typedef struct TA_FaceGlobalsRec_* TA_FaceGlobals;
 363
 364 /* This is the main structure that combines everything.  Autofit modules */
 365 /* specific to writing systems derive their structures from it, for      */
 366 /* example `TA_LatinMetrics'.                                            */
 367
 368 typedef struct TA_StyleMetricsRec_
 369 {
 370   TA_StyleClass style_class;
 371   TA_ScalerRec scaler;
 372   FT_Bool digits_have_same_width;
 373
 374   TA_FaceGlobals globals; /* to access properties */
 375 } TA_StyleMetricsRec;
 376
 377 #ifdef __cplusplus
 378 } /* extern "C" */
 379 #endif
 380
 381 #endif /* __TATYPES_H__ */
 382
 383 /* end of tatypes.h */