1 /**************************************************************************** 2 * 3 * ttobjs.h 4 * 5 * Objects manager (specification). 6 * 7 * Copyright (C) 1996-2022 by 8 * David Turner, Robert Wilhelm, and Werner Lemberg. 9 * 10 * This file is part of the FreeType project, and may only be used, 11 * modified, and distributed under the terms of the FreeType project 12 * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 * this file you indicate that you have read the license and 14 * understand and accept it fully. 15 * 16 */ 17 18 19 #ifndef TTOBJS_H_ 20 #define TTOBJS_H_ 21 22 23 #include <freetype/internal/ftobjs.h> 24 #include <freetype/internal/tttypes.h> 25 26 27 FT_BEGIN_HEADER 28 29 30 /************************************************************************** 31 * 32 * @Type: 33 * TT_Driver 34 * 35 * @Description: 36 * A handle to a TrueType driver object. 37 */ 38 typedef struct TT_DriverRec_* TT_Driver; 39 40 41 /************************************************************************** 42 * 43 * @Type: 44 * TT_GlyphSlot 45 * 46 * @Description: 47 * A handle to a TrueType glyph slot object. 48 * 49 * @Note: 50 * This is a direct typedef of FT_GlyphSlot, as there is nothing 51 * specific about the TrueType glyph slot. 52 */ 53 typedef FT_GlyphSlot TT_GlyphSlot; 54 55 56 /************************************************************************** 57 * 58 * @Struct: 59 * TT_GraphicsState 60 * 61 * @Description: 62 * The TrueType graphics state used during bytecode interpretation. 63 */ 64 typedef struct TT_GraphicsState_ 65 { 66 FT_UShort rp0; 67 FT_UShort rp1; 68 FT_UShort rp2; 69 70 FT_UnitVector dualVector; 71 FT_UnitVector projVector; 72 FT_UnitVector freeVector; 73 74 FT_Long loop; 75 FT_F26Dot6 minimum_distance; 76 FT_Int round_state; 77 78 FT_Bool auto_flip; 79 FT_F26Dot6 control_value_cutin; 80 FT_F26Dot6 single_width_cutin; 81 FT_F26Dot6 single_width_value; 82 FT_UShort delta_base; 83 FT_UShort delta_shift; 84 85 FT_Byte instruct_control; 86 /* According to Greg Hitchcock from Microsoft, the `scan_control' */ 87 /* variable as documented in the TrueType specification is a 32-bit */ 88 /* integer; the high-word part holds the SCANTYPE value, the low-word */ 89 /* part the SCANCTRL value. We separate it into two fields. */ 90 FT_Bool scan_control; 91 FT_Int scan_type; 92 93 FT_UShort gep0; 94 FT_UShort gep1; 95 FT_UShort gep2; 96 97 } TT_GraphicsState; 98 99 100 #ifdef TT_USE_BYTECODE_INTERPRETER 101 102 FT_LOCAL( void ) 103 tt_glyphzone_done( TT_GlyphZone zone ); 104 105 FT_LOCAL( FT_Error ) 106 tt_glyphzone_new( FT_Memory memory, 107 FT_UShort maxPoints, 108 FT_Short maxContours, 109 TT_GlyphZone zone ); 110 111 #endif /* TT_USE_BYTECODE_INTERPRETER */ 112 113 114 115 /************************************************************************** 116 * 117 * EXECUTION SUBTABLES 118 * 119 * These sub-tables relate to instruction execution. 120 * 121 */ 122 123 124 #define TT_MAX_CODE_RANGES 3 125 126 127 /************************************************************************** 128 * 129 * There can only be 3 active code ranges at once: 130 * - the Font Program 131 * - the CVT Program 132 * - a glyph's instructions set 133 */ 134 typedef enum TT_CodeRange_Tag_ 135 { 136 tt_coderange_none = 0, 137 tt_coderange_font, 138 tt_coderange_cvt, 139 tt_coderange_glyph 140 141 } TT_CodeRange_Tag; 142 143 144 typedef struct TT_CodeRange_ 145 { 146 FT_Byte* base; 147 FT_Long size; 148 149 } TT_CodeRange; 150 151 typedef TT_CodeRange TT_CodeRangeTable[TT_MAX_CODE_RANGES]; 152 153 154 /************************************************************************** 155 * 156 * Defines a function/instruction definition record. 157 */ 158 typedef struct TT_DefRecord_ 159 { 160 FT_Int range; /* in which code range is it located? */ 161 FT_Long start; /* where does it start? */ 162 FT_Long end; /* where does it end? */ 163 FT_UInt opc; /* function #, or instruction code */ 164 FT_Bool active; /* is it active? */ 165 FT_Bool inline_delta; /* is function that defines inline delta? */ 166 FT_ULong sph_fdef_flags; /* flags to identify special functions */ 167 168 } TT_DefRecord, *TT_DefArray; 169 170 171 /************************************************************************** 172 * 173 * Subglyph transformation record. 174 */ 175 typedef struct TT_Transform_ 176 { 177 FT_Fixed xx, xy; /* transformation matrix coefficients */ 178 FT_Fixed yx, yy; 179 FT_F26Dot6 ox, oy; /* offsets */ 180 181 } TT_Transform; 182 183 184 /************************************************************************** 185 * 186 * A note regarding non-squared pixels: 187 * 188 * (This text will probably go into some docs at some time; for now, it 189 * is kept here to explain some definitions in the TT_Size_Metrics 190 * record). 191 * 192 * The CVT is a one-dimensional array containing values that control 193 * certain important characteristics in a font, like the height of all 194 * capitals, all lowercase letter, default spacing or stem width/height. 195 * 196 * These values are found in FUnits in the font file, and must be scaled 197 * to pixel coordinates before being used by the CVT and glyph programs. 198 * Unfortunately, when using distinct x and y resolutions (or distinct x 199 * and y pointsizes), there are two possible scalings. 200 * 201 * A first try was to implement a `lazy' scheme where all values were 202 * scaled when first used. However, while some values are always used 203 * in the same direction, some others are used under many different 204 * circumstances and orientations. 205 * 206 * I have found a simpler way to do the same, and it even seems to work 207 * in most of the cases: 208 * 209 * - All CVT values are scaled to the maximum ppem size. 210 * 211 * - When performing a read or write in the CVT, a ratio factor is used 212 * to perform adequate scaling. Example: 213 * 214 * x_ppem = 14 215 * y_ppem = 10 216 * 217 * We choose ppem = x_ppem = 14 as the CVT scaling size. All cvt 218 * entries are scaled to it. 219 * 220 * x_ratio = 1.0 221 * y_ratio = y_ppem/ppem (< 1.0) 222 * 223 * We compute the current ratio like: 224 * 225 * - If projVector is horizontal, 226 * ratio = x_ratio = 1.0 227 * 228 * - if projVector is vertical, 229 * ratio = y_ratio 230 * 231 * - else, 232 * ratio = sqrt( (proj.x * x_ratio) ^ 2 + (proj.y * y_ratio) ^ 2 ) 233 * 234 * Reading a cvt value returns 235 * ratio * cvt[index] 236 * 237 * Writing a cvt value in pixels: 238 * cvt[index] / ratio 239 * 240 * The current ppem is simply 241 * ratio * ppem 242 * 243 */ 244 245 246 /************************************************************************** 247 * 248 * Metrics used by the TrueType size and context objects. 249 */ 250 typedef struct TT_Size_Metrics_ 251 { 252 /* for non-square pixels */ 253 FT_Long x_ratio; 254 FT_Long y_ratio; 255 256 FT_UShort ppem; /* maximum ppem size */ 257 FT_Long ratio; /* current ratio */ 258 FT_Fixed scale; 259 260 FT_F26Dot6 compensations[4]; /* device-specific compensations */ 261 262 FT_Bool valid; 263 264 FT_Bool rotated; /* `is the glyph rotated?'-flag */ 265 FT_Bool stretched; /* `is the glyph stretched?'-flag */ 266 267 } TT_Size_Metrics; 268 269 270 /************************************************************************** 271 * 272 * TrueType size class. 273 */ 274 typedef struct TT_SizeRec_ 275 { 276 FT_SizeRec root; 277 278 /* we have our own copy of metrics so that we can modify */ 279 /* it without affecting auto-hinting (when used) */ 280 FT_Size_Metrics* metrics; /* for the current rendering mode */ 281 FT_Size_Metrics hinted_metrics; /* for the hinted rendering mode */ 282 283 TT_Size_Metrics ttmetrics; 284 285 FT_Byte* widthp; /* glyph widths from the hdmx table */ 286 287 FT_ULong strike_index; /* 0xFFFFFFFF to indicate invalid */ 288 289 #ifdef TT_USE_BYTECODE_INTERPRETER 290 291 FT_Long point_size; /* for the `MPS' bytecode instruction */ 292 293 FT_UInt num_function_defs; /* number of function definitions */ 294 FT_UInt max_function_defs; 295 TT_DefArray function_defs; /* table of function definitions */ 296 297 FT_UInt num_instruction_defs; /* number of ins. definitions */ 298 FT_UInt max_instruction_defs; 299 TT_DefArray instruction_defs; /* table of ins. definitions */ 300 301 FT_UInt max_func; 302 FT_UInt max_ins; 303 304 TT_CodeRangeTable codeRangeTable; 305 306 TT_GraphicsState GS; 307 308 FT_ULong cvt_size; /* the scaled control value table */ 309 FT_Long* cvt; 310 311 FT_UShort storage_size; /* The storage area is now part of */ 312 FT_Long* storage; /* the instance */ 313 314 TT_GlyphZoneRec twilight; /* The instance's twilight zone */ 315 316 TT_ExecContext context; 317 318 /* if negative, `fpgm' (resp. `prep'), wasn't executed yet; */ 319 /* otherwise it is the returned error code */ 320 FT_Error bytecode_ready; 321 FT_Error cvt_ready; 322 323 #endif /* TT_USE_BYTECODE_INTERPRETER */ 324 325 } TT_SizeRec; 326 327 328 /************************************************************************** 329 * 330 * TrueType driver class. 331 */ 332 typedef struct TT_DriverRec_ 333 { 334 FT_DriverRec root; 335 336 TT_GlyphZoneRec zone; /* glyph loader points zone */ 337 338 FT_UInt interpreter_version; 339 340 } TT_DriverRec; 341 342 343 /* Note: All of the functions below (except tt_size_reset()) are used */ 344 /* as function pointers in a FT_Driver_ClassRec. Therefore their */ 345 /* parameters are of types FT_Face, FT_Size, etc., rather than TT_Face, */ 346 /* TT_Size, etc., so that the compiler can confirm that the types and */ 347 /* number of parameters are correct. In all cases the FT_xxx types are */ 348 /* cast to their TT_xxx counterparts inside the functions since FreeType */ 349 /* will always use the TT driver to create them. */ 350 351 352 /************************************************************************** 353 * 354 * Face functions 355 */ 356 FT_LOCAL( FT_Error ) 357 tt_face_init( FT_Stream stream, 358 FT_Face ttface, /* TT_Face */ 359 FT_Int face_index, 360 FT_Int num_params, 361 FT_Parameter* params ); 362 363 FT_LOCAL( void ) 364 tt_face_done( FT_Face ttface ); /* TT_Face */ 365 366 367 /************************************************************************** 368 * 369 * Size functions 370 */ 371 FT_LOCAL( FT_Error ) 372 tt_size_init( FT_Size ttsize ); /* TT_Size */ 373 374 FT_LOCAL( void ) 375 tt_size_done( FT_Size ttsize ); /* TT_Size */ 376 377 #ifdef TT_USE_BYTECODE_INTERPRETER 378 379 FT_LOCAL( FT_Error ) 380 tt_size_run_fpgm( TT_Size size, 381 FT_Bool pedantic ); 382 383 FT_LOCAL( FT_Error ) 384 tt_size_run_prep( TT_Size size, 385 FT_Bool pedantic ); 386 387 FT_LOCAL( FT_Error ) 388 tt_size_ready_bytecode( TT_Size size, 389 FT_Bool pedantic ); 390 391 #endif /* TT_USE_BYTECODE_INTERPRETER */ 392 393 FT_LOCAL( FT_Error ) 394 tt_size_reset( TT_Size size, 395 FT_Bool only_height ); 396 397 398 /************************************************************************** 399 * 400 * Driver functions 401 */ 402 FT_LOCAL( FT_Error ) 403 tt_driver_init( FT_Module ttdriver ); /* TT_Driver */ 404 405 FT_LOCAL( void ) 406 tt_driver_done( FT_Module ttdriver ); /* TT_Driver */ 407 408 409 /************************************************************************** 410 * 411 * Slot functions 412 */ 413 FT_LOCAL( FT_Error ) 414 tt_slot_init( FT_GlyphSlot slot ); 415 416 417 /* auxiliary */ 418 #define IS_HINTED( flags ) ( ( flags & FT_LOAD_NO_HINTING ) == 0 ) 419 420 421 FT_END_HEADER 422 423 #endif /* TTOBJS_H_ */ 424 425 426 /* END */ 427