freetype1/lib/extend/ftxkern.c

   1 /*******************************************************************
   2  *
   3  *  ftxkern.c                                                    1.0
   4  *
   5  *    Kerning support extension.
   6  *
   7  *  Copyright 1996-1999 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  *  The kerning support is currently part of the engine extensions.
  18  *
  19  ******************************************************************/
  20
  21 #include "ftxkern.h"
  22
  23 #include "ttextend.h"
  24 #include "tttypes.h"
  25 #include "ttdebug.h"
  26 #include "ttmemory.h"
  27 #include "ttfile.h"
  28 #include "ttobjs.h"
  29 #include "ttload.h"  /* For the macros */
  30 #include "tttags.h"
  31
  32 /* Required by the tracing mode */
  33 #undef  TT_COMPONENT
  34 #define TT_COMPONENT  trace_any
  35
  36 #define KERNING_ID  Build_Extension_ID( 'k', 'e', 'r', 'n' )
  37
  38
  39 /*******************************************************************
  40  *
  41  *  Function    :  SubTable_Load_0
  42  *
  43  *  Description :  Loads a format 0 kerning subtable data.
  44  *
  45  *  Input  :  kern0   pointer to the kerning subtable
  46  *
  47  *  Output :  error code
  48  *
  49  *  Notes  :  - Assumes that the stream is already `used'
  50  *
  51  *            - the file cursor must be set by the caller
  52  *
  53  *            - in case of error, the function _must_ destroy
  54  *              the data it allocates!
  55  *
  56  ******************************************************************/
  57
  58   static TT_Error  Subtable_Load_0( TT_Kern_0*  kern0,
  59                                     PFace       input )
  60   {
  61     DEFINE_LOAD_LOCALS( input->stream );
  62
  63     UShort  num_pairs, n;
  64
  65
  66     if ( ACCESS_Frame( 8L ) )
  67       return error;
  68
  69     num_pairs            = GET_UShort();
  70     kern0->nPairs        = 0;
  71     kern0->searchRange   = GET_UShort();
  72     kern0->entrySelector = GET_UShort();
  73     kern0->rangeShift    = GET_UShort();
  74
  75     /* we only set kern0->nPairs if the subtable has been loaded */
  76
  77     FORGET_Frame();
  78
  79     if ( ALLOC_ARRAY( kern0->pairs, num_pairs, TT_Kern_0_Pair ) )
  80       return error;
  81
  82     if ( ACCESS_Frame( num_pairs * 6L ) )
  83       goto Fail;
  84
  85     for ( n = 0; n < num_pairs; n++ )
  86     {
  87       kern0->pairs[n].left  = GET_UShort();
  88       kern0->pairs[n].right = GET_UShort();
  89       kern0->pairs[n].value = GET_UShort();
  90
  91       if ( kern0->pairs[n].left >= input->numGlyphs ||
  92            kern0->pairs[n].right >= input->numGlyphs )
  93       {
  94         FORGET_Frame();
  95         error = TT_Err_Invalid_Kerning_Table;
  96         goto Fail;
  97       }
  98     }
  99
 100     FORGET_Frame();
 101
 102     /* we're ok, set the pairs count */
 103     kern0->nPairs = num_pairs;
 104
 105     return TT_Err_Ok;
 106
 107     Fail:
 108       FREE( kern0->pairs );
 109       return error;
 110   }
 111
 112
 113 /*******************************************************************
 114  *
 115  *  Function    :  SubTable_Load_2
 116  *
 117  *  Description :  Loads a format 2 kerning subtable data.
 118  *
 119  *  Input  :  kern2   pointer to the kerning subtable
 120  *            length  subtable length.  This is required as
 121  *                    the subheader doesn't give any indication
 122  *                    of the size of the `array' table.
 123  *
 124  *  Output :  error code
 125  *
 126  *  Notes  :  - Assumes that the stream is already `used'
 127  *
 128  *            - the file cursor must be set by the caller
 129  *
 130  *            - in case of error, the function _must_ destroy
 131  *              the data it allocates!
 132  *
 133  ******************************************************************/
 134
 135   static TT_Error  Subtable_Load_2( TT_Kern_2*  kern2,
 136                                     PFace       input )
 137   {
 138     DEFINE_LOAD_LOCALS( input->stream );
 139
 140     Long  table_base;
 141
 142     UShort  left_offset, right_offset, array_offset;
 143     ULong   array_size;
 144     UShort  left_max, right_max, n;
 145
 146
 147     /* record the table offset */
 148     table_base = FILE_Pos();
 149
 150     if ( ACCESS_Frame( 8L ) )
 151       return error;
 152
 153     kern2->rowWidth = GET_UShort();
 154     left_offset     = GET_UShort();
 155     right_offset    = GET_UShort();
 156     array_offset    = GET_UShort();
 157
 158     FORGET_Frame();
 159
 160     /* first load left and right glyph classes */
 161
 162     if ( FILE_Seek( table_base + left_offset ) ||
 163          ACCESS_Frame( 4L ) )
 164       return error;
 165
 166     kern2->leftClass.firstGlyph = GET_UShort();
 167     kern2->leftClass.nGlyphs    = GET_UShort();
 168
 169     FORGET_Frame();
 170
 171     if ( ALLOC_ARRAY( kern2->leftClass.classes,
 172                       kern2->leftClass.nGlyphs,
 173                       UShort ) )
 174       return error;
 175
 176     /* load left offsets */
 177
 178     if ( ACCESS_Frame( kern2->leftClass.nGlyphs * 2L ) )
 179       goto Fail_Left;
 180
 181     for ( n = 0; n < kern2->leftClass.nGlyphs; n++ )
 182       kern2->leftClass.classes[n] = GET_UShort();
 183
 184     FORGET_Frame();
 185
 186     /* right class */
 187
 188     if ( FILE_Seek( table_base + right_offset ) ||
 189          ACCESS_Frame( 4L ) )
 190       goto Fail_Left;
 191
 192     kern2->rightClass.firstGlyph = GET_UShort();
 193     kern2->rightClass.nGlyphs    = GET_UShort();
 194
 195     FORGET_Frame();
 196
 197     if ( ALLOC_ARRAY( kern2->rightClass.classes,
 198                       kern2->rightClass.nGlyphs,
 199                       UShort ) )
 200       goto Fail_Left;
 201
 202     /* load right offsets */
 203
 204     if ( ACCESS_Frame( kern2->rightClass.nGlyphs * 2L ) )
 205       goto Fail_Right;
 206
 207     for ( n = 0; n < kern2->rightClass.nGlyphs; n++ )
 208       kern2->rightClass.classes[n] = GET_UShort();
 209
 210     FORGET_Frame();
 211
 212     /* Now load the kerning array.  We don't have its size, we */
 213     /* must compute it from what we know.                      */
 214
 215     /* We thus compute the maximum left and right offsets and  */
 216     /* add them to get the array size.                         */
 217
 218     left_max = right_max = 0;
 219
 220     for ( n = 0; n < kern2->leftClass.nGlyphs; n++ )
 221       left_max = MAX( left_max, kern2->leftClass.classes[n] );
 222
 223     for ( n = 0; n < kern2->rightClass.nGlyphs; n++ )
 224       right_max = MAX( right_max, kern2->leftClass.classes[n] );
 225
 226     array_size = left_max + right_max + 2;
 227
 228     if ( ALLOC( kern2->array, array_size ) )
 229       goto Fail_Right;
 230
 231     if ( ACCESS_Frame( array_size ) )
 232       goto Fail_Array;
 233
 234     for ( n = 0; n < array_size/2; n++ )
 235       kern2->array[n] = GET_Short();
 236
 237     FORGET_Frame();
 238
 239     /* we're good now */
 240
 241     return TT_Err_Ok;
 242
 243   Fail_Array:
 244     FREE( kern2->array );
 245
 246   Fail_Right:
 247     FREE( kern2->rightClass.classes );
 248     kern2->rightClass.nGlyphs = 0;
 249
 250   Fail_Left:
 251     FREE( kern2->leftClass.classes );
 252     kern2->leftClass.nGlyphs = 0;
 253
 254     return error;
 255   }
 256
 257
 258 /*******************************************************************
 259  *
 260  *  Function    :  Kerning_Create
 261  *
 262  *  Description :  Creates the kerning directory if a face is
 263  *                 loaded.  The tables however are loaded on
 264  *                 demand to save space.
 265  *
 266  *  Input  :  face    pointer to the parent face object
 267  *            kern    pointer to the extension's kerning field
 268  *
 269  *  Output :  error code
 270  *
 271  *  Notes  :  as in all constructors, the memory allocated isn't
 272  *            released in case of failure.  Rather, the task is left
 273  *            to the destructor (which is called if an error
 274  *            occurs during the loading of a face).
 275  *
 276  ******************************************************************/
 277
 278   static TT_Error  Kerning_Create( void*  ext,
 279                                    PFace  face )
 280   {
 281     DEFINE_LOAD_LOCALS( face->stream );
 282
 283     TT_Kerning*  kern = (TT_Kerning*)ext;
 284     UShort       num_tables;
 285     Long         table;
 286
 287     TT_Kern_Subtable*  sub;
 288
 289
 290     /* by convention */
 291     if ( !kern )
 292       return TT_Err_Ok;
 293
 294     /* Now load the kerning directory. We're called from the face */
 295     /* constructor.  We thus need not use the stream.             */
 296
 297     kern->version = 0;
 298     kern->nTables = 0;
 299     kern->tables  = NULL;
 300
 301     table = TT_LookUp_Table( face, TTAG_kern );
 302     if ( table < 0 )
 303       return TT_Err_Ok;  /* The table is optional */
 304
 305     if ( FILE_Seek( face->dirTables[table].Offset ) ||
 306          ACCESS_Frame( 4L ) )
 307       return error;
 308
 309     kern->version = GET_UShort();
 310     num_tables    = GET_UShort();
 311
 312     FORGET_Frame();
 313
 314     /* we don't set kern->nTables until we have allocated the array */
 315
 316     if ( ALLOC_ARRAY( kern->tables, num_tables, TT_Kern_Subtable ) )
 317       return error;
 318
 319     kern->nTables = num_tables;
 320
 321     /* now load the directory entries, but do _not_ load the tables ! */
 322
 323     sub = kern->tables;
 324
 325     for ( table = 0; table < num_tables; table++ )
 326     {
 327       if ( ACCESS_Frame( 6L ) )
 328         return error;
 329
 330       sub->loaded   = FALSE;             /* redundant, but good to see */
 331       sub->version  = GET_UShort();
 332       sub->length   = GET_UShort() - 6;  /* substract header length */
 333       sub->format   = GET_Byte();
 334       sub->coverage = GET_Byte();
 335
 336       FORGET_Frame();
 337
 338       sub->offset = FILE_Pos();
 339
 340       /* now skip to the next table */
 341
 342       if ( FILE_Skip( sub->length ) )
 343         return error;
 344
 345       sub++;
 346     }
 347
 348     /* that's fine, leave now */
 349
 350     return TT_Err_Ok;
 351   }
 352
 353
 354 /*******************************************************************
 355  *
 356  *  Function    :  Kerning_Destroy
 357  *
 358  *  Description :  Destroys all kerning information.
 359  *
 360  *  Input  :  kern   pointer to the extension's kerning field
 361  *
 362  *  Output :  error code
 363  *
 364  *  Notes  :  This function is a destructor; it must be able
 365  *            to destroy partially built tables.
 366  *
 367  ******************************************************************/
 368
 369   static TT_Error  Kerning_Destroy( void*  ext,
 370                                     PFace  face )
 371   {
 372     TT_Kerning*        kern = (TT_Kerning*)ext;
 373     TT_Kern_Subtable*  sub;
 374     UShort             n;
 375
 376
 377     /* by convention */
 378     if ( !kern )
 379       return TT_Err_Ok;
 380
 381     if ( kern->nTables == 0 )
 382       return TT_Err_Ok;      /* no tables to release */
 383
 384     /* scan the table directory and release loaded entries */
 385
 386     sub = kern->tables;
 387     for ( n = 0; n < kern->nTables; n++ )
 388     {
 389       if ( sub->loaded )
 390       {
 391         switch ( sub->format )
 392         {
 393         case 0:
 394           FREE( sub->t.kern0.pairs );
 395           sub->t.kern0.nPairs        = 0;
 396           sub->t.kern0.searchRange   = 0;
 397           sub->t.kern0.entrySelector = 0;
 398           sub->t.kern0.rangeShift    = 0;
 399           break;
 400
 401         case 2:
 402           FREE( sub->t.kern2.leftClass.classes );
 403           sub->t.kern2.leftClass.firstGlyph = 0;
 404           sub->t.kern2.leftClass.nGlyphs    = 0;
 405
 406           FREE( sub->t.kern2.rightClass.classes );
 407           sub->t.kern2.rightClass.firstGlyph = 0;
 408           sub->t.kern2.rightClass.nGlyphs    = 0;
 409
 410           FREE( sub->t.kern2.array );
 411           sub->t.kern2.rowWidth = 0;
 412           break;
 413
 414         default:
 415           ;       /* invalid subtable format - do nothing */
 416         }
 417
 418         sub->loaded   = FALSE;
 419         sub->version  = 0;
 420         sub->offset   = 0;
 421         sub->length   = 0;
 422         sub->coverage = 0;
 423         sub->format   = 0;
 424       }
 425       sub++;
 426     }
 427
 428     FREE( kern->tables );
 429     kern->nTables = 0;
 430
 431     return TT_Err_Ok;
 432   }
 433
 434
 435 /*******************************************************************
 436  *
 437  *  Function    :  TT_Get_Kerning_Directory
 438  *
 439  *  Description :  Returns a given face's kerning directory.
 440  *
 441  *  Input  :  face       handle to the face object
 442  *            directory  pointer to client's target directory
 443  *
 444  *  Output :  error code
 445  *
 446  *  Notes  :  The kerning table directory is loaded with the face
 447  *            through the extension constructor.  However, the kerning
 448  *            tables themselves are only loaded on demand, as they
 449  *            may represent a lot of data, unneeded by most uses of
 450  *            the engine.
 451  *
 452  ******************************************************************/
 453
 454   EXPORT_FUNC
 455   TT_Error  TT_Get_Kerning_Directory( TT_Face      face,
 456                                       TT_Kerning*  directory )
 457   {
 458     PFace        faze = HANDLE_Face( face );
 459     TT_Error     error;
 460     TT_Kerning*  kerning;
 461
 462
 463     if ( !faze )
 464       return TT_Err_Invalid_Face_Handle;
 465
 466     /* copy directory header */
 467     error = TT_Extension_Get( faze, KERNING_ID, (void**)&kerning );
 468     if ( !error )
 469       *directory = *kerning;
 470
 471     return error;
 472   }
 473
 474
 475 /*******************************************************************
 476  *
 477  *  Function    :  TT_Load_Kerning_Table
 478  *
 479  *  Description :  Loads a kerning table intro memory.
 480  *
 481  *  Input  :  face          face handle
 482  *            kern_index    index in the face's kerning directory
 483  *
 484  *  Output :  error code
 485  *
 486  *  Notes  :
 487  *
 488  ******************************************************************/
 489
 490   EXPORT_FUNC
 491   TT_Error  TT_Load_Kerning_Table( TT_Face    face,
 492                                    TT_UShort  kern_index )
 493   {
 494     TT_Error   error;
 495     TT_Stream  stream;
 496
 497     TT_Kerning*        kern;
 498     TT_Kern_Subtable*  sub;
 499
 500
 501     PFace  faze = HANDLE_Face( face );
 502
 503     if ( !faze )
 504       return TT_Err_Invalid_Face_Handle;
 505
 506     error = TT_Extension_Get( faze, KERNING_ID, (void**)&kern );
 507     if ( error )
 508       return error;
 509
 510     if ( kern->nTables == 0 )
 511       return TT_Err_Table_Missing;
 512
 513     if ( kern_index >= kern->nTables )
 514       return TT_Err_Invalid_Argument;
 515
 516     sub = kern->tables + kern_index;
 517
 518     if ( sub->format != 0 && sub->format != 2 )
 519       return TT_Err_Invalid_Kerning_Table_Format;
 520
 521     /* now access stream */
 522     if ( USE_Stream( faze->stream, stream ) )
 523       return error;
 524
 525     if ( FILE_Seek( sub->offset ) )
 526       goto Fail;
 527
 528     if ( sub->format == 0 )
 529       error = Subtable_Load_0( &sub->t.kern0, faze );
 530     else if ( sub->format == 2 )
 531       error = Subtable_Load_2( &sub->t.kern2, faze );
 532
 533     if ( !error )
 534       sub->loaded = TRUE;
 535
 536   Fail:
 537     /* release stream */
 538     DONE_Stream( stream );
 539
 540     return error;
 541   }
 542
 543
 544   EXPORT_FUNC
 545   TT_Error  TT_Init_Kerning_Extension( TT_Engine  engine )
 546   {
 547     PEngine_Instance  _engine = HANDLE_Engine( engine );
 548
 549     TT_Error  error;
 550
 551
 552     if ( !_engine )
 553       return TT_Err_Invalid_Engine;
 554
 555     error = TT_Register_Extension( _engine,
 556                                 KERNING_ID,
 557                                 sizeof ( TT_Kerning ),
 558                                 Kerning_Create,
 559                                 Kerning_Destroy );
 560     return error;
 561   }
 562
 563
 564 /* END */