src/third_party/freetype2/src/src/pfr/pfrobjs.c

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