1 /****************************************************************************
2 *
3 * ttobjs.h
4 *
5 * Objects manager (specification).
6 *
7 * Copyright (C) 1996-2023 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
166 } TT_DefRecord, *TT_DefArray;
167
168
169 /**************************************************************************
170 *
171 * Subglyph transformation record.
172 */
173 typedef struct TT_Transform_
174 {
175 FT_Fixed xx, xy; /* transformation matrix coefficients */
176 FT_Fixed yx, yy;
177 FT_F26Dot6 ox, oy; /* offsets */
178
179 } TT_Transform;
180
181
182 /**************************************************************************
183 *
184 * A note regarding non-squared pixels:
185 *
186 * (This text will probably go into some docs at some time; for now, it
187 * is kept here to explain some definitions in the TT_Size_Metrics
188 * record).
189 *
190 * The CVT is a one-dimensional array containing values that control
191 * certain important characteristics in a font, like the height of all
192 * capitals, all lowercase letter, default spacing or stem width/height.
193 *
194 * These values are found in FUnits in the font file, and must be scaled
195 * to pixel coordinates before being used by the CVT and glyph programs.
196 * Unfortunately, when using distinct x and y resolutions (or distinct x
197 * and y pointsizes), there are two possible scalings.
198 *
199 * A first try was to implement a `lazy' scheme where all values were
200 * scaled when first used. However, while some values are always used
201 * in the same direction, some others are used under many different
202 * circumstances and orientations.
203 *
204 * I have found a simpler way to do the same, and it even seems to work
205 * in most of the cases:
206 *
207 * - All CVT values are scaled to the maximum ppem size.
208 *
209 * - When performing a read or write in the CVT, a ratio factor is used
210 * to perform adequate scaling. Example:
211 *
212 * x_ppem = 14
213 * y_ppem = 10
214 *
215 * We choose ppem = x_ppem = 14 as the CVT scaling size. All cvt
216 * entries are scaled to it.
217 *
218 * x_ratio = 1.0
219 * y_ratio = y_ppem/ppem (< 1.0)
220 *
221 * We compute the current ratio like:
222 *
223 * - If projVector is horizontal,
224 * ratio = x_ratio = 1.0
225 *
226 * - if projVector is vertical,
227 * ratio = y_ratio
228 *
229 * - else,
230 * ratio = sqrt( (proj.x * x_ratio) ^ 2 + (proj.y * y_ratio) ^ 2 )
231 *
232 * Reading a cvt value returns
233 * ratio * cvt[index]
234 *
235 * Writing a cvt value in pixels:
236 * cvt[index] / ratio
237 *
238 * The current ppem is simply
239 * ratio * ppem
240 *
241 */
242
243
244 /**************************************************************************
245 *
246 * Metrics used by the TrueType size and context objects.
247 */
248 typedef struct TT_Size_Metrics_
249 {
250 /* for non-square pixels */
251 FT_Long x_ratio;
252 FT_Long y_ratio;
253
254 FT_UShort ppem; /* maximum ppem size */
255 FT_Long ratio; /* current ratio */
256 FT_Fixed scale;
257
258 FT_F26Dot6 compensations[4]; /* device-specific compensations */
259
260 FT_Bool valid;
261
262 FT_Bool rotated; /* `is the glyph rotated?'-flag */
263 FT_Bool stretched; /* `is the glyph stretched?'-flag */
264
265 } TT_Size_Metrics;
266
267
268 /**************************************************************************
269 *
270 * TrueType size class.
271 */
272 typedef struct TT_SizeRec_
273 {
274 FT_SizeRec root;
275
276 /* we have our own copy of metrics so that we can modify */
277 /* it without affecting auto-hinting (when used) */
278 FT_Size_Metrics* metrics; /* for the current rendering mode */
279 FT_Size_Metrics hinted_metrics; /* for the hinted rendering mode */
280
281 TT_Size_Metrics ttmetrics;
282
283 FT_Byte* widthp; /* glyph widths from the hdmx table */
284
285 FT_ULong strike_index; /* 0xFFFFFFFF to indicate invalid */
286
287 #ifdef TT_USE_BYTECODE_INTERPRETER
288
289 FT_Long point_size; /* for the `MPS' bytecode instruction */
290
291 FT_UInt num_function_defs; /* number of function definitions */
292 FT_UInt max_function_defs;
293 TT_DefArray function_defs; /* table of function definitions */
294
295 FT_UInt num_instruction_defs; /* number of ins. definitions */
296 FT_UInt max_instruction_defs;
297 TT_DefArray instruction_defs; /* table of ins. definitions */
298
299 FT_UInt max_func;
300 FT_UInt max_ins;
301
302 TT_CodeRangeTable codeRangeTable;
303
304 TT_GraphicsState GS;
305
306 FT_ULong cvt_size; /* the scaled control value table */
307 FT_Long* cvt;
308
309 FT_UShort storage_size; /* The storage area is now part of */
310 FT_Long* storage; /* the instance */
311
312 TT_GlyphZoneRec twilight; /* The instance's twilight zone */
313
314 TT_ExecContext context;
315
316 /* if negative, `fpgm' (resp. `prep'), wasn't executed yet; */
317 /* otherwise it is the returned error code */
318 FT_Error bytecode_ready;
319 FT_Error cvt_ready;
320
321 #endif /* TT_USE_BYTECODE_INTERPRETER */
322
323 } TT_SizeRec;
324
325
326 /**************************************************************************
327 *
328 * TrueType driver class.
329 */
330 typedef struct TT_DriverRec_
331 {
332 FT_DriverRec root;
333
334 TT_GlyphZoneRec zone; /* glyph loader points zone */
335
336 FT_UInt interpreter_version;
337
338 } TT_DriverRec;
339
340
341 /* Note: All of the functions below (except tt_size_reset()) are used */
342 /* as function pointers in a FT_Driver_ClassRec. Therefore their */
343 /* parameters are of types FT_Face, FT_Size, etc., rather than TT_Face, */
344 /* TT_Size, etc., so that the compiler can confirm that the types and */
345 /* number of parameters are correct. In all cases the FT_xxx types are */
346 /* cast to their TT_xxx counterparts inside the functions since FreeType */
347 /* will always use the TT driver to create them. */
348
349
350 /**************************************************************************
351 *
352 * Face functions
353 */
354 FT_LOCAL( FT_Error )
355 tt_face_init( FT_Stream stream,
356 FT_Face ttface, /* TT_Face */
357 FT_Int face_index,
358 FT_Int num_params,
359 FT_Parameter* params );
360
361 FT_LOCAL( void )
362 tt_face_done( FT_Face ttface ); /* TT_Face */
363
364
365 /**************************************************************************
366 *
367 * Size functions
368 */
369 FT_LOCAL( FT_Error )
370 tt_size_init( FT_Size ttsize ); /* TT_Size */
371
372 FT_LOCAL( void )
373 tt_size_done( FT_Size ttsize ); /* TT_Size */
374
375 #ifdef TT_USE_BYTECODE_INTERPRETER
376
377 FT_LOCAL( FT_Error )
378 tt_size_run_fpgm( TT_Size size,
379 FT_Bool pedantic );
380
381 FT_LOCAL( FT_Error )
382 tt_size_run_prep( TT_Size size,
383 FT_Bool pedantic );
384
385 FT_LOCAL( FT_Error )
386 tt_size_ready_bytecode( TT_Size size,
387 FT_Bool pedantic );
388
389 #endif /* TT_USE_BYTECODE_INTERPRETER */
390
391 FT_LOCAL( FT_Error )
392 tt_size_reset_height( FT_Size size );
393
394 FT_LOCAL( FT_Error )
395 tt_size_reset( TT_Size size );
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 */