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