source: trunk/poppler/freetype2/src/truetype/ttgload.c @ 182

Last change on this file since 182 was 182, checked in by Eugene Romanenko, 15 years ago

freetype update to version 2.3.0

File size: 63.5 KB
Line 
1/***************************************************************************/
2/*                                                                         */
3/*  ttgload.c                                                              */
4/*                                                                         */
5/*    TrueType Glyph Loader (body).                                        */
6/*                                                                         */
7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 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#include <ft2build.h>
20#include FT_INTERNAL_DEBUG_H
21#include FT_INTERNAL_CALC_H
22#include FT_INTERNAL_STREAM_H
23#include FT_INTERNAL_SFNT_H
24#include FT_TRUETYPE_TAGS_H
25#include FT_OUTLINE_H
26
27#include "ttgload.h"
28#include "ttpload.h"
29
30#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
31#include "ttgxvar.h"
32#endif
33
34#include "tterrors.h"
35
36
37  /*************************************************************************/
38  /*                                                                       */
39  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
40  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
41  /* messages during execution.                                            */
42  /*                                                                       */
43#undef  FT_COMPONENT
44#define FT_COMPONENT  trace_ttgload
45
46
47  /*************************************************************************/
48  /*                                                                       */
49  /* Composite font flags.                                                 */
50  /*                                                                       */
51#define ARGS_ARE_WORDS             0x0001
52#define ARGS_ARE_XY_VALUES         0x0002
53#define ROUND_XY_TO_GRID           0x0004
54#define WE_HAVE_A_SCALE            0x0008
55/* reserved                        0x0010 */
56#define MORE_COMPONENTS            0x0020
57#define WE_HAVE_AN_XY_SCALE        0x0040
58#define WE_HAVE_A_2X2              0x0080
59#define WE_HAVE_INSTR              0x0100
60#define USE_MY_METRICS             0x0200
61#define OVERLAP_COMPOUND           0x0400
62#define SCALED_COMPONENT_OFFSET    0x0800
63#define UNSCALED_COMPONENT_OFFSET  0x1000
64
65
66  /*************************************************************************/
67  /*                                                                       */
68  /* Returns the horizontal metrics in font units for a given glyph.  If   */
69  /* `check' is true, take care of monospaced fonts by returning the       */
70  /* advance width maximum.                                                */
71  /*                                                                       */
72  static void
73  Get_HMetrics( TT_Face     face,
74                FT_UInt     idx,
75                FT_Bool     check,
76                FT_Short*   lsb,
77                FT_UShort*  aw )
78  {
79    ( (SFNT_Service)face->sfnt )->get_metrics( face, 0, idx, lsb, aw );
80
81    if ( check && face->postscript.isFixedPitch )
82      *aw = face->horizontal.advance_Width_Max;
83  }
84
85
86  /*************************************************************************/
87  /*                                                                       */
88  /* Returns the vertical metrics in font units for a given glyph.         */
89  /* Greg Hitchcock from Microsoft told us that if there were no `vmtx'    */
90  /* table, typoAscender/Descender from the `OS/2' table would be used     */
91  /* instead, and if there were no `OS/2' table, use ascender/descender    */
92  /* from the `hhea' table.  But that is not what Microsoft's rasterizer   */
93  /* apparently does: It uses the ppem value as the advance height, and    */
94  /* sets the top side bearing to be zero.                                 */
95  /*                                                                       */
96  /* The monospace `check' is probably not meaningful here, but we leave   */
97  /* it in for a consistent interface.                                     */
98  /*                                                                       */
99  static void
100  Get_VMetrics( TT_Face     face,
101                FT_UInt     idx,
102                FT_Bool     check,
103                FT_Short*   tsb,
104                FT_UShort*  ah )
105  {
106    FT_UNUSED( check );
107
108    if ( face->vertical_info )
109      ( (SFNT_Service)face->sfnt )->get_metrics( face, 1, idx, tsb, ah );
110
111#if 1             /* Emperically determined, at variance with what MS said */
112
113    else
114    {
115      *tsb = 0;
116      *ah  = face->root.units_per_EM;
117    }
118
119#else      /* This is what MS said to do.  It isn't what they do, however. */
120
121    else if ( face->os2.version != 0xFFFFU )
122    {
123      *tsb = face->os2.sTypoAscender;
124      *ah  = face->os2.sTypoAscender - face->os2.sTypoDescender;
125    }
126    else
127    {
128      *tsb = face->horizontal.Ascender;
129      *ah  = face->horizontal.Ascender - face->horizontal.Descender;
130    }
131
132#endif
133
134  }
135
136
137  /*************************************************************************/
138  /*                                                                       */
139  /* Translates an array of coordinates.                                   */
140  /*                                                                       */
141  static void
142  translate_array( FT_UInt     n,
143                   FT_Vector*  coords,
144                   FT_Pos      delta_x,
145                   FT_Pos      delta_y )
146  {
147    FT_UInt  k;
148
149
150    if ( delta_x )
151      for ( k = 0; k < n; k++ )
152        coords[k].x += delta_x;
153
154    if ( delta_y )
155      for ( k = 0; k < n; k++ )
156        coords[k].y += delta_y;
157  }
158
159
160#undef  IS_HINTED
161#define IS_HINTED( flags )  ( ( flags & FT_LOAD_NO_HINTING ) == 0 )
162
163
164  /*************************************************************************/
165  /*                                                                       */
166  /* The following functions are used by default with TrueType fonts.      */
167  /* However, they can be replaced by alternatives if we need to support   */
168  /* TrueType-compressed formats (like MicroType) in the future.           */
169  /*                                                                       */
170  /*************************************************************************/
171
172  FT_CALLBACK_DEF( FT_Error )
173  TT_Access_Glyph_Frame( TT_Loader  loader,
174                         FT_UInt    glyph_index,
175                         FT_ULong   offset,
176                         FT_UInt    byte_count )
177  {
178    FT_Error   error;
179    FT_Stream  stream = loader->stream;
180
181    /* for non-debug mode */
182    FT_UNUSED( glyph_index );
183
184
185    FT_TRACE5(( "Glyph %ld\n", glyph_index ));
186
187    /* the following line sets the `error' variable through macros! */
188    if ( FT_STREAM_SEEK( offset ) || FT_FRAME_ENTER( byte_count ) )
189      return error;
190
191    loader->cursor = stream->cursor;
192    loader->limit  = stream->limit;
193
194    return TT_Err_Ok;
195  }
196
197
198  FT_CALLBACK_DEF( void )
199  TT_Forget_Glyph_Frame( TT_Loader  loader )
200  {
201    FT_Stream  stream = loader->stream;
202
203
204    FT_FRAME_EXIT();
205  }
206
207
208  FT_CALLBACK_DEF( FT_Error )
209  TT_Load_Glyph_Header( TT_Loader  loader )
210  {
211    FT_Byte*  p     = loader->cursor;
212    FT_Byte*  limit = loader->limit;
213
214
215    if ( p + 10 > limit )
216      return TT_Err_Invalid_Outline;
217
218    loader->n_contours = FT_NEXT_SHORT( p );
219
220    loader->bbox.xMin = FT_NEXT_SHORT( p );
221    loader->bbox.yMin = FT_NEXT_SHORT( p );
222    loader->bbox.xMax = FT_NEXT_SHORT( p );
223    loader->bbox.yMax = FT_NEXT_SHORT( p );
224
225    FT_TRACE5(( "  # of contours: %d\n", loader->n_contours ));
226    FT_TRACE5(( "  xMin: %4d  xMax: %4d\n", loader->bbox.xMin,
227                                            loader->bbox.xMax ));
228    FT_TRACE5(( "  yMin: %4d  yMax: %4d\n", loader->bbox.yMin,
229                                            loader->bbox.yMax ));
230    loader->cursor = p;
231
232    return TT_Err_Ok;
233  }
234
235
236  FT_CALLBACK_DEF( FT_Error )
237  TT_Load_Simple_Glyph( TT_Loader  load )
238  {
239    FT_Error        error;
240    FT_Byte*        p          = load->cursor;
241    FT_Byte*        limit      = load->limit;
242    FT_GlyphLoader  gloader    = load->gloader;
243    FT_Int          n_contours = load->n_contours;
244    FT_Outline*     outline;
245    TT_Face         face       = (TT_Face)load->face;
246    FT_UShort       n_ins;
247    FT_Int          n, n_points;
248
249    FT_Byte         *flag, *flag_limit;
250    FT_Byte         c, count;
251    FT_Vector       *vec, *vec_limit;
252    FT_Pos          x;
253    FT_Short        *cont, *cont_limit;
254
255
256    /* check that we can add the contours to the glyph */
257    error = FT_GLYPHLOADER_CHECK_POINTS( gloader, 0, n_contours );
258    if ( error )
259      goto Fail;
260
261    /* reading the contours' endpoints & number of points */
262    cont       = gloader->current.outline.contours;
263    cont_limit = cont + n_contours;
264
265    /* check space for contours array + instructions count */
266    if ( n_contours >= 0xFFF || p + (n_contours + 1) * 2 > limit )
267      goto Invalid_Outline;
268
269    for ( ; cont < cont_limit; cont++ )
270      cont[0] = FT_NEXT_USHORT( p );
271
272    n_points = 0;
273    if ( n_contours > 0 )
274      n_points = cont[-1] + 1;
275
276    /* note that we will add four phantom points later */
277    error = FT_GLYPHLOADER_CHECK_POINTS( gloader, n_points + 4, 0 );
278    if ( error )
279      goto Fail;
280
281    /* we'd better check the contours table right now */
282    outline = &gloader->current.outline;
283
284    for ( cont = outline->contours + 1; cont < cont_limit; cont++ )
285      if ( cont[-1] >= cont[0] )
286        goto Invalid_Outline;
287
288    /* reading the bytecode instructions */
289    load->glyph->control_len  = 0;
290    load->glyph->control_data = 0;
291
292    if ( p + 2 > limit )
293      goto Invalid_Outline;
294
295    n_ins = FT_NEXT_USHORT( p );
296
297    FT_TRACE5(( "  Instructions size: %u\n", n_ins ));
298
299    if ( n_ins > face->max_profile.maxSizeOfInstructions )
300    {
301      FT_TRACE0(( "TT_Load_Simple_Glyph: Too many instructions!\n" ));
302      error = TT_Err_Too_Many_Hints;
303      goto Fail;
304    }
305
306    if ( ( limit - p ) < n_ins )
307    {
308      FT_TRACE0(( "TT_Load_Simple_Glyph: Instruction count mismatch!\n" ));
309      error = TT_Err_Too_Many_Hints;
310      goto Fail;
311    }
312
313#ifdef TT_USE_BYTECODE_INTERPRETER
314
315    if ( IS_HINTED( load->load_flags ) )
316    {
317      load->glyph->control_len  = n_ins;
318      load->glyph->control_data = load->exec->glyphIns;
319
320      FT_MEM_COPY( load->exec->glyphIns, p, (FT_Long)n_ins );
321    }
322
323#endif /* TT_USE_BYTECODE_INTERPRETER */
324
325    p += n_ins;
326
327    /* reading the point tags */
328    flag       = (FT_Byte*)outline->tags;
329    flag_limit = flag + n_points;
330
331    FT_ASSERT( flag != NULL );
332
333    while ( flag < flag_limit )
334    {
335      if ( p + 1 > limit )
336        goto Invalid_Outline;
337
338      *flag++ = c = FT_NEXT_BYTE( p );
339      if ( c & 8 )
340      {
341        if ( p + 1 > limit )
342          goto Invalid_Outline;
343
344        count = FT_NEXT_BYTE( p );
345        if ( flag + (FT_Int)count > flag_limit )
346          goto Invalid_Outline;
347
348        for ( ; count > 0; count-- )
349          *flag++ = c;
350      }
351    }
352
353    /* reading the X coordinates */
354
355    vec       = outline->points;
356    vec_limit = vec + n_points;
357    flag      = (FT_Byte*)outline->tags;
358    x         = 0;
359
360    for ( ; vec < vec_limit; vec++, flag++ )
361    {
362      FT_Pos  y = 0;
363
364
365      if ( *flag & 2 )
366      {
367        if ( p + 1 > limit )
368          goto Invalid_Outline;
369
370        y = (FT_Pos)FT_NEXT_BYTE( p );
371        if ( ( *flag & 16 ) == 0 )
372          y = -y;
373      }
374      else if ( ( *flag & 16 ) == 0 )
375      {
376        if ( p + 2 > limit )
377          goto Invalid_Outline;
378
379        y = (FT_Pos)FT_NEXT_SHORT( p );
380      }
381
382      x     += y;
383      vec->x = x;
384    }
385
386    /* reading the Y coordinates */
387
388    vec       = gloader->current.outline.points;
389    vec_limit = vec + n_points;
390    flag      = (FT_Byte*)outline->tags;
391    x         = 0;
392
393    for ( ; vec < vec_limit; vec++, flag++ )
394    {
395      FT_Pos  y = 0;
396
397
398      if ( *flag & 4 )
399      {
400        if ( p  +1 > limit )
401          goto Invalid_Outline;
402
403        y = (FT_Pos)FT_NEXT_BYTE( p );
404        if ( ( *flag & 32 ) == 0 )
405          y = -y;
406      }
407      else if ( ( *flag & 32 ) == 0 )
408      {
409        if ( p + 2 > limit )
410          goto Invalid_Outline;
411
412        y = (FT_Pos)FT_NEXT_SHORT( p );
413      }
414
415      x     += y;
416      vec->y = x;
417    }
418
419    /* clear the touch tags */
420    for ( n = 0; n < n_points; n++ )
421      outline->tags[n] &= FT_CURVE_TAG_ON;
422
423    outline->n_points   = (FT_UShort)n_points;
424    outline->n_contours = (FT_Short) n_contours;
425
426    load->cursor = p;
427
428  Fail:
429    return error;
430
431  Invalid_Outline:
432    error = TT_Err_Invalid_Outline;
433    goto Fail;
434  }
435
436
437  FT_CALLBACK_DEF( FT_Error )
438  TT_Load_Composite_Glyph( TT_Loader  loader )
439  {
440    FT_Error        error;
441    FT_Byte*        p       = loader->cursor;
442    FT_Byte*        limit   = loader->limit;
443    FT_GlyphLoader  gloader = loader->gloader;
444    FT_SubGlyph     subglyph;
445    FT_UInt         num_subglyphs;
446
447
448    num_subglyphs = 0;
449
450    do
451    {
452      FT_Fixed  xx, xy, yy, yx;
453      FT_UInt   count;
454
455
456      /* check that we can load a new subglyph */
457      error = FT_GlyphLoader_CheckSubGlyphs( gloader, num_subglyphs + 1 );
458      if ( error )
459        goto Fail;
460
461      /* check space */
462      if ( p + 4 > limit )
463        goto Invalid_Composite;
464
465      subglyph = gloader->current.subglyphs + num_subglyphs;
466
467      subglyph->arg1 = subglyph->arg2 = 0;
468
469      subglyph->flags = FT_NEXT_USHORT( p );
470      subglyph->index = FT_NEXT_USHORT( p );
471
472      /* check space */
473      count = 2;
474      if ( subglyph->flags & ARGS_ARE_WORDS )
475        count += 2;
476      if ( subglyph->flags & WE_HAVE_A_SCALE )
477        count += 2;
478      else if ( subglyph->flags & WE_HAVE_AN_XY_SCALE )
479        count += 4;
480      else if ( subglyph->flags & WE_HAVE_A_2X2 )
481        count += 8;
482
483      if ( p + count > limit )
484        goto Invalid_Composite;
485
486      /* read arguments */
487      if ( subglyph->flags & ARGS_ARE_WORDS )
488      {
489        subglyph->arg1 = FT_NEXT_SHORT( p );
490        subglyph->arg2 = FT_NEXT_SHORT( p );
491      }
492      else
493      {
494        subglyph->arg1 = FT_NEXT_CHAR( p );
495        subglyph->arg2 = FT_NEXT_CHAR( p );
496      }
497
498      /* read transform */
499      xx = yy = 0x10000L;
500      xy = yx = 0;
501
502      if ( subglyph->flags & WE_HAVE_A_SCALE )
503      {
504        xx = (FT_Fixed)FT_NEXT_SHORT( p ) << 2;
505        yy = xx;
506      }
507      else if ( subglyph->flags & WE_HAVE_AN_XY_SCALE )
508      {
509        xx = (FT_Fixed)FT_NEXT_SHORT( p ) << 2;
510        yy = (FT_Fixed)FT_NEXT_SHORT( p ) << 2;
511      }
512      else if ( subglyph->flags & WE_HAVE_A_2X2 )
513      {
514        xx = (FT_Fixed)FT_NEXT_SHORT( p ) << 2;
515        yx = (FT_Fixed)FT_NEXT_SHORT( p ) << 2;
516        xy = (FT_Fixed)FT_NEXT_SHORT( p ) << 2;
517        yy = (FT_Fixed)FT_NEXT_SHORT( p ) << 2;
518      }
519
520      subglyph->transform.xx = xx;
521      subglyph->transform.xy = xy;
522      subglyph->transform.yx = yx;
523      subglyph->transform.yy = yy;
524
525      num_subglyphs++;
526
527    } while ( subglyph->flags & MORE_COMPONENTS );
528
529    gloader->current.num_subglyphs = num_subglyphs;
530
531#ifdef TT_USE_BYTECODE_INTERPRETER
532
533    {
534      FT_Stream  stream = loader->stream;
535
536
537      /* we must undo the FT_FRAME_ENTER in order to point to the */
538      /* composite instructions, if we find some.               */
539      /* we will process them later...                          */
540      /*                                                        */
541      loader->ins_pos = (FT_ULong)( FT_STREAM_POS() +
542                                    p - limit );
543    }
544
545#endif
546
547    loader->cursor = p;
548
549  Fail:
550    return error;
551
552  Invalid_Composite:
553    error = TT_Err_Invalid_Composite;
554    goto Fail;
555  }
556
557
558  FT_LOCAL_DEF( void )
559  TT_Init_Glyph_Loading( TT_Face  face )
560  {
561    face->access_glyph_frame   = TT_Access_Glyph_Frame;
562    face->read_glyph_header    = TT_Load_Glyph_Header;
563    face->read_simple_glyph    = TT_Load_Simple_Glyph;
564    face->read_composite_glyph = TT_Load_Composite_Glyph;
565    face->forget_glyph_frame   = TT_Forget_Glyph_Frame;
566  }
567
568
569  static void
570  tt_prepare_zone( TT_GlyphZone  zone,
571                   FT_GlyphLoad  load,
572                   FT_UInt       start_point,
573                   FT_UInt       start_contour )
574  {
575    zone->n_points   = (FT_UShort)( load->outline.n_points - start_point );
576    zone->n_contours = (FT_Short) ( load->outline.n_contours - start_contour );
577    zone->org        = load->extra_points + start_point;
578    zone->cur        = load->outline.points + start_point;
579    zone->orus       = load->extra_points2 + start_point;
580    zone->tags       = (FT_Byte*)load->outline.tags + start_point;
581    zone->contours   = (FT_UShort*)load->outline.contours + start_contour;
582    zone->first_point = (FT_UShort)start_point;
583  }
584
585
586  /*************************************************************************/
587  /*                                                                       */
588  /* <Function>                                                            */
589  /*    TT_Hint_Glyph                                                      */
590  /*                                                                       */
591  /* <Description>                                                         */
592  /*    Hint the glyph using the zone prepared by the caller.  Note that   */
593  /*    the zone is supposed to include four phantom points.               */
594  /*                                                                       */
595  static FT_Error
596  TT_Hint_Glyph( TT_Loader  loader,
597                 FT_Bool    is_composite )
598  {
599    TT_GlyphZone  zone = &loader->zone;
600    FT_Pos        origin;
601
602#ifdef TT_USE_BYTECODE_INTERPRETER
603    FT_UInt       n_ins;
604#else
605    FT_UNUSED( is_composite );
606#endif
607
608
609#ifdef TT_USE_BYTECODE_INTERPRETER
610    n_ins = loader->glyph->control_len;
611#endif
612
613    origin = zone->cur[zone->n_points - 4].x;
614    origin = FT_PIX_ROUND( origin ) - origin;
615    if ( origin )
616      translate_array( zone->n_points, zone->cur, origin, 0 );
617
618#ifdef TT_USE_BYTECODE_INTERPRETER
619    /* save original point positioin in org */
620    if ( n_ins > 0 )
621      FT_ARRAY_COPY( zone->org, zone->cur, zone->n_points );
622#endif
623
624    /* round pp2 and pp4 */
625    zone->cur[zone->n_points - 3].x =
626      FT_PIX_ROUND( zone->cur[zone->n_points - 3].x );
627    zone->cur[zone->n_points - 1].y =
628      FT_PIX_ROUND( zone->cur[zone->n_points - 1].y );
629
630#ifdef TT_USE_BYTECODE_INTERPRETER
631
632    if ( n_ins > 0 )
633    {
634      FT_Bool   debug;
635      FT_Error  error;
636
637
638      error = TT_Set_CodeRange( loader->exec, tt_coderange_glyph,
639                                loader->exec->glyphIns, n_ins );
640      if ( error )
641        return error;
642
643      loader->exec->is_composite = is_composite;
644      loader->exec->pts          = *zone;
645
646      debug = FT_BOOL( !( loader->load_flags & FT_LOAD_NO_SCALE ) &&
647                       ((TT_Size)loader->size)->debug             );
648
649      error = TT_Run_Context( loader->exec, debug );
650      if ( error && loader->exec->pedantic_hinting )
651        return error;
652    }
653
654#endif
655
656    /* save glyph phantom points */
657    if ( !loader->preserve_pps )
658    {
659      loader->pp1 = zone->cur[zone->n_points - 4];
660      loader->pp2 = zone->cur[zone->n_points - 3];
661      loader->pp3 = zone->cur[zone->n_points - 2];
662      loader->pp4 = zone->cur[zone->n_points - 1];
663    }
664
665    return TT_Err_Ok;
666  }
667
668
669  /*************************************************************************/
670  /*                                                                       */
671  /* <Function>                                                            */
672  /*    TT_Process_Simple_Glyph                                            */
673  /*                                                                       */
674  /* <Description>                                                         */
675  /*    Once a simple glyph has been loaded, it needs to be processed.     */
676  /*    Usually, this means scaling and hinting through bytecode           */
677  /*    interpretation.                                                    */
678  /*                                                                       */
679  static FT_Error
680  TT_Process_Simple_Glyph( TT_Loader  loader )
681  {
682    FT_GlyphLoader  gloader = loader->gloader;
683    FT_Error        error   = TT_Err_Ok;
684    FT_Outline*     outline;
685    FT_UInt         n_points;
686
687
688    outline  = &gloader->current.outline;
689    n_points = outline->n_points;
690
691    /* set phantom points */
692
693    outline->points[n_points    ] = loader->pp1;
694    outline->points[n_points + 1] = loader->pp2;
695    outline->points[n_points + 2] = loader->pp3;
696    outline->points[n_points + 3] = loader->pp4;
697
698    outline->tags[n_points    ] = 0;
699    outline->tags[n_points + 1] = 0;
700    outline->tags[n_points + 2] = 0;
701    outline->tags[n_points + 3] = 0;
702
703    n_points += 4;
704
705#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
706
707    if ( ((TT_Face)loader->face)->doblend )
708    {
709      /* Deltas apply to the unscaled data. */
710      FT_Vector*  deltas;
711      FT_Memory   memory = loader->face->memory;
712      FT_UInt     i;
713
714
715      error = TT_Vary_Get_Glyph_Deltas( (TT_Face)(loader->face),
716                                        loader->glyph_index,
717                                        &deltas,
718                                        n_points );
719      if ( error )
720        return error;
721
722      for ( i = 0; i < n_points; ++i )
723      {
724        outline->points[i].x += deltas[i].x;
725        outline->points[i].y += deltas[i].y;
726      }
727
728      FT_FREE( deltas );
729    }
730
731#endif /* TT_CONFIG_OPTION_GX_VAR_SUPPORT */
732
733    if ( IS_HINTED( loader->load_flags ) )
734    {
735      tt_prepare_zone( &loader->zone, &gloader->current, 0, 0 );
736
737      FT_ARRAY_COPY( loader->zone.orus, loader->zone.cur,
738                     loader->zone.n_points + 4 );
739    }
740
741    /* scale the glyph */
742    if ( ( loader->load_flags & FT_LOAD_NO_SCALE ) == 0 )
743    {
744      FT_Vector*  vec     = outline->points;
745      FT_Vector*  limit   = outline->points + n_points;
746      FT_Fixed    x_scale = ((TT_Size)loader->size)->metrics.x_scale;
747      FT_Fixed    y_scale = ((TT_Size)loader->size)->metrics.y_scale;
748
749
750      for ( ; vec < limit; vec++ )
751      {
752        vec->x = FT_MulFix( vec->x, x_scale );
753        vec->y = FT_MulFix( vec->y, y_scale );
754      }
755
756      loader->pp1 = outline->points[n_points - 4];
757      loader->pp2 = outline->points[n_points - 3];
758      loader->pp3 = outline->points[n_points - 2];
759      loader->pp4 = outline->points[n_points - 1];
760    }
761
762    if ( IS_HINTED( loader->load_flags ) )
763    {
764      loader->zone.n_points += 4;
765
766      error = TT_Hint_Glyph( loader, 0 );
767    }
768
769    return error;
770  }
771
772
773  /*************************************************************************/
774  /*                                                                       */
775  /* <Function>                                                            */
776  /*    TT_Process_Composite_Component                                     */
777  /*                                                                       */
778  /* <Description>                                                         */
779  /*    Once a composite component has been loaded, it needs to be         */
780  /*    processed.  Usually, this means transforming and translating.      */
781  /*                                                                       */
782  static FT_Error
783  TT_Process_Composite_Component( TT_Loader    loader,
784                                  FT_SubGlyph  subglyph,
785                                  FT_UInt      start_point,
786                                  FT_UInt      num_base_points )
787  {
788    FT_GlyphLoader  gloader    = loader->gloader;
789    FT_Vector*      base_vec   = gloader->base.outline.points;
790    FT_UInt         num_points = gloader->base.outline.n_points;
791    FT_Bool         have_scale;
792    FT_Pos          x, y;
793
794
795    have_scale = FT_BOOL( subglyph->flags & ( WE_HAVE_A_SCALE     |
796                                              WE_HAVE_AN_XY_SCALE |
797                                              WE_HAVE_A_2X2       ) );
798
799    /* perform the transform required for this subglyph */
800    if ( have_scale )
801    {
802      FT_UInt  i;
803
804
805      for ( i = num_base_points; i < num_points; i++ )
806        FT_Vector_Transform( base_vec + i, &subglyph->transform );
807    }
808
809    /* get offset */
810    if ( !( subglyph->flags & ARGS_ARE_XY_VALUES ) )
811    {
812      FT_UInt     k = subglyph->arg1;
813      FT_UInt     l = subglyph->arg2;
814      FT_Vector*  p1;
815      FT_Vector*  p2;
816
817
818      /* match l-th point of the newly loaded component to the k-th point */
819      /* of the previously loaded components.                             */
820
821      /* change to the point numbers used by our outline */
822      k += start_point;
823      l += num_base_points;
824      if ( k >= num_base_points ||
825           l >= num_points      )
826        return TT_Err_Invalid_Composite;
827
828      p1 = gloader->base.outline.points + k;
829      p2 = gloader->base.outline.points + l;
830
831      x = p1->x - p2->x;
832      y = p1->y - p2->y;
833    }
834    else
835    {
836      x = subglyph->arg1;
837      y = subglyph->arg2;
838
839      if ( !x && !y )
840        return TT_Err_Ok;
841
842  /* Use a default value dependent on                                     */
843  /* TT_CONFIG_OPTION_COMPONENT_OFFSET_SCALED.  This is useful for old TT */
844  /* fonts which don't set the xxx_COMPONENT_OFFSET bit.                  */
845
846      if ( have_scale &&
847#ifdef TT_CONFIG_OPTION_COMPONENT_OFFSET_SCALED
848           !( subglyph->flags & UNSCALED_COMPONENT_OFFSET ) )
849#else
850            ( subglyph->flags & SCALED_COMPONENT_OFFSET ) )
851#endif
852      {
853
854#if 0
855
856  /*************************************************************************/
857  /*                                                                       */
858  /* This algorithm is what Apple documents.  But it doesn't work.         */
859  /*                                                                       */
860        int  a = subglyph->transform.xx > 0 ?  subglyph->transform.xx
861                                            : -subglyph->transform.xx;
862        int  b = subglyph->transform.yx > 0 ?  subglyph->transform.yx
863                                            : -subglyph->transform.yx;
864        int  c = subglyph->transform.xy > 0 ?  subglyph->transform.xy
865                                            : -subglyph->transform.xy;
866        int  d = subglyph->transform.yy > 0 ? subglyph->transform.yy
867                                            : -subglyph->transform.yy;
868        int  m = a > b ? a : b;
869        int  n = c > d ? c : d;
870
871
872        if ( a - b <= 33 && a - b >= -33 )
873          m *= 2;
874        if ( c - d <= 33 && c - d >= -33 )
875          n *= 2;
876        x = FT_MulFix( x, m );
877        y = FT_MulFix( y, n );
878
879#else /* 0 */
880
881  /*************************************************************************/
882  /*                                                                       */
883  /* This algorithm is a guess and works much better than the above.       */
884  /*                                                                       */
885        FT_Fixed  mac_xscale = FT_SqrtFixed(
886                                 FT_MulFix( subglyph->transform.xx,
887                                            subglyph->transform.xx ) +
888                                 FT_MulFix( subglyph->transform.xy,
889                                            subglyph->transform.xy ) );
890        FT_Fixed  mac_yscale = FT_SqrtFixed(
891                                 FT_MulFix( subglyph->transform.yy,
892                                            subglyph->transform.yy ) +
893                                 FT_MulFix( subglyph->transform.yx,
894                                            subglyph->transform.yx ) );
895
896
897        x = FT_MulFix( x, mac_xscale );
898        y = FT_MulFix( y, mac_yscale );
899
900#endif /* 0 */
901
902      }
903
904      if ( !( loader->load_flags & FT_LOAD_NO_SCALE ) )
905      {
906        FT_Fixed  x_scale = ((TT_Size)loader->size)->metrics.x_scale;
907        FT_Fixed  y_scale = ((TT_Size)loader->size)->metrics.y_scale;
908
909
910        x = FT_MulFix( x, x_scale );
911        y = FT_MulFix( y, y_scale );
912
913        if ( subglyph->flags & ROUND_XY_TO_GRID )
914        {
915          x = FT_PIX_ROUND( x );
916          y = FT_PIX_ROUND( y );
917        }
918      }
919    }
920
921    if ( x || y )
922      translate_array( num_points - num_base_points,
923                       base_vec + num_base_points,
924                       x, y );
925
926    return TT_Err_Ok;
927  }
928
929
930  /*************************************************************************/
931  /*                                                                       */
932  /* <Function>                                                            */
933  /*    TT_Process_Composite_Glyph                                         */
934  /*                                                                       */
935  /* <Description>                                                         */
936  /*    This is slightly different from TT_Process_Simple_Glyph, in that   */
937  /*    it's sole purpose is to hint the glyph.  Thus this function is     */
938  /*    only available when bytecode interpreter is enabled.               */
939  /*                                                                       */
940  static FT_Error
941  TT_Process_Composite_Glyph( TT_Loader  loader,
942                              FT_UInt    start_point,
943                              FT_UInt    start_contour )
944  {
945    FT_Error     error;
946    FT_Outline*  outline;
947    FT_UInt      i;
948
949
950    outline = &loader->gloader->base.outline;
951
952    /* make room for phantom points */
953    error = FT_GLYPHLOADER_CHECK_POINTS( loader->gloader,
954                                         outline->n_points + 4,
955                                         0 );
956    if ( error )
957      return error;
958
959    outline->points[outline->n_points    ] = loader->pp1;
960    outline->points[outline->n_points + 1] = loader->pp2;
961    outline->points[outline->n_points + 2] = loader->pp3;
962    outline->points[outline->n_points + 3] = loader->pp4;
963
964    outline->tags[outline->n_points    ] = 0;
965    outline->tags[outline->n_points + 1] = 0;
966    outline->tags[outline->n_points + 2] = 0;
967    outline->tags[outline->n_points + 3] = 0;
968
969#ifdef TT_USE_BYTECODE_INTERPRETER
970
971    {
972      FT_Stream  stream = loader->stream;
973      FT_UShort  n_ins;
974
975
976      /* TT_Load_Composite_Glyph only gives us the offset of instructions */
977      /* so we read them here                                             */
978      if ( FT_STREAM_SEEK( loader->ins_pos ) ||
979           FT_READ_USHORT( n_ins )           )
980        return error;
981
982      FT_TRACE5(( "  Instructions size = %d\n", n_ins ));
983
984      /* check it */
985      if ( n_ins > ((TT_Face)loader->face)->max_profile.maxSizeOfInstructions )
986      {
987        FT_TRACE0(( "Too many instructions (%d)\n", n_ins ));
988
989        return TT_Err_Too_Many_Hints;
990      }
991      else if ( n_ins == 0 )
992        return TT_Err_Ok;
993
994      if ( FT_STREAM_READ( loader->exec->glyphIns, n_ins ) )
995        return error;
996
997      loader->glyph->control_data = loader->exec->glyphIns;
998      loader->glyph->control_len  = n_ins;
999    }
1000
1001#endif
1002
1003    tt_prepare_zone( &loader->zone, &loader->gloader->base,
1004                     start_point, start_contour );
1005
1006    /* Some points are likely touched during execution of  */
1007    /* instructions on components.  So let's untouch them. */
1008    for ( i = start_point; i < loader->zone.n_points; i++ )
1009      loader->zone.tags[i] &= ~( FT_CURVE_TAG_TOUCH_X |
1010                                 FT_CURVE_TAG_TOUCH_Y );
1011
1012    loader->zone.n_points += 4;
1013
1014    return TT_Hint_Glyph( loader, 1 );
1015  }
1016
1017
1018  /* Calculate the four phantom points.                     */
1019  /* The first two stand for horizontal origin and advance. */
1020  /* The last two stand for vertical origin and advance.    */
1021#define TT_LOADER_SET_PP( loader )                                          \
1022          do {                                                              \
1023            (loader)->pp1.x = (loader)->bbox.xMin - (loader)->left_bearing; \
1024            (loader)->pp1.y = 0;                                            \
1025            (loader)->pp2.x = (loader)->pp1.x + (loader)->advance;          \
1026            (loader)->pp2.y = 0;                                            \
1027            (loader)->pp3.x = 0;                                            \
1028            (loader)->pp3.y = (loader)->top_bearing + (loader)->bbox.yMax;  \
1029            (loader)->pp4.x = 0;                                            \
1030            (loader)->pp4.y = (loader)->pp3.y - (loader)->vadvance;         \
1031          } while ( 0 )
1032
1033
1034  /*************************************************************************/
1035  /*                                                                       */
1036  /* <Function>                                                            */
1037  /*    load_truetype_glyph                                                */
1038  /*                                                                       */
1039  /* <Description>                                                         */
1040  /*    Loads a given truetype glyph.  Handles composites and uses a       */
1041  /*    TT_Loader object.                                                  */
1042  /*                                                                       */
1043  static FT_Error
1044  load_truetype_glyph( TT_Loader  loader,
1045                       FT_UInt    glyph_index,
1046                       FT_UInt    recurse_count )
1047  {
1048    FT_Error        error;
1049    FT_Fixed        x_scale, y_scale;
1050    FT_ULong        offset;
1051    TT_Face         face         = (TT_Face)loader->face;
1052    FT_GlyphLoader  gloader      = loader->gloader;
1053    FT_Bool         opened_frame = 0;
1054
1055#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
1056    FT_Vector*      deltas       = NULL;
1057#endif
1058
1059#ifdef FT_CONFIG_OPTION_INCREMENTAL
1060    FT_StreamRec    inc_stream;
1061    FT_Data         glyph_data;
1062    FT_Bool         glyph_data_loaded = 0;
1063#endif
1064
1065
1066    if ( recurse_count > face->max_profile.maxComponentDepth )
1067    {
1068      error = TT_Err_Invalid_Composite;
1069      goto Exit;
1070    }
1071
1072    /* check glyph index */
1073    if ( glyph_index >= (FT_UInt)face->root.num_glyphs )
1074    {
1075      error = TT_Err_Invalid_Glyph_Index;
1076      goto Exit;
1077    }
1078
1079    loader->glyph_index = glyph_index;
1080
1081    if ( ( loader->load_flags & FT_LOAD_NO_SCALE ) == 0 )
1082    {
1083      x_scale = ((TT_Size)loader->size)->metrics.x_scale;
1084      y_scale = ((TT_Size)loader->size)->metrics.y_scale;
1085    }
1086    else
1087    {
1088      x_scale = 0x10000L;
1089      y_scale = 0x10000L;
1090    }
1091
1092    /* get metrics, horizontal and vertical */
1093    {
1094      FT_Short   left_bearing = 0, top_bearing = 0;
1095      FT_UShort  advance_width = 0, advance_height = 0;
1096
1097
1098      Get_HMetrics( face, glyph_index,
1099                    (FT_Bool)!( loader->load_flags &
1100                                FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH ),
1101                    &left_bearing,
1102                    &advance_width );
1103      Get_VMetrics( face, glyph_index,
1104                    (FT_Bool)!( loader->load_flags &
1105                                FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH ),
1106                    &top_bearing,
1107                    &advance_height );
1108
1109#ifdef FT_CONFIG_OPTION_INCREMENTAL
1110
1111      /* If this is an incrementally loaded font see if there are */
1112      /* overriding metrics for this glyph.                       */
1113      if ( face->root.internal->incremental_interface &&
1114           face->root.internal->incremental_interface->funcs->get_glyph_metrics )
1115      {
1116        FT_Incremental_MetricsRec  metrics;
1117
1118
1119        metrics.bearing_x = left_bearing;
1120        metrics.bearing_y = 0;
1121        metrics.advance = advance_width;
1122        error = face->root.internal->incremental_interface->funcs->get_glyph_metrics(
1123                  face->root.internal->incremental_interface->object,
1124                  glyph_index, FALSE, &metrics );
1125        if ( error )
1126          goto Exit;
1127        left_bearing  = (FT_Short)metrics.bearing_x;
1128        advance_width = (FT_UShort)metrics.advance;
1129
1130#if 0
1131
1132        /* GWW: Do I do the same for vertical metrics? */
1133        metrics.bearing_x = 0;
1134        metrics.bearing_y = top_bearing;
1135        metrics.advance = advance_height;
1136        error = face->root.internal->incremental_interface->funcs->get_glyph_metrics(
1137                  face->root.internal->incremental_interface->object,
1138                  glyph_index, TRUE, &metrics );
1139        if ( error )
1140          goto Exit;
1141        top_bearing  = (FT_Short)metrics.bearing_y;
1142        advance_height = (FT_UShort)metrics.advance;
1143
1144#endif /* 0 */
1145
1146      }
1147
1148#endif /* FT_CONFIG_OPTION_INCREMENTAL */
1149
1150      loader->left_bearing = left_bearing;
1151      loader->advance      = advance_width;
1152      loader->top_bearing  = top_bearing;
1153      loader->vadvance     = advance_height;
1154
1155      if ( !loader->linear_def )
1156      {
1157        loader->linear_def = 1;
1158        loader->linear     = advance_width;
1159      }
1160    }
1161
1162    /* Set `offset' to the start of the glyph relative to the start of */
1163    /* the `glyf' table, and `byte_len' to the length of the glyph in  */
1164    /* bytes.                                                          */
1165
1166#ifdef FT_CONFIG_OPTION_INCREMENTAL
1167
1168    /* If we are loading glyph data via the incremental interface, set */
1169    /* the loader stream to a memory stream reading the data returned  */
1170    /* by the interface.                                               */
1171    if ( face->root.internal->incremental_interface )
1172    {
1173      error = face->root.internal->incremental_interface->funcs->get_glyph_data(
1174                face->root.internal->incremental_interface->object,
1175                glyph_index, &glyph_data );
1176      if ( error )
1177        goto Exit;
1178
1179      glyph_data_loaded = 1;
1180      offset            = 0;
1181      loader->byte_len  = glyph_data.length;
1182
1183      FT_MEM_ZERO( &inc_stream, sizeof ( inc_stream ) );
1184      FT_Stream_OpenMemory( &inc_stream,
1185                            glyph_data.pointer, glyph_data.length );
1186
1187      loader->stream = &inc_stream;
1188    }
1189    else
1190
1191#endif /* FT_CONFIG_OPTION_INCREMENTAL */
1192
1193      offset = tt_face_get_location( face, glyph_index,
1194                                     (FT_UInt*)&loader->byte_len );
1195
1196    if ( loader->byte_len == 0 )
1197    {
1198      /* as described by Frederic Loyer, these are spaces or */
1199      /* the unknown glyph.                                  */
1200      loader->bbox.xMin = 0;
1201      loader->bbox.xMax = 0;
1202      loader->bbox.yMin = 0;
1203      loader->bbox.yMax = 0;
1204
1205      TT_LOADER_SET_PP( loader );
1206
1207#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
1208
1209      if ( ((TT_Face)(loader->face))->doblend )
1210      {
1211        /* this must be done before scaling */
1212        FT_Memory  memory = loader->face->memory;
1213
1214
1215        error = TT_Vary_Get_Glyph_Deltas( (TT_Face)(loader->face),
1216                                          glyph_index, &deltas, 4 );
1217        if ( error )
1218          goto Exit;
1219
1220        loader->pp1.x += deltas[0].x; loader->pp1.y += deltas[0].y;
1221        loader->pp2.x += deltas[1].x; loader->pp2.y += deltas[1].y;
1222        loader->pp3.x += deltas[2].x; loader->pp3.y += deltas[2].y;
1223        loader->pp4.x += deltas[3].x; loader->pp4.y += deltas[3].y;
1224
1225        FT_FREE( deltas );
1226      }
1227
1228#endif
1229
1230      if ( ( loader->load_flags & FT_LOAD_NO_SCALE ) == 0 )
1231      {
1232        loader->pp1.x = FT_MulFix( loader->pp1.x, x_scale );
1233        loader->pp2.x = FT_MulFix( loader->pp2.x, x_scale );
1234        loader->pp3.y = FT_MulFix( loader->pp3.y, y_scale );
1235        loader->pp4.y = FT_MulFix( loader->pp4.y, y_scale );
1236      }
1237
1238      error = TT_Err_Ok;
1239      goto Exit;
1240    }
1241
1242    error = face->access_glyph_frame( loader, glyph_index,
1243                                      loader->glyf_offset + offset,
1244                                      loader->byte_len );
1245    if ( error )
1246      goto Exit;
1247
1248    opened_frame = 1;
1249
1250    /* read first glyph header */
1251    error = face->read_glyph_header( loader );
1252    if ( error )
1253      goto Exit;
1254
1255    TT_LOADER_SET_PP( loader );
1256
1257    /***********************************************************************/
1258    /***********************************************************************/
1259    /***********************************************************************/
1260
1261    /* if it is a simple glyph, load it */
1262
1263    if ( loader->n_contours >= 0 )
1264    {
1265      error = face->read_simple_glyph( loader );
1266      if ( error )
1267        goto Exit;
1268
1269      /* all data have been read */
1270      face->forget_glyph_frame( loader );
1271      opened_frame = 0;
1272
1273      error = TT_Process_Simple_Glyph( loader );
1274      if ( error )
1275        goto Exit;
1276
1277      FT_GlyphLoader_Add( gloader );
1278    }
1279
1280    /***********************************************************************/
1281    /***********************************************************************/
1282    /***********************************************************************/
1283
1284    /* otherwise, load a composite! */
1285    else if ( loader->n_contours == -1 )
1286    {
1287      FT_UInt       start_point;
1288      FT_UInt       start_contour;
1289      FT_ULong      ins_pos;  /* position of composite instructions, if any */
1290
1291
1292      start_point   = gloader->base.outline.n_points;
1293      start_contour = gloader->base.outline.n_contours;
1294
1295      /* for each subglyph, read composite header */
1296      error = face->read_composite_glyph( loader );
1297      if ( error )
1298        goto Exit;
1299
1300      /* store the offset of instructions */
1301      ins_pos = loader->ins_pos;
1302
1303      /* all data we need are read */
1304      face->forget_glyph_frame( loader );
1305      opened_frame = 0;
1306
1307#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
1308
1309      if ( face->doblend )
1310      {
1311        FT_Int       i, limit;
1312        FT_SubGlyph  subglyph;
1313        FT_Memory    memory = face->root.memory;
1314
1315
1316        /* this provides additional offsets */
1317        /* for each component's translation */
1318
1319        if ( (error = TT_Vary_Get_Glyph_Deltas(
1320                        face,
1321                        glyph_index,
1322                        &deltas,
1323                        gloader->current.num_subglyphs + 4 )) != 0 )
1324          goto Exit;
1325
1326        subglyph = gloader->current.subglyphs + gloader->base.num_subglyphs;
1327        limit    = gloader->current.num_subglyphs;
1328
1329        for ( i = 0; i < limit; ++i, ++subglyph )
1330        {
1331          if ( subglyph->flags & ARGS_ARE_XY_VALUES )
1332          {
1333            subglyph->arg1 += deltas[i].x;
1334            subglyph->arg2 += deltas[i].y;
1335          }
1336        }
1337
1338        loader->pp1.x += deltas[i + 0].x; loader->pp1.y += deltas[i + 0].y;
1339        loader->pp2.x += deltas[i + 1].x; loader->pp2.y += deltas[i + 1].y;
1340        loader->pp3.x += deltas[i + 2].x; loader->pp3.y += deltas[i + 2].y;
1341        loader->pp4.x += deltas[i + 3].x; loader->pp4.y += deltas[i + 3].y;
1342
1343        FT_FREE( deltas );
1344      }
1345
1346#endif /* TT_CONFIG_OPTION_GX_VAR_SUPPORT */
1347
1348      if ( ( loader->load_flags & FT_LOAD_NO_SCALE ) == 0 )
1349      {
1350        loader->pp1.x = FT_MulFix( loader->pp1.x, x_scale );
1351        loader->pp2.x = FT_MulFix( loader->pp2.x, x_scale );
1352        loader->pp3.y = FT_MulFix( loader->pp3.y, y_scale );
1353        loader->pp4.y = FT_MulFix( loader->pp4.y, y_scale );
1354      }
1355
1356      /* if the flag FT_LOAD_NO_RECURSE is set, we return the subglyph */
1357      /* `as is' in the glyph slot (the client application will be     */
1358      /* responsible for interpreting these data)...                   */
1359      /*                                                               */
1360      if ( loader->load_flags & FT_LOAD_NO_RECURSE )
1361      {
1362        FT_GlyphLoader_Add( gloader );
1363        loader->glyph->format = FT_GLYPH_FORMAT_COMPOSITE;
1364
1365        goto Exit;
1366      }
1367
1368      /*********************************************************************/
1369      /*********************************************************************/
1370      /*********************************************************************/
1371
1372      {
1373        FT_UInt      n, num_base_points;
1374        FT_SubGlyph  subglyph       = 0;
1375
1376        FT_UInt      num_points     = start_point;
1377        FT_UInt      num_subglyphs  = gloader->current.num_subglyphs;
1378        FT_UInt      num_base_subgs = gloader->base.num_subglyphs;
1379
1380
1381        FT_GlyphLoader_Add( gloader );
1382
1383        /* read each subglyph independently */
1384        for ( n = 0; n < num_subglyphs; n++ )
1385        {
1386          FT_Vector  pp[4];
1387
1388
1389          /* Each time we call load_truetype_glyph in this loop, the   */
1390          /* value of `gloader.base.subglyphs' can change due to table */
1391          /* reallocations.  We thus need to recompute the subglyph    */
1392          /* pointer on each iteration.                                */
1393          subglyph = gloader->base.subglyphs + num_base_subgs + n;
1394
1395          pp[0] = loader->pp1;
1396          pp[1] = loader->pp2;
1397          pp[2] = loader->pp3;
1398          pp[3] = loader->pp4;
1399
1400          num_base_points = gloader->base.outline.n_points;
1401
1402          error = load_truetype_glyph( loader, subglyph->index,
1403                                       recurse_count + 1 );
1404          if ( error )
1405            goto Exit;
1406
1407          /* restore subglyph pointer */
1408          subglyph = gloader->base.subglyphs + num_base_subgs + n;
1409
1410          if ( !( subglyph->flags & USE_MY_METRICS ) )
1411          {
1412            loader->pp1 = pp[0];
1413            loader->pp2 = pp[1];
1414            loader->pp3 = pp[2];
1415            loader->pp4 = pp[3];
1416          }
1417
1418          num_points = gloader->base.outline.n_points;
1419
1420          if ( num_points == num_base_points )
1421            continue;
1422
1423          /* gloader->base.outline consists of three part:                  */
1424          /* 0 -(1)-> start_point -(2)-> num_base_points -(3)-> n_points.   */
1425          /*                                                                */
1426          /* (1): exist from the beginning                                  */
1427          /* (2): components that have been loaded so far                   */
1428          /* (3): the newly loaded component                                */
1429          TT_Process_Composite_Component( loader, subglyph, start_point,
1430                                          num_base_points );
1431        }
1432
1433
1434        /* process the glyph */
1435        loader->ins_pos = ins_pos;
1436        if ( IS_HINTED( loader->load_flags ) &&
1437
1438#ifdef TT_USE_BYTECODE_INTERPRETER
1439
1440             subglyph->flags & WE_HAVE_INSTR &&
1441
1442#endif
1443
1444             num_points > start_point )
1445          TT_Process_Composite_Glyph( loader, start_point, start_contour );
1446
1447      }
1448    }
1449    else
1450    {
1451      /* invalid composite count ( negative but not -1 ) */
1452      error = TT_Err_Invalid_Outline;
1453      goto Exit;
1454    }
1455
1456    /***********************************************************************/
1457    /***********************************************************************/
1458    /***********************************************************************/
1459
1460  Exit:
1461
1462    if ( opened_frame )
1463      face->forget_glyph_frame( loader );
1464
1465#ifdef FT_CONFIG_OPTION_INCREMENTAL
1466
1467    if ( glyph_data_loaded )
1468      face->root.internal->incremental_interface->funcs->free_glyph_data(
1469        face->root.internal->incremental_interface->object,
1470        &glyph_data );
1471
1472#endif
1473
1474    return error;
1475  }
1476
1477
1478  static FT_Error
1479  compute_glyph_metrics( TT_Loader   loader,
1480                         FT_UInt     glyph_index )
1481  {
1482    FT_BBox       bbox;
1483    TT_Face       face = (TT_Face)loader->face;
1484    FT_Fixed      y_scale;
1485    TT_GlyphSlot  glyph = loader->glyph;
1486    TT_Size       size = (TT_Size)loader->size;
1487
1488
1489    y_scale = 0x10000L;
1490    if ( ( loader->load_flags & FT_LOAD_NO_SCALE ) == 0 )
1491      y_scale = size->root.metrics.y_scale;
1492
1493    if ( glyph->format != FT_GLYPH_FORMAT_COMPOSITE )
1494      FT_Outline_Get_CBox( &glyph->outline, &bbox );
1495    else
1496      bbox = loader->bbox;
1497
1498    /* get the device-independent horizontal advance.  It is scaled later */
1499    /* by the base layer.                                                 */
1500    {
1501      FT_Pos  advance = loader->linear;
1502
1503
1504      /* the flag FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH was introduced to */
1505      /* correctly support DynaLab fonts, which have an incorrect       */
1506      /* `advance_Width_Max' field!  It is used, to my knowledge,       */
1507      /* exclusively in the X-TrueType font server.                     */
1508      /*                                                                */
1509      if ( face->postscript.isFixedPitch                                     &&
1510           ( loader->load_flags & FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH ) == 0 )
1511        advance = face->horizontal.advance_Width_Max;
1512
1513      /* we need to return the advance in font units in linearHoriAdvance, */
1514      /* it will be scaled later by the base layer.                        */
1515      glyph->linearHoriAdvance = advance;
1516    }
1517
1518    glyph->metrics.horiBearingX = bbox.xMin;
1519    glyph->metrics.horiBearingY = bbox.yMax;
1520    glyph->metrics.horiAdvance  = loader->pp2.x - loader->pp1.x;
1521
1522    /* Now take care of vertical metrics.  In the case where there is    */
1523    /* no vertical information within the font (relatively common), make */
1524    /* up some metrics by `hand'...                                      */
1525
1526    {
1527      FT_Pos  top;      /* scaled vertical top side bearing  */
1528      FT_Pos  advance;  /* scaled vertical advance height    */
1529
1530
1531      /* Get the unscaled top bearing and advance height. */
1532      if ( face->vertical_info &&
1533           face->vertical.number_Of_VMetrics > 0 )
1534      {
1535        top = (FT_Short)FT_DivFix( loader->pp3.y - bbox.yMax,
1536                                   y_scale );
1537
1538        if ( loader->pp3.y <= loader->pp4.y )
1539          advance = 0;
1540        else
1541          advance = (FT_UShort)FT_DivFix( loader->pp3.y - loader->pp4.y,
1542                                          y_scale );
1543      }
1544      else
1545      {
1546        FT_Pos  height;
1547
1548
1549        /* XXX Compute top side bearing and advance height in  */
1550        /*     Get_VMetrics instead of here.                   */
1551
1552        /* NOTE: The OS/2 values are the only `portable' ones, */
1553        /*       which is why we use them, if there is an OS/2 */
1554        /*       table in the font.  Otherwise, we use the     */
1555        /*       values defined in the horizontal header.      */
1556
1557        height = (FT_Short)FT_DivFix( bbox.yMax - bbox.yMin,
1558                                      y_scale );
1559        if ( face->os2.version != 0xFFFFU )
1560          advance = (FT_Pos)( face->os2.sTypoAscender -
1561                              face->os2.sTypoDescender );
1562        else
1563          advance = (FT_Pos)( face->horizontal.Ascender -
1564                              face->horizontal.Descender );
1565
1566        top = ( advance - height ) / 2;
1567      }
1568
1569#ifdef FT_CONFIG_OPTION_INCREMENTAL
1570      {
1571        FT_Incremental_InterfaceRec*  incr;
1572        FT_Incremental_MetricsRec     metrics;
1573        FT_Error                      error;
1574
1575
1576        incr = face->root.internal->incremental_interface;
1577
1578        /* If this is an incrementally loaded font see if there are */
1579        /* overriding metrics for this glyph.                       */
1580        if ( incr && incr->funcs->get_glyph_metrics )
1581        {
1582          metrics.bearing_x = 0;
1583          metrics.bearing_y = top;
1584          metrics.advance   = advance;
1585
1586          error = incr->funcs->get_glyph_metrics( incr->object,
1587                                                  glyph_index,
1588                                                  TRUE,
1589                                                  &metrics );
1590          if ( error )
1591            return error;
1592
1593          top     = metrics.bearing_y;
1594          advance = metrics.advance;
1595        }
1596      }
1597
1598      /* GWW: Do vertical metrics get loaded incrementally too? */
1599
1600#endif /* FT_CONFIG_OPTION_INCREMENTAL */
1601
1602      glyph->linearVertAdvance = advance;
1603
1604      /* scale the metrics */
1605      if ( !( loader->load_flags & FT_LOAD_NO_SCALE ) )
1606      {
1607        top     = FT_MulFix( top, y_scale );
1608        advance = FT_MulFix( advance, y_scale );
1609      }
1610
1611      /* XXX: for now, we have no better algorithm for the lsb, but it */
1612      /*      should work fine.                                        */
1613      /*                                                               */
1614      glyph->metrics.vertBearingX = ( bbox.xMin - bbox.xMax ) / 2;
1615      glyph->metrics.vertBearingY = top;
1616      glyph->metrics.vertAdvance  = advance;
1617    }
1618
1619    /* adjust advance width to the value contained in the hdmx table */
1620    if ( !face->postscript.isFixedPitch &&
1621         IS_HINTED( loader->load_flags )        )
1622    {
1623      FT_Byte*  widthp;
1624
1625
1626      widthp = tt_face_get_device_metrics( face,
1627                                           size->root.metrics.x_ppem,
1628                                           glyph_index );
1629
1630      if ( widthp )
1631        glyph->metrics.horiAdvance = *widthp << 6;
1632    }
1633
1634    /* set glyph dimensions */
1635    glyph->metrics.width  = bbox.xMax - bbox.xMin;
1636    glyph->metrics.height = bbox.yMax - bbox.yMin;
1637
1638    return 0;
1639  }
1640
1641
1642#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
1643
1644  static FT_Error
1645  load_sbit_image( TT_Size       size,
1646                   TT_GlyphSlot  glyph,
1647                   FT_UInt       glyph_index,
1648                   FT_Int32      load_flags )
1649  {
1650    TT_Face             face;
1651    SFNT_Service        sfnt;
1652    FT_Stream           stream;
1653    FT_Error            error;
1654    TT_SBit_MetricsRec  metrics;
1655
1656
1657    face   = (TT_Face)glyph->face;
1658    sfnt   = (SFNT_Service)face->sfnt;
1659    stream = face->root.stream;
1660
1661    error = sfnt->load_sbit_image( face,
1662                                   size->strike_index,
1663                                   glyph_index,
1664                                   (FT_Int)load_flags,
1665                                   stream,
1666                                   &glyph->bitmap,
1667                                   &metrics );
1668    if ( !error )
1669    {
1670      glyph->outline.n_points   = 0;
1671      glyph->outline.n_contours = 0;
1672
1673      glyph->metrics.width  = (FT_Pos)metrics.width  << 6;
1674      glyph->metrics.height = (FT_Pos)metrics.height << 6;
1675
1676      glyph->metrics.horiBearingX = (FT_Pos)metrics.horiBearingX << 6;
1677      glyph->metrics.horiBearingY = (FT_Pos)metrics.horiBearingY << 6;
1678      glyph->metrics.horiAdvance  = (FT_Pos)metrics.horiAdvance  << 6;
1679
1680      glyph->metrics.vertBearingX = (FT_Pos)metrics.vertBearingX << 6;
1681      glyph->metrics.vertBearingY = (FT_Pos)metrics.vertBearingY << 6;
1682      glyph->metrics.vertAdvance  = (FT_Pos)metrics.vertAdvance  << 6;
1683
1684      glyph->format = FT_GLYPH_FORMAT_BITMAP;
1685      if ( load_flags & FT_LOAD_VERTICAL_LAYOUT )
1686      {
1687        glyph->bitmap_left = metrics.vertBearingX;
1688        glyph->bitmap_top  = metrics.vertBearingY;
1689      }
1690      else
1691      {
1692        glyph->bitmap_left = metrics.horiBearingX;
1693        glyph->bitmap_top  = metrics.horiBearingY;
1694      }
1695    }
1696
1697    return error;
1698  }
1699
1700#endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
1701
1702
1703  static FT_Error
1704  tt_loader_init( TT_Loader     loader,
1705                  TT_Size       size,
1706                  TT_GlyphSlot  glyph,
1707                  FT_Int32      load_flags )
1708  {
1709    TT_Face    face;
1710    FT_Stream  stream;
1711
1712
1713    face   = (TT_Face)glyph->face;
1714    stream = face->root.stream;
1715
1716    FT_MEM_ZERO( loader, sizeof ( TT_LoaderRec ) );
1717
1718#ifdef TT_USE_BYTECODE_INTERPRETER
1719
1720    /* load execution context */
1721    if ( IS_HINTED( load_flags ) )
1722    {
1723      TT_ExecContext  exec;
1724      FT_Bool         grayscale;
1725
1726
1727      if ( !size->cvt_ready )
1728      {
1729        FT_Error  error = tt_size_ready_bytecode( size );
1730        if ( error )
1731          return error;
1732      }
1733
1734      /* query new execution context */
1735      exec = size->debug ? size->context
1736                         : ( (TT_Driver)FT_FACE_DRIVER( face ) )->context;
1737      if ( !exec )
1738        return TT_Err_Could_Not_Find_Context;
1739
1740      grayscale =
1741        FT_BOOL( FT_LOAD_TARGET_MODE( load_flags ) != FT_RENDER_MODE_MONO );
1742
1743      TT_Load_Context( exec, face, size );
1744
1745      /* a change from mono to grayscale rendering (and vice versa) */
1746      /* requires a re-execution of the CVT program                 */
1747      if ( grayscale != exec->grayscale )
1748      {
1749        FT_UInt  i;
1750
1751
1752        exec->grayscale = grayscale;
1753
1754        for ( i = 0; i < size->cvt_size; i++ )
1755          size->cvt[i] = FT_MulFix( face->cvt[i], size->ttmetrics.scale );
1756        tt_size_run_prep( size );
1757      }
1758
1759      /* see if the cvt program has disabled hinting */
1760      if ( exec->GS.instruct_control & 1 )
1761        load_flags |= FT_LOAD_NO_HINTING;
1762
1763      /* load default graphics state - if needed */
1764      if ( exec->GS.instruct_control & 2 )
1765        exec->GS = tt_default_graphics_state;
1766
1767      exec->pedantic_hinting = FT_BOOL( load_flags & FT_LOAD_PEDANTIC );
1768      loader->exec = exec;
1769      loader->instructions = exec->glyphIns;
1770    }
1771
1772#endif /* TT_USE_BYTECODE_INTERPRETER */
1773
1774    /* seek to the beginning of the glyph table.  For Type 42 fonts      */
1775    /* the table might be accessed from a Postscript stream or something */
1776    /* else...                                                           */
1777
1778#ifdef FT_CONFIG_OPTION_INCREMENTAL
1779
1780    if ( face->root.internal->incremental_interface )
1781      loader->glyf_offset = 0;
1782    else
1783
1784#endif
1785
1786    {
1787      FT_Error  error = face->goto_table( face, TTAG_glyf, stream, 0 );
1788
1789
1790      if ( error )
1791      {
1792        FT_ERROR(( "TT_Load_Glyph: could not access glyph table\n" ));
1793        return error;
1794      }
1795      loader->glyf_offset = FT_STREAM_POS();
1796    }
1797
1798    /* get face's glyph loader */
1799    {
1800      FT_GlyphLoader  gloader = glyph->internal->loader;
1801
1802
1803      FT_GlyphLoader_Rewind( gloader );
1804      loader->gloader = gloader;
1805    }
1806
1807    loader->load_flags    = load_flags;
1808
1809    loader->face   = (FT_Face)face;
1810    loader->size   = (FT_Size)size;
1811    loader->glyph  = (FT_GlyphSlot)glyph;
1812    loader->stream = stream;
1813
1814    return TT_Err_Ok;
1815  }
1816
1817
1818  /*************************************************************************/
1819  /*                                                                       */
1820  /* <Function>                                                            */
1821  /*    TT_Load_Glyph                                                      */
1822  /*                                                                       */
1823  /* <Description>                                                         */
1824  /*    A function used to load a single glyph within a given glyph slot,  */
1825  /*    for a given size.                                                  */
1826  /*                                                                       */
1827  /* <Input>                                                               */
1828  /*    glyph       :: A handle to a target slot object where the glyph    */
1829  /*                   will be loaded.                                     */
1830  /*                                                                       */
1831  /*    size        :: A handle to the source face size at which the glyph */
1832  /*                   must be scaled/loaded.                              */
1833  /*                                                                       */
1834  /*    glyph_index :: The index of the glyph in the font file.            */
1835  /*                                                                       */
1836  /*    load_flags  :: A flag indicating what to load for this glyph.  The */
1837  /*                   FT_LOAD_XXX constants can be used to control the    */
1838  /*                   glyph loading process (e.g., whether the outline    */
1839  /*                   should be scaled, whether to load bitmaps or not,   */
1840  /*                   whether to hint the outline, etc).                  */
1841  /*                                                                       */
1842  /* <Return>                                                              */
1843  /*    FreeType error code.  0 means success.                             */
1844  /*                                                                       */
1845  FT_LOCAL_DEF( FT_Error )
1846  TT_Load_Glyph( TT_Size       size,
1847                 TT_GlyphSlot  glyph,
1848                 FT_UInt       glyph_index,
1849                 FT_Int32      load_flags )
1850  {
1851    TT_Face       face;
1852    FT_Stream     stream;
1853    FT_Error      error;
1854    TT_LoaderRec  loader;
1855
1856
1857    face   = (TT_Face)glyph->face;
1858    stream = face->root.stream;
1859    error  = TT_Err_Ok;
1860
1861#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
1862
1863    /* try to load embedded bitmap if any              */
1864    /*                                                 */
1865    /* XXX: The convention should be emphasized in     */
1866    /*      the documents because it can be confusing. */
1867    if ( size->strike_index != 0xFFFFFFFFUL      &&
1868         ( load_flags & FT_LOAD_NO_BITMAP ) == 0 )
1869    {
1870      error = load_sbit_image( size, glyph, glyph_index, load_flags );
1871      if ( !error )
1872        return TT_Err_Ok;
1873    }
1874
1875#endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
1876
1877    /* if FT_LOAD_NO_SCALE is not set, `ttmetrics' must be valid */
1878    if ( !( load_flags & FT_LOAD_NO_SCALE ) && !size->ttmetrics.valid )
1879      return TT_Err_Invalid_Size_Handle;
1880
1881    if ( load_flags & FT_LOAD_SBITS_ONLY )
1882      return TT_Err_Invalid_Argument;
1883
1884    error = tt_loader_init( &loader, size, glyph, load_flags );
1885    if ( error )
1886      return error;
1887
1888    glyph->format        = FT_GLYPH_FORMAT_OUTLINE;
1889    glyph->num_subglyphs = 0;
1890    glyph->outline.flags = 0;
1891
1892    /* Main loading loop */
1893    error = load_truetype_glyph( &loader, glyph_index, 0 );
1894    if ( !error )
1895    {
1896      if ( glyph->format == FT_GLYPH_FORMAT_COMPOSITE )
1897      {
1898        glyph->num_subglyphs = loader.gloader->base.num_subglyphs;
1899        glyph->subglyphs     = loader.gloader->base.subglyphs;
1900      }
1901      else
1902      {
1903        glyph->outline        = loader.gloader->base.outline;
1904        glyph->outline.flags &= ~FT_OUTLINE_SINGLE_PASS;
1905
1906        /* In case bit 1 of the `flags' field in the `head' table isn't */
1907        /* set, translate array so that (0,0) is the glyph's origin.    */
1908        if ( ( face->header.Flags & 2 ) == 0 && loader.pp1.x )
1909          FT_Outline_Translate( &glyph->outline, -loader.pp1.x, 0 );
1910      }
1911
1912      compute_glyph_metrics( &loader, glyph_index );
1913    }
1914
1915    /* Set the `high precision' bit flag.                           */
1916    /* This is _critical_ to get correct output for monochrome      */
1917    /* TrueType glyphs at all sizes using the bytecode interpreter. */
1918    /*                                                              */
1919    if ( !( load_flags & FT_LOAD_NO_SCALE ) &&
1920         size->root.metrics.y_ppem < 24     )
1921      glyph->outline.flags |= FT_OUTLINE_HIGH_PRECISION;
1922
1923    return error;
1924  }
1925
1926
1927/* END */
Note: See TracBrowser for help on using the repository browser.