freetype1/lib/ttobjs.c

   1 /*******************************************************************
   2  *
   3  *  ttobjs.c                                                     1.0
   4  *
   5  *    Objects manager.
   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
  18 #include "ttobjs.h"
  19 #include "ttfile.h"
  20 #include "ttcalc.h"
  21 #include "ttmemory.h"
  22 #include "ttload.h"
  23 #include "ttinterp.h"
  24 #include "ttdebug.h"
  25
  26
  27 /* Add extensions definition */
  28 #ifdef TT_CONFIG_OPTION_EXTEND_ENGINE
  29 #include "ttextend.h"
  30 #endif
  31
  32 /* Required by tracing mode */
  33 #undef   TT_COMPONENT
  34 #define  TT_COMPONENT  trace_objs
  35
  36 /*******************************************************************
  37  *
  38  *  Function    :  New_Context
  39  *
  40  *  Description :  Creates a new execution context for a given
  41  *                 face object.
  42  *
  43  ******************************************************************/
  44
  45   LOCAL_FUNC
  46   PExecution_Context  New_Context( PFace  face )
  47   {
  48     PEngine_Instance    engine;
  49     PExecution_Context  exec;
  50
  51
  52     if ( !face )
  53       return NULL;
  54
  55     engine = face->engine;
  56     CACHE_New( engine->objs_exec_cache, exec, face );
  57     return exec;
  58   }
  59
  60
  61 /*******************************************************************
  62  *
  63  *  Function    :  Done_Context
  64  *
  65  *  Description :  Discards an execution context.
  66  *
  67  ******************************************************************/
  68
  69   LOCAL_FUNC
  70   TT_Error  Done_Context( PExecution_Context  exec )
  71   {
  72     PEngine_Instance  engine;
  73
  74
  75     if ( !exec )
  76       return TT_Err_Ok;
  77
  78     engine = exec->face->engine;
  79     return CACHE_Done( engine->objs_exec_cache, exec );
  80   }
  81
  82
  83 #if 0
  84
  85 /*******************************************************************
  86  *
  87  *  Function    :  New_Instance
  88  *
  89  *  Description :  Creates a new instance for a given face object.
  90  *
  91  ******************************************************************/
  92
  93   LOCAL_FUNC
  94   PInstance  New_Instance( PFace  face )
  95   {
  96     PInstance  ins;
  97
  98
  99     if ( !face )
 100       return NULL;
 101
 102     CACHE_New( &face->instances, ins, face );
 103
 104     return ins;
 105   }
 106
 107
 108 /*******************************************************************
 109  *
 110  *  Function    :  Done_Instance
 111  *
 112  *  Description :  Discards an instance.
 113  *
 114  ******************************************************************/
 115
 116   LOCAL_FUNC
 117   TT_Error  Done_Instance( PInstance  instance )
 118   {
 119     return CACHE_Done( &instance->owner->instances, instance );
 120   }
 121
 122 #endif
 123
 124
 125 /*******************************************************************
 126  *                                                                 *
 127  *                     GLYPH ZONE FUNCTIONS                        *
 128  *                                                                 *
 129  *                                                                 *
 130  *******************************************************************/
 131
 132 /*******************************************************************
 133  *
 134  *  Function    :  New_Glyph_Zone
 135  *
 136  *  Description :  Allocates a new glyph zone
 137  *
 138  *  Input  :  pts          pointer to the target glyph zone record
 139  *            maxPoints    capacity of glyph zone in points
 140  *            maxContours  capacity of glyph zone in contours
 141  *
 142  *  Return :  Error code.
 143  *
 144  *****************************************************************/
 145
 146   static
 147   TT_Error  New_Glyph_Zone( PGlyph_Zone  pts,
 148                             UShort       maxPoints,
 149                             UShort       maxContours )
 150   {
 151     TT_Error  error;
 152
 153
 154     if ( ALLOC( pts->org, maxPoints * 2 * sizeof ( TT_F26Dot6 ) ) ||
 155          ALLOC( pts->cur, maxPoints * 2 * sizeof ( TT_F26Dot6 ) ) ||
 156          ALLOC( pts->touch, maxPoints * sizeof ( Byte )         ) ||
 157          ALLOC( pts->contours, maxContours * sizeof ( Short ) ) )
 158       return error;
 159
 160     return TT_Err_Ok;
 161   }
 162
 163
 164 /*******************************************************************
 165  *
 166  *  Function    :  Done_Glyph_Zone
 167  *
 168  *  Description :  Deallocates a glyph zone
 169  *
 170  *  Input  :  pts          pointer to the target glyph zone record
 171  *
 172  *  Return :  Error code.
 173  *
 174  *****************************************************************/
 175
 176   static
 177   TT_Error  Done_Glyph_Zone( PGlyph_Zone  pts )
 178   {
 179     FREE( pts->contours );
 180     FREE( pts->touch );
 181     FREE( pts->cur );
 182     FREE( pts->org );
 183
 184     return TT_Err_Ok;
 185   }
 186
 187
 188
 189 /*******************************************************************
 190  *                                                                 *
 191  *                     CODERANGE FUNCTIONS                         *
 192  *                                                                 *
 193  *******************************************************************/
 194
 195 /*******************************************************************
 196  *
 197  *  Function    :  Goto_CodeRange
 198  *
 199  *  Description :  Switch to a new code range (updates Code and IP).
 200  *
 201  *  Input  :  exec    target execution context
 202  *            range   new execution code range
 203  *            IP      new IP in new code range
 204  *
 205  *  Output :  SUCCESS on success.  FAILURE on error (no code range).
 206  *
 207  *****************************************************************/
 208
 209   LOCAL_FUNC
 210   TT_Error  Goto_CodeRange( PExecution_Context  exec,
 211                             Int                 range,
 212                             ULong               IP )
 213   {
 214     PCodeRange  cr;
 215
 216
 217     if ( range < 1 || range > 3 )
 218       return TT_Err_Bad_Argument;
 219
 220     cr = &exec->codeRangeTable[range - 1];
 221
 222     if ( cr->Base == NULL )
 223       return TT_Err_Invalid_CodeRange;
 224
 225     /* NOTE:  Because the last instruction of a program may be a CALL */
 226     /*        which will return to the first byte *after* the code    */
 227     /*        range, we test for IP <= Size, instead of IP < Size.    */
 228
 229     if ( IP > cr->Size )
 230       return TT_Err_Code_Overflow;
 231
 232     exec->code     = cr->Base;
 233     exec->codeSize = cr->Size;
 234     exec->IP       = IP;
 235     exec->curRange = range;
 236
 237     return TT_Err_Ok;
 238   }
 239
 240
 241 #if 0
 242
 243 /*******************************************************************
 244  *
 245  *  Function    :  Get_CodeRange
 246  *
 247  *  Description :  Returns a pointer to a given code range.  Should
 248  *                 be used only by the debugger.  Returns NULL if
 249  *                 'range' is out of current bounds.
 250  *
 251  *  Input  :  exec    target execution context
 252  *            range   new execution code range
 253  *
 254  *  Output :  Pointer to the code range record.  NULL on failure.
 255  *
 256  *****************************************************************/
 257
 258   LOCAL_FUNC
 259   PCodeRange  Get_CodeRange( PExecution_Context  exec, Int  range )
 260   {
 261     if ( range < 1 || range > 3 )
 262       return NULL;
 263     else                /* arrays start with 1 in Pascal, and with 0 in C */
 264       return &exec->codeRangeTable[range - 1];
 265   }
 266
 267 #endif
 268
 269
 270 /*******************************************************************
 271  *
 272  *  Function    :  Set_CodeRange
 273  *
 274  *  Description :  Sets a code range.
 275  *
 276  *  Input  :  exec    target execution context
 277  *            range   code range index
 278  *            base    new code base
 279  *            length  range size in bytes
 280  *
 281  *  Output :  SUCCESS on success.  FAILURE on error.
 282  *
 283  *****************************************************************/
 284
 285   LOCAL_FUNC
 286   TT_Error  Set_CodeRange( PExecution_Context  exec,
 287                            Int                 range,
 288                            void*               base,
 289                            ULong               length )
 290   {
 291     if ( range < 1 || range > 3 )
 292       return TT_Err_Bad_Argument;
 293
 294     exec->codeRangeTable[range - 1].Base = (Byte*)base;
 295     exec->codeRangeTable[range - 1].Size = length;
 296
 297     return TT_Err_Ok;
 298   }
 299
 300
 301 /*******************************************************************
 302  *
 303  *  Function    :  Clear_CodeRange
 304  *
 305  *  Description :  Clears a code range.
 306  *
 307  *  Input  :  exec    target execution context
 308  *            range   code range index
 309  *
 310  *  Output :  SUCCESS on success.  FAILURE on error.
 311  *
 312  *  Note   : Does not set the Error variable.
 313  *
 314  *****************************************************************/
 315
 316   LOCAL_FUNC
 317   TT_Error Clear_CodeRange( PExecution_Context  exec, Int  range )
 318   {
 319     if ( range < 1 || range > 3 )
 320       return TT_Err_Bad_Argument;
 321
 322     exec->codeRangeTable[range - 1].Base = NULL;
 323     exec->codeRangeTable[range - 1].Size = 0;
 324
 325     return TT_Err_Ok;
 326   }
 327
 328
 329
 330 /*******************************************************************
 331  *                                                                 *
 332  *                EXECUTION CONTEXT ROUTINES                       *
 333  *                                                                 *
 334  *******************************************************************/
 335
 336 /*******************************************************************
 337  *
 338  *  Function    :  Context_Destroy
 339  *
 340  *****************************************************************/
 341
 342   LOCAL_FUNC
 343   TT_Error  Context_Destroy( void*  _context )
 344   {
 345     PExecution_Context  exec = (PExecution_Context)_context;
 346
 347     if ( !exec )
 348       return TT_Err_Ok;
 349
 350     /* free composite load stack */
 351     FREE( exec->loadStack );
 352     exec->loadSize = 0;
 353
 354     /* points zone */
 355     Done_Glyph_Zone( &exec->pts );
 356     exec->maxPoints   = 0;
 357     exec->maxContours = 0;
 358
 359     /* free stack */
 360     FREE( exec->stack );
 361     exec->stackSize = 0;
 362
 363     /* free call stack */
 364     FREE( exec->callStack );
 365     exec->callSize = 0;
 366     exec->callTop  = 0;
 367
 368     /* free glyph code range */
 369     FREE( exec->glyphIns );
 370     exec->glyphSize = 0;
 371
 372     exec->instance = NULL;
 373     exec->face     = NULL;
 374
 375     return TT_Err_Ok;
 376   }
 377
 378
 379 /*******************************************************************
 380  *
 381  *  Function    :  Context_Create
 382  *
 383  *****************************************************************/
 384
 385   LOCAL_FUNC
 386   TT_Error  Context_Create( void*  _context, void*  _face )
 387   {
 388     PExecution_Context  exec = (PExecution_Context)_context;
 389
 390     PFace        face = (PFace)_face;
 391     TT_Error     error;
 392
 393
 394     /* XXX : We don't reserve arrays anymore, this is done automatically */
 395     /*       during a "Context_Load"..                                   */
 396
 397     exec->callSize  = 32;
 398     if ( ALLOC_ARRAY( exec->callStack, exec->callSize, TCallRecord ) )
 399       goto Fail_Memory;
 400
 401     /* all values in the context are set to 0 already, but this is */
 402     /* here as a remainder                                         */
 403     exec->maxPoints   = 0;
 404     exec->maxContours = 0;
 405
 406     exec->stackSize = 0;
 407     exec->loadSize  = 0;
 408     exec->glyphSize = 0;
 409
 410     exec->stack     = NULL;
 411     exec->loadStack = NULL;
 412     exec->glyphIns  = NULL;
 413
 414     exec->face     = face;
 415     exec->instance = NULL;
 416
 417     return TT_Err_Ok;
 418
 419   Fail_Memory:
 420     Context_Destroy( exec );
 421     return error;
 422   }
 423
 424
 425 /*******************************************************************
 426  *
 427  *  Function    :  Context_Load
 428  *
 429  *****************************************************************/
 430
 431 /****************************************************************/
 432 /*                                                              */
 433 /* Update_Max : Reallocate a buffer if it needs to              */
 434 /*                                                              */
 435 /* input:  size        address of buffer's current size         */
 436 /*                     expressed in elements                    */
 437 /*                                                              */
 438 /*         multiplier  size in bytes of each element in the     */
 439 /*                     buffer                                   */
 440 /*                                                              */
 441 /*         buff        address of the buffer base pointer       */
 442 /*                                                              */
 443 /*         new_max     new capacity (size) of the buffer        */
 444
 445   static
 446   TT_Error  Update_Max( ULong*  size,
 447                         ULong   multiplier,
 448                         void**  buff,
 449                         ULong   new_max )
 450   {
 451     TT_Error  error;
 452
 453     if ( *size < new_max )
 454     {
 455       FREE( *buff );
 456       if ( ALLOC( *buff, new_max * multiplier ) )
 457         return error;
 458       *size = new_max;
 459     }
 460     return TT_Err_Ok;
 461   }
 462
 463
 464 /****************************************************************/
 465 /*                                                              */
 466 /* Update_Zone: Reallocate a zone if it needs to                */
 467 /*                                                              */
 468 /* input:  zone        address of the target zone               */
 469 /*                                                              */
 470 /*         maxPoints   address of the zone's current capacity   */
 471 /*                     in points                                */
 472 /*                                                              */
 473 /*         maxContours address of the zone's current capacity   */
 474 /*                     in contours                              */
 475 /*                                                              */
 476 /*         newPoints   new capacity in points                   */
 477 /*                                                              */
 478 /*         newContours new capacity in contours                 */
 479 /*                                                              */
 480
 481   static
 482   TT_Error  Update_Zone( PGlyph_Zone  zone,
 483                          UShort*      maxPoints,
 484                          UShort*      maxContours,
 485                          UShort       newPoints,
 486                          UShort       newContours )
 487   {
 488     if ( *maxPoints < newPoints || *maxContours < newContours )
 489     {
 490       TT_Error  error;
 491
 492
 493       Done_Glyph_Zone( zone );
 494
 495       error = New_Glyph_Zone( zone, newPoints, newContours );
 496       if ( error )
 497         return error;
 498
 499       *maxPoints   = newPoints;
 500       *maxContours = newContours;
 501     }
 502     return TT_Err_Ok;
 503   }
 504
 505
 506   LOCAL_FUNC
 507   TT_Error Context_Load( PExecution_Context  exec,
 508                          PFace               face,
 509                          PInstance           ins )
 510   {
 511     Int           i;
 512     TMaxProfile*  maxp;
 513     TT_Error      error;
 514
 515     exec->face     = face;
 516     maxp           = &face->maxProfile;
 517
 518     exec->instance = ins;
 519
 520     if ( ins )
 521     {
 522       exec->numFDefs = ins->numFDefs;
 523       exec->numIDefs = ins->numIDefs;
 524       exec->maxFDefs = ins->maxFDefs;
 525       exec->maxIDefs = ins->maxIDefs;
 526       exec->FDefs    = ins->FDefs;
 527       exec->IDefs    = ins->IDefs;
 528       exec->metrics  = ins->metrics;
 529
 530       exec->maxFunc  = ins->maxFunc;
 531       exec->maxIns   = ins->maxIns;
 532
 533       for ( i = 0; i < MAX_CODE_RANGES; i++ )
 534         exec->codeRangeTable[i] = ins->codeRangeTable[i];
 535
 536       /* set graphics state */
 537       exec->GS = ins->GS;
 538
 539       exec->cvtSize = ins->cvtSize;
 540       exec->cvt     = ins->cvt;
 541
 542       exec->storeSize = ins->storeSize;
 543       exec->storage   = ins->storage;
 544
 545       exec->twilight  = ins->twilight;
 546     }
 547
 548     error = Update_Max( &exec->loadSize,
 549                         sizeof ( TSubglyph_Record ),
 550                         (void**)&exec->loadStack,
 551                         face->maxComponents + 1 );
 552     if ( error )
 553       return error;
 554
 555     error = Update_Max( &exec->stackSize,
 556                         sizeof ( TT_F26Dot6 ),
 557                         (void**)&exec->stack,
 558                         maxp->maxStackElements + 32 );
 559     /* XXX : We reserve a little more elements on the stack to deal safely */
 560     /*       with broken fonts like arialbs, courbs, timesbs...            */
 561     if ( error )
 562       return error;
 563
 564     error = Update_Max( &exec->glyphSize,
 565                         sizeof ( Byte ),
 566                         (void**)&exec->glyphIns,
 567                         maxp->maxSizeOfInstructions );
 568     if ( error )
 569       return error;
 570
 571     error = Update_Zone( &exec->pts,
 572                          &exec->maxPoints,
 573                          &exec->maxContours,
 574                          exec->face->maxPoints + 2,
 575                          exec->face->maxContours );
 576     /* XXX : We reserve two positions for the phantom points! */
 577     if ( error )
 578       return error;
 579
 580     exec->pts.n_points   = 0;
 581     exec->pts.n_contours = 0;
 582
 583     exec->instruction_trap = FALSE;
 584
 585     return TT_Err_Ok;
 586   }
 587
 588
 589 /*******************************************************************
 590  *
 591  *  Function    :  Context_Save
 592  *
 593  *****************************************************************/
 594
 595   LOCAL_FUNC
 596   TT_Error  Context_Save( PExecution_Context  exec,
 597                           PInstance           ins )
 598   {
 599     Int  i;
 600
 601     /* XXXX : Will probably disappear soon with all the coderange */
 602     /*        management, which is now rather obsolete.           */
 603
 604     ins->numFDefs = exec->numFDefs;
 605     ins->numIDefs = exec->numIDefs;
 606     ins->maxFunc  = exec->maxFunc;
 607     ins->maxIns   = exec->maxIns;
 608
 609     for ( i = 0; i < MAX_CODE_RANGES; i++ )
 610       ins->codeRangeTable[i] = exec->codeRangeTable[i];
 611
 612     return TT_Err_Ok;
 613   }
 614
 615
 616 /*******************************************************************
 617  *
 618  *  Function    :  Context_Run
 619  *
 620  *****************************************************************/
 621
 622   LOCAL_FUNC
 623   TT_Error  Context_Run( PExecution_Context  exec,
 624                          Bool                debug )
 625   {
 626     TT_Error  error;
 627
 628
 629     if ( (error = Goto_CodeRange( exec,
 630                                   TT_CodeRange_Glyph, 0 )) != TT_Err_Ok )
 631       return error;
 632
 633     exec->zp0 = exec->pts;
 634     exec->zp1 = exec->pts;
 635     exec->zp2 = exec->pts;
 636
 637     exec->GS.gep0 = 1;
 638     exec->GS.gep1 = 1;
 639     exec->GS.gep2 = 1;
 640
 641     exec->GS.projVector.x = 0x4000;
 642     exec->GS.projVector.y = 0x0000;
 643
 644     exec->GS.freeVector = exec->GS.projVector;
 645     exec->GS.dualVector = exec->GS.projVector;
 646
 647     exec->GS.round_state = 1;
 648     exec->GS.loop        = 1;
 649
 650     /* some glyphs leave something on the stack. so we clean it */
 651     /* before a new execution.                                  */
 652     exec->top     = 0;
 653     exec->callTop = 0;
 654
 655     if ( !debug )
 656       return RunIns( exec );
 657     else
 658       return TT_Err_Ok;
 659   }
 660
 661
 662   LOCAL_FUNC
 663   const TGraphicsState  Default_GraphicsState =
 664   {
 665     0, 0, 0,
 666     { 0x4000, 0 },
 667     { 0x4000, 0 },
 668     { 0x4000, 0 },
 669     1, 64, 1,
 670     TRUE, 68, 0, 0, 9, 3,
 671     0, FALSE, 2, 1, 1, 1
 672   };
 673
 674
 675
 676 /*******************************************************************
 677  *                                                                 *
 678  *                     INSTANCE  FUNCTIONS                         *
 679  *                                                                 *
 680  *                                                                 *
 681  *******************************************************************/
 682
 683 /*******************************************************************
 684  *
 685  *  Function    : Instance_Destroy
 686  *
 687  *  Description :
 688  *
 689  *  Input  :  _instance   the instance object to destroy
 690  *
 691  *  Output :  error code.
 692  *
 693  ******************************************************************/
 694
 695   LOCAL_FUNC
 696   TT_Error  Instance_Destroy( void* _instance )
 697   {
 698     PInstance  ins = (PInstance)_instance;
 699
 700
 701     if ( !_instance )
 702       return TT_Err_Ok;
 703
 704     if ( ins->debug )
 705     {
 706       /* the debug context must be deleted by the debugger itself */
 707       ins->context = NULL;
 708       ins->debug   = FALSE;
 709     }
 710
 711     FREE( ins->cvt );
 712     ins->cvtSize = 0;
 713
 714     /* free storage area */
 715     FREE( ins->storage );
 716     ins->storeSize = 0;
 717
 718     /* twilight zone */
 719     Done_Glyph_Zone( &ins->twilight );
 720
 721     FREE( ins->FDefs );
 722     FREE( ins->IDefs );
 723     ins->numFDefs = 0;
 724     ins->numIDefs = 0;
 725     ins->maxFDefs = 0;
 726     ins->maxIDefs = 0;
 727     ins->maxFunc  = -1;
 728     ins->maxIns   = -1;
 729
 730     ins->owner = NULL;
 731     ins->valid = FALSE;
 732
 733     return TT_Err_Ok;
 734   }
 735
 736
 737 /*******************************************************************
 738  *
 739  *  Function    : Instance_Create
 740  *
 741  *  Description :
 742  *
 743  *  Input  :  _instance    instance record to initialize
 744  *            _face        parent face object
 745  *
 746  *  Output :  Error code.  All partially built subtables are
 747  *            released on error.
 748  *
 749  ******************************************************************/
 750
 751   LOCAL_FUNC
 752   TT_Error  Instance_Create( void*  _instance,
 753                              void*  _face )
 754   {
 755     PInstance  ins  = (PInstance)_instance;
 756     PFace      face = (PFace)_face;
 757     TT_Error   error;
 758     Int        i;
 759     UShort     n_twilight;
 760
 761     PMaxProfile  maxp = &face->maxProfile;
 762
 763
 764     ins->owner = face;
 765     ins->valid = FALSE;
 766
 767     ins->maxFDefs  = maxp->maxFunctionDefs;
 768     ins->maxIDefs  = maxp->maxInstructionDefs;
 769     ins->cvtSize   = face->cvtSize;
 770     ins->storeSize = maxp->maxStorage;
 771
 772     /* Set default metrics */
 773     {
 774       PIns_Metrics   metrics = &ins->metrics;
 775
 776
 777       metrics->pointSize    = 10 * 64;     /* default pointsize  = 10pts */
 778
 779       metrics->x_resolution = 96;          /* default resolution = 96dpi */
 780       metrics->y_resolution = 96;
 781
 782       metrics->x_ppem = 0;
 783       metrics->y_ppem = 0;
 784
 785       metrics->rotated   = FALSE;
 786       metrics->stretched = FALSE;
 787
 788       /* set default compensation ( all 0 ) */
 789       for ( i = 0; i < 4; i++ )
 790         metrics->compensations[i] = 0;
 791     }
 792
 793     /* allocate function defs, instruction defs, cvt and storage area */
 794     if ( ALLOC_ARRAY( ins->FDefs,   ins->maxFDefs,  TDefRecord )  ||
 795          ALLOC_ARRAY( ins->IDefs,   ins->maxIDefs,  TDefRecord )  ||
 796          ALLOC_ARRAY( ins->cvt,     ins->cvtSize,   Long       )  ||
 797          ALLOC_ARRAY( ins->storage, ins->storeSize, Long       )  )
 798       goto Fail_Memory;
 799
 800     /* reserve twilight zone */
 801     n_twilight = maxp->maxTwilightPoints;
 802     error = New_Glyph_Zone( &ins->twilight, n_twilight, 0 );
 803     if (error)
 804       goto Fail_Memory;
 805
 806     ins->twilight.n_points = n_twilight;
 807
 808     return TT_Err_Ok;
 809
 810   Fail_Memory:
 811     Instance_Destroy( ins );
 812     return error;
 813   }
 814
 815
 816 /*******************************************************************
 817  *
 818  *  Function    : Instance_Init
 819  *
 820  *  Description : Initialize a fresh new instance.
 821  *                Executes the font program if any is found.
 822  *
 823  *  Input  :  _instance   the instance object to destroy
 824  *
 825  *  Output :  Error code.
 826  *
 827  ******************************************************************/
 828
 829   LOCAL_FUNC
 830   TT_Error  Instance_Init( PInstance  ins )
 831   {
 832     PExecution_Context  exec;
 833
 834     TT_Error  error;
 835     PFace     face = ins->owner;
 836
 837
 838     if ( ins->debug )
 839       exec = ins->context;
 840     else
 841       exec = New_Context( face );
 842     /* debugging instances have their own context */
 843
 844     if ( !exec )
 845       return TT_Err_Could_Not_Find_Context;
 846
 847     ins->GS = Default_GraphicsState;
 848
 849     ins->numFDefs = 0;
 850     ins->numIDefs = 0;
 851     ins->maxFunc  = -1;
 852     ins->maxIns   = -1;
 853
 854     Context_Load( exec, face, ins );
 855
 856     exec->callTop   = 0;
 857     exec->top       = 0;
 858
 859     exec->period    = 64;
 860     exec->phase     = 0;
 861     exec->threshold = 0;
 862
 863     {
 864       PIns_Metrics  metrics = &exec->metrics;
 865
 866
 867       metrics->x_ppem    = 0;
 868       metrics->y_ppem    = 0;
 869       metrics->pointSize = 0;
 870       metrics->x_scale1  = 0;
 871       metrics->x_scale2  = 1;
 872       metrics->y_scale1  = 0;
 873       metrics->y_scale2  = 1;
 874
 875       metrics->ppem      = 0;
 876       metrics->scale1    = 0;
 877       metrics->scale2    = 1;
 878       metrics->ratio     = 1L << 16;
 879     }
 880
 881     exec->instruction_trap = FALSE;
 882
 883     exec->cvtSize = ins->cvtSize;
 884     exec->cvt     = ins->cvt;
 885
 886     exec->F_dot_P = 0x10000;
 887
 888     /* allow font program execution */
 889     Set_CodeRange( exec,
 890                    TT_CodeRange_Font,
 891                    face->fontProgram,
 892                    face->fontPgmSize );
 893
 894     /* disable CVT and glyph programs coderange */
 895     Clear_CodeRange( exec, TT_CodeRange_Cvt );
 896     Clear_CodeRange( exec, TT_CodeRange_Glyph );
 897
 898     if ( face->fontPgmSize > 0 )
 899     {
 900       error = Goto_CodeRange( exec, TT_CodeRange_Font, 0 );
 901       if ( error )
 902         goto Fin;
 903
 904       error = RunIns( exec );
 905     }
 906     else
 907       error = TT_Err_Ok;
 908
 909   Fin:
 910     Context_Save( exec, ins );
 911
 912     if ( !ins->debug )
 913       Done_Context( exec );
 914     /* debugging instances keep their context */
 915
 916     ins->valid = FALSE;
 917
 918     return error;
 919   }
 920
 921
 922 /*******************************************************************
 923  *
 924  *  Function    : Instance_Reset
 925  *
 926  *  Description : Resets an instance to a new pointsize/transform.
 927  *                Executes the cvt program if any is found.
 928  *
 929  *  Input  :  _instance   the instance object to destroy
 930  *
 931  *  Output :  Error code.
 932  *
 933  ******************************************************************/
 934
 935   LOCAL_FUNC
 936   TT_Error  Instance_Reset( PInstance  ins )
 937   {
 938     PExecution_Context  exec;
 939
 940     TT_Error  error;
 941     ULong     i;
 942     UShort    j;
 943     PFace     face;
 944
 945
 946     if ( !ins )
 947       return TT_Err_Invalid_Instance_Handle;
 948
 949     if ( ins->valid )
 950       return TT_Err_Ok;
 951
 952     face = ins->owner;
 953
 954     if ( ins->metrics.x_ppem < 1 ||
 955          ins->metrics.y_ppem < 1 )
 956       return TT_Err_Invalid_PPem;
 957
 958     /* compute new transformation */
 959     if ( ins->metrics.x_ppem >= ins->metrics.y_ppem )
 960     {
 961       ins->metrics.scale1  = ins->metrics.x_scale1;
 962       ins->metrics.scale2  = ins->metrics.x_scale2;
 963       ins->metrics.ppem    = ins->metrics.x_ppem;
 964       ins->metrics.x_ratio = 1L << 16;
 965       ins->metrics.y_ratio = TT_MulDiv( ins->metrics.y_ppem,
 966                                         0x10000,
 967                                         ins->metrics.x_ppem );
 968     }
 969     else
 970     {
 971       ins->metrics.scale1  = ins->metrics.y_scale1;
 972       ins->metrics.scale2  = ins->metrics.y_scale2;
 973       ins->metrics.ppem    = ins->metrics.y_ppem;
 974       ins->metrics.x_ratio = TT_MulDiv( ins->metrics.x_ppem,
 975                                         0x10000,
 976                                         ins->metrics.y_ppem );
 977       ins->metrics.y_ratio = 1L << 16;
 978     }
 979
 980     /* Scale the cvt values to the new ppem.          */
 981     /* We use by default the y ppem to scale the CVT. */
 982
 983     for ( i = 0; i < ins->cvtSize; i++ )
 984       ins->cvt[i] = TT_MulDiv( face->cvt[i],
 985                                ins->metrics.scale1,
 986                                ins->metrics.scale2 );
 987
 988     /* All twilight points are originally zero */
 989     for ( j = 0; j < ins->twilight.n_points; j++ )
 990     {
 991       ins->twilight.org[j].x = 0;
 992       ins->twilight.org[j].y = 0;
 993       ins->twilight.cur[j].x = 0;
 994       ins->twilight.cur[j].y = 0;
 995     }
 996
 997     /* clear storage area */
 998     for ( i = 0; i < ins->storeSize; i++ )
 999       ins->storage[i] = 0;
1000
1001     ins->GS = Default_GraphicsState;
1002
1003     /* get execution context and run prep program */
1004
1005     if ( ins->debug )
1006       exec = ins->context;
1007     else
1008       exec = New_Context(face);
1009     /* debugging instances have their own context */
1010
1011     if ( !exec )
1012       return TT_Err_Could_Not_Find_Context;
1013
1014     Context_Load( exec, face, ins );
1015
1016     Set_CodeRange( exec,
1017                    TT_CodeRange_Cvt,
1018                    face->cvtProgram,
1019                    face->cvtPgmSize );
1020
1021     Clear_CodeRange( exec, TT_CodeRange_Glyph );
1022
1023     exec->instruction_trap = FALSE;
1024
1025     exec->top     = 0;
1026     exec->callTop = 0;
1027
1028     if ( face->cvtPgmSize > 0 )
1029     {
1030       error = Goto_CodeRange( exec, TT_CodeRange_Cvt, 0 );
1031       if ( error )
1032         goto Fin;
1033
1034       if ( !ins->debug )
1035         error = RunIns( exec );
1036     }
1037     else
1038       error = TT_Err_Ok;
1039
1040     ins->GS = exec->GS;
1041     /* save default graphics state */
1042
1043   Fin:
1044     Context_Save( exec, ins );
1045
1046     if ( !ins->debug )
1047       Done_Context( exec );
1048     /* debugging instances keep their context */
1049
1050     if ( !error )
1051       ins->valid = TRUE;
1052
1053     return error;
1054   }
1055
1056
1057
1058 /*******************************************************************
1059  *                                                                 *
1060  *                         FACE  FUNCTIONS                         *
1061  *                                                                 *
1062  *                                                                 *
1063  *******************************************************************/
1064
1065 /*******************************************************************
1066  *
1067  *  Function    :  Face_Destroy
1068  *
1069  *  Description :  The face object destructor.
1070  *
1071  *  Input  :  _face   typeless pointer to the face object to destroy
1072  *
1073  *  Output :  Error code.
1074  *
1075  ******************************************************************/
1076
1077   LOCAL_FUNC
1078   TT_Error  Face_Destroy( void*  _face )
1079   {
1080     PFace   face = (PFace)_face;
1081     UShort  n;
1082
1083
1084     if ( !face )
1085       return TT_Err_Ok;
1086
1087     /* well, we assume that no other thread is using the face */
1088     /* at this moment, but one is never sure enough.          */
1089     MUTEX_Lock( face->lock );
1090
1091     /* first of all, destroys the cached sub-objects */
1092     Cache_Destroy( &face->instances );
1093     Cache_Destroy( &face->glyphs );
1094
1095     /* destroy the extensions */
1096 #ifdef TT_CONFIG_OPTION_EXTEND_ENGINE
1097     Extension_Destroy( face );
1098 #endif
1099
1100     /* freeing the collection table */
1101     FREE( face->ttcHeader.TableDirectory );
1102     face->ttcHeader.DirCount = 0;
1103
1104     /* freeing table directory */
1105     FREE( face->dirTables );
1106     face->numTables = 0;
1107
1108     /* freeing the locations table */
1109     FREE( face->glyphLocations );
1110     face->numLocations = 0;
1111
1112     /* freeing the character mapping tables */
1113     for ( n = 0; n < face->numCMaps; n++ )
1114       CharMap_Free( face->cMaps + n );
1115
1116     FREE( face->cMaps );
1117     face->numCMaps = 0;
1118
1119     /* freeing the CVT */
1120     FREE( face->cvt );
1121     face->cvtSize = 0;
1122
1123     /* freeing the horizontal metrics */
1124     FREE( face->horizontalHeader.long_metrics );
1125     FREE( face->horizontalHeader.short_metrics );
1126
1127     /* freeing the vertical ones, if any */
1128     if (face->verticalInfo)
1129     {
1130       FREE( face->verticalHeader.long_metrics  );
1131       FREE( face->verticalHeader.short_metrics );
1132       face->verticalInfo = 0;
1133     }
1134
1135     /* freeing the programs */
1136     FREE( face->fontProgram );
1137     FREE( face->cvtProgram );
1138     face->fontPgmSize = 0;
1139     face->cvtPgmSize  = 0;
1140
1141     /* freeing the gasp table */
1142     FREE( face->gasp.gaspRanges );
1143     face->gasp.numRanges = 0;
1144
1145     /* freeing the name table */
1146     Free_TrueType_Names( face );
1147
1148     /* freeing the hdmx table */
1149     Free_TrueType_Hdmx( face );
1150
1151     /* TT_Close_Stream( &face->stream ); -- this is performed by the API */
1152
1153     /* destroy the mutex */
1154     MUTEX_Destroy(face->lock);
1155
1156     return TT_Err_Ok;
1157   }
1158
1159
1160 /*******************************************************************
1161  *
1162  *  Function    :  Face_Create
1163  *
1164  *  Description :  The face object constructor.
1165  *
1166  *  Input  :  _face    face record to build
1167  *            _input   input stream where to load font data
1168  *
1169  *  Output :  Error code.
1170  *
1171  *  NOTE : The input stream is kept in the face object.  The
1172  *         caller shouldn't destroy it after calling Face_Create().
1173  *
1174  ******************************************************************/
1175
1176 #undef  LOAD_
1177 #define LOAD_( table ) \
1178           (error = Load_TrueType_##table (face)) != TT_Err_Ok
1179
1180
1181   LOCAL_FUNC
1182   TT_Error  Face_Create( void*  _face,
1183                          void*  _input )
1184   {
1185     PEngine_Instance  engine;
1186
1187     TFont_Input*  input = (TFont_Input*)_input;
1188     PFace         face  = (PFace)_face;
1189     TT_Error      error;
1190
1191
1192     face->stream = input->stream;
1193     face->engine = input->engine;
1194
1195     engine = face->engine;
1196
1197     MUTEX_Create( face->lock );
1198
1199     Cache_Create( engine,
1200                   engine->objs_instance_class,
1201                   &face->instances,
1202                   &face->lock );
1203
1204     Cache_Create( engine,
1205                   engine->objs_glyph_class,
1206                   &face->glyphs,
1207                   &face->lock );
1208
1209     /* Load collection directory if present, then font directory */
1210
1211     error = Load_TrueType_Directory( face, input->fontIndex );
1212     if ( error )
1213       goto Fail;
1214
1215     /* Load tables */
1216
1217     if ( LOAD_( Header )        ||
1218          LOAD_( MaxProfile )    ||
1219          LOAD_( Locations )     ||
1220
1221          (error = Load_TrueType_Metrics_Header( face, 0 )) != TT_Err_Ok  ||
1222          /* load the 'hhea' & 'hmtx' tables at once */
1223
1224          LOAD_( CMap )          ||
1225          LOAD_( CVT )           ||
1226          LOAD_( Programs )      ||
1227          LOAD_( Gasp )          ||
1228          LOAD_( Names )         ||
1229          LOAD_( OS2 )           ||
1230          LOAD_( PostScript )    ||
1231
1232          (error = Load_TrueType_Metrics_Header( face, 1 )) != TT_Err_Ok ||
1233          /* try to load the 'vhea' & 'vmtx' at once if present */
1234
1235          LOAD_( Hdmx )          )
1236
1237       goto Fail;
1238
1239 #ifdef TT_CONFIG_OPTION_EXTEND_ENGINE
1240     if ( ( error = Extension_Create( face ) ) != TT_Err_Ok )
1241       return error;
1242 #endif
1243
1244     return TT_Err_Ok;
1245
1246   Fail :
1247     Face_Destroy( face );
1248     return error;
1249   }
1250
1251 #undef LOAD_
1252
1253
1254 /*******************************************************************
1255  *
1256  *  Function    :  Glyph_Destroy
1257  *
1258  *  Description :  The glyph object destructor.
1259  *
1260  *  Input  :  _glyph  typeless pointer to the glyph record to destroy
1261  *
1262  *  Output :  Error code.
1263  *
1264  ******************************************************************/
1265
1266   LOCAL_FUNC
1267   TT_Error  Glyph_Destroy( void*  _glyph )
1268   {
1269     PGlyph  glyph = (PGlyph)_glyph;
1270
1271
1272     if ( !glyph )
1273       return TT_Err_Ok;
1274
1275     glyph->outline.owner = TRUE;
1276     return TT_Done_Outline( &glyph->outline );
1277   }
1278
1279
1280 /*******************************************************************
1281  *
1282  *  Function    :  Glyph_Create
1283  *
1284  *  Description :  The glyph object constructor.
1285  *
1286  *  Input  :  _glyph   glyph record to build.
1287  *            _face    the glyph's parent face.
1288  *
1289  *  Output :  Error code.
1290  *
1291  ******************************************************************/
1292
1293   LOCAL_FUNC
1294   TT_Error  Glyph_Create( void*  _glyph,
1295                           void*  _face )
1296   {
1297     PFace     face  = (PFace)_face;
1298     PGlyph    glyph = (PGlyph)_glyph;
1299
1300
1301     if ( !face )
1302       return TT_Err_Invalid_Face_Handle;
1303
1304     if ( !glyph )
1305       return TT_Err_Invalid_Glyph_Handle;
1306
1307     glyph->face = face;
1308
1309     /* XXX: Don't forget the space for the 2 phantom points */
1310     return TT_New_Outline( glyph->face->maxPoints + 2,
1311                            glyph->face->maxContours,
1312                            &glyph->outline );
1313   }
1314
1315
1316 /*******************************************************************
1317  *
1318  *  Function    :  Scale_X
1319  *
1320  *  Description :  scale an horizontal distance from font
1321  *                 units to 26.6 pixels
1322  *
1323  *  Input  :  metrics  pointer to metrics
1324  *            x        value to scale
1325  *
1326  *  Output :  scaled value
1327  *
1328  ******************************************************************/
1329
1330   LOCAL_FUNC
1331   TT_Pos  Scale_X( PIns_Metrics  metrics, TT_Pos  x )
1332   {
1333     return TT_MulDiv( x, metrics->x_scale1, metrics->x_scale2 );
1334   }
1335
1336
1337 /*******************************************************************
1338  *
1339  *  Function    :  Scale_Y
1340  *
1341  *  Description :  scale a vertical distance from font
1342  *                 units to 26.6 pixels
1343  *
1344  *  Input  :  metrics  pointer to metrics
1345  *            y        value to scale
1346  *
1347  *  Output :  scaled value
1348  *
1349  ******************************************************************/
1350
1351   LOCAL_FUNC
1352   TT_Pos  Scale_Y( PIns_Metrics  metrics, TT_Pos  y )
1353   {
1354     return TT_MulDiv( y, metrics->y_scale1, metrics->y_scale2 );
1355   }
1356
1357
1358 /*******************************************************************
1359  *
1360  *  Function    :  TTObjs_Init
1361  *
1362  *  Description :  The TTObjs component initializer.  Creates the
1363  *                 object cache classes, as well as the face record
1364  *                 cache.
1365  *
1366  *  Input  :  engine    engine instance
1367  *
1368  *  Output :  Error code.
1369  *
1370  ******************************************************************/
1371
1372   static
1373   const TCache_Class  objs_face_class =
1374   {
1375     sizeof ( TFace ),
1376     -1,
1377     Face_Create,
1378     Face_Destroy,
1379     NULL,
1380     NULL
1381   };
1382
1383   static
1384   const TCache_Class  objs_instance_class =
1385   {
1386     sizeof ( TInstance ),
1387     -1,
1388     Instance_Create,
1389     Instance_Destroy,
1390     NULL,
1391     NULL
1392   };
1393
1394   /* Note that we use a cache size of 1 for the execution context.  */
1395   /* This is to avoid re-creating a new context each time we        */
1396   /* change one instance's attribute (resolution and/or char sizes) */
1397   /* or when we load a glyph.                                       */
1398
1399   static
1400   const TCache_Class  objs_exec_class =
1401   {
1402     sizeof ( TExecution_Context ),
1403     1,
1404     Context_Create,
1405     Context_Destroy,
1406     NULL,
1407     NULL
1408   };
1409
1410   static
1411   const TCache_Class  objs_glyph_class =
1412   {
1413     sizeof ( TGlyph ),
1414     -1,
1415     Glyph_Create,
1416     Glyph_Destroy,
1417     NULL,
1418     NULL
1419   };
1420
1421
1422   LOCAL_FUNC
1423   TT_Error  TTObjs_Init( PEngine_Instance  engine )
1424   {
1425     PCache        face_cache, exec_cache;
1426     TT_Error      error;
1427
1428
1429     face_cache = 0;
1430     exec_cache = 0;
1431
1432     if ( ALLOC( face_cache, sizeof ( TCache ) ) ||
1433          ALLOC( exec_cache, sizeof ( TCache ) ) )
1434       goto Fail;
1435
1436       /* create face cache */
1437     error = Cache_Create( engine, (PCache_Class)&objs_face_class,
1438                           face_cache, &engine->lock );
1439     if ( error )
1440       goto Fail;
1441
1442     engine->objs_face_cache = face_cache;
1443
1444     error = Cache_Create( engine, (PCache_Class)&objs_exec_class,
1445                           exec_cache, &engine->lock );
1446     if ( error )
1447       goto Fail;
1448
1449     engine->objs_exec_cache = exec_cache;
1450
1451     engine->objs_face_class      = (PCache_Class)&objs_face_class;
1452     engine->objs_instance_class  = (PCache_Class)&objs_instance_class;
1453     engine->objs_execution_class = (PCache_Class)&objs_exec_class;
1454     engine->objs_glyph_class     = (PCache_Class)&objs_glyph_class;
1455
1456     goto Exit;
1457
1458   Fail:
1459     FREE( face_cache );
1460     FREE( exec_cache );
1461
1462   Exit:
1463     return error;
1464   }
1465
1466
1467 /*******************************************************************
1468  *
1469  *  Function    :  TTObjs_Done
1470  *
1471  *  Description :  The TTObjs component finalizer.
1472  *
1473  *  Input  :  engine    engine instance
1474  *
1475  *  Output :  Error code.
1476  *
1477  ******************************************************************/
1478
1479   LOCAL_FUNC
1480   TT_Error  TTObjs_Done( PEngine_Instance  engine )
1481   {
1482     /* destroy all active faces and contexts before releasing the */
1483     /* caches                                                     */
1484     Cache_Destroy( (TCache*)engine->objs_exec_cache );
1485     Cache_Destroy( (TCache*)engine->objs_face_cache );
1486
1487     /* Now frees caches and cache classes */
1488     FREE( engine->objs_exec_cache );
1489     FREE( engine->objs_face_cache );
1490
1491     return TT_Err_Ok;
1492   }
1493
1494
1495 /* END */