source: trunk/poppler/freetype-2.1.10/src/pfr/pfrobjs.c @ 2

Last change on this file since 2 was 2, checked in by Eugene Romanenko, 16 years ago

First import

File size: 17.2 KB
Line 
1/***************************************************************************/
2/*                                                                         */
3/*  pfrobjs.c                                                              */
4/*                                                                         */
5/*    FreeType PFR object methods (body).                                  */
6/*                                                                         */
7/*  Copyright 2002, 2003, 2004, 2005 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 "pfrobjs.h"
20#include "pfrload.h"
21#include "pfrgload.h"
22#include "pfrcmap.h"
23#include "pfrsbit.h"
24#include FT_OUTLINE_H
25#include FT_INTERNAL_DEBUG_H
26
27#include "pfrerror.h"
28
29#undef  FT_COMPONENT
30#define FT_COMPONENT  trace_pfr
31
32
33  /*************************************************************************/
34  /*************************************************************************/
35  /*****                                                               *****/
36  /*****                     FACE OBJECT METHODS                       *****/
37  /*****                                                               *****/
38  /*************************************************************************/
39  /*************************************************************************/
40
41  FT_LOCAL_DEF( void )
42  pfr_face_done( FT_Face  pfrface )     /* PFR_Face */
43  {
44    PFR_Face   face   = (PFR_Face)pfrface;
45    FT_Memory  memory = pfrface->driver->root.memory;
46
47
48    /* we don't want dangling pointers */
49    pfrface->family_name = NULL;
50    pfrface->style_name  = NULL;
51
52    /* finalize the physical font record */
53    pfr_phy_font_done( &face->phy_font, FT_FACE_MEMORY( face ) );
54
55    /* no need to finalize the logical font or the header */
56    FT_FREE( pfrface->available_sizes );
57  }
58
59
60  FT_LOCAL_DEF( FT_Error )
61  pfr_face_init( FT_Stream      stream,
62                 FT_Face        pfrface,
63                 FT_Int         face_index,
64                 FT_Int         num_params,
65                 FT_Parameter*  params )
66  {
67    PFR_Face  face = (PFR_Face)pfrface;
68    FT_Error  error;
69
70    FT_UNUSED( num_params );
71    FT_UNUSED( params );
72
73
74    /* load the header and check it */
75    error = pfr_header_load( &face->header, stream );
76    if ( error )
77      goto Exit;
78
79    if ( !pfr_header_check( &face->header ) )
80    {
81      FT_TRACE4(( "pfr_face_init: not a valid PFR font\n" ));
82      error = PFR_Err_Unknown_File_Format;
83      goto Exit;
84    }
85
86    /* check face index */
87    {
88      FT_UInt  num_faces;
89
90
91      error = pfr_log_font_count( stream,
92                                  face->header.log_dir_offset,
93                                  &num_faces );
94      if ( error )
95        goto Exit;
96
97      pfrface->num_faces = num_faces;
98    }
99
100    if ( face_index < 0 )
101      goto Exit;
102
103    if ( face_index >= pfrface->num_faces )
104    {
105      FT_ERROR(( "pfr_face_init: invalid face index\n" ));
106      error = PFR_Err_Invalid_Argument;
107      goto Exit;
108    }
109
110    /* load the face */
111    error = pfr_log_font_load(
112               &face->log_font, stream, face_index,
113               face->header.log_dir_offset,
114               FT_BOOL( face->header.phy_font_max_size_high != 0 ) );
115    if ( error )
116      goto Exit;
117
118    /* now load the physical font descriptor */
119    error = pfr_phy_font_load( &face->phy_font, stream,
120                               face->log_font.phys_offset,
121                               face->log_font.phys_size );
122    if ( error )
123      goto Exit;
124
125    /* now, set-up all root face fields */
126    {
127      PFR_PhyFont  phy_font = &face->phy_font;
128
129
130      pfrface->face_index = face_index;
131      pfrface->num_glyphs = phy_font->num_chars;
132      pfrface->face_flags = FT_FACE_FLAG_SCALABLE;
133
134      if ( (phy_font->flags & PFR_PHY_PROPORTIONAL) == 0 )
135        pfrface->face_flags |= FT_FACE_FLAG_FIXED_WIDTH;
136
137      if ( phy_font->flags & PFR_PHY_VERTICAL )
138        pfrface->face_flags |= FT_FACE_FLAG_VERTICAL;
139      else
140        pfrface->face_flags |= FT_FACE_FLAG_HORIZONTAL;
141
142      if ( phy_font->num_strikes > 0 )
143        pfrface->face_flags |= FT_FACE_FLAG_FIXED_SIZES;
144
145      if ( phy_font->num_kern_pairs > 0 )
146        pfrface->face_flags |= FT_FACE_FLAG_KERNING;
147
148      /* If no family name was found in the "undocumented" auxiliary
149       * data, use the font ID instead.  This sucks but is better than
150       * nothing.
151       */
152      pfrface->family_name = phy_font->family_name;
153      if ( pfrface->family_name == NULL )
154        pfrface->family_name = phy_font->font_id;
155
156      /* note that the style name can be NULL in certain PFR fonts,
157       * probably meaning "Regular"
158       */
159      pfrface->style_name = phy_font->style_name;
160
161      pfrface->num_fixed_sizes = 0;
162      pfrface->available_sizes = 0;
163
164      pfrface->bbox         = phy_font->bbox;
165      pfrface->units_per_EM = (FT_UShort)phy_font->outline_resolution;
166      pfrface->ascender     = (FT_Short) phy_font->bbox.yMax;
167      pfrface->descender    = (FT_Short) phy_font->bbox.yMin;
168      pfrface->height       = (FT_Short)(
169        ( ( pfrface->ascender - pfrface->descender ) * 12 ) / 10 );
170
171      if ( phy_font->num_strikes > 0 )
172      {
173        FT_UInt          n, count = phy_font->num_strikes;
174        FT_Bitmap_Size*  size;
175        PFR_Strike       strike;
176        FT_Memory        memory = pfrface->stream->memory;
177
178
179        if ( FT_NEW_ARRAY( pfrface->available_sizes, count ) )
180          goto Exit;
181
182        size   = pfrface->available_sizes;
183        strike = phy_font->strikes;
184        for ( n = 0; n < count; n++, size++, strike++ )
185        {
186          size->height = (FT_UShort)strike->y_ppm;
187          size->width  = (FT_UShort)strike->x_ppm;
188        }
189        pfrface->num_fixed_sizes = count;
190      }
191
192      /* now compute maximum advance width */
193      if ( ( phy_font->flags & PFR_PHY_PROPORTIONAL ) == 0 )
194        pfrface->max_advance_width = (FT_Short)phy_font->standard_advance;
195      else
196      {
197        FT_Int    max = 0;
198        FT_UInt   count = phy_font->num_chars;
199        PFR_Char  gchar = phy_font->chars;
200
201
202        for ( ; count > 0; count--, gchar++ )
203        {
204          if ( max < gchar->advance )
205            max = gchar->advance;
206        }
207
208        pfrface->max_advance_width = (FT_Short)max;
209      }
210
211      pfrface->max_advance_height = pfrface->height;
212
213      pfrface->underline_position  = (FT_Short)( -pfrface->units_per_EM / 10 );
214      pfrface->underline_thickness = (FT_Short)(  pfrface->units_per_EM / 30 );
215
216      /* create charmap */
217      {
218        FT_CharMapRec  charmap;
219
220
221        charmap.face        = pfrface;
222        charmap.platform_id = 3;
223        charmap.encoding_id = 1;
224        charmap.encoding    = FT_ENCODING_UNICODE;
225
226        FT_CMap_New( &pfr_cmap_class_rec, NULL, &charmap, NULL );
227
228#if 0
229        /* Select default charmap */
230        if ( pfrface->num_charmaps )
231          pfrface->charmap = pfrface->charmaps[0];
232#endif
233      }
234
235      /* check whether we've loaded any kerning pairs */
236      if ( phy_font->num_kern_pairs )
237        pfrface->face_flags |= FT_FACE_FLAG_KERNING;
238    }
239
240  Exit:
241    return error;
242  }
243
244
245  /*************************************************************************/
246  /*************************************************************************/
247  /*****                                                               *****/
248  /*****                    SLOT OBJECT METHOD                         *****/
249  /*****                                                               *****/
250  /*************************************************************************/
251  /*************************************************************************/
252
253  FT_LOCAL_DEF( FT_Error )
254  pfr_slot_init( FT_GlyphSlot  pfrslot )        /* PFR_Slot */
255  {
256    PFR_Slot        slot   = (PFR_Slot)pfrslot;
257    FT_GlyphLoader  loader = pfrslot->internal->loader;
258
259
260    pfr_glyph_init( &slot->glyph, loader );
261
262    return 0;
263  }
264
265
266  FT_LOCAL_DEF( void )
267  pfr_slot_done( FT_GlyphSlot  pfrslot )        /* PFR_Slot */
268  {
269    PFR_Slot  slot = (PFR_Slot)pfrslot;
270
271
272    pfr_glyph_done( &slot->glyph );
273  }
274
275
276  FT_LOCAL_DEF( FT_Error )
277  pfr_slot_load( FT_GlyphSlot  pfrslot,         /* PFR_Slot */
278                 FT_Size       pfrsize,         /* PFR_Size */
279                 FT_UInt       gindex,
280                 FT_Int32      load_flags )
281  {
282    PFR_Slot     slot    = (PFR_Slot)pfrslot;
283    PFR_Size     size    = (PFR_Size)pfrsize;
284    FT_Error     error;
285    PFR_Face     face    = (PFR_Face)pfrslot->face;
286    PFR_Char     gchar;
287    FT_Outline*  outline = &pfrslot->outline;
288    FT_ULong     gps_offset;
289
290
291    if ( gindex > 0 )
292      gindex--;
293
294    /* check that the glyph index is correct */
295    FT_ASSERT( gindex < face->phy_font.num_chars );
296
297    /* try to load an embedded bitmap */
298    if ( ( load_flags & ( FT_LOAD_NO_SCALE | FT_LOAD_NO_BITMAP ) ) == 0 )
299    {
300      error = pfr_slot_load_bitmap( slot, size, gindex );
301      if ( error == 0 )
302        goto Exit;
303    }
304
305    if ( load_flags & FT_LOAD_SBITS_ONLY )
306    {
307      error = PFR_Err_Invalid_Argument;
308      goto Exit;
309    }
310
311    gchar               = face->phy_font.chars + gindex;
312    pfrslot->format     = FT_GLYPH_FORMAT_OUTLINE;
313    outline->n_points   = 0;
314    outline->n_contours = 0;
315    gps_offset          = face->header.gps_section_offset;
316
317    /* load the glyph outline (FT_LOAD_NO_RECURSE isn't supported) */
318    error = pfr_glyph_load( &slot->glyph, face->root.stream,
319                            gps_offset, gchar->gps_offset, gchar->gps_size );
320
321    if ( !error )
322    {
323      FT_BBox            cbox;
324      FT_Glyph_Metrics*  metrics = &pfrslot->metrics;
325      FT_Pos             advance;
326      FT_Int             em_metrics, em_outline;
327      FT_Bool            scaling;
328
329
330      scaling = FT_BOOL( ( load_flags & FT_LOAD_NO_SCALE ) == 0 );
331
332      /* copy outline data */
333      *outline = slot->glyph.loader->base.outline;
334
335      outline->flags &= ~FT_OUTLINE_OWNER;
336      outline->flags |= FT_OUTLINE_REVERSE_FILL;
337
338      if ( size && pfrsize->metrics.y_ppem < 24 )
339        outline->flags |= FT_OUTLINE_HIGH_PRECISION;
340
341      /* compute the advance vector */
342      metrics->horiAdvance = 0;
343      metrics->vertAdvance = 0;
344
345      advance    = gchar->advance;
346      em_metrics = face->phy_font.metrics_resolution;
347      em_outline = face->phy_font.outline_resolution;
348
349      if ( em_metrics != em_outline )
350        advance = FT_MulDiv( advance, em_outline, em_metrics );
351
352      if ( face->phy_font.flags & PFR_PHY_VERTICAL )
353        metrics->vertAdvance = advance;
354      else
355        metrics->horiAdvance = advance;
356
357      pfrslot->linearHoriAdvance = metrics->horiAdvance;
358      pfrslot->linearVertAdvance = metrics->vertAdvance;
359
360      /* make-up vertical metrics(?) */
361      metrics->vertBearingX = 0;
362      metrics->vertBearingY = 0;
363
364#if 0 /* some fonts seem to be broken here! */
365
366      /* Apply the font matrix, if any.                 */
367      /* TODO: Test existing fonts with unusual matrix  */
368      /* whether we have to adjust Units per EM.        */
369      {
370        FT_Matrix font_matrix;
371
372
373        font_matrix.xx = face->log_font.matrix[0] << 8;
374        font_matrix.yx = face->log_font.matrix[1] << 8;
375        font_matrix.xy = face->log_font.matrix[2] << 8;
376        font_matrix.yy = face->log_font.matrix[3] << 8;
377
378        FT_Outline_Transform( outline, &font_matrix );
379      }
380#endif
381
382      /* scale when needed */
383      if ( scaling )
384      {
385        FT_Int      n;
386        FT_Fixed    x_scale = pfrsize->metrics.x_scale;
387        FT_Fixed    y_scale = pfrsize->metrics.y_scale;
388        FT_Vector*  vec     = outline->points;
389
390
391        /* scale outline points */
392        for ( n = 0; n < outline->n_points; n++, vec++ )
393        {
394          vec->x = FT_MulFix( vec->x, x_scale );
395          vec->y = FT_MulFix( vec->y, y_scale );
396        }
397
398        /* scale the advance */
399        metrics->horiAdvance = FT_MulFix( metrics->horiAdvance, x_scale );
400        metrics->vertAdvance = FT_MulFix( metrics->vertAdvance, y_scale );
401      }
402
403      /* compute the rest of the metrics */
404      FT_Outline_Get_CBox( outline, &cbox );
405
406      metrics->width        = cbox.xMax - cbox.xMin;
407      metrics->height       = cbox.yMax - cbox.yMin;
408      metrics->horiBearingX = cbox.xMin;
409      metrics->horiBearingY = cbox.yMax - metrics->height;
410    }
411
412  Exit:
413    return error;
414  }
415
416
417  /*************************************************************************/
418  /*************************************************************************/
419  /*****                                                               *****/
420  /*****                      KERNING METHOD                           *****/
421  /*****                                                               *****/
422  /*************************************************************************/
423  /*************************************************************************/
424
425#ifdef FT_OPTIMIZE_MEMORY
426
427  FT_LOCAL_DEF( FT_Error )
428  pfr_face_get_kerning( FT_Face     pfrface,        /* PFR_Face */
429                        FT_UInt     glyph1,
430                        FT_UInt     glyph2,
431                        FT_Vector*  kerning )
432  {
433    PFR_Face     face     = (PFR_Face)pfrface;
434    FT_Error     error    = PFR_Err_Ok;
435    PFR_PhyFont  phy_font = &face->phy_font;
436    FT_UInt32    code1, code2, pair;
437
438
439    kerning->x = 0;
440    kerning->y = 0;
441
442    if ( glyph1 > 0 )
443      glyph1--;
444
445    if ( glyph2 > 0 )
446      glyph2--;
447
448    /* convert glyph indices to character codes */
449    if ( glyph1 > phy_font->num_chars ||
450         glyph2 > phy_font->num_chars )
451      goto Exit;
452
453    code1 = phy_font->chars[glyph1].char_code;
454    code2 = phy_font->chars[glyph2].char_code;
455    pair  = PFR_KERN_INDEX( code1, code2 );
456
457    /* now search the list of kerning items */
458    {
459      PFR_KernItem  item   = phy_font->kern_items;
460      FT_Stream     stream = pfrface->stream;
461
462
463      for ( ; item; item = item->next )
464      {
465        if ( pair >= item->pair1 && pair <= item->pair2 )
466          goto FoundPair;
467      }
468      goto Exit;
469
470    FoundPair: /* we found an item, now parse it and find the value if any */
471      if ( FT_STREAM_SEEK( item->offset )                       ||
472           FT_FRAME_ENTER( item->pair_count * item->pair_size ) )
473        goto Exit;
474
475      {
476        FT_UInt    count    = item->pair_count;
477        FT_UInt    size     = item->pair_size;
478        FT_UInt    power    = (FT_UInt)ft_highpow2( (FT_UInt32)count );
479        FT_UInt    probe    = power * size;
480        FT_UInt    extra    = count - power;
481        FT_Byte*   base     = stream->cursor;
482        FT_Bool    twobytes = item->flags & 1;
483        FT_Byte*   p;
484        FT_UInt32  cpair;
485
486
487        if ( extra > 0 )
488        {
489          p = base + extra * size;
490
491          if ( twobytes )
492            cpair = FT_NEXT_ULONG( p );
493          else
494            cpair = PFR_NEXT_KPAIR( p );
495
496          if ( cpair == pair )
497            goto Found;
498
499          if ( cpair < pair )
500            base = p;
501        }
502
503        while ( probe > size )
504        {
505          probe >>= 1;
506          p       = base + probe;
507
508          if ( twobytes )
509            cpair = FT_NEXT_ULONG( p );
510          else
511            cpair = PFR_NEXT_KPAIR( p );
512
513          if ( cpair == pair )
514            goto Found;
515
516          if ( cpair < pair )
517            base += probe;
518        }
519
520        p = base;
521
522        if ( twobytes )
523          cpair = FT_NEXT_ULONG( p );
524        else
525          cpair = PFR_NEXT_KPAIR( p );
526
527        if ( cpair == pair )
528        {
529          FT_Int  value;
530
531
532        Found:
533          if ( item->flags & 2 )
534            value = FT_PEEK_SHORT( p );
535          else
536            value = p[0];
537
538          kerning->x = item->base_adj + value;
539        }
540      }
541
542      FT_FRAME_EXIT();
543    }
544
545  Exit:
546    return error;
547  }
548
549#else /* !FT_OPTIMIZE_MEMORY */
550
551  FT_LOCAL_DEF( FT_Error )
552  pfr_face_get_kerning( FT_Face     pfrface,        /* PFR_Face */
553                        FT_UInt     glyph1,
554                        FT_UInt     glyph2,
555                        FT_Vector*  kerning )
556  {
557    PFR_Face      face     = (PFR_Face)pfrface;
558    FT_Error      error    = PFR_Err_Ok;
559    PFR_PhyFont   phy_font = &face->phy_font;
560    PFR_KernPair  pairs    = phy_font->kern_pairs;
561    FT_UInt32     idx      = PFR_KERN_INDEX( glyph1, glyph2 );
562    FT_UInt       min, max;
563
564
565    kerning->x = 0;
566    kerning->y = 0;
567
568    min = 0;
569    max = phy_font->num_kern_pairs;
570
571    while ( min < max )
572    {
573      FT_UInt       mid  = ( min + max ) >> 1;
574      PFR_KernPair  pair = pairs + mid;
575      FT_UInt32     pidx = PFR_KERN_PAIR_INDEX( pair );
576
577
578      if ( pidx == idx )
579      {
580        kerning->x = pair->kerning;
581        break;
582      }
583
584      if ( pidx < idx )
585        min = mid + 1;
586      else
587        max = mid;
588    }
589
590    return error;
591  }
592
593#endif /* !FT_OPTIMIZE_MEMORY */
594
595
596/* END */
Note: See TracBrowser for help on using the repository browser.