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 */ |
427 | |