1/***************************************************************************/ 2/* */ 3/* ftobjs.c */ 4/* */ 5/* The FreeType private base classes (body). */ 6/* */ 7/* Copyright 1996-2018 by */ 8/* David Turner, Robert Wilhelm, and Werner Lemberg. */ 9/* */ 10/* This file is part of the FreeType project, and may only be used, */ 11/* modified, and distributed under the terms of the FreeType project */ 12/* license, LICENSE.TXT. By continuing to use, modify, or distribute */ 13/* this file you indicate that you have read the license and */ 14/* understand and accept it fully. */ 15/* */ 16/***************************************************************************/ 17 18 19#include <ft2build.h> 20#include FT_LIST_H 21#include FT_OUTLINE_H 22#include FT_FONT_FORMATS_H 23 24#include FT_INTERNAL_VALIDATE_H 25#include FT_INTERNAL_OBJECTS_H 26#include FT_INTERNAL_DEBUG_H 27#include FT_INTERNAL_RFORK_H 28#include FT_INTERNAL_STREAM_H 29#include FT_INTERNAL_SFNT_H /* for SFNT_Load_Table_Func */ 30#include FT_INTERNAL_POSTSCRIPT_AUX_H /* for PS_Driver */ 31 32#include FT_TRUETYPE_TABLES_H 33#include FT_TRUETYPE_TAGS_H 34#include FT_TRUETYPE_IDS_H 35 36#include FT_SERVICE_PROPERTIES_H 37#include FT_SERVICE_SFNT_H 38#include FT_SERVICE_POSTSCRIPT_NAME_H 39#include FT_SERVICE_GLYPH_DICT_H 40#include FT_SERVICE_TT_CMAP_H 41#include FT_SERVICE_KERNING_H 42#include FT_SERVICE_TRUETYPE_ENGINE_H 43 44#include FT_DRIVER_H 45 46#ifdef FT_CONFIG_OPTION_MAC_FONTS 47#include "ftbase.h" 48#endif 49 50 51#ifdef FT_DEBUG_LEVEL_TRACE 52 53#include FT_BITMAP_H 54 55#if defined( _MSC_VER ) /* Visual C++ (and Intel C++) */ 56 /* We disable the warning `conversion from XXX to YYY, */ 57 /* possible loss of data' in order to compile cleanly with */ 58 /* the maximum level of warnings: `md5.c' is non-FreeType */ 59 /* code, and it gets used during development builds only. */ 60#pragma warning( push ) 61#pragma warning( disable : 4244 ) 62#endif /* _MSC_VER */ 63 64 /* It's easiest to include `md5.c' directly. However, since OpenSSL */ 65 /* also provides the same functions, there might be conflicts if */ 66 /* both FreeType and OpenSSL are built as static libraries. For */ 67 /* this reason, we put the MD5 stuff into the `FT_' namespace. */ 68#define MD5_u32plus FT_MD5_u32plus 69#define MD5_CTX FT_MD5_CTX 70#define MD5_Init FT_MD5_Init 71#define MD5_Update FT_MD5_Update 72#define MD5_Final FT_MD5_Final 73 74#undef HAVE_OPENSSL 75 76#include "md5.c" 77 78#if defined( _MSC_VER ) 79#pragma warning( pop ) 80#endif 81 82#endif /* FT_DEBUG_LEVEL_TRACE */ 83 84 85#define GRID_FIT_METRICS 86 87 88 /* forward declaration */ 89 static FT_Error 90 ft_open_face_internal( FT_Library library, 91 const FT_Open_Args* args, 92 FT_Long face_index, 93 FT_Face *aface, 94 FT_Bool test_mac_fonts ); 95 96 97 FT_BASE_DEF( FT_Pointer ) 98 ft_service_list_lookup( FT_ServiceDesc service_descriptors, 99 const char* service_id ) 100 { 101 FT_Pointer result = NULL; 102 FT_ServiceDesc desc = service_descriptors; 103 104 105 if ( desc && service_id ) 106 { 107 for ( ; desc->serv_id != NULL; desc++ ) 108 { 109 if ( ft_strcmp( desc->serv_id, service_id ) == 0 ) 110 { 111 result = (FT_Pointer)desc->serv_data; 112 break; 113 } 114 } 115 } 116 117 return result; 118 } 119 120 121 FT_BASE_DEF( void ) 122 ft_validator_init( FT_Validator valid, 123 const FT_Byte* base, 124 const FT_Byte* limit, 125 FT_ValidationLevel level ) 126 { 127 valid->base = base; 128 valid->limit = limit; 129 valid->level = level; 130 valid->error = FT_Err_Ok; 131 } 132 133 134 FT_BASE_DEF( FT_Int ) 135 ft_validator_run( FT_Validator valid ) 136 { 137 /* This function doesn't work! None should call it. */ 138 FT_UNUSED( valid ); 139 140 return -1; 141 } 142 143 144 FT_BASE_DEF( void ) 145 ft_validator_error( FT_Validator valid, 146 FT_Error error ) 147 { 148 /* since the cast below also disables the compiler's */ 149 /* type check, we introduce a dummy variable, which */ 150 /* will be optimized away */ 151 volatile ft_jmp_buf* jump_buffer = &valid->jump_buffer; 152 153 154 valid->error = error; 155 156 /* throw away volatileness; use `jump_buffer' or the */ 157 /* compiler may warn about an unused local variable */ 158 ft_longjmp( *(ft_jmp_buf*) jump_buffer, 1 ); 159 } 160 161 162 /*************************************************************************/ 163 /*************************************************************************/ 164 /*************************************************************************/ 165 /**** ****/ 166 /**** ****/ 167 /**** S T R E A M ****/ 168 /**** ****/ 169 /**** ****/ 170 /*************************************************************************/ 171 /*************************************************************************/ 172 /*************************************************************************/ 173 174 175 /* create a new input stream from an FT_Open_Args structure */ 176 /* */ 177 FT_BASE_DEF( FT_Error ) 178 FT_Stream_New( FT_Library library, 179 const FT_Open_Args* args, 180 FT_Stream *astream ) 181 { 182 FT_Error error; 183 FT_Memory memory; 184 FT_Stream stream = NULL; 185 186 187 *astream = NULL; 188 189 if ( !library ) 190 return FT_THROW( Invalid_Library_Handle ); 191 192 if ( !args ) 193 return FT_THROW( Invalid_Argument ); 194 195 memory = library->memory; 196 197 if ( FT_NEW( stream ) ) 198 goto Exit; 199 200 stream->memory = memory; 201 202 if ( args->flags & FT_OPEN_MEMORY ) 203 { 204 /* create a memory-based stream */ 205 FT_Stream_OpenMemory( stream, 206 (const FT_Byte*)args->memory_base, 207 (FT_ULong)args->memory_size ); 208 } 209 210#ifndef FT_CONFIG_OPTION_DISABLE_STREAM_SUPPORT 211 212 else if ( args->flags & FT_OPEN_PATHNAME ) 213 { 214 /* create a normal system stream */ 215 error = FT_Stream_Open( stream, args->pathname ); 216 stream->pathname.pointer = args->pathname; 217 } 218 else if ( ( args->flags & FT_OPEN_STREAM ) && args->stream ) 219 { 220 /* use an existing, user-provided stream */ 221 222 /* in this case, we do not need to allocate a new stream object */ 223 /* since the caller is responsible for closing it himself */ 224 FT_FREE( stream ); 225 stream = args->stream; 226 } 227 228#endif 229 230 else 231 error = FT_THROW( Invalid_Argument ); 232 233 if ( error ) 234 FT_FREE( stream ); 235 else 236 stream->memory = memory; /* just to be certain */ 237 238 *astream = stream; 239 240 Exit: 241 return error; 242 } 243 244 245 FT_BASE_DEF( void ) 246 FT_Stream_Free( FT_Stream stream, 247 FT_Int external ) 248 { 249 if ( stream ) 250 { 251 FT_Memory memory = stream->memory; 252 253 254 FT_Stream_Close( stream ); 255 256 if ( !external ) 257 FT_FREE( stream ); 258 } 259 } 260 261 262 /*************************************************************************/ 263 /* */ 264 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */ 265 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */ 266 /* messages during execution. */ 267 /* */ 268#undef FT_COMPONENT 269#define FT_COMPONENT trace_objs 270 271 272 /*************************************************************************/ 273 /*************************************************************************/ 274 /*************************************************************************/ 275 /**** ****/ 276 /**** ****/ 277 /**** FACE, SIZE & GLYPH SLOT OBJECTS ****/ 278 /**** ****/ 279 /**** ****/ 280 /*************************************************************************/ 281 /*************************************************************************/ 282 /*************************************************************************/ 283 284 285 static FT_Error 286 ft_glyphslot_init( FT_GlyphSlot slot ) 287 { 288 FT_Driver driver = slot->face->driver; 289 FT_Driver_Class clazz = driver->clazz; 290 FT_Memory memory = driver->root.memory; 291 FT_Error error = FT_Err_Ok; 292 FT_Slot_Internal internal = NULL; 293 294 295 slot->library = driver->root.library; 296 297 if ( FT_NEW( internal ) ) 298 goto Exit; 299 300 slot->internal = internal; 301 302 if ( FT_DRIVER_USES_OUTLINES( driver ) ) 303 error = FT_GlyphLoader_New( memory, &internal->loader ); 304 305 if ( !error && clazz->init_slot ) 306 error = clazz->init_slot( slot ); 307 308 Exit: 309 return error; 310 } 311 312 313 FT_BASE_DEF( void ) 314 ft_glyphslot_free_bitmap( FT_GlyphSlot slot ) 315 { 316 if ( slot->internal && ( slot->internal->flags & FT_GLYPH_OWN_BITMAP ) ) 317 { 318 FT_Memory memory = FT_FACE_MEMORY( slot->face ); 319 320 321 FT_FREE( slot->bitmap.buffer ); 322 slot->internal->flags &= ~FT_GLYPH_OWN_BITMAP; 323 } 324 else 325 { 326 /* assume that the bitmap buffer was stolen or not */ 327 /* allocated from the heap */ 328 slot->bitmap.buffer = NULL; 329 } 330 } 331 332 333 FT_BASE_DEF( void ) 334 ft_glyphslot_preset_bitmap( FT_GlyphSlot slot, 335 FT_Render_Mode mode, 336 const FT_Vector* origin ) 337 { 338 FT_Outline* outline = &slot->outline; 339 FT_Bitmap* bitmap = &slot->bitmap; 340 341 FT_Pixel_Mode pixel_mode; 342 343 FT_BBox cbox; 344 FT_Pos x_shift = 0; 345 FT_Pos y_shift = 0; 346 FT_Pos x_left, y_top; 347 FT_Pos width, height, pitch; 348 349 350 if ( slot->internal && ( slot->internal->flags & FT_GLYPH_OWN_BITMAP ) ) 351 return; 352 353 if ( origin ) 354 { 355 x_shift = origin->x; 356 y_shift = origin->y; 357 } 358 359 /* compute the control box, and grid-fit it, */ 360 /* taking into account the origin shift */ 361 FT_Outline_Get_CBox( outline, &cbox ); 362 363 cbox.xMin += x_shift; 364 cbox.yMin += y_shift; 365 cbox.xMax += x_shift; 366 cbox.yMax += y_shift; 367 368 switch ( mode ) 369 { 370 case FT_RENDER_MODE_MONO: 371 pixel_mode = FT_PIXEL_MODE_MONO; 372#if 1 373 /* undocumented but confirmed: bbox values get rounded */ 374 /* unless the rounded box can collapse for a narrow glyph */ 375 if ( cbox.xMax - cbox.xMin < 64 ) 376 { 377 cbox.xMin = FT_PIX_FLOOR( cbox.xMin ); 378 cbox.xMax = FT_PIX_CEIL_LONG( cbox.xMax ); 379 } 380 else 381 { 382 cbox.xMin = FT_PIX_ROUND_LONG( cbox.xMin ); 383 cbox.xMax = FT_PIX_ROUND_LONG( cbox.xMax ); 384 } 385 386 if ( cbox.yMax - cbox.yMin < 64 ) 387 { 388 cbox.yMin = FT_PIX_FLOOR( cbox.yMin ); 389 cbox.yMax = FT_PIX_CEIL_LONG( cbox.yMax ); 390 } 391 else 392 { 393 cbox.yMin = FT_PIX_ROUND_LONG( cbox.yMin ); 394 cbox.yMax = FT_PIX_ROUND_LONG( cbox.yMax ); 395 } 396#else 397 cbox.xMin = FT_PIX_FLOOR( cbox.xMin ); 398 cbox.yMin = FT_PIX_FLOOR( cbox.yMin ); 399 cbox.xMax = FT_PIX_CEIL_LONG( cbox.xMax ); 400 cbox.yMax = FT_PIX_CEIL_LONG( cbox.yMax ); 401#endif 402 break; 403 404 case FT_RENDER_MODE_LCD: 405 pixel_mode = FT_PIXEL_MODE_LCD; 406 ft_lcd_padding( &cbox.xMin, &cbox.xMax, slot ); 407 goto Round; 408 409 case FT_RENDER_MODE_LCD_V: 410 pixel_mode = FT_PIXEL_MODE_LCD_V; 411 ft_lcd_padding( &cbox.yMin, &cbox.yMax, slot ); 412 goto Round; 413 414 case FT_RENDER_MODE_NORMAL: 415 case FT_RENDER_MODE_LIGHT: 416 default: 417 pixel_mode = FT_PIXEL_MODE_GRAY; 418 Round: 419 cbox.xMin = FT_PIX_FLOOR( cbox.xMin ); 420 cbox.yMin = FT_PIX_FLOOR( cbox.yMin ); 421 cbox.xMax = FT_PIX_CEIL_LONG( cbox.xMax ); 422 cbox.yMax = FT_PIX_CEIL_LONG( cbox.yMax ); 423 } 424 425 x_shift = SUB_LONG( x_shift, cbox.xMin ); 426 y_shift = SUB_LONG( y_shift, cbox.yMin ); 427 428 x_left = cbox.xMin >> 6; 429 y_top = cbox.yMax >> 6; 430 431 width = ( (FT_ULong)cbox.xMax - (FT_ULong)cbox.xMin ) >> 6; 432 height = ( (FT_ULong)cbox.yMax - (FT_ULong)cbox.yMin ) >> 6; 433 434 switch ( pixel_mode ) 435 { 436 case FT_PIXEL_MODE_MONO: 437 pitch = ( ( width + 15 ) >> 4 ) << 1; 438 break; 439 440 case FT_PIXEL_MODE_LCD: 441 width *= 3; 442 pitch = FT_PAD_CEIL( width, 4 ); 443 break; 444 445 case FT_PIXEL_MODE_LCD_V: 446 height *= 3; 447 /* fall through */ 448 449 case FT_PIXEL_MODE_GRAY: 450 default: 451 pitch = width; 452 } 453 454 slot->bitmap_left = (FT_Int)x_left; 455 slot->bitmap_top = (FT_Int)y_top; 456 457 bitmap->pixel_mode = (unsigned char)pixel_mode; 458 bitmap->num_grays = 256; 459 bitmap->width = (unsigned int)width; 460 bitmap->rows = (unsigned int)height; 461 bitmap->pitch = pitch; 462 } 463 464 465 FT_BASE_DEF( void ) 466 ft_glyphslot_set_bitmap( FT_GlyphSlot slot, 467 FT_Byte* buffer ) 468 { 469 ft_glyphslot_free_bitmap( slot ); 470 471 slot->bitmap.buffer = buffer; 472 473 FT_ASSERT( (slot->internal->flags & FT_GLYPH_OWN_BITMAP) == 0 ); 474 } 475 476 477 FT_BASE_DEF( FT_Error ) 478 ft_glyphslot_alloc_bitmap( FT_GlyphSlot slot, 479 FT_ULong size ) 480 { 481 FT_Memory memory = FT_FACE_MEMORY( slot->face ); 482 FT_Error error; 483 484 485 if ( slot->internal->flags & FT_GLYPH_OWN_BITMAP ) 486 FT_FREE( slot->bitmap.buffer ); 487 else 488 slot->internal->flags |= FT_GLYPH_OWN_BITMAP; 489 490 (void)FT_ALLOC( slot->bitmap.buffer, size ); 491 return error; 492 } 493 494 495 static void 496 ft_glyphslot_clear( FT_GlyphSlot slot ) 497 { 498 /* free bitmap if needed */ 499 ft_glyphslot_free_bitmap( slot ); 500 501 /* clear all public fields in the glyph slot */ 502 FT_ZERO( &slot->metrics ); 503 FT_ZERO( &slot->outline ); 504 505 slot->bitmap.width = 0; 506 slot->bitmap.rows = 0; 507 slot->bitmap.pitch = 0; 508 slot->bitmap.pixel_mode = 0; 509 /* `slot->bitmap.buffer' has been handled by ft_glyphslot_free_bitmap */ 510 511 slot->bitmap_left = 0; 512 slot->bitmap_top = 0; 513 slot->num_subglyphs = 0; 514 slot->subglyphs = NULL; 515 slot->control_data = NULL; 516 slot->control_len = 0; 517 slot->other = NULL; 518 slot->format = FT_GLYPH_FORMAT_NONE; 519 520 slot->linearHoriAdvance = 0; 521 slot->linearVertAdvance = 0; 522 slot->lsb_delta = 0; 523 slot->rsb_delta = 0; 524 } 525 526 527 static void 528 ft_glyphslot_done( FT_GlyphSlot slot ) 529 { 530 FT_Driver driver = slot->face->driver; 531 FT_Driver_Class clazz = driver->clazz; 532 FT_Memory memory = driver->root.memory; 533 534 535 if ( clazz->done_slot ) 536 clazz->done_slot( slot ); 537 538 /* free bitmap buffer if needed */ 539 ft_glyphslot_free_bitmap( slot ); 540 541 /* slot->internal might be NULL in out-of-memory situations */ 542 if ( slot->internal ) 543 { 544 /* free glyph loader */ 545 if ( FT_DRIVER_USES_OUTLINES( driver ) ) 546 { 547 FT_GlyphLoader_Done( slot->internal->loader ); 548 slot->internal->loader = NULL; 549 } 550 551 FT_FREE( slot->internal ); 552 } 553 } 554 555 556 /* documentation is in ftobjs.h */ 557 558 FT_BASE_DEF( FT_Error ) 559 FT_New_GlyphSlot( FT_Face face, 560 FT_GlyphSlot *aslot ) 561 { 562 FT_Error error; 563 FT_Driver driver; 564 FT_Driver_Class clazz; 565 FT_Memory memory; 566 FT_GlyphSlot slot = NULL; 567 568 569 if ( !face ) 570 return FT_THROW( Invalid_Face_Handle ); 571 572 if ( !face->driver ) 573 return FT_THROW( Invalid_Argument ); 574 575 driver = face->driver; 576 clazz = driver->clazz; 577 memory = driver->root.memory; 578 579 FT_TRACE4(( "FT_New_GlyphSlot: Creating new slot object\n" )); 580 if ( !FT_ALLOC( slot, clazz->slot_object_size ) ) 581 { 582 slot->face = face; 583 584 error = ft_glyphslot_init( slot ); 585 if ( error ) 586 { 587 ft_glyphslot_done( slot ); 588 FT_FREE( slot ); 589 goto Exit; 590 } 591 592 slot->next = face->glyph; 593 face->glyph = slot; 594 595 if ( aslot ) 596 *aslot = slot; 597 } 598 else if ( aslot ) 599 *aslot = NULL; 600 601 602 Exit: 603 FT_TRACE4(( "FT_New_GlyphSlot: Return 0x%x\n", error )); 604 605 return error; 606 } 607 608 609 /* documentation is in ftobjs.h */ 610 611 FT_BASE_DEF( void ) 612 FT_Done_GlyphSlot( FT_GlyphSlot slot ) 613 { 614 if ( slot ) 615 { 616 FT_Driver driver = slot->face->driver; 617 FT_Memory memory = driver->root.memory; 618 FT_GlyphSlot prev; 619 FT_GlyphSlot cur; 620 621 622 /* Remove slot from its parent face's list */ 623 prev = NULL; 624 cur = slot->face->glyph; 625 626 while ( cur ) 627 { 628 if ( cur == slot ) 629 { 630 if ( !prev ) 631 slot->face->glyph = cur->next; 632 else 633 prev->next = cur->next; 634 635 /* finalize client-specific data */ 636 if ( slot->generic.finalizer ) 637 slot->generic.finalizer( slot ); 638 639 ft_glyphslot_done( slot ); 640 FT_FREE( slot ); 641 break; 642 } 643 prev = cur; 644 cur = cur->next; 645 } 646 } 647 } 648 649 650 /* documentation is in freetype.h */ 651 652 FT_EXPORT_DEF( void ) 653 FT_Set_Transform( FT_Face face, 654 FT_Matrix* matrix, 655 FT_Vector* delta ) 656 { 657 FT_Face_Internal internal; 658 659 660 if ( !face ) 661 return; 662 663 internal = face->internal; 664 665 internal->transform_flags = 0; 666 667 if ( !matrix ) 668 { 669 internal->transform_matrix.xx = 0x10000L; 670 internal->transform_matrix.xy = 0; 671 internal->transform_matrix.yx = 0; 672 internal->transform_matrix.yy = 0x10000L; 673 674 matrix = &internal->transform_matrix; 675 } 676 else 677 internal->transform_matrix = *matrix; 678 679 /* set transform_flags bit flag 0 if `matrix' isn't the identity */ 680 if ( ( matrix->xy | matrix->yx ) || 681 matrix->xx != 0x10000L || 682 matrix->yy != 0x10000L ) 683 internal->transform_flags |= 1; 684 685 if ( !delta ) 686 { 687 internal->transform_delta.x = 0; 688 internal->transform_delta.y = 0; 689 690 delta = &internal->transform_delta; 691 } 692 else 693 internal->transform_delta = *delta; 694 695 /* set transform_flags bit flag 1 if `delta' isn't the null vector */ 696 if ( delta->x | delta->y ) 697 internal->transform_flags |= 2; 698 } 699 700 701 static FT_Renderer 702 ft_lookup_glyph_renderer( FT_GlyphSlot slot ); 703 704 705#ifdef GRID_FIT_METRICS 706 static void 707 ft_glyphslot_grid_fit_metrics( FT_GlyphSlot slot, 708 FT_Bool vertical ) 709 { 710 FT_Glyph_Metrics* metrics = &slot->metrics; 711 FT_Pos right, bottom; 712 713 714 if ( vertical ) 715 { 716 metrics->horiBearingX = FT_PIX_FLOOR( metrics->horiBearingX ); 717 metrics->horiBearingY = FT_PIX_CEIL_LONG( metrics->horiBearingY ); 718 719 right = FT_PIX_CEIL_LONG( ADD_LONG( metrics->vertBearingX, 720 metrics->width ) ); 721 bottom = FT_PIX_CEIL_LONG( ADD_LONG( metrics->vertBearingY, 722 metrics->height ) ); 723 724 metrics->vertBearingX = FT_PIX_FLOOR( metrics->vertBearingX ); 725 metrics->vertBearingY = FT_PIX_FLOOR( metrics->vertBearingY ); 726 727 metrics->width = SUB_LONG( right, 728 metrics->vertBearingX ); 729 metrics->height = SUB_LONG( bottom, 730 metrics->vertBearingY ); 731 } 732 else 733 { 734 metrics->vertBearingX = FT_PIX_FLOOR( metrics->vertBearingX ); 735 metrics->vertBearingY = FT_PIX_FLOOR( metrics->vertBearingY ); 736 737 right = FT_PIX_CEIL_LONG( ADD_LONG( metrics->horiBearingX, 738 metrics->width ) ); 739 bottom = FT_PIX_FLOOR( SUB_LONG( metrics->horiBearingY, 740 metrics->height ) ); 741 742 metrics->horiBearingX = FT_PIX_FLOOR( metrics->horiBearingX ); 743 metrics->horiBearingY = FT_PIX_CEIL_LONG( metrics->horiBearingY ); 744 745 metrics->width = SUB_LONG( right, 746 metrics->horiBearingX ); 747 metrics->height = SUB_LONG( metrics->horiBearingY, 748 bottom ); 749 } 750 751 metrics->horiAdvance = FT_PIX_ROUND_LONG( metrics->horiAdvance ); 752 metrics->vertAdvance = FT_PIX_ROUND_LONG( metrics->vertAdvance ); 753 } 754#endif /* GRID_FIT_METRICS */ 755 756 757 /* documentation is in freetype.h */ 758 759 FT_EXPORT_DEF( FT_Error ) 760 FT_Load_Glyph( FT_Face face, 761 FT_UInt glyph_index, 762 FT_Int32 load_flags ) 763 { 764 FT_Error error; 765 FT_Driver driver; 766 FT_GlyphSlot slot; 767 FT_Library library; 768 FT_Bool autohint = FALSE; 769 FT_Module hinter; 770 TT_Face ttface = (TT_Face)face; 771 772 773 if ( !face || !face->size || !face->glyph ) 774 return FT_THROW( Invalid_Face_Handle ); 775 776 /* The validity test for `glyph_index' is performed by the */ 777 /* font drivers. */ 778 779 slot = face->glyph; 780 ft_glyphslot_clear( slot ); 781 782 driver = face->driver; 783 library = driver->root.library; 784 hinter = library->auto_hinter; 785 786 /* resolve load flags dependencies */ 787 788 if ( load_flags & FT_LOAD_NO_RECURSE ) 789 load_flags |= FT_LOAD_NO_SCALE | 790 FT_LOAD_IGNORE_TRANSFORM; 791 792 if ( load_flags & FT_LOAD_NO_SCALE ) 793 { 794 load_flags |= FT_LOAD_NO_HINTING | 795 FT_LOAD_NO_BITMAP; 796 797 load_flags &= ~FT_LOAD_RENDER; 798 } 799 800 if ( load_flags & FT_LOAD_BITMAP_METRICS_ONLY ) 801 load_flags &= ~FT_LOAD_RENDER; 802 803 /* 804 * Determine whether we need to auto-hint or not. 805 * The general rules are: 806 * 807 * - Do only auto-hinting if we have 808 * 809 * - a hinter module, 810 * - a scalable font format dealing with outlines, 811 * - not a tricky font, and 812 * - no transforms except simple slants and/or rotations by 813 * integer multiples of 90 degrees. 814 * 815 * - Then, auto-hint if FT_LOAD_FORCE_AUTOHINT is set or if we don't 816 * have a native font hinter. 817 * 818 * - Otherwise, auto-hint for LIGHT hinting mode or if there isn't 819 * any hinting bytecode in the TrueType/OpenType font. 820 * 821 * - Exception: The font is `tricky' and requires the native hinter to 822 * load properly. 823 */ 824 825 if ( hinter && 826 !( load_flags & FT_LOAD_NO_HINTING ) && 827 !( load_flags & FT_LOAD_NO_AUTOHINT ) && 828 FT_DRIVER_IS_SCALABLE( driver ) && 829 FT_DRIVER_USES_OUTLINES( driver ) && 830 !FT_IS_TRICKY( face ) && 831 ( ( load_flags & FT_LOAD_IGNORE_TRANSFORM ) || 832 ( face->internal->transform_matrix.yx == 0 && 833 face->internal->transform_matrix.xx != 0 ) || 834 ( face->internal->transform_matrix.xx == 0 && 835 face->internal->transform_matrix.yx != 0 ) ) ) 836 { 837 if ( ( load_flags & FT_LOAD_FORCE_AUTOHINT ) || 838 !FT_DRIVER_HAS_HINTER( driver ) ) 839 autohint = TRUE; 840 else 841 { 842 FT_Render_Mode mode = FT_LOAD_TARGET_MODE( load_flags ); 843 FT_Bool is_light_type1; 844 845 846 /* only the new Adobe engine (for both CFF and Type 1) is `light'; */ 847 /* we use `strstr' to catch both `Type 1' and `CID Type 1' */ 848 is_light_type1 = 849 ft_strstr( FT_Get_Font_Format( face ), "Type 1" ) != NULL && 850 ((PS_Driver)driver)->hinting_engine == FT_HINTING_ADOBE; 851 852 /* the check for `num_locations' assures that we actually */ 853 /* test for instructions in a TTF and not in a CFF-based OTF */ 854 /* */ 855 /* since `maxSizeOfInstructions' might be unreliable, we */ 856 /* check the size of the `fpgm' and `prep' tables, too -- */ 857 /* the assumption is that there don't exist real TTFs where */ 858 /* both `fpgm' and `prep' tables are missing */ 859 if ( ( mode == FT_RENDER_MODE_LIGHT && 860 ( !FT_DRIVER_HINTS_LIGHTLY( driver ) && 861 !is_light_type1 ) ) || 862 ( FT_IS_SFNT( face ) && 863 ttface->num_locations && 864 ttface->max_profile.maxSizeOfInstructions == 0 && 865 ttface->font_program_size == 0 && 866 ttface->cvt_program_size == 0 ) ) 867 autohint = TRUE; 868 } 869 } 870 871 if ( autohint ) 872 { 873 FT_AutoHinter_Interface hinting; 874 875 876 /* try to load embedded bitmaps first if available */ 877 /* */ 878 /* XXX: This is really a temporary hack that should disappear */ 879 /* promptly with FreeType 2.1! */ 880 /* */ 881 if ( FT_HAS_FIXED_SIZES( face ) && 882 ( load_flags & FT_LOAD_NO_BITMAP ) == 0 ) 883 { 884 error = driver->clazz->load_glyph( slot, face->size, 885 glyph_index, 886 load_flags | FT_LOAD_SBITS_ONLY ); 887 888 if ( !error && slot->format == FT_GLYPH_FORMAT_BITMAP ) 889 goto Load_Ok; 890 } 891 892 { 893 FT_Face_Internal internal = face->internal; 894 FT_Int transform_flags = internal->transform_flags; 895 896 897 /* since the auto-hinter calls FT_Load_Glyph by itself, */ 898 /* make sure that glyphs aren't transformed */ 899 internal->transform_flags = 0; 900 901 /* load auto-hinted outline */ 902 hinting = (FT_AutoHinter_Interface)hinter->clazz->module_interface; 903 904 error = hinting->load_glyph( (FT_AutoHinter)hinter, 905 slot, face->size, 906 glyph_index, load_flags ); 907 908 internal->transform_flags = transform_flags; 909 } 910 } 911 else 912 { 913 error = driver->clazz->load_glyph( slot, 914 face->size, 915 glyph_index, 916 load_flags ); 917 if ( error ) 918 goto Exit; 919 920 if ( slot->format == FT_GLYPH_FORMAT_OUTLINE ) 921 { 922 /* check that the loaded outline is correct */ 923 error = FT_Outline_Check( &slot->outline ); 924 if ( error ) 925 goto Exit; 926 927#ifdef GRID_FIT_METRICS 928 if ( !( load_flags & FT_LOAD_NO_HINTING ) ) 929 ft_glyphslot_grid_fit_metrics( slot, 930 FT_BOOL( load_flags & FT_LOAD_VERTICAL_LAYOUT ) ); 931#endif 932 } 933 } 934 935 Load_Ok: 936 /* compute the advance */ 937 if ( load_flags & FT_LOAD_VERTICAL_LAYOUT ) 938 { 939 slot->advance.x = 0; 940 slot->advance.y = slot->metrics.vertAdvance; 941 } 942 else 943 { 944 slot->advance.x = slot->metrics.horiAdvance; 945 slot->advance.y = 0; 946 } 947 948 /* compute the linear advance in 16.16 pixels */ 949 if ( ( load_flags & FT_LOAD_LINEAR_DESIGN ) == 0 && 950 FT_IS_SCALABLE( face ) ) 951 { 952 FT_Size_Metrics* metrics = &face->size->metrics; 953 954 955 /* it's tricky! */ 956 slot->linearHoriAdvance = FT_MulDiv( slot->linearHoriAdvance, 957 metrics->x_scale, 64 ); 958 959 slot->linearVertAdvance = FT_MulDiv( slot->linearVertAdvance, 960 metrics->y_scale, 64 ); 961 } 962 963 if ( ( load_flags & FT_LOAD_IGNORE_TRANSFORM ) == 0 ) 964 { 965 FT_Face_Internal internal = face->internal; 966 967 968 /* now, transform the glyph image if needed */ 969 if ( internal->transform_flags ) 970 { 971 /* get renderer */ 972 FT_Renderer renderer = ft_lookup_glyph_renderer( slot ); 973 974 975 if ( renderer ) 976 error = renderer->clazz->transform_glyph( 977 renderer, slot, 978 &internal->transform_matrix, 979 &internal->transform_delta ); 980 else if ( slot->format == FT_GLYPH_FORMAT_OUTLINE ) 981 { 982 /* apply `standard' transformation if no renderer is available */ 983 if ( internal->transform_flags & 1 ) 984 FT_Outline_Transform( &slot->outline, 985 &internal->transform_matrix ); 986 987 if ( internal->transform_flags & 2 ) 988 FT_Outline_Translate( &slot->outline, 989 internal->transform_delta.x, 990 internal->transform_delta.y ); 991 } 992 993 /* transform advance */ 994 FT_Vector_Transform( &slot->advance, &internal->transform_matrix ); 995 } 996 } 997 998 /* do we need to render the image or preset the bitmap now? */ 999 if ( !error && 1000 ( load_flags & FT_LOAD_NO_SCALE ) == 0 && 1001 slot->format != FT_GLYPH_FORMAT_BITMAP && 1002 slot->format != FT_GLYPH_FORMAT_COMPOSITE ) 1003 { 1004 FT_Render_Mode mode = FT_LOAD_TARGET_MODE( load_flags ); 1005 1006 1007 if ( mode == FT_RENDER_MODE_NORMAL && 1008 load_flags & FT_LOAD_MONOCHROME ) 1009 mode = FT_RENDER_MODE_MONO; 1010 1011 if ( load_flags & FT_LOAD_RENDER ) 1012 error = FT_Render_Glyph( slot, mode ); 1013 else 1014 ft_glyphslot_preset_bitmap( slot, mode, NULL ); 1015 } 1016 1017 FT_TRACE5(( "FT_Load_Glyph: index %d, flags %x\n", 1018 glyph_index, load_flags )); 1019 FT_TRACE5(( " x advance: %f\n", slot->advance.x / 64.0 )); 1020 FT_TRACE5(( " y advance: %f\n", slot->advance.y / 64.0 )); 1021 FT_TRACE5(( " linear x advance: %f\n", 1022 slot->linearHoriAdvance / 65536.0 )); 1023 FT_TRACE5(( " linear y advance: %f\n", 1024 slot->linearVertAdvance / 65536.0 )); 1025 FT_TRACE5(( " bitmap %dx%d, mode %d\n", 1026 slot->bitmap.width, slot->bitmap.rows, 1027 slot->bitmap.pixel_mode )); 1028 1029 Exit: 1030 return error; 1031 } 1032 1033 1034 /* documentation is in freetype.h */ 1035 1036 FT_EXPORT_DEF( FT_Error ) 1037 FT_Load_Char( FT_Face face, 1038 FT_ULong char_code, 1039 FT_Int32 load_flags ) 1040 { 1041 FT_UInt glyph_index; 1042 1043 1044 if ( !face ) 1045 return FT_THROW( Invalid_Face_Handle ); 1046 1047 glyph_index = (FT_UInt)char_code; 1048 if ( face->charmap ) 1049 glyph_index = FT_Get_Char_Index( face, char_code ); 1050 1051 return FT_Load_Glyph( face, glyph_index, load_flags ); 1052 } 1053 1054 1055 /* destructor for sizes list */ 1056 static void 1057 destroy_size( FT_Memory memory, 1058 FT_Size size, 1059 FT_Driver driver ) 1060 { 1061 /* finalize client-specific data */ 1062 if ( size->generic.finalizer ) 1063 size->generic.finalizer( size ); 1064 1065 /* finalize format-specific stuff */ 1066 if ( driver->clazz->done_size ) 1067 driver->clazz->done_size( size ); 1068 1069 FT_FREE( size->internal ); 1070 FT_FREE( size ); 1071 } 1072 1073 1074 static void 1075 ft_cmap_done_internal( FT_CMap cmap ); 1076 1077 1078 static void 1079 destroy_charmaps( FT_Face face, 1080 FT_Memory memory ) 1081 { 1082 FT_Int n; 1083 1084 1085 if ( !face ) 1086 return; 1087 1088 for ( n = 0; n < face->num_charmaps; n++ ) 1089 { 1090 FT_CMap cmap = FT_CMAP( face->charmaps[n] ); 1091 1092 1093 ft_cmap_done_internal( cmap ); 1094 1095 face->charmaps[n] = NULL; 1096 } 1097 1098 FT_FREE( face->charmaps ); 1099 face->num_charmaps = 0; 1100 } 1101 1102 1103 /* destructor for faces list */ 1104 static void 1105 destroy_face( FT_Memory memory, 1106 FT_Face face, 1107 FT_Driver driver ) 1108 { 1109 FT_Driver_Class clazz = driver->clazz; 1110 1111 1112 /* discard auto-hinting data */ 1113 if ( face->autohint.finalizer ) 1114 face->autohint.finalizer( face->autohint.data ); 1115 1116 /* Discard glyph slots for this face. */ 1117 /* Beware! FT_Done_GlyphSlot() changes the field `face->glyph' */ 1118 while ( face->glyph ) 1119 FT_Done_GlyphSlot( face->glyph ); 1120 1121 /* discard all sizes for this face */ 1122 FT_List_Finalize( &face->sizes_list, 1123 (FT_List_Destructor)destroy_size, 1124 memory, 1125 driver ); 1126 face->size = NULL; 1127 1128 /* now discard client data */ 1129 if ( face->generic.finalizer ) 1130 face->generic.finalizer( face ); 1131 1132 /* discard charmaps */ 1133 destroy_charmaps( face, memory ); 1134 1135 /* finalize format-specific stuff */ 1136 if ( clazz->done_face ) 1137 clazz->done_face( face ); 1138 1139 /* close the stream for this face if needed */ 1140 FT_Stream_Free( 1141 face->stream, 1142 ( face->face_flags & FT_FACE_FLAG_EXTERNAL_STREAM ) != 0 ); 1143 1144 face->stream = NULL; 1145 1146 /* get rid of it */ 1147 if ( face->internal ) 1148 { 1149 FT_FREE( face->internal ); 1150 } 1151 FT_FREE( face ); 1152 } 1153 1154 1155 static void 1156 Destroy_Driver( FT_Driver driver ) 1157 { 1158 FT_List_Finalize( &driver->faces_list, 1159 (FT_List_Destructor)destroy_face, 1160 driver->root.memory, 1161 driver ); 1162 } 1163 1164 1165 /*************************************************************************/ 1166 /* */ 1167 /* <Function> */ 1168 /* find_unicode_charmap */ 1169 /* */ 1170 /* <Description> */ 1171 /* This function finds a Unicode charmap, if there is one. */ 1172 /* And if there is more than one, it tries to favour the more */ 1173 /* extensive one, i.e., one that supports UCS-4 against those which */ 1174 /* are limited to the BMP (said UCS-2 encoding.) */ 1175 /* */ 1176 /* This function is called from open_face() (just below), and also */ 1177 /* from FT_Select_Charmap( ..., FT_ENCODING_UNICODE ). */ 1178 /* */ 1179 static FT_Error 1180 find_unicode_charmap( FT_Face face ) 1181 { 1182 FT_CharMap* first; 1183 FT_CharMap* cur; 1184 1185 1186 /* caller should have already checked that `face' is valid */ 1187 FT_ASSERT( face ); 1188 1189 first = face->charmaps; 1190 1191 if ( !first ) 1192 return FT_THROW( Invalid_CharMap_Handle ); 1193 1194 /* 1195 * The original TrueType specification(s) only specified charmap 1196 * formats that are capable of mapping 8 or 16 bit character codes to 1197 * glyph indices. 1198 * 1199 * However, recent updates to the Apple and OpenType specifications 1200 * introduced new formats that are capable of mapping 32-bit character 1201 * codes as well. And these are already used on some fonts, mainly to 1202 * map non-BMP Asian ideographs as defined in Unicode. 1203 * 1204 * For compatibility purposes, these fonts generally come with 1205 * *several* Unicode charmaps: 1206 * 1207 * - One of them in the "old" 16-bit format, that cannot access 1208 * all glyphs in the font. 1209 * 1210 * - Another one in the "new" 32-bit format, that can access all 1211 * the glyphs. 1212 * 1213 * This function has been written to always favor a 32-bit charmap 1214 * when found. Otherwise, a 16-bit one is returned when found. 1215 */ 1216 1217 /* Since the `interesting' table, with IDs (3,10), is normally the */ 1218 /* last one, we loop backwards. This loses with type1 fonts with */ 1219 /* non-BMP characters (<.0001%), this wins with .ttf with non-BMP */ 1220 /* chars (.01% ?), and this is the same about 99.99% of the time! */ 1221 1222 cur = first + face->num_charmaps; /* points after the last one */ 1223 1224 for ( ; --cur >= first; ) 1225 { 1226 if ( cur[0]->encoding == FT_ENCODING_UNICODE ) 1227 { 1228 /* XXX If some new encodings to represent UCS-4 are added, */ 1229 /* they should be added here. */ 1230 if ( ( cur[0]->platform_id == TT_PLATFORM_MICROSOFT && 1231 cur[0]->encoding_id == TT_MS_ID_UCS_4 ) || 1232 ( cur[0]->platform_id == TT_PLATFORM_APPLE_UNICODE && 1233 cur[0]->encoding_id == TT_APPLE_ID_UNICODE_32 ) ) 1234 { 1235 face->charmap = cur[0]; 1236 return FT_Err_Ok; 1237 } 1238 } 1239 } 1240 1241 /* We do not have any UCS-4 charmap. */ 1242 /* Do the loop again and search for UCS-2 charmaps. */ 1243 cur = first + face->num_charmaps; 1244 1245 for ( ; --cur >= first; ) 1246 { 1247 if ( cur[0]->encoding == FT_ENCODING_UNICODE ) 1248 { 1249 face->charmap = cur[0]; 1250 return FT_Err_Ok; 1251 } 1252 } 1253 1254 return FT_THROW( Invalid_CharMap_Handle ); 1255 } 1256 1257 1258 /*************************************************************************/ 1259 /* */ 1260 /* <Function> */ 1261 /* find_variant_selector_charmap */ 1262 /* */ 1263 /* <Description> */ 1264 /* This function finds the variant selector charmap, if there is one. */ 1265 /* There can only be one (platform=0, specific=5, format=14). */ 1266 /* */ 1267 static FT_CharMap 1268 find_variant_selector_charmap( FT_Face face ) 1269 { 1270 FT_CharMap* first; 1271 FT_CharMap* end; 1272 FT_CharMap* cur; 1273 1274 1275 /* caller should have already checked that `face' is valid */ 1276 FT_ASSERT( face ); 1277 1278 first = face->charmaps; 1279 1280 if ( !first ) 1281 return NULL; 1282 1283 end = first + face->num_charmaps; /* points after the last one */ 1284 1285 for ( cur = first; cur < end; cur++ ) 1286 { 1287 if ( cur[0]->platform_id == TT_PLATFORM_APPLE_UNICODE && 1288 cur[0]->encoding_id == TT_APPLE_ID_VARIANT_SELECTOR && 1289 FT_Get_CMap_Format( cur[0] ) == 14 ) 1290 return cur[0]; 1291 } 1292 1293 return NULL; 1294 } 1295 1296 1297 /*************************************************************************/ 1298 /* */ 1299 /* <Function> */ 1300 /* open_face */ 1301 /* */ 1302 /* <Description> */ 1303 /* This function does some work for FT_Open_Face(). */ 1304 /* */ 1305 static FT_Error 1306 open_face( FT_Driver driver, 1307 FT_Stream *astream, 1308 FT_Bool external_stream, 1309 FT_Long face_index, 1310 FT_Int num_params, 1311 FT_Parameter* params, 1312 FT_Face *aface ) 1313 { 1314 FT_Memory memory; 1315 FT_Driver_Class clazz; 1316 FT_Face face = NULL; 1317 FT_Face_Internal internal = NULL; 1318 1319 FT_Error error, error2; 1320 1321 1322 clazz = driver->clazz; 1323 memory = driver->root.memory; 1324 1325 /* allocate the face object and perform basic initialization */ 1326 if ( FT_ALLOC( face, clazz->face_object_size ) ) 1327 goto Fail; 1328 1329 face->driver = driver; 1330 face->memory = memory; 1331 face->stream = *astream; 1332 1333 /* set the FT_FACE_FLAG_EXTERNAL_STREAM bit for FT_Done_Face */ 1334 if ( external_stream ) 1335 face->face_flags |= FT_FACE_FLAG_EXTERNAL_STREAM; 1336 1337 if ( FT_NEW( internal ) ) 1338 goto Fail; 1339 1340 face->internal = internal; 1341 1342#ifdef FT_CONFIG_OPTION_INCREMENTAL 1343 { 1344 int i; 1345 1346 1347 face->internal->incremental_interface = NULL; 1348 for ( i = 0; i < num_params && !face->internal->incremental_interface; 1349 i++ ) 1350 if ( params[i].tag == FT_PARAM_TAG_INCREMENTAL ) 1351 face->internal->incremental_interface = 1352 (FT_Incremental_Interface)params[i].data; 1353 } 1354#endif 1355 1356 face->internal->random_seed = -1; 1357 1358 if ( clazz->init_face ) 1359 error = clazz->init_face( *astream, 1360 face, 1361 (FT_Int)face_index, 1362 num_params, 1363 params ); 1364 *astream = face->stream; /* Stream may have been changed. */ 1365 if ( error ) 1366 goto Fail; 1367 1368 /* select Unicode charmap by default */ 1369 error2 = find_unicode_charmap( face ); 1370 1371 /* if no Unicode charmap can be found, FT_Err_Invalid_CharMap_Handle */ 1372 /* is returned. */ 1373 1374 /* no error should happen, but we want to play safe */ 1375 if ( error2 && FT_ERR_NEQ( error2, Invalid_CharMap_Handle ) ) 1376 { 1377 error = error2; 1378 goto Fail; 1379 } 1380 1381 *aface = face; 1382 1383 Fail: 1384 if ( error ) 1385 { 1386 destroy_charmaps( face, memory ); 1387 if ( clazz->done_face ) 1388 clazz->done_face( face ); 1389 FT_FREE( internal ); 1390 FT_FREE( face ); 1391 *aface = NULL; 1392 } 1393 1394 return error; 1395 } 1396 1397 1398 /* there's a Mac-specific extended implementation of FT_New_Face() */ 1399 /* in src/base/ftmac.c */ 1400 1401#ifndef FT_MACINTOSH 1402 1403 /* documentation is in freetype.h */ 1404 1405 FT_EXPORT_DEF( FT_Error ) 1406 FT_New_Face( FT_Library library, 1407 const char* pathname, 1408 FT_Long face_index, 1409 FT_Face *aface ) 1410 { 1411 FT_Open_Args args; 1412 1413 1414 /* test for valid `library' and `aface' delayed to `FT_Open_Face' */ 1415 if ( !pathname ) 1416 return FT_THROW( Invalid_Argument ); 1417 1418 args.flags = FT_OPEN_PATHNAME; 1419 args.pathname = (char*)pathname; 1420 args.stream = NULL; 1421 1422 return ft_open_face_internal( library, &args, face_index, aface, 1 ); 1423 } 1424 1425#endif 1426 1427 1428 /* documentation is in freetype.h */ 1429 1430 FT_EXPORT_DEF( FT_Error ) 1431 FT_New_Memory_Face( FT_Library library, 1432 const FT_Byte* file_base, 1433 FT_Long file_size, 1434 FT_Long face_index, 1435 FT_Face *aface ) 1436 { 1437 FT_Open_Args args; 1438 1439 1440 /* test for valid `library' and `face' delayed to `FT_Open_Face' */ 1441 if ( !file_base ) 1442 return FT_THROW( Invalid_Argument ); 1443 1444 args.flags = FT_OPEN_MEMORY; 1445 args.memory_base = file_base; 1446 args.memory_size = file_size; 1447 args.stream = NULL; 1448 1449 return ft_open_face_internal( library, &args, face_index, aface, 1 ); 1450 } 1451 1452 1453#ifdef FT_CONFIG_OPTION_MAC_FONTS 1454 1455 /* The behavior here is very similar to that in base/ftmac.c, but it */ 1456 /* is designed to work on non-mac systems, so no mac specific calls. */ 1457 /* */ 1458 /* We look at the file and determine if it is a mac dfont file or a mac */ 1459 /* resource file, or a macbinary file containing a mac resource file. */ 1460 /* */ 1461 /* Unlike ftmac I'm not going to look at a `FOND'. I don't really see */ 1462 /* the point, especially since there may be multiple `FOND' resources. */ 1463 /* Instead I'll just look for `sfnt' and `POST' resources, ordered as */ 1464 /* they occur in the file. */ 1465 /* */ 1466 /* Note that multiple `POST' resources do not mean multiple postscript */ 1467 /* fonts; they all get jammed together to make what is essentially a */ 1468 /* pfb file. */ 1469 /* */ 1470 /* We aren't interested in `NFNT' or `FONT' bitmap resources. */ 1471 /* */ 1472 /* As soon as we get an `sfnt' load it into memory and pass it off to */ 1473 /* FT_Open_Face. */ 1474 /* */ 1475 /* If we have a (set of) `POST' resources, massage them into a (memory) */ 1476 /* pfb file and pass that to FT_Open_Face. (As with ftmac.c I'm not */ 1477 /* going to try to save the kerning info. After all that lives in the */ 1478 /* `FOND' which isn't in the file containing the `POST' resources so */ 1479 /* we don't really have access to it. */ 1480 1481 1482 /* Finalizer for a memory stream; gets called by FT_Done_Face(). */ 1483 /* It frees the memory it uses. */ 1484 /* From `ftmac.c'. */ 1485 static void 1486 memory_stream_close( FT_Stream stream ) 1487 { 1488 FT_Memory memory = stream->memory; 1489 1490 1491 FT_FREE( stream->base ); 1492 1493 stream->size = 0; 1494 stream->base = NULL; 1495 stream->close = NULL; 1496 } 1497 1498 1499 /* Create a new memory stream from a buffer and a size. */ 1500 /* From `ftmac.c'. */ 1501 static FT_Error 1502 new_memory_stream( FT_Library library, 1503 FT_Byte* base, 1504 FT_ULong size, 1505 FT_Stream_CloseFunc close, 1506 FT_Stream *astream ) 1507 { 1508 FT_Error error; 1509 FT_Memory memory; 1510 FT_Stream stream = NULL; 1511 1512 1513 if ( !library ) 1514 return FT_THROW( Invalid_Library_Handle ); 1515 1516 if ( !base ) 1517 return FT_THROW( Invalid_Argument ); 1518 1519 *astream = NULL; 1520 memory = library->memory; 1521 if ( FT_NEW( stream ) ) 1522 goto Exit; 1523 1524 FT_Stream_OpenMemory( stream, base, size ); 1525 1526 stream->close = close; 1527 1528 *astream = stream; 1529 1530 Exit: 1531 return error; 1532 } 1533 1534 1535 /* Create a new FT_Face given a buffer and a driver name. */ 1536 /* From `ftmac.c'. */ 1537 FT_LOCAL_DEF( FT_Error ) 1538 open_face_from_buffer( FT_Library library, 1539 FT_Byte* base, 1540 FT_ULong size, 1541 FT_Long face_index, 1542 const char* driver_name, 1543 FT_Face *aface ) 1544 { 1545 FT_Open_Args args; 1546 FT_Error error; 1547 FT_Stream stream = NULL; 1548 FT_Memory memory = library->memory; 1549 1550 1551 error = new_memory_stream( library, 1552 base, 1553 size, 1554 memory_stream_close, 1555 &stream ); 1556 if ( error ) 1557 { 1558 FT_FREE( base ); 1559 return error; 1560 } 1561 1562 args.flags = FT_OPEN_STREAM; 1563 args.stream = stream; 1564 if ( driver_name ) 1565 { 1566 args.flags = args.flags | FT_OPEN_DRIVER; 1567 args.driver = FT_Get_Module( library, driver_name ); 1568 } 1569 1570#ifdef FT_MACINTOSH 1571 /* At this point, the face index has served its purpose; */ 1572 /* whoever calls this function has already used it to */ 1573 /* locate the correct font data. We should not propagate */ 1574 /* this index to FT_Open_Face() (unless it is negative). */ 1575 1576 if ( face_index > 0 ) 1577 face_index &= 0x7FFF0000L; /* retain GX data */ 1578#endif 1579 1580 error = ft_open_face_internal( library, &args, face_index, aface, 0 ); 1581 1582 if ( !error ) 1583 (*aface)->face_flags &= ~FT_FACE_FLAG_EXTERNAL_STREAM; 1584 else 1585#ifdef FT_MACINTOSH 1586 FT_Stream_Free( stream, 0 ); 1587#else 1588 { 1589 FT_Stream_Close( stream ); 1590 FT_FREE( stream ); 1591 } 1592#endif 1593 1594 return error; 1595 } 1596 1597 1598 /* Look up `TYP1' or `CID ' table from sfnt table directory. */ 1599 /* `offset' and `length' must exclude the binary header in tables. */ 1600 1601 /* Type 1 and CID-keyed font drivers should recognize sfnt-wrapped */ 1602 /* format too. Here, since we can't expect that the TrueType font */ 1603 /* driver is loaded unconditionally, we must parse the font by */ 1604 /* ourselves. We are only interested in the name of the table and */ 1605 /* the offset. */ 1606 1607 static FT_Error 1608 ft_lookup_PS_in_sfnt_stream( FT_Stream stream, 1609 FT_Long face_index, 1610 FT_ULong* offset, 1611 FT_ULong* length, 1612 FT_Bool* is_sfnt_cid ) 1613 { 1614 FT_Error error; 1615 FT_UShort numTables; 1616 FT_Long pstable_index; 1617 FT_ULong tag; 1618 int i; 1619 1620 1621 *offset = 0; 1622 *length = 0; 1623 *is_sfnt_cid = FALSE; 1624 1625 /* TODO: support for sfnt-wrapped PS/CID in TTC format */ 1626 1627 /* version check for 'typ1' (should be ignored?) */ 1628 if ( FT_READ_ULONG( tag ) ) 1629 return error; 1630 if ( tag != TTAG_typ1 ) 1631 return FT_THROW( Unknown_File_Format ); 1632 1633 if ( FT_READ_USHORT( numTables ) ) 1634 return error; 1635 if ( FT_STREAM_SKIP( 2 * 3 ) ) /* skip binary search header */ 1636 return error; 1637 1638 pstable_index = -1; 1639 *is_sfnt_cid = FALSE; 1640 1641 for ( i = 0; i < numTables; i++ ) 1642 { 1643 if ( FT_READ_ULONG( tag ) || FT_STREAM_SKIP( 4 ) || 1644 FT_READ_ULONG( *offset ) || FT_READ_ULONG( *length ) ) 1645 return error; 1646 1647 if ( tag == TTAG_CID ) 1648 { 1649 pstable_index++; 1650 *offset += 22; 1651 *length -= 22; 1652 *is_sfnt_cid = TRUE; 1653 if ( face_index < 0 ) 1654 return FT_Err_Ok; 1655 } 1656 else if ( tag == TTAG_TYP1 ) 1657 { 1658 pstable_index++; 1659 *offset += 24; 1660 *length -= 24; 1661 *is_sfnt_cid = FALSE; 1662 if ( face_index < 0 ) 1663 return FT_Err_Ok; 1664 } 1665 if ( face_index >= 0 && pstable_index == face_index ) 1666 return FT_Err_Ok; 1667 } 1668 1669 return FT_THROW( Table_Missing ); 1670 } 1671 1672 1673 FT_LOCAL_DEF( FT_Error ) 1674 open_face_PS_from_sfnt_stream( FT_Library library, 1675 FT_Stream stream, 1676 FT_Long face_index, 1677 FT_Int num_params, 1678 FT_Parameter *params, 1679 FT_Face *aface ) 1680 { 1681 FT_Error error; 1682 FT_Memory memory = library->memory; 1683 FT_ULong offset, length; 1684 FT_ULong pos; 1685 FT_Bool is_sfnt_cid; 1686 FT_Byte* sfnt_ps = NULL; 1687 1688 FT_UNUSED( num_params ); 1689 FT_UNUSED( params ); 1690 1691 1692 /* ignore GX stuff */ 1693 if ( face_index > 0 ) 1694 face_index &= 0xFFFFL; 1695 1696 pos = FT_STREAM_POS(); 1697 1698 error = ft_lookup_PS_in_sfnt_stream( stream, 1699 face_index, 1700 &offset, 1701 &length, 1702 &is_sfnt_cid ); 1703 if ( error ) 1704 goto Exit; 1705 1706 if ( offset > stream->size ) 1707 { 1708 FT_TRACE2(( "open_face_PS_from_sfnt_stream: invalid table offset\n" )); 1709 error = FT_THROW( Invalid_Table ); 1710 goto Exit; 1711 } 1712 else if ( length > stream->size - offset ) 1713 { 1714 FT_TRACE2(( "open_face_PS_from_sfnt_stream: invalid table length\n" )); 1715 error = FT_THROW( Invalid_Table ); 1716 goto Exit; 1717 } 1718 1719 error = FT_Stream_Seek( stream, pos + offset ); 1720 if ( error ) 1721 goto Exit; 1722 1723 if ( FT_ALLOC( sfnt_ps, (FT_Long)length ) ) 1724 goto Exit; 1725 1726 error = FT_Stream_Read( stream, (FT_Byte *)sfnt_ps, length ); 1727 if ( error ) 1728 { 1729 FT_FREE( sfnt_ps ); 1730 goto Exit; 1731 } 1732 1733 error = open_face_from_buffer( library, 1734 sfnt_ps, 1735 length, 1736 FT_MIN( face_index, 0 ), 1737 is_sfnt_cid ? "cid" : "type1", 1738 aface ); 1739 Exit: 1740 { 1741 FT_Error error1; 1742 1743 1744 if ( FT_ERR_EQ( error, Unknown_File_Format ) ) 1745 { 1746 error1 = FT_Stream_Seek( stream, pos ); 1747 if ( error1 ) 1748 return error1; 1749 } 1750 1751 return error; 1752 } 1753 } 1754 1755 1756#ifndef FT_MACINTOSH 1757 1758 /* The resource header says we've got resource_cnt `POST' (type1) */ 1759 /* resources in this file. They all need to be coalesced into */ 1760 /* one lump which gets passed on to the type1 driver. */ 1761 /* Here can be only one PostScript font in a file so face_index */ 1762 /* must be 0 (or -1). */ 1763 /* */ 1764 static FT_Error 1765 Mac_Read_POST_Resource( FT_Library library, 1766 FT_Stream stream, 1767 FT_Long *offsets, 1768 FT_Long resource_cnt, 1769 FT_Long face_index, 1770 FT_Face *aface ) 1771 { 1772 FT_Error error = FT_ERR( Cannot_Open_Resource ); 1773 FT_Memory memory = library->memory; 1774 1775 FT_Byte* pfb_data = NULL; 1776 int i, type, flags; 1777 FT_ULong len; 1778 FT_ULong pfb_len, pfb_pos, pfb_lenpos; 1779 FT_ULong rlen, temp; 1780 1781 1782 if ( face_index == -1 ) 1783 face_index = 0; 1784 if ( face_index != 0 ) 1785 return error; 1786 1787 /* Find the length of all the POST resources, concatenated. Assume */ 1788 /* worst case (each resource in its own section). */ 1789 pfb_len = 0; 1790 for ( i = 0; i < resource_cnt; i++ ) 1791 { 1792 error = FT_Stream_Seek( stream, (FT_ULong)offsets[i] ); 1793 if ( error ) 1794 goto Exit; 1795 if ( FT_READ_ULONG( temp ) ) /* actually LONG */ 1796 goto Exit; 1797 1798 /* FT2 allocator takes signed long buffer length, 1799 * too large value causing overflow should be checked 1800 */ 1801 FT_TRACE4(( " POST fragment #%d: length=0x%08x" 1802 " total pfb_len=0x%08x\n", 1803 i, temp, pfb_len + temp + 6 )); 1804 1805 if ( FT_MAC_RFORK_MAX_LEN < temp || 1806 FT_MAC_RFORK_MAX_LEN - temp < pfb_len + 6 ) 1807 { 1808 FT_TRACE2(( " MacOS resource length cannot exceed" 1809 " 0x%08x\n", 1810 FT_MAC_RFORK_MAX_LEN )); 1811 1812 error = FT_THROW( Invalid_Offset ); 1813 goto Exit; 1814 } 1815 1816 pfb_len += temp + 6; 1817 } 1818 1819 FT_TRACE2(( " total buffer size to concatenate" 1820 " %d POST fragments: 0x%08x\n", 1821 resource_cnt, pfb_len + 2 )); 1822 1823 if ( pfb_len + 2 < 6 ) 1824 { 1825 FT_TRACE2(( " too long fragment length makes" 1826 " pfb_len confused: pfb_len=0x%08x\n", 1827 pfb_len )); 1828 1829 error = FT_THROW( Array_Too_Large ); 1830 goto Exit; 1831 } 1832 1833 if ( FT_ALLOC( pfb_data, (FT_Long)pfb_len + 2 ) ) 1834 goto Exit; 1835 1836 pfb_data[0] = 0x80; 1837 pfb_data[1] = 1; /* Ascii section */ 1838 pfb_data[2] = 0; /* 4-byte length, fill in later */ 1839 pfb_data[3] = 0; 1840 pfb_data[4] = 0; 1841 pfb_data[5] = 0; 1842 pfb_pos = 6; 1843 pfb_lenpos = 2; 1844 1845 len = 0; 1846 type = 1; 1847 1848 for ( i = 0; i < resource_cnt; i++ ) 1849 { 1850 error = FT_Stream_Seek( stream, (FT_ULong)offsets[i] ); 1851 if ( error ) 1852 goto Exit2; 1853 if ( FT_READ_ULONG( rlen ) ) 1854 goto Exit2; 1855 1856 /* FT2 allocator takes signed long buffer length, 1857 * too large fragment length causing overflow should be checked 1858 */ 1859 if ( 0x7FFFFFFFUL < rlen ) 1860 { 1861 error = FT_THROW( Invalid_Offset ); 1862 goto Exit2; 1863 } 1864 1865 if ( FT_READ_USHORT( flags ) ) 1866 goto Exit2; 1867 1868 FT_TRACE3(( "POST fragment[%d]:" 1869 " offsets=0x%08x, rlen=0x%08x, flags=0x%04x\n", 1870 i, offsets[i], rlen, flags )); 1871 1872 error = FT_ERR( Array_Too_Large ); 1873 1874 /* postpone the check of `rlen longer than buffer' */ 1875 /* until `FT_Stream_Read' */ 1876 1877 if ( ( flags >> 8 ) == 0 ) /* Comment, should not be loaded */ 1878 { 1879 FT_TRACE3(( " Skip POST fragment #%d because it is a comment\n", 1880 i )); 1881 continue; 1882 } 1883 1884 /* the flags are part of the resource, so rlen >= 2, */ 1885 /* but some fonts declare rlen = 0 for empty fragment */ 1886 if ( rlen > 2 ) 1887 rlen -= 2; 1888 else 1889 rlen = 0; 1890 1891 if ( ( flags >> 8 ) == type ) 1892 len += rlen; 1893 else 1894 { 1895 FT_TRACE3(( " Write POST fragment #%d header (4-byte) to buffer" 1896 " %p + 0x%08x\n", 1897 i, pfb_data, pfb_lenpos )); 1898 1899 if ( pfb_lenpos + 3 > pfb_len + 2 ) 1900 goto Exit2; 1901 1902 pfb_data[pfb_lenpos ] = (FT_Byte)( len ); 1903 pfb_data[pfb_lenpos + 1] = (FT_Byte)( len >> 8 ); 1904 pfb_data[pfb_lenpos + 2] = (FT_Byte)( len >> 16 ); 1905 pfb_data[pfb_lenpos + 3] = (FT_Byte)( len >> 24 ); 1906 1907 if ( ( flags >> 8 ) == 5 ) /* End of font mark */ 1908 break; 1909 1910 FT_TRACE3(( " Write POST fragment #%d header (6-byte) to buffer" 1911 " %p + 0x%08x\n", 1912 i, pfb_data, pfb_pos )); 1913 1914 if ( pfb_pos + 6 > pfb_len + 2 ) 1915 goto Exit2; 1916 1917 pfb_data[pfb_pos++] = 0x80; 1918 1919 type = flags >> 8; 1920 len = rlen; 1921 1922 pfb_data[pfb_pos++] = (FT_Byte)type; 1923 pfb_lenpos = pfb_pos; 1924 pfb_data[pfb_pos++] = 0; /* 4-byte length, fill in later */ 1925 pfb_data[pfb_pos++] = 0; 1926 pfb_data[pfb_pos++] = 0; 1927 pfb_data[pfb_pos++] = 0; 1928 } 1929 1930 if ( pfb_pos > pfb_len || pfb_pos + rlen > pfb_len ) 1931 goto Exit2; 1932 1933 FT_TRACE3(( " Load POST fragment #%d (%d byte) to buffer" 1934 " %p + 0x%08x\n", 1935 i, rlen, pfb_data, pfb_pos )); 1936 1937 error = FT_Stream_Read( stream, (FT_Byte *)pfb_data + pfb_pos, rlen ); 1938 if ( error ) 1939 goto Exit2; 1940 1941 pfb_pos += rlen; 1942 } 1943 1944 error = FT_ERR( Array_Too_Large ); 1945 1946 if ( pfb_pos + 2 > pfb_len + 2 ) 1947 goto Exit2; 1948 pfb_data[pfb_pos++] = 0x80; 1949 pfb_data[pfb_pos++] = 3; 1950 1951 if ( pfb_lenpos + 3 > pfb_len + 2 ) 1952 goto Exit2; 1953 pfb_data[pfb_lenpos ] = (FT_Byte)( len ); 1954 pfb_data[pfb_lenpos + 1] = (FT_Byte)( len >> 8 ); 1955 pfb_data[pfb_lenpos + 2] = (FT_Byte)( len >> 16 ); 1956 pfb_data[pfb_lenpos + 3] = (FT_Byte)( len >> 24 ); 1957 1958 return open_face_from_buffer( library, 1959 pfb_data, 1960 pfb_pos, 1961 face_index, 1962 "type1", 1963 aface ); 1964 1965 Exit2: 1966 if ( FT_ERR_EQ( error, Array_Too_Large ) ) 1967 FT_TRACE2(( " Abort due to too-short buffer to store" 1968 " all POST fragments\n" )); 1969 else if ( FT_ERR_EQ( error, Invalid_Offset ) ) 1970 FT_TRACE2(( " Abort due to invalid offset in a POST fragment\n" )); 1971 1972 if ( error ) 1973 error = FT_ERR( Cannot_Open_Resource ); 1974 FT_FREE( pfb_data ); 1975 1976 Exit: 1977 return error; 1978 } 1979 1980 1981 /* The resource header says we've got resource_cnt `sfnt' */ 1982 /* (TrueType/OpenType) resources in this file. Look through */ 1983 /* them for the one indicated by face_index, load it into mem, */ 1984 /* pass it on to the truetype driver, and return it. */ 1985 /* */ 1986 static FT_Error 1987 Mac_Read_sfnt_Resource( FT_Library library, 1988 FT_Stream stream, 1989 FT_Long *offsets, 1990 FT_Long resource_cnt, 1991 FT_Long face_index, 1992 FT_Face *aface ) 1993 { 1994 FT_Memory memory = library->memory; 1995 FT_Byte* sfnt_data = NULL; 1996 FT_Error error; 1997 FT_ULong flag_offset; 1998 FT_Long rlen; 1999 int is_cff; 2000 FT_Long face_index_in_resource = 0; 2001 2002 2003 if ( face_index < 0 ) 2004 face_index = -face_index - 1; 2005 if ( face_index >= resource_cnt ) 2006 return FT_THROW( Cannot_Open_Resource ); 2007 2008 flag_offset = (FT_ULong)offsets[face_index]; 2009 error = FT_Stream_Seek( stream, flag_offset ); 2010 if ( error ) 2011 goto Exit; 2012 2013 if ( FT_READ_LONG( rlen ) ) 2014 goto Exit; 2015 if ( rlen < 1 ) 2016 return FT_THROW( Cannot_Open_Resource ); 2017 if ( (FT_ULong)rlen > FT_MAC_RFORK_MAX_LEN ) 2018 return FT_THROW( Invalid_Offset ); 2019 2020 error = open_face_PS_from_sfnt_stream( library, 2021 stream, 2022 face_index, 2023 0, NULL, 2024 aface ); 2025 if ( !error ) 2026 goto Exit; 2027 2028 /* rewind sfnt stream before open_face_PS_from_sfnt_stream() */ 2029 error = FT_Stream_Seek( stream, flag_offset + 4 ); 2030 if ( error ) 2031 goto Exit; 2032 2033 if ( FT_ALLOC( sfnt_data, rlen ) ) 2034 return error; 2035 error = FT_Stream_Read( stream, (FT_Byte *)sfnt_data, (FT_ULong)rlen ); 2036 if ( error ) { 2037 FT_FREE( sfnt_data ); 2038 goto Exit; 2039 } 2040 2041 is_cff = rlen > 4 && !ft_memcmp( sfnt_data, "OTTO", 4 ); 2042 error = open_face_from_buffer( library, 2043 sfnt_data, 2044 (FT_ULong)rlen, 2045 face_index_in_resource, 2046 is_cff ? "cff" : "truetype", 2047 aface ); 2048 2049 Exit: 2050 return error; 2051 } 2052 2053 2054 /* Check for a valid resource fork header, or a valid dfont */ 2055 /* header. In a resource fork the first 16 bytes are repeated */ 2056 /* at the location specified by bytes 4-7. In a dfont bytes */ 2057 /* 4-7 point to 16 bytes of zeroes instead. */ 2058 /* */ 2059 static FT_Error 2060 IsMacResource( FT_Library library, 2061 FT_Stream stream, 2062 FT_Long resource_offset, 2063 FT_Long face_index, 2064 FT_Face *aface ) 2065 { 2066 FT_Memory memory = library->memory; 2067 FT_Error error; 2068 FT_Long map_offset, rdata_pos; 2069 FT_Long *data_offsets; 2070 FT_Long count; 2071 2072 2073 error = FT_Raccess_Get_HeaderInfo( library, stream, resource_offset, 2074 &map_offset, &rdata_pos ); 2075 if ( error ) 2076 return error; 2077 2078 /* POST resources must be sorted to concatenate properly */ 2079 error = FT_Raccess_Get_DataOffsets( library, stream, 2080 map_offset, rdata_pos, 2081 TTAG_POST, TRUE, 2082 &data_offsets, &count ); 2083 if ( !error ) 2084 { 2085 error = Mac_Read_POST_Resource( library, stream, data_offsets, count, 2086 face_index, aface ); 2087 FT_FREE( data_offsets ); 2088 /* POST exists in an LWFN providing a single face */ 2089 if ( !error ) 2090 (*aface)->num_faces = 1; 2091 return error; 2092 } 2093 2094 /* sfnt resources should not be sorted to preserve the face order by 2095 QuickDraw API */ 2096 error = FT_Raccess_Get_DataOffsets( library, stream, 2097 map_offset, rdata_pos, 2098 TTAG_sfnt, FALSE, 2099 &data_offsets, &count ); 2100 if ( !error ) 2101 { 2102 FT_Long face_index_internal = face_index % count; 2103 2104 2105 error = Mac_Read_sfnt_Resource( library, stream, data_offsets, count, 2106 face_index_internal, aface ); 2107 FT_FREE( data_offsets ); 2108 if ( !error ) 2109 (*aface)->num_faces = count; 2110 } 2111 2112 return error; 2113 } 2114 2115 2116 /* Check for a valid macbinary header, and if we find one */ 2117 /* check that the (flattened) resource fork in it is valid. */ 2118 /* */ 2119 static FT_Error 2120 IsMacBinary( FT_Library library, 2121 FT_Stream stream, 2122 FT_Long face_index, 2123 FT_Face *aface ) 2124 { 2125 unsigned char header[128]; 2126 FT_Error error; 2127 FT_Long dlen, offset; 2128 2129 2130 if ( !stream ) 2131 return FT_THROW( Invalid_Stream_Operation ); 2132 2133 error = FT_Stream_Seek( stream, 0 ); 2134 if ( error ) 2135 goto Exit; 2136 2137 error = FT_Stream_Read( stream, (FT_Byte*)header, 128 ); 2138 if ( error ) 2139 goto Exit; 2140 2141 if ( header[ 0] != 0 || 2142 header[74] != 0 || 2143 header[82] != 0 || 2144 header[ 1] == 0 || 2145 header[ 1] > 33 || 2146 header[63] != 0 || 2147 header[2 + header[1]] != 0 || 2148 header[0x53] > 0x7F ) 2149 return FT_THROW( Unknown_File_Format ); 2150 2151 dlen = ( header[0x53] << 24 ) | 2152 ( header[0x54] << 16 ) | 2153 ( header[0x55] << 8 ) | 2154 header[0x56]; 2155#if 0 2156 rlen = ( header[0x57] << 24 ) | 2157 ( header[0x58] << 16 ) | 2158 ( header[0x59] << 8 ) | 2159 header[0x5A]; 2160#endif /* 0 */ 2161 offset = 128 + ( ( dlen + 127 ) & ~127 ); 2162 2163 return IsMacResource( library, stream, offset, face_index, aface ); 2164 2165 Exit: 2166 return error; 2167 } 2168 2169 2170 static FT_Error 2171 load_face_in_embedded_rfork( FT_Library library, 2172 FT_Stream stream, 2173 FT_Long face_index, 2174 FT_Face *aface, 2175 const FT_Open_Args *args ) 2176 { 2177 2178#undef FT_COMPONENT 2179#define FT_COMPONENT trace_raccess 2180 2181 FT_Memory memory = library->memory; 2182 FT_Error error = FT_ERR( Unknown_File_Format ); 2183 FT_UInt i; 2184 2185 char * file_names[FT_RACCESS_N_RULES]; 2186 FT_Long offsets[FT_RACCESS_N_RULES]; 2187 FT_Error errors[FT_RACCESS_N_RULES]; 2188 FT_Bool is_darwin_vfs, vfs_rfork_has_no_font = FALSE; /* not tested */ 2189 2190 FT_Open_Args args2; 2191 FT_Stream stream2 = NULL; 2192 2193 2194 FT_Raccess_Guess( library, stream, 2195 args->pathname, file_names, offsets, errors ); 2196 2197 for ( i = 0; i < FT_RACCESS_N_RULES; i++ ) 2198 { 2199 is_darwin_vfs = ft_raccess_rule_by_darwin_vfs( library, i ); 2200 if ( is_darwin_vfs && vfs_rfork_has_no_font ) 2201 { 2202 FT_TRACE3(( "Skip rule %d: darwin vfs resource fork" 2203 " is already checked and" 2204 " no font is found\n", 2205 i )); 2206 continue; 2207 } 2208 2209 if ( errors[i] ) 2210 { 2211 FT_TRACE3(( "Error 0x%x has occurred in rule %d\n", 2212 errors[i], i )); 2213 continue; 2214 } 2215 2216 args2.flags = FT_OPEN_PATHNAME; 2217 args2.pathname = file_names[i] ? file_names[i] : args->pathname; 2218 2219 FT_TRACE3(( "Try rule %d: %s (offset=%d) ...", 2220 i, args2.pathname, offsets[i] )); 2221 2222 error = FT_Stream_New( library, &args2, &stream2 ); 2223 if ( is_darwin_vfs && FT_ERR_EQ( error, Cannot_Open_Stream ) ) 2224 vfs_rfork_has_no_font = TRUE; 2225 2226 if ( error ) 2227 { 2228 FT_TRACE3(( "failed\n" )); 2229 continue; 2230 } 2231 2232 error = IsMacResource( library, stream2, offsets[i], 2233 face_index, aface ); 2234 FT_Stream_Free( stream2, 0 ); 2235 2236 FT_TRACE3(( "%s\n", error ? "failed": "successful" )); 2237 2238 if ( !error ) 2239 break; 2240 else if ( is_darwin_vfs ) 2241 vfs_rfork_has_no_font = TRUE; 2242 } 2243 2244 for (i = 0; i < FT_RACCESS_N_RULES; i++) 2245 { 2246 if ( file_names[i] ) 2247 FT_FREE( file_names[i] ); 2248 } 2249 2250 /* Caller (load_mac_face) requires FT_Err_Unknown_File_Format. */ 2251 if ( error ) 2252 error = FT_ERR( Unknown_File_Format ); 2253 2254 return error; 2255 2256#undef FT_COMPONENT 2257#define FT_COMPONENT trace_objs 2258 2259 } 2260 2261 2262 /* Check for some macintosh formats without Carbon framework. */ 2263 /* Is this a macbinary file? If so look at the resource fork. */ 2264 /* Is this a mac dfont file? */ 2265 /* Is this an old style resource fork? (in data) */ 2266 /* Else call load_face_in_embedded_rfork to try extra rules */ 2267 /* (defined in `ftrfork.c'). */ 2268 /* */ 2269 static FT_Error 2270 load_mac_face( FT_Library library, 2271 FT_Stream stream, 2272 FT_Long face_index, 2273 FT_Face *aface, 2274 const FT_Open_Args *args ) 2275 { 2276 FT_Error error; 2277 FT_UNUSED( args ); 2278 2279 2280 error = IsMacBinary( library, stream, face_index, aface ); 2281 if ( FT_ERR_EQ( error, Unknown_File_Format ) ) 2282 { 2283 2284#undef FT_COMPONENT 2285#define FT_COMPONENT trace_raccess 2286 2287#ifdef FT_DEBUG_LEVEL_TRACE 2288 FT_TRACE3(( "Try as dfont: " )); 2289 if ( !( args->flags & FT_OPEN_MEMORY ) ) 2290 FT_TRACE3(( "%s ...", args->pathname )); 2291#endif 2292 2293 error = IsMacResource( library, stream, 0, face_index, aface ); 2294 2295 FT_TRACE3(( "%s\n", error ? "failed" : "successful" )); 2296 2297#undef FT_COMPONENT 2298#define FT_COMPONENT trace_objs 2299 2300 } 2301 2302 if ( ( FT_ERR_EQ( error, Unknown_File_Format ) || 2303 FT_ERR_EQ( error, Invalid_Stream_Operation ) ) && 2304 ( args->flags & FT_OPEN_PATHNAME ) ) 2305 error = load_face_in_embedded_rfork( library, stream, 2306 face_index, aface, args ); 2307 return error; 2308 } 2309#endif 2310 2311#endif /* !FT_MACINTOSH && FT_CONFIG_OPTION_MAC_FONTS */ 2312 2313 2314 /* documentation is in freetype.h */ 2315 2316 FT_EXPORT_DEF( FT_Error ) 2317 FT_Open_Face( FT_Library library, 2318 const FT_Open_Args* args, 2319 FT_Long face_index, 2320 FT_Face *aface ) 2321 { 2322 return ft_open_face_internal( library, args, face_index, aface, 1 ); 2323 } 2324 2325 2326 static FT_Error 2327 ft_open_face_internal( FT_Library library, 2328 const FT_Open_Args* args, 2329 FT_Long face_index, 2330 FT_Face *aface, 2331 FT_Bool test_mac_fonts ) 2332 { 2333 FT_Error error; 2334 FT_Driver driver = NULL; 2335 FT_Memory memory = NULL; 2336 FT_Stream stream = NULL; 2337 FT_Face face = NULL; 2338 FT_ListNode node = NULL; 2339 FT_Bool external_stream; 2340 FT_Module* cur; 2341 FT_Module* limit; 2342 2343#ifndef FT_CONFIG_OPTION_MAC_FONTS 2344 FT_UNUSED( test_mac_fonts ); 2345#endif 2346 2347 2348#ifdef FT_DEBUG_LEVEL_TRACE 2349 FT_TRACE3(( "FT_Open_Face: " )); 2350 if ( face_index < 0 ) 2351 FT_TRACE3(( "Requesting number of faces and named instances\n")); 2352 else 2353 { 2354 FT_TRACE3(( "Requesting face %ld", face_index & 0xFFFFL )); 2355 if ( face_index & 0x7FFF0000L ) 2356 FT_TRACE3(( ", named instance %ld", face_index >> 16 )); 2357 FT_TRACE3(( "\n" )); 2358 } 2359#endif 2360 2361 /* test for valid `library' delayed to `FT_Stream_New' */ 2362 2363 if ( ( !aface && face_index >= 0 ) || !args ) 2364 return FT_THROW( Invalid_Argument ); 2365 2366 external_stream = FT_BOOL( ( args->flags & FT_OPEN_STREAM ) && 2367 args->stream ); 2368 2369 /* create input stream */ 2370 error = FT_Stream_New( library, args, &stream ); 2371 if ( error ) 2372 goto Fail3; 2373 2374 memory = library->memory; 2375 2376 /* If the font driver is specified in the `args' structure, use */ 2377 /* it. Otherwise, we scan the list of registered drivers. */ 2378 if ( ( args->flags & FT_OPEN_DRIVER ) && args->driver ) 2379 { 2380 driver = FT_DRIVER( args->driver ); 2381 2382 /* not all modules are drivers, so check... */ 2383 if ( FT_MODULE_IS_DRIVER( driver ) ) 2384 { 2385 FT_Int num_params = 0; 2386 FT_Parameter* params = NULL; 2387 2388 2389 if ( args->flags & FT_OPEN_PARAMS ) 2390 { 2391 num_params = args->num_params; 2392 params = args->params; 2393 } 2394 2395 error = open_face( driver, &stream, external_stream, face_index, 2396 num_params, params, &face ); 2397 if ( !error ) 2398 goto Success; 2399 } 2400 else 2401 error = FT_THROW( Invalid_Handle ); 2402 2403 FT_Stream_Free( stream, external_stream ); 2404 goto Fail; 2405 } 2406 else 2407 { 2408 error = FT_ERR( Missing_Module ); 2409 2410 /* check each font driver for an appropriate format */ 2411 cur = library->modules; 2412 limit = cur + library->num_modules; 2413 2414 for ( ; cur < limit; cur++ ) 2415 { 2416 /* not all modules are font drivers, so check... */ 2417 if ( FT_MODULE_IS_DRIVER( cur[0] ) ) 2418 { 2419 FT_Int num_params = 0; 2420 FT_Parameter* params = NULL; 2421 2422 2423 driver = FT_DRIVER( cur[0] ); 2424 2425 if ( args->flags & FT_OPEN_PARAMS ) 2426 { 2427 num_params = args->num_params; 2428 params = args->params; 2429 } 2430 2431 error = open_face( driver, &stream, external_stream, face_index, 2432 num_params, params, &face ); 2433 if ( !error ) 2434 goto Success; 2435 2436#ifdef FT_CONFIG_OPTION_MAC_FONTS 2437 if ( test_mac_fonts && 2438 ft_strcmp( cur[0]->clazz->module_name, "truetype" ) == 0 && 2439 FT_ERR_EQ( error, Table_Missing ) ) 2440 { 2441 /* TrueType but essential tables are missing */ 2442 error = FT_Stream_Seek( stream, 0 ); 2443 if ( error ) 2444 break; 2445 2446 error = open_face_PS_from_sfnt_stream( library, 2447 stream, 2448 face_index, 2449 num_params, 2450 params, 2451 aface ); 2452 if ( !error ) 2453 { 2454 FT_Stream_Free( stream, external_stream ); 2455 return error; 2456 } 2457 } 2458#endif 2459 2460 if ( FT_ERR_NEQ( error, Unknown_File_Format ) ) 2461 goto Fail3; 2462 } 2463 } 2464 2465 Fail3: 2466 /* If we are on the mac, and we get an */ 2467 /* FT_Err_Invalid_Stream_Operation it may be because we have an */ 2468 /* empty data fork, so we need to check the resource fork. */ 2469 if ( FT_ERR_NEQ( error, Cannot_Open_Stream ) && 2470 FT_ERR_NEQ( error, Unknown_File_Format ) && 2471 FT_ERR_NEQ( error, Invalid_Stream_Operation ) ) 2472 goto Fail2; 2473 2474#if !defined( FT_MACINTOSH ) && defined( FT_CONFIG_OPTION_MAC_FONTS ) 2475 if ( test_mac_fonts ) 2476 { 2477 error = load_mac_face( library, stream, face_index, aface, args ); 2478 if ( !error ) 2479 { 2480 /* We don't want to go to Success here. We've already done */ 2481 /* that. On the other hand, if we succeeded we still need to */ 2482 /* close this stream (we opened a different stream which */ 2483 /* extracted the interesting information out of this stream */ 2484 /* here. That stream will still be open and the face will */ 2485 /* point to it). */ 2486 FT_Stream_Free( stream, external_stream ); 2487 return error; 2488 } 2489 } 2490 2491 if ( FT_ERR_NEQ( error, Unknown_File_Format ) ) 2492 goto Fail2; 2493#endif /* !FT_MACINTOSH && FT_CONFIG_OPTION_MAC_FONTS */ 2494 2495 /* no driver is able to handle this format */ 2496 error = FT_THROW( Unknown_File_Format ); 2497 2498 Fail2: 2499 FT_Stream_Free( stream, external_stream ); 2500 goto Fail; 2501 } 2502 2503 Success: 2504 FT_TRACE4(( "FT_Open_Face: New face object, adding to list\n" )); 2505 2506 /* add the face object to its driver's list */ 2507 if ( FT_NEW( node ) ) 2508 goto Fail; 2509 2510 node->data = face; 2511 /* don't assume driver is the same as face->driver, so use */ 2512 /* face->driver instead. */ 2513 FT_List_Add( &face->driver->faces_list, node ); 2514 2515 /* now allocate a glyph slot object for the face */ 2516 FT_TRACE4(( "FT_Open_Face: Creating glyph slot\n" )); 2517 2518 if ( face_index >= 0 ) 2519 { 2520 error = FT_New_GlyphSlot( face, NULL ); 2521 if ( error ) 2522 goto Fail; 2523 2524 /* finally, allocate a size object for the face */ 2525 { 2526 FT_Size size; 2527 2528 2529 FT_TRACE4(( "FT_Open_Face: Creating size object\n" )); 2530 2531 error = FT_New_Size( face, &size ); 2532 if ( error ) 2533 goto Fail; 2534 2535 face->size = size; 2536 } 2537 } 2538 2539 /* some checks */ 2540 2541 if ( FT_IS_SCALABLE( face ) ) 2542 { 2543 if ( face->height < 0 ) 2544 face->height = (FT_Short)-face->height; 2545 2546 if ( !FT_HAS_VERTICAL( face ) ) 2547 face->max_advance_height = (FT_Short)face->height; 2548 } 2549 2550 if ( FT_HAS_FIXED_SIZES( face ) ) 2551 { 2552 FT_Int i; 2553 2554 2555 for ( i = 0; i < face->num_fixed_sizes; i++ ) 2556 { 2557 FT_Bitmap_Size* bsize = face->available_sizes + i; 2558 2559 2560 if ( bsize->height < 0 ) 2561 bsize->height = -bsize->height; 2562 if ( bsize->x_ppem < 0 ) 2563 bsize->x_ppem = -bsize->x_ppem; 2564 if ( bsize->y_ppem < 0 ) 2565 bsize->y_ppem = -bsize->y_ppem; 2566 2567 /* check whether negation actually has worked */ 2568 if ( bsize->height < 0 || bsize->x_ppem < 0 || bsize->y_ppem < 0 ) 2569 { 2570 FT_TRACE0(( "FT_Open_Face:" 2571 " Invalid bitmap dimensions for strike %d," 2572 " now disabled\n", i )); 2573 bsize->width = 0; 2574 bsize->height = 0; 2575 bsize->size = 0; 2576 bsize->x_ppem = 0; 2577 bsize->y_ppem = 0; 2578 } 2579 } 2580 } 2581 2582 /* initialize internal face data */ 2583 { 2584 FT_Face_Internal internal = face->internal; 2585 2586 2587 internal->transform_matrix.xx = 0x10000L; 2588 internal->transform_matrix.xy = 0; 2589 internal->transform_matrix.yx = 0; 2590 internal->transform_matrix.yy = 0x10000L; 2591 2592 internal->transform_delta.x = 0; 2593 internal->transform_delta.y = 0; 2594 2595 internal->refcount = 1; 2596 2597 internal->no_stem_darkening = -1; 2598 2599#ifdef FT_CONFIG_OPTION_SUBPIXEL_RENDERING 2600 /* Per-face filtering can only be set up by FT_Face_Properties */ 2601 internal->lcd_filter_func = NULL; 2602#endif 2603 } 2604 2605 if ( aface ) 2606 *aface = face; 2607 else 2608 FT_Done_Face( face ); 2609 2610 goto Exit; 2611 2612 Fail: 2613 if ( node ) 2614 FT_Done_Face( face ); /* face must be in the driver's list */ 2615 else if ( face ) 2616 destroy_face( memory, face, driver ); 2617 2618 Exit: 2619#ifdef FT_DEBUG_LEVEL_TRACE 2620 if ( !error && face_index < 0 ) 2621 { 2622 FT_TRACE3(( "FT_Open_Face: The font has %ld face%s\n" 2623 " and %ld named instance%s for face %ld\n", 2624 face->num_faces, 2625 face->num_faces == 1 ? "" : "s", 2626 face->style_flags >> 16, 2627 ( face->style_flags >> 16 ) == 1 ? "" : "s", 2628 -face_index - 1 )); 2629 } 2630#endif 2631 2632 FT_TRACE4(( "FT_Open_Face: Return 0x%x\n", error )); 2633 2634 return error; 2635 } 2636 2637 2638 /* documentation is in freetype.h */ 2639 2640 FT_EXPORT_DEF( FT_Error ) 2641 FT_Attach_File( FT_Face face, 2642 const char* filepathname ) 2643 { 2644 FT_Open_Args open; 2645 2646 2647 /* test for valid `face' delayed to `FT_Attach_Stream' */ 2648 2649 if ( !filepathname ) 2650 return FT_THROW( Invalid_Argument ); 2651 2652 open.stream = NULL; 2653 open.flags = FT_OPEN_PATHNAME; 2654 open.pathname = (char*)filepathname; 2655 2656 return FT_Attach_Stream( face, &open ); 2657 } 2658 2659 2660 /* documentation is in freetype.h */ 2661 2662 FT_EXPORT_DEF( FT_Error ) 2663 FT_Attach_Stream( FT_Face face, 2664 FT_Open_Args* parameters ) 2665 { 2666 FT_Stream stream; 2667 FT_Error error; 2668 FT_Driver driver; 2669 2670 FT_Driver_Class clazz; 2671 2672 2673 /* test for valid `parameters' delayed to `FT_Stream_New' */ 2674 2675 if ( !face ) 2676 return FT_THROW( Invalid_Face_Handle ); 2677 2678 driver = face->driver; 2679 if ( !driver ) 2680 return FT_THROW( Invalid_Driver_Handle ); 2681 2682 error = FT_Stream_New( driver->root.library, parameters, &stream ); 2683 if ( error ) 2684 goto Exit; 2685 2686 /* we implement FT_Attach_Stream in each driver through the */ 2687 /* `attach_file' interface */ 2688 2689 error = FT_ERR( Unimplemented_Feature ); 2690 clazz = driver->clazz; 2691 if ( clazz->attach_file ) 2692 error = clazz->attach_file( face, stream ); 2693 2694 /* close the attached stream */ 2695 FT_Stream_Free( stream, 2696 (FT_Bool)( parameters->stream && 2697 ( parameters->flags & FT_OPEN_STREAM ) ) ); 2698 2699 Exit: 2700 return error; 2701 } 2702 2703 2704 /* documentation is in freetype.h */ 2705 2706 FT_EXPORT_DEF( FT_Error ) 2707 FT_Reference_Face( FT_Face face ) 2708 { 2709 if ( !face ) 2710 return FT_THROW( Invalid_Face_Handle ); 2711 2712 face->internal->refcount++; 2713 2714 return FT_Err_Ok; 2715 } 2716 2717 2718 /* documentation is in freetype.h */ 2719 2720 FT_EXPORT_DEF( FT_Error ) 2721 FT_Done_Face( FT_Face face ) 2722 { 2723 FT_Error error; 2724 FT_Driver driver; 2725 FT_Memory memory; 2726 FT_ListNode node; 2727 2728 2729 error = FT_ERR( Invalid_Face_Handle ); 2730 if ( face && face->driver ) 2731 { 2732 face->internal->refcount--; 2733 if ( face->internal->refcount > 0 ) 2734 error = FT_Err_Ok; 2735 else 2736 { 2737 driver = face->driver; 2738 memory = driver->root.memory; 2739 2740 /* find face in driver's list */ 2741 node = FT_List_Find( &driver->faces_list, face ); 2742 if ( node ) 2743 { 2744 /* remove face object from the driver's list */ 2745 FT_List_Remove( &driver->faces_list, node ); 2746 FT_FREE( node ); 2747 2748 /* now destroy the object proper */ 2749 destroy_face( memory, face, driver ); 2750 error = FT_Err_Ok; 2751 } 2752 } 2753 } 2754 2755 return error; 2756 } 2757 2758 2759 /* documentation is in ftobjs.h */ 2760 2761 FT_EXPORT_DEF( FT_Error ) 2762 FT_New_Size( FT_Face face, 2763 FT_Size *asize ) 2764 { 2765 FT_Error error; 2766 FT_Memory memory; 2767 FT_Driver driver; 2768 FT_Driver_Class clazz; 2769 2770 FT_Size size = NULL; 2771 FT_ListNode node = NULL; 2772 2773 FT_Size_Internal internal = NULL; 2774 2775 2776 if ( !face ) 2777 return FT_THROW( Invalid_Face_Handle ); 2778 2779 if ( !asize ) 2780 return FT_THROW( Invalid_Argument ); 2781 2782 if ( !face->driver ) 2783 return FT_THROW( Invalid_Driver_Handle ); 2784 2785 *asize = NULL; 2786 2787 driver = face->driver; 2788 clazz = driver->clazz; 2789 memory = face->memory; 2790 2791 /* Allocate new size object and perform basic initialisation */ 2792 if ( FT_ALLOC( size, clazz->size_object_size ) || FT_NEW( node ) ) 2793 goto Exit; 2794 2795 size->face = face; 2796 2797 if ( FT_NEW( internal ) ) 2798 goto Exit; 2799 2800 size->internal = internal; 2801 2802 if ( clazz->init_size ) 2803 error = clazz->init_size( size ); 2804 2805 /* in case of success, add to the face's list */ 2806 if ( !error ) 2807 { 2808 *asize = size; 2809 node->data = size; 2810 FT_List_Add( &face->sizes_list, node ); 2811 } 2812 2813 Exit: 2814 if ( error ) 2815 { 2816 FT_FREE( node ); 2817 FT_FREE( size ); 2818 } 2819 2820 return error; 2821 } 2822 2823 2824 /* documentation is in ftobjs.h */ 2825 2826 FT_EXPORT_DEF( FT_Error ) 2827 FT_Done_Size( FT_Size size ) 2828 { 2829 FT_Error error; 2830 FT_Driver driver; 2831 FT_Memory memory; 2832 FT_Face face; 2833 FT_ListNode node; 2834 2835 2836 if ( !size ) 2837 return FT_THROW( Invalid_Size_Handle ); 2838 2839 face = size->face; 2840 if ( !face ) 2841 return FT_THROW( Invalid_Face_Handle ); 2842 2843 driver = face->driver; 2844 if ( !driver ) 2845 return FT_THROW( Invalid_Driver_Handle ); 2846 2847 memory = driver->root.memory; 2848 2849 error = FT_Err_Ok; 2850 node = FT_List_Find( &face->sizes_list, size ); 2851 if ( node ) 2852 { 2853 FT_List_Remove( &face->sizes_list, node ); 2854 FT_FREE( node ); 2855 2856 if ( face->size == size ) 2857 { 2858 face->size = NULL; 2859 if ( face->sizes_list.head ) 2860 face->size = (FT_Size)(face->sizes_list.head->data); 2861 } 2862 2863 destroy_size( memory, size, driver ); 2864 } 2865 else 2866 error = FT_THROW( Invalid_Size_Handle ); 2867 2868 return error; 2869 } 2870 2871 2872 /* documentation is in ftobjs.h */ 2873 2874 FT_BASE_DEF( FT_Error ) 2875 FT_Match_Size( FT_Face face, 2876 FT_Size_Request req, 2877 FT_Bool ignore_width, 2878 FT_ULong* size_index ) 2879 { 2880 FT_Int i; 2881 FT_Long w, h; 2882 2883 2884 if ( !FT_HAS_FIXED_SIZES( face ) ) 2885 return FT_THROW( Invalid_Face_Handle ); 2886 2887 /* FT_Bitmap_Size doesn't provide enough info... */ 2888 if ( req->type != FT_SIZE_REQUEST_TYPE_NOMINAL ) 2889 return FT_THROW( Unimplemented_Feature ); 2890 2891 w = FT_REQUEST_WIDTH ( req ); 2892 h = FT_REQUEST_HEIGHT( req ); 2893 2894 if ( req->width && !req->height ) 2895 h = w; 2896 else if ( !req->width && req->height ) 2897 w = h; 2898 2899 w = FT_PIX_ROUND( w ); 2900 h = FT_PIX_ROUND( h ); 2901 2902 if ( !w || !h ) 2903 return FT_THROW( Invalid_Pixel_Size ); 2904 2905 for ( i = 0; i < face->num_fixed_sizes; i++ ) 2906 { 2907 FT_Bitmap_Size* bsize = face->available_sizes + i; 2908 2909 2910 if ( h != FT_PIX_ROUND( bsize->y_ppem ) ) 2911 continue; 2912 2913 if ( w == FT_PIX_ROUND( bsize->x_ppem ) || ignore_width ) 2914 { 2915 FT_TRACE3(( "FT_Match_Size: bitmap strike %d matches\n", i )); 2916 2917 if ( size_index ) 2918 *size_index = (FT_ULong)i; 2919 2920 return FT_Err_Ok; 2921 } 2922 } 2923 2924 FT_TRACE3(( "FT_Match_Size: no matching bitmap strike\n" )); 2925 2926 return FT_THROW( Invalid_Pixel_Size ); 2927 } 2928 2929 2930 /* documentation is in ftobjs.h */ 2931 2932 FT_BASE_DEF( void ) 2933 ft_synthesize_vertical_metrics( FT_Glyph_Metrics* metrics, 2934 FT_Pos advance ) 2935 { 2936 FT_Pos height = metrics->height; 2937 2938 2939 /* compensate for glyph with bbox above/below the baseline */ 2940 if ( metrics->horiBearingY < 0 ) 2941 { 2942 if ( height < metrics->horiBearingY ) 2943 height = metrics->horiBearingY; 2944 } 2945 else if ( metrics->horiBearingY > 0 ) 2946 height -= metrics->horiBearingY; 2947 2948 /* the factor 1.2 is a heuristical value */ 2949 if ( !advance ) 2950 advance = height * 12 / 10; 2951 2952 metrics->vertBearingX = metrics->horiBearingX - metrics->horiAdvance / 2; 2953 metrics->vertBearingY = ( advance - height ) / 2; 2954 metrics->vertAdvance = advance; 2955 } 2956 2957 2958 static void 2959 ft_recompute_scaled_metrics( FT_Face face, 2960 FT_Size_Metrics* metrics ) 2961 { 2962 /* Compute root ascender, descender, test height, and max_advance */ 2963 2964#ifdef GRID_FIT_METRICS 2965 metrics->ascender = FT_PIX_CEIL( FT_MulFix( face->ascender, 2966 metrics->y_scale ) ); 2967 2968 metrics->descender = FT_PIX_FLOOR( FT_MulFix( face->descender, 2969 metrics->y_scale ) ); 2970 2971 metrics->height = FT_PIX_ROUND( FT_MulFix( face->height, 2972 metrics->y_scale ) ); 2973 2974 metrics->max_advance = FT_PIX_ROUND( FT_MulFix( face->max_advance_width, 2975 metrics->x_scale ) ); 2976#else /* !GRID_FIT_METRICS */ 2977 metrics->ascender = FT_MulFix( face->ascender, 2978 metrics->y_scale ); 2979 2980 metrics->descender = FT_MulFix( face->descender, 2981 metrics->y_scale ); 2982 2983 metrics->height = FT_MulFix( face->height, 2984 metrics->y_scale ); 2985 2986 metrics->max_advance = FT_MulFix( face->max_advance_width, 2987 metrics->x_scale ); 2988#endif /* !GRID_FIT_METRICS */ 2989 } 2990 2991 2992 FT_BASE_DEF( void ) 2993 FT_Select_Metrics( FT_Face face, 2994 FT_ULong strike_index ) 2995 { 2996 FT_Size_Metrics* metrics; 2997 FT_Bitmap_Size* bsize; 2998 2999 3000 metrics = &face->size->metrics; 3001 bsize = face->available_sizes + strike_index; 3002 3003 metrics->x_ppem = (FT_UShort)( ( bsize->x_ppem + 32 ) >> 6 ); 3004 metrics->y_ppem = (FT_UShort)( ( bsize->y_ppem + 32 ) >> 6 ); 3005 3006 if ( FT_IS_SCALABLE( face ) ) 3007 { 3008 metrics->x_scale = FT_DivFix( bsize->x_ppem, 3009 face->units_per_EM ); 3010 metrics->y_scale = FT_DivFix( bsize->y_ppem, 3011 face->units_per_EM ); 3012 3013 ft_recompute_scaled_metrics( face, metrics ); 3014 } 3015 else 3016 { 3017 metrics->x_scale = 1L << 16; 3018 metrics->y_scale = 1L << 16; 3019 metrics->ascender = bsize->y_ppem; 3020 metrics->descender = 0; 3021 metrics->height = bsize->height << 6; 3022 metrics->max_advance = bsize->x_ppem; 3023 } 3024 } 3025 3026 3027 FT_BASE_DEF( void ) 3028 FT_Request_Metrics( FT_Face face, 3029 FT_Size_Request req ) 3030 { 3031 FT_Size_Metrics* metrics; 3032 3033 3034 metrics = &face->size->metrics; 3035 3036 if ( FT_IS_SCALABLE( face ) ) 3037 { 3038 FT_Long w = 0, h = 0, scaled_w = 0, scaled_h = 0; 3039 3040 3041 switch ( req->type ) 3042 { 3043 case FT_SIZE_REQUEST_TYPE_NOMINAL: 3044 w = h = face->units_per_EM; 3045 break; 3046 3047 case FT_SIZE_REQUEST_TYPE_REAL_DIM: 3048 w = h = face->ascender - face->descender; 3049 break; 3050 3051 case FT_SIZE_REQUEST_TYPE_BBOX: 3052 w = face->bbox.xMax - face->bbox.xMin; 3053 h = face->bbox.yMax - face->bbox.yMin; 3054 break; 3055 3056 case FT_SIZE_REQUEST_TYPE_CELL: 3057 w = face->max_advance_width; 3058 h = face->ascender - face->descender; 3059 break; 3060 3061 case FT_SIZE_REQUEST_TYPE_SCALES: 3062 metrics->x_scale = (FT_Fixed)req->width; 3063 metrics->y_scale = (FT_Fixed)req->height; 3064 if ( !metrics->x_scale ) 3065 metrics->x_scale = metrics->y_scale; 3066 else if ( !metrics->y_scale ) 3067 metrics->y_scale = metrics->x_scale; 3068 goto Calculate_Ppem; 3069 3070 case FT_SIZE_REQUEST_TYPE_MAX: 3071 break; 3072 } 3073 3074 /* to be on the safe side */ 3075 if ( w < 0 ) 3076 w = -w; 3077 3078 if ( h < 0 ) 3079 h = -h; 3080 3081 scaled_w = FT_REQUEST_WIDTH ( req ); 3082 scaled_h = FT_REQUEST_HEIGHT( req ); 3083 3084 /* determine scales */ 3085 if ( req->width ) 3086 { 3087 metrics->x_scale = FT_DivFix( scaled_w, w ); 3088 3089 if ( req->height ) 3090 { 3091 metrics->y_scale = FT_DivFix( scaled_h, h ); 3092 3093 if ( req->type == FT_SIZE_REQUEST_TYPE_CELL ) 3094 { 3095 if ( metrics->y_scale > metrics->x_scale ) 3096 metrics->y_scale = metrics->x_scale; 3097 else 3098 metrics->x_scale = metrics->y_scale; 3099 } 3100 } 3101 else 3102 { 3103 metrics->y_scale = metrics->x_scale; 3104 scaled_h = FT_MulDiv( scaled_w, h, w ); 3105 } 3106 } 3107 else 3108 { 3109 metrics->x_scale = metrics->y_scale = FT_DivFix( scaled_h, h ); 3110 scaled_w = FT_MulDiv( scaled_h, w, h ); 3111 } 3112 3113 Calculate_Ppem: 3114 /* calculate the ppems */ 3115 if ( req->type != FT_SIZE_REQUEST_TYPE_NOMINAL ) 3116 { 3117 scaled_w = FT_MulFix( face->units_per_EM, metrics->x_scale ); 3118 scaled_h = FT_MulFix( face->units_per_EM, metrics->y_scale ); 3119 } 3120 3121 metrics->x_ppem = (FT_UShort)( ( scaled_w + 32 ) >> 6 ); 3122 metrics->y_ppem = (FT_UShort)( ( scaled_h + 32 ) >> 6 ); 3123 3124 ft_recompute_scaled_metrics( face, metrics ); 3125 } 3126 else 3127 { 3128 FT_ZERO( metrics ); 3129 metrics->x_scale = 1L << 16; 3130 metrics->y_scale = 1L << 16; 3131 } 3132 } 3133 3134 3135 /* documentation is in freetype.h */ 3136 3137 FT_EXPORT_DEF( FT_Error ) 3138 FT_Select_Size( FT_Face face, 3139 FT_Int strike_index ) 3140 { 3141 FT_Error error = FT_Err_Ok; 3142 FT_Driver_Class clazz; 3143 3144 3145 if ( !face || !FT_HAS_FIXED_SIZES( face ) ) 3146 return FT_THROW( Invalid_Face_Handle ); 3147 3148 if ( strike_index < 0 || strike_index >= face->num_fixed_sizes ) 3149 return FT_THROW( Invalid_Argument ); 3150 3151 clazz = face->driver->clazz; 3152 3153 if ( clazz->select_size ) 3154 { 3155 error = clazz->select_size( face->size, (FT_ULong)strike_index ); 3156 3157 FT_TRACE5(( "FT_Select_Size (%s driver):\n", 3158 face->driver->root.clazz->module_name )); 3159 } 3160 else 3161 { 3162 FT_Select_Metrics( face, (FT_ULong)strike_index ); 3163 3164 FT_TRACE5(( "FT_Select_Size:\n" )); 3165 } 3166 3167#ifdef FT_DEBUG_LEVEL_TRACE 3168 { 3169 FT_Size_Metrics* metrics = &face->size->metrics; 3170 3171 3172 FT_TRACE5(( " x scale: %d (%f)\n", 3173 metrics->x_scale, metrics->x_scale / 65536.0 )); 3174 FT_TRACE5(( " y scale: %d (%f)\n", 3175 metrics->y_scale, metrics->y_scale / 65536.0 )); 3176 FT_TRACE5(( " ascender: %f\n", metrics->ascender / 64.0 )); 3177 FT_TRACE5(( " descender: %f\n", metrics->descender / 64.0 )); 3178 FT_TRACE5(( " height: %f\n", metrics->height / 64.0 )); 3179 FT_TRACE5(( " max advance: %f\n", metrics->max_advance / 64.0 )); 3180 FT_TRACE5(( " x ppem: %d\n", metrics->x_ppem )); 3181 FT_TRACE5(( " y ppem: %d\n", metrics->y_ppem )); 3182 } 3183#endif 3184 3185 return error; 3186 } 3187 3188 3189 /* documentation is in freetype.h */ 3190 3191 FT_EXPORT_DEF( FT_Error ) 3192 FT_Request_Size( FT_Face face, 3193 FT_Size_Request req ) 3194 { 3195 FT_Error error = FT_Err_Ok; 3196 FT_Driver_Class clazz; 3197 FT_ULong strike_index; 3198 3199 3200 if ( !face ) 3201 return FT_THROW( Invalid_Face_Handle ); 3202 3203 if ( !req || req->width < 0 || req->height < 0 || 3204 req->type >= FT_SIZE_REQUEST_TYPE_MAX ) 3205 return FT_THROW( Invalid_Argument ); 3206 3207 /* signal the auto-hinter to recompute its size metrics */ 3208 /* (if requested) */ 3209 face->size->internal->autohint_metrics.x_scale = 0; 3210 3211 clazz = face->driver->clazz; 3212 3213 if ( clazz->request_size ) 3214 { 3215 error = clazz->request_size( face->size, req ); 3216 3217 FT_TRACE5(( "FT_Request_Size (%s driver):\n", 3218 face->driver->root.clazz->module_name )); 3219 } 3220 else if ( !FT_IS_SCALABLE( face ) && FT_HAS_FIXED_SIZES( face ) ) 3221 { 3222 /* 3223 * The reason that a driver doesn't have `request_size' defined is 3224 * either that the scaling here suffices or that the supported formats 3225 * are bitmap-only and size matching is not implemented. 3226 * 3227 * In the latter case, a simple size matching is done. 3228 */ 3229 error = FT_Match_Size( face, req, 0, &strike_index ); 3230 if ( error ) 3231 return error; 3232 3233 return FT_Select_Size( face, (FT_Int)strike_index ); 3234 } 3235 else 3236 { 3237 FT_Request_Metrics( face, req ); 3238 3239 FT_TRACE5(( "FT_Request_Size:\n" )); 3240 } 3241 3242#ifdef FT_DEBUG_LEVEL_TRACE 3243 { 3244 FT_Size_Metrics* metrics = &face->size->metrics; 3245 3246 3247 FT_TRACE5(( " x scale: %d (%f)\n", 3248 metrics->x_scale, metrics->x_scale / 65536.0 )); 3249 FT_TRACE5(( " y scale: %d (%f)\n", 3250 metrics->y_scale, metrics->y_scale / 65536.0 )); 3251 FT_TRACE5(( " ascender: %f\n", metrics->ascender / 64.0 )); 3252 FT_TRACE5(( " descender: %f\n", metrics->descender / 64.0 )); 3253 FT_TRACE5(( " height: %f\n", metrics->height / 64.0 )); 3254 FT_TRACE5(( " max advance: %f\n", metrics->max_advance / 64.0 )); 3255 FT_TRACE5(( " x ppem: %d\n", metrics->x_ppem )); 3256 FT_TRACE5(( " y ppem: %d\n", metrics->y_ppem )); 3257 } 3258#endif 3259 3260 return error; 3261 } 3262 3263 3264 /* documentation is in freetype.h */ 3265 3266 FT_EXPORT_DEF( FT_Error ) 3267 FT_Set_Char_Size( FT_Face face, 3268 FT_F26Dot6 char_width, 3269 FT_F26Dot6 char_height, 3270 FT_UInt horz_resolution, 3271 FT_UInt vert_resolution ) 3272 { 3273 FT_Size_RequestRec req; 3274 3275 3276 /* check of `face' delayed to `FT_Request_Size' */ 3277 3278 if ( !char_width ) 3279 char_width = char_height; 3280 else if ( !char_height ) 3281 char_height = char_width; 3282 3283 if ( !horz_resolution ) 3284 horz_resolution = vert_resolution; 3285 else if ( !vert_resolution ) 3286 vert_resolution = horz_resolution; 3287 3288 if ( char_width < 1 * 64 ) 3289 char_width = 1 * 64; 3290 if ( char_height < 1 * 64 ) 3291 char_height = 1 * 64; 3292 3293 if ( !horz_resolution ) 3294 horz_resolution = vert_resolution = 72; 3295 3296 req.type = FT_SIZE_REQUEST_TYPE_NOMINAL; 3297 req.width = char_width; 3298 req.height = char_height; 3299 req.horiResolution = horz_resolution; 3300 req.vertResolution = vert_resolution; 3301 3302 return FT_Request_Size( face, &req ); 3303 } 3304 3305 3306 /* documentation is in freetype.h */ 3307 3308 FT_EXPORT_DEF( FT_Error ) 3309 FT_Set_Pixel_Sizes( FT_Face face, 3310 FT_UInt pixel_width, 3311 FT_UInt pixel_height ) 3312 { 3313 FT_Size_RequestRec req; 3314 3315 3316 /* check of `face' delayed to `FT_Request_Size' */ 3317 3318 if ( pixel_width == 0 ) 3319 pixel_width = pixel_height; 3320 else if ( pixel_height == 0 ) 3321 pixel_height = pixel_width; 3322 3323 if ( pixel_width < 1 ) 3324 pixel_width = 1; 3325 if ( pixel_height < 1 ) 3326 pixel_height = 1; 3327 3328 /* use `>=' to avoid potential compiler warning on 16bit platforms */ 3329 if ( pixel_width >= 0xFFFFU ) 3330 pixel_width = 0xFFFFU; 3331 if ( pixel_height >= 0xFFFFU ) 3332 pixel_height = 0xFFFFU; 3333 3334 req.type = FT_SIZE_REQUEST_TYPE_NOMINAL; 3335 req.width = (FT_Long)( pixel_width << 6 ); 3336 req.height = (FT_Long)( pixel_height << 6 ); 3337 req.horiResolution = 0; 3338 req.vertResolution = 0; 3339 3340 return FT_Request_Size( face, &req ); 3341 } 3342 3343 3344 /* documentation is in freetype.h */ 3345 3346 FT_EXPORT_DEF( FT_Error ) 3347 FT_Get_Kerning( FT_Face face, 3348 FT_UInt left_glyph, 3349 FT_UInt right_glyph, 3350 FT_UInt kern_mode, 3351 FT_Vector *akerning ) 3352 { 3353 FT_Error error = FT_Err_Ok; 3354 FT_Driver driver; 3355 3356 3357 if ( !face ) 3358 return FT_THROW( Invalid_Face_Handle ); 3359 3360 if ( !akerning ) 3361 return FT_THROW( Invalid_Argument ); 3362 3363 driver = face->driver; 3364 3365 akerning->x = 0; 3366 akerning->y = 0; 3367 3368 if ( driver->clazz->get_kerning ) 3369 { 3370 error = driver->clazz->get_kerning( face, 3371 left_glyph, 3372 right_glyph, 3373 akerning ); 3374 if ( !error ) 3375 { 3376 if ( kern_mode != FT_KERNING_UNSCALED ) 3377 { 3378 akerning->x = FT_MulFix( akerning->x, face->size->metrics.x_scale ); 3379 akerning->y = FT_MulFix( akerning->y, face->size->metrics.y_scale ); 3380 3381 if ( kern_mode != FT_KERNING_UNFITTED ) 3382 { 3383 FT_Pos orig_x = akerning->x; 3384 FT_Pos orig_y = akerning->y; 3385 3386 3387 /* we scale down kerning values for small ppem values */ 3388 /* to avoid that rounding makes them too big. */ 3389 /* `25' has been determined heuristically. */ 3390 if ( face->size->metrics.x_ppem < 25 ) 3391 akerning->x = FT_MulDiv( orig_x, 3392 face->size->metrics.x_ppem, 25 ); 3393 if ( face->size->metrics.y_ppem < 25 ) 3394 akerning->y = FT_MulDiv( orig_y, 3395 face->size->metrics.y_ppem, 25 ); 3396 3397 akerning->x = FT_PIX_ROUND( akerning->x ); 3398 akerning->y = FT_PIX_ROUND( akerning->y ); 3399 3400#ifdef FT_DEBUG_LEVEL_TRACE 3401 { 3402 FT_Pos orig_x_rounded = FT_PIX_ROUND( orig_x ); 3403 FT_Pos orig_y_rounded = FT_PIX_ROUND( orig_y ); 3404 3405 3406 if ( akerning->x != orig_x_rounded || 3407 akerning->y != orig_y_rounded ) 3408 FT_TRACE5(( "FT_Get_Kerning: horizontal kerning" 3409 " (%d, %d) scaled down to (%d, %d) pixels\n", 3410 orig_x_rounded / 64, orig_y_rounded / 64, 3411 akerning->x / 64, akerning->y / 64 )); 3412 } 3413#endif 3414 } 3415 } 3416 } 3417 } 3418 3419 return error; 3420 } 3421 3422 3423 /* documentation is in freetype.h */ 3424 3425 FT_EXPORT_DEF( FT_Error ) 3426 FT_Get_Track_Kerning( FT_Face face, 3427 FT_Fixed point_size, 3428 FT_Int degree, 3429 FT_Fixed* akerning ) 3430 { 3431 FT_Service_Kerning service; 3432 FT_Error error = FT_Err_Ok; 3433 3434 3435 if ( !face ) 3436 return FT_THROW( Invalid_Face_Handle ); 3437 3438 if ( !akerning ) 3439 return FT_THROW( Invalid_Argument ); 3440 3441 FT_FACE_FIND_SERVICE( face, service, KERNING ); 3442 if ( !service ) 3443 return FT_THROW( Unimplemented_Feature ); 3444 3445 error = service->get_track( face, 3446 point_size, 3447 degree, 3448 akerning ); 3449 3450 return error; 3451 } 3452 3453 3454 /* documentation is in freetype.h */ 3455 3456 FT_EXPORT_DEF( FT_Error ) 3457 FT_Select_Charmap( FT_Face face, 3458 FT_Encoding encoding ) 3459 { 3460 FT_CharMap* cur; 3461 FT_CharMap* limit; 3462 3463 3464 if ( !face ) 3465 return FT_THROW( Invalid_Face_Handle ); 3466 3467 if ( encoding == FT_ENCODING_NONE ) 3468 return FT_THROW( Invalid_Argument ); 3469 3470 /* FT_ENCODING_UNICODE is special. We try to find the `best' Unicode */ 3471 /* charmap available, i.e., one with UCS-4 characters, if possible. */ 3472 /* */ 3473 /* This is done by find_unicode_charmap() above, to share code. */ 3474 if ( encoding == FT_ENCODING_UNICODE ) 3475 return find_unicode_charmap( face ); 3476 3477 cur = face->charmaps; 3478 if ( !cur ) 3479 return FT_THROW( Invalid_CharMap_Handle ); 3480 3481 limit = cur + face->num_charmaps; 3482 3483 for ( ; cur < limit; cur++ ) 3484 { 3485 if ( cur[0]->encoding == encoding ) 3486 { 3487 face->charmap = cur[0]; 3488 return 0; 3489 } 3490 } 3491 3492 return FT_THROW( Invalid_Argument ); 3493 } 3494 3495 3496 /* documentation is in freetype.h */ 3497 3498 FT_EXPORT_DEF( FT_Error ) 3499 FT_Set_Charmap( FT_Face face, 3500 FT_CharMap charmap ) 3501 { 3502 FT_CharMap* cur; 3503 FT_CharMap* limit; 3504 3505 3506 if ( !face ) 3507 return FT_THROW( Invalid_Face_Handle ); 3508 3509 cur = face->charmaps; 3510 if ( !cur || !charmap ) 3511 return FT_THROW( Invalid_CharMap_Handle ); 3512 3513 if ( FT_Get_CMap_Format( charmap ) == 14 ) 3514 return FT_THROW( Invalid_Argument ); 3515 3516 limit = cur + face->num_charmaps; 3517 3518 for ( ; cur < limit; cur++ ) 3519 { 3520 if ( cur[0] == charmap ) 3521 { 3522 face->charmap = cur[0]; 3523 return FT_Err_Ok; 3524 } 3525 } 3526 3527 return FT_THROW( Invalid_Argument ); 3528 } 3529 3530 3531 /* documentation is in freetype.h */ 3532 3533 FT_EXPORT_DEF( FT_Int ) 3534 FT_Get_Charmap_Index( FT_CharMap charmap ) 3535 { 3536 FT_Int i; 3537 3538 3539 if ( !charmap || !charmap->face ) 3540 return -1; 3541 3542 for ( i = 0; i < charmap->face->num_charmaps; i++ ) 3543 if ( charmap->face->charmaps[i] == charmap ) 3544 break; 3545 3546 FT_ASSERT( i < charmap->face->num_charmaps ); 3547 3548 return i; 3549 } 3550 3551 3552 static void 3553 ft_cmap_done_internal( FT_CMap cmap ) 3554 { 3555 FT_CMap_Class clazz = cmap->clazz; 3556 FT_Face face = cmap->charmap.face; 3557 FT_Memory memory = FT_FACE_MEMORY( face ); 3558 3559 3560 if ( clazz->done ) 3561 clazz->done( cmap ); 3562 3563 FT_FREE( cmap ); 3564 } 3565 3566 3567 FT_BASE_DEF( void ) 3568 FT_CMap_Done( FT_CMap cmap ) 3569 { 3570 if ( cmap ) 3571 { 3572 FT_Face face = cmap->charmap.face; 3573 FT_Memory memory = FT_FACE_MEMORY( face ); 3574 FT_Error error; 3575 FT_Int i, j; 3576 3577 3578 for ( i = 0; i < face->num_charmaps; i++ ) 3579 { 3580 if ( (FT_CMap)face->charmaps[i] == cmap ) 3581 { 3582 FT_CharMap last_charmap = face->charmaps[face->num_charmaps - 1]; 3583 3584 3585 if ( FT_RENEW_ARRAY( face->charmaps, 3586 face->num_charmaps, 3587 face->num_charmaps - 1 ) ) 3588 return; 3589 3590 /* remove it from our list of charmaps */ 3591 for ( j = i + 1; j < face->num_charmaps; j++ ) 3592 { 3593 if ( j == face->num_charmaps - 1 ) 3594 face->charmaps[j - 1] = last_charmap; 3595 else 3596 face->charmaps[j - 1] = face->charmaps[j]; 3597 } 3598 3599 face->num_charmaps--; 3600 3601 if ( (FT_CMap)face->charmap == cmap ) 3602 face->charmap = NULL; 3603 3604 ft_cmap_done_internal( cmap ); 3605 3606 break; 3607 } 3608 } 3609 } 3610 } 3611 3612 3613 FT_BASE_DEF( FT_Error ) 3614 FT_CMap_New( FT_CMap_Class clazz, 3615 FT_Pointer init_data, 3616 FT_CharMap charmap, 3617 FT_CMap *acmap ) 3618 { 3619 FT_Error error = FT_Err_Ok; 3620 FT_Face face; 3621 FT_Memory memory; 3622 FT_CMap cmap = NULL; 3623 3624 3625 if ( !clazz || !charmap || !charmap->face ) 3626 return FT_THROW( Invalid_Argument ); 3627 3628 face = charmap->face; 3629 memory = FT_FACE_MEMORY( face ); 3630 3631 if ( !FT_ALLOC( cmap, clazz->size ) ) 3632 { 3633 cmap->charmap = *charmap; 3634 cmap->clazz = clazz; 3635 3636 if ( clazz->init ) 3637 { 3638 error = clazz->init( cmap, init_data ); 3639 if ( error ) 3640 goto Fail; 3641 } 3642 3643 /* add it to our list of charmaps */ 3644 if ( FT_RENEW_ARRAY( face->charmaps, 3645 face->num_charmaps, 3646 face->num_charmaps + 1 ) ) 3647 goto Fail; 3648 3649 face->charmaps[face->num_charmaps++] = (FT_CharMap)cmap; 3650 } 3651 3652 Exit: 3653 if ( acmap ) 3654 *acmap = cmap; 3655 3656 return error; 3657 3658 Fail: 3659 ft_cmap_done_internal( cmap ); 3660 cmap = NULL; 3661 goto Exit; 3662 } 3663 3664 3665 /* documentation is in freetype.h */ 3666 3667 FT_EXPORT_DEF( FT_UInt ) 3668 FT_Get_Char_Index( FT_Face face, 3669 FT_ULong charcode ) 3670 { 3671 FT_UInt result = 0; 3672 3673 3674 if ( face && face->charmap ) 3675 { 3676 FT_CMap cmap = FT_CMAP( face->charmap ); 3677 3678 3679 if ( charcode > 0xFFFFFFFFUL ) 3680 { 3681 FT_TRACE1(( "FT_Get_Char_Index: too large charcode" )); 3682 FT_TRACE1(( " 0x%x is truncated\n", charcode )); 3683 } 3684 3685 result = cmap->clazz->char_index( cmap, (FT_UInt32)charcode ); 3686 if ( result >= (FT_UInt)face->num_glyphs ) 3687 result = 0; 3688 } 3689 3690 return result; 3691 } 3692 3693 3694 /* documentation is in freetype.h */ 3695 3696 FT_EXPORT_DEF( FT_ULong ) 3697 FT_Get_First_Char( FT_Face face, 3698 FT_UInt *agindex ) 3699 { 3700 FT_ULong result = 0; 3701 FT_UInt gindex = 0; 3702 3703 3704 /* only do something if we have a charmap, and we have glyphs at all */ 3705 if ( face && face->charmap && face->num_glyphs ) 3706 { 3707 gindex = FT_Get_Char_Index( face, 0 ); 3708 if ( gindex == 0 ) 3709 result = FT_Get_Next_Char( face, 0, &gindex ); 3710 } 3711 3712 if ( agindex ) 3713 *agindex = gindex; 3714 3715 return result; 3716 } 3717 3718 3719 /* documentation is in freetype.h */ 3720 3721 FT_EXPORT_DEF( FT_ULong ) 3722 FT_Get_Next_Char( FT_Face face, 3723 FT_ULong charcode, 3724 FT_UInt *agindex ) 3725 { 3726 FT_ULong result = 0; 3727 FT_UInt gindex = 0; 3728 3729 3730 if ( face && face->charmap && face->num_glyphs ) 3731 { 3732 FT_UInt32 code = (FT_UInt32)charcode; 3733 FT_CMap cmap = FT_CMAP( face->charmap ); 3734 3735 3736 do 3737 { 3738 gindex = cmap->clazz->char_next( cmap, &code ); 3739 3740 } while ( gindex >= (FT_UInt)face->num_glyphs ); 3741 3742 result = ( gindex == 0 ) ? 0 : code; 3743 } 3744 3745 if ( agindex ) 3746 *agindex = gindex; 3747 3748 return result; 3749 } 3750 3751 3752 /* documentation is in freetype.h */ 3753 3754 FT_EXPORT_DEF( FT_Error ) 3755 FT_Face_Properties( FT_Face face, 3756 FT_UInt num_properties, 3757 FT_Parameter* properties ) 3758 { 3759 FT_Error error = FT_Err_Ok; 3760 3761 3762 if ( num_properties > 0 && !properties ) 3763 { 3764 error = FT_THROW( Invalid_Argument ); 3765 goto Exit; 3766 } 3767 3768 for ( ; num_properties > 0; num_properties-- ) 3769 { 3770 if ( properties->tag == FT_PARAM_TAG_STEM_DARKENING ) 3771 { 3772 if ( properties->data ) 3773 { 3774 if ( *( (FT_Bool*)properties->data ) == TRUE ) 3775 face->internal->no_stem_darkening = FALSE; 3776 else 3777 face->internal->no_stem_darkening = TRUE; 3778 } 3779 else 3780 { 3781 /* use module default */ 3782 face->internal->no_stem_darkening = -1; 3783 } 3784 } 3785 else if ( properties->tag == FT_PARAM_TAG_LCD_FILTER_WEIGHTS ) 3786 { 3787#ifdef FT_CONFIG_OPTION_SUBPIXEL_RENDERING 3788 if ( properties->data ) 3789 { 3790 ft_memcpy( face->internal->lcd_weights, 3791 properties->data, 3792 FT_LCD_FILTER_FIVE_TAPS ); 3793 face->internal->lcd_filter_func = ft_lcd_filter_fir; 3794 } 3795#else 3796 error = FT_THROW( Unimplemented_Feature ); 3797 goto Exit; 3798#endif 3799 } 3800 else if ( properties->tag == FT_PARAM_TAG_RANDOM_SEED ) 3801 { 3802 if ( properties->data ) 3803 { 3804 face->internal->random_seed = *( (FT_Int32*)properties->data ); 3805 if ( face->internal->random_seed < 0 ) 3806 face->internal->random_seed = 0; 3807 } 3808 else 3809 { 3810 /* use module default */ 3811 face->internal->random_seed = -1; 3812 } 3813 } 3814 else 3815 { 3816 error = FT_THROW( Invalid_Argument ); 3817 goto Exit; 3818 } 3819 3820 if ( error ) 3821 break; 3822 3823 properties++; 3824 } 3825 3826 Exit: 3827 return error; 3828 } 3829 3830 3831 /* documentation is in freetype.h */ 3832 3833 FT_EXPORT_DEF( FT_UInt ) 3834 FT_Face_GetCharVariantIndex( FT_Face face, 3835 FT_ULong charcode, 3836 FT_ULong variantSelector ) 3837 { 3838 FT_UInt result = 0; 3839 3840 3841 if ( face && 3842 face->charmap && 3843 face->charmap->encoding == FT_ENCODING_UNICODE ) 3844 { 3845 FT_CharMap charmap = find_variant_selector_charmap( face ); 3846 FT_CMap ucmap = FT_CMAP( face->charmap ); 3847 3848 3849 if ( charmap ) 3850 { 3851 FT_CMap vcmap = FT_CMAP( charmap ); 3852 3853 3854 if ( charcode > 0xFFFFFFFFUL ) 3855 { 3856 FT_TRACE1(( "FT_Face_GetCharVariantIndex:" 3857 " too large charcode" )); 3858 FT_TRACE1(( " 0x%x is truncated\n", charcode )); 3859 } 3860 if ( variantSelector > 0xFFFFFFFFUL ) 3861 { 3862 FT_TRACE1(( "FT_Face_GetCharVariantIndex:" 3863 " too large variantSelector" )); 3864 FT_TRACE1(( " 0x%x is truncated\n", variantSelector )); 3865 } 3866 3867 result = vcmap->clazz->char_var_index( vcmap, ucmap, 3868 (FT_UInt32)charcode, 3869 (FT_UInt32)variantSelector ); 3870 } 3871 } 3872 3873 return result; 3874 } 3875 3876 3877 /* documentation is in freetype.h */ 3878 3879 FT_EXPORT_DEF( FT_Int ) 3880 FT_Face_GetCharVariantIsDefault( FT_Face face, 3881 FT_ULong charcode, 3882 FT_ULong variantSelector ) 3883 { 3884 FT_Int result = -1; 3885 3886 3887 if ( face ) 3888 { 3889 FT_CharMap charmap = find_variant_selector_charmap( face ); 3890 3891 3892 if ( charmap ) 3893 { 3894 FT_CMap vcmap = FT_CMAP( charmap ); 3895 3896 3897 if ( charcode > 0xFFFFFFFFUL ) 3898 { 3899 FT_TRACE1(( "FT_Face_GetCharVariantIsDefault:" 3900 " too large charcode" )); 3901 FT_TRACE1(( " 0x%x is truncated\n", charcode )); 3902 } 3903 if ( variantSelector > 0xFFFFFFFFUL ) 3904 { 3905 FT_TRACE1(( "FT_Face_GetCharVariantIsDefault:" 3906 " too large variantSelector" )); 3907 FT_TRACE1(( " 0x%x is truncated\n", variantSelector )); 3908 } 3909 3910 result = vcmap->clazz->char_var_default( vcmap, 3911 (FT_UInt32)charcode, 3912 (FT_UInt32)variantSelector ); 3913 } 3914 } 3915 3916 return result; 3917 } 3918 3919 3920 /* documentation is in freetype.h */ 3921 3922 FT_EXPORT_DEF( FT_UInt32* ) 3923 FT_Face_GetVariantSelectors( FT_Face face ) 3924 { 3925 FT_UInt32 *result = NULL; 3926 3927 3928 if ( face ) 3929 { 3930 FT_CharMap charmap = find_variant_selector_charmap( face ); 3931 3932 3933 if ( charmap ) 3934 { 3935 FT_CMap vcmap = FT_CMAP( charmap ); 3936 FT_Memory memory = FT_FACE_MEMORY( face ); 3937 3938 3939 result = vcmap->clazz->variant_list( vcmap, memory ); 3940 } 3941 } 3942 3943 return result; 3944 } 3945 3946 3947 /* documentation is in freetype.h */ 3948 3949 FT_EXPORT_DEF( FT_UInt32* ) 3950 FT_Face_GetVariantsOfChar( FT_Face face, 3951 FT_ULong charcode ) 3952 { 3953 FT_UInt32 *result = NULL; 3954 3955 3956 if ( face ) 3957 { 3958 FT_CharMap charmap = find_variant_selector_charmap( face ); 3959 3960 3961 if ( charmap ) 3962 { 3963 FT_CMap vcmap = FT_CMAP( charmap ); 3964 FT_Memory memory = FT_FACE_MEMORY( face ); 3965 3966 3967 if ( charcode > 0xFFFFFFFFUL ) 3968 { 3969 FT_TRACE1(( "FT_Face_GetVariantsOfChar: too large charcode" )); 3970 FT_TRACE1(( " 0x%x is truncated\n", charcode )); 3971 } 3972 3973 result = vcmap->clazz->charvariant_list( vcmap, memory, 3974 (FT_UInt32)charcode ); 3975 } 3976 } 3977 return result; 3978 } 3979 3980 3981 /* documentation is in freetype.h */ 3982 3983 FT_EXPORT_DEF( FT_UInt32* ) 3984 FT_Face_GetCharsOfVariant( FT_Face face, 3985 FT_ULong variantSelector ) 3986 { 3987 FT_UInt32 *result = NULL; 3988 3989 3990 if ( face ) 3991 { 3992 FT_CharMap charmap = find_variant_selector_charmap( face ); 3993 3994 3995 if ( charmap ) 3996 { 3997 FT_CMap vcmap = FT_CMAP( charmap ); 3998 FT_Memory memory = FT_FACE_MEMORY( face ); 3999 4000 4001 if ( variantSelector > 0xFFFFFFFFUL ) 4002 { 4003 FT_TRACE1(( "FT_Get_Char_Index: too large variantSelector" )); 4004 FT_TRACE1(( " 0x%x is truncated\n", variantSelector )); 4005 } 4006 4007 result = vcmap->clazz->variantchar_list( vcmap, memory, 4008 (FT_UInt32)variantSelector ); 4009 } 4010 } 4011 4012 return result; 4013 } 4014 4015 4016 /* documentation is in freetype.h */ 4017 4018 FT_EXPORT_DEF( FT_UInt ) 4019 FT_Get_Name_Index( FT_Face face, 4020 FT_String* glyph_name ) 4021 { 4022 FT_UInt result = 0; 4023 4024 4025 if ( face && 4026 FT_HAS_GLYPH_NAMES( face ) && 4027 glyph_name ) 4028 { 4029 FT_Service_GlyphDict service; 4030 4031 4032 FT_FACE_LOOKUP_SERVICE( face, 4033 service, 4034 GLYPH_DICT ); 4035 4036 if ( service && service->name_index ) 4037 result = service->name_index( face, glyph_name ); 4038 } 4039 4040 return result; 4041 } 4042 4043 4044 /* documentation is in freetype.h */ 4045 4046 FT_EXPORT_DEF( FT_Error ) 4047 FT_Get_Glyph_Name( FT_Face face, 4048 FT_UInt glyph_index, 4049 FT_Pointer buffer, 4050 FT_UInt buffer_max ) 4051 { 4052 FT_Error error; 4053 FT_Service_GlyphDict service; 4054 4055 4056 if ( !face ) 4057 return FT_THROW( Invalid_Face_Handle ); 4058 4059 if ( !buffer || buffer_max == 0 ) 4060 return FT_THROW( Invalid_Argument ); 4061 4062 /* clean up buffer */ 4063 ((FT_Byte*)buffer)[0] = '\0'; 4064 4065 if ( (FT_Long)glyph_index >= face->num_glyphs ) 4066 return FT_THROW( Invalid_Glyph_Index ); 4067 4068 if ( !FT_HAS_GLYPH_NAMES( face ) ) 4069 return FT_THROW( Invalid_Argument ); 4070 4071 FT_FACE_LOOKUP_SERVICE( face, service, GLYPH_DICT ); 4072 if ( service && service->get_name ) 4073 error = service->get_name( face, glyph_index, buffer, buffer_max ); 4074 else 4075 error = FT_THROW( Invalid_Argument ); 4076 4077 return error; 4078 } 4079 4080 4081 /* documentation is in freetype.h */ 4082 4083 FT_EXPORT_DEF( const char* ) 4084 FT_Get_Postscript_Name( FT_Face face ) 4085 { 4086 const char* result = NULL; 4087 4088 4089 if ( !face ) 4090 goto Exit; 4091 4092 if ( !result ) 4093 { 4094 FT_Service_PsFontName service; 4095 4096 4097 FT_FACE_LOOKUP_SERVICE( face, 4098 service, 4099 POSTSCRIPT_FONT_NAME ); 4100 4101 if ( service && service->get_ps_font_name ) 4102 result = service->get_ps_font_name( face ); 4103 } 4104 4105 Exit: 4106 return result; 4107 } 4108 4109 4110 /* documentation is in tttables.h */ 4111 4112 FT_EXPORT_DEF( void* ) 4113 FT_Get_Sfnt_Table( FT_Face face, 4114 FT_Sfnt_Tag tag ) 4115 { 4116 void* table = NULL; 4117 FT_Service_SFNT_Table service; 4118 4119 4120 if ( face && FT_IS_SFNT( face ) ) 4121 { 4122 FT_FACE_FIND_SERVICE( face, service, SFNT_TABLE ); 4123 if ( service ) 4124 table = service->get_table( face, tag ); 4125 } 4126 4127 return table; 4128 } 4129 4130 4131 /* documentation is in tttables.h */ 4132 4133 FT_EXPORT_DEF( FT_Error ) 4134 FT_Load_Sfnt_Table( FT_Face face, 4135 FT_ULong tag, 4136 FT_Long offset, 4137 FT_Byte* buffer, 4138 FT_ULong* length ) 4139 { 4140 FT_Service_SFNT_Table service; 4141 4142 4143 if ( !face || !FT_IS_SFNT( face ) ) 4144 return FT_THROW( Invalid_Face_Handle ); 4145 4146 FT_FACE_FIND_SERVICE( face, service, SFNT_TABLE ); 4147 if ( !service ) 4148 return FT_THROW( Unimplemented_Feature ); 4149 4150 return service->load_table( face, tag, offset, buffer, length ); 4151 } 4152 4153 4154 /* documentation is in tttables.h */ 4155 4156 FT_EXPORT_DEF( FT_Error ) 4157 FT_Sfnt_Table_Info( FT_Face face, 4158 FT_UInt table_index, 4159 FT_ULong *tag, 4160 FT_ULong *length ) 4161 { 4162 FT_Service_SFNT_Table service; 4163 FT_ULong offset; 4164 4165 4166 /* test for valid `length' delayed to `service->table_info' */ 4167 4168 if ( !face || !FT_IS_SFNT( face ) ) 4169 return FT_THROW( Invalid_Face_Handle ); 4170 4171 FT_FACE_FIND_SERVICE( face, service, SFNT_TABLE ); 4172 if ( !service ) 4173 return FT_THROW( Unimplemented_Feature ); 4174 4175 return service->table_info( face, table_index, tag, &offset, length ); 4176 } 4177 4178 4179 /* documentation is in tttables.h */ 4180 4181 FT_EXPORT_DEF( FT_ULong ) 4182 FT_Get_CMap_Language_ID( FT_CharMap charmap ) 4183 { 4184 FT_Service_TTCMaps service; 4185 FT_Face face; 4186 TT_CMapInfo cmap_info; 4187 4188 4189 if ( !charmap || !charmap->face ) 4190 return 0; 4191 4192 face = charmap->face; 4193 FT_FACE_FIND_SERVICE( face, service, TT_CMAP ); 4194 if ( !service ) 4195 return 0; 4196 if ( service->get_cmap_info( charmap, &cmap_info )) 4197 return 0; 4198 4199 return cmap_info.language; 4200 } 4201 4202 4203 /* documentation is in tttables.h */ 4204 4205 FT_EXPORT_DEF( FT_Long ) 4206 FT_Get_CMap_Format( FT_CharMap charmap ) 4207 { 4208 FT_Service_TTCMaps service; 4209 FT_Face face; 4210 TT_CMapInfo cmap_info; 4211 4212 4213 if ( !charmap || !charmap->face ) 4214 return -1; 4215 4216 face = charmap->face; 4217 FT_FACE_FIND_SERVICE( face, service, TT_CMAP ); 4218 if ( !service ) 4219 return -1; 4220 if ( service->get_cmap_info( charmap, &cmap_info )) 4221 return -1; 4222 4223 return cmap_info.format; 4224 } 4225 4226 4227 /* documentation is in ftsizes.h */ 4228 4229 FT_EXPORT_DEF( FT_Error ) 4230 FT_Activate_Size( FT_Size size ) 4231 { 4232 FT_Face face; 4233 4234 4235 if ( !size ) 4236 return FT_THROW( Invalid_Size_Handle ); 4237 4238 face = size->face; 4239 if ( !face || !face->driver ) 4240 return FT_THROW( Invalid_Face_Handle ); 4241 4242 /* we don't need anything more complex than that; all size objects */ 4243 /* are already listed by the face */ 4244 face->size = size; 4245 4246 return FT_Err_Ok; 4247 } 4248 4249 4250 /*************************************************************************/ 4251 /*************************************************************************/ 4252 /*************************************************************************/ 4253 /**** ****/ 4254 /**** ****/ 4255 /**** R E N D E R E R S ****/ 4256 /**** ****/ 4257 /**** ****/ 4258 /*************************************************************************/ 4259 /*************************************************************************/ 4260 /*************************************************************************/ 4261 4262 /* lookup a renderer by glyph format in the library's list */ 4263 FT_BASE_DEF( FT_Renderer ) 4264 FT_Lookup_Renderer( FT_Library library, 4265 FT_Glyph_Format format, 4266 FT_ListNode* node ) 4267 { 4268 FT_ListNode cur; 4269 FT_Renderer result = NULL; 4270 4271 4272 if ( !library ) 4273 goto Exit; 4274 4275 cur = library->renderers.head; 4276 4277 if ( node ) 4278 { 4279 if ( *node ) 4280 cur = (*node)->next; 4281 *node = NULL; 4282 } 4283 4284 while ( cur ) 4285 { 4286 FT_Renderer renderer = FT_RENDERER( cur->data ); 4287 4288 4289 if ( renderer->glyph_format == format ) 4290 { 4291 if ( node ) 4292 *node = cur; 4293 4294 result = renderer; 4295 break; 4296 } 4297 cur = cur->next; 4298 } 4299 4300 Exit: 4301 return result; 4302 } 4303 4304 4305 static FT_Renderer 4306 ft_lookup_glyph_renderer( FT_GlyphSlot slot ) 4307 { 4308 FT_Face face = slot->face; 4309 FT_Library library = FT_FACE_LIBRARY( face ); 4310 FT_Renderer result = library->cur_renderer; 4311 4312 4313 if ( !result || result->glyph_format != slot->format ) 4314 result = FT_Lookup_Renderer( library, slot->format, 0 ); 4315 4316 return result; 4317 } 4318 4319 4320 static void 4321 ft_set_current_renderer( FT_Library library ) 4322 { 4323 FT_Renderer renderer; 4324 4325 4326 renderer = FT_Lookup_Renderer( library, FT_GLYPH_FORMAT_OUTLINE, 0 ); 4327 library->cur_renderer = renderer; 4328 } 4329 4330 4331 static FT_Error 4332 ft_add_renderer( FT_Module module ) 4333 { 4334 FT_Library library = module->library; 4335 FT_Memory memory = library->memory; 4336 FT_Error error; 4337 FT_ListNode node = NULL; 4338 4339 4340 if ( FT_NEW( node ) ) 4341 goto Exit; 4342 4343 { 4344 FT_Renderer render = FT_RENDERER( module ); 4345 FT_Renderer_Class* clazz = (FT_Renderer_Class*)module->clazz; 4346 4347 4348 render->clazz = clazz; 4349 render->glyph_format = clazz->glyph_format; 4350 4351 /* allocate raster object if needed */ 4352 if ( clazz->glyph_format == FT_GLYPH_FORMAT_OUTLINE && 4353 clazz->raster_class->raster_new ) 4354 { 4355 error = clazz->raster_class->raster_new( memory, &render->raster ); 4356 if ( error ) 4357 goto Fail; 4358 4359 render->raster_render = clazz->raster_class->raster_render; 4360 render->render = clazz->render_glyph; 4361 } 4362 4363 /* add to list */ 4364 node->data = module; 4365 FT_List_Add( &library->renderers, node ); 4366 4367 ft_set_current_renderer( library ); 4368 } 4369 4370 Fail: 4371 if ( error ) 4372 FT_FREE( node ); 4373 4374 Exit: 4375 return error; 4376 } 4377 4378 4379 static void 4380 ft_remove_renderer( FT_Module module ) 4381 { 4382 FT_Library library; 4383 FT_Memory memory; 4384 FT_ListNode node; 4385 4386 4387 library = module->library; 4388 if ( !library ) 4389 return; 4390 4391 memory = library->memory; 4392 4393 node = FT_List_Find( &library->renderers, module ); 4394 if ( node ) 4395 { 4396 FT_Renderer render = FT_RENDERER( module ); 4397 4398 4399 /* release raster object, if any */ 4400 if ( render->clazz->glyph_format == FT_GLYPH_FORMAT_OUTLINE && 4401 render->raster ) 4402 render->clazz->raster_class->raster_done( render->raster ); 4403 4404 /* remove from list */ 4405 FT_List_Remove( &library->renderers, node ); 4406 FT_FREE( node ); 4407 4408 ft_set_current_renderer( library ); 4409 } 4410 } 4411 4412 4413 /* documentation is in ftrender.h */ 4414 4415 FT_EXPORT_DEF( FT_Renderer ) 4416 FT_Get_Renderer( FT_Library library, 4417 FT_Glyph_Format format ) 4418 { 4419 /* test for valid `library' delayed to `FT_Lookup_Renderer' */ 4420 4421 return FT_Lookup_Renderer( library, format, 0 ); 4422 } 4423 4424 4425 /* documentation is in ftrender.h */ 4426 4427 FT_EXPORT_DEF( FT_Error ) 4428 FT_Set_Renderer( FT_Library library, 4429 FT_Renderer renderer, 4430 FT_UInt num_params, 4431 FT_Parameter* parameters ) 4432 { 4433 FT_ListNode node; 4434 FT_Error error = FT_Err_Ok; 4435 4436 FT_Renderer_SetModeFunc set_mode; 4437 4438 4439 if ( !library ) 4440 { 4441 error = FT_THROW( Invalid_Library_Handle ); 4442 goto Exit; 4443 } 4444 4445 if ( !renderer ) 4446 { 4447 error = FT_THROW( Invalid_Argument ); 4448 goto Exit; 4449 } 4450 4451 if ( num_params > 0 && !parameters ) 4452 { 4453 error = FT_THROW( Invalid_Argument ); 4454 goto Exit; 4455 } 4456 4457 node = FT_List_Find( &library->renderers, renderer ); 4458 if ( !node ) 4459 { 4460 error = FT_THROW( Invalid_Argument ); 4461 goto Exit; 4462 } 4463 4464 FT_List_Up( &library->renderers, node ); 4465 4466 if ( renderer->glyph_format == FT_GLYPH_FORMAT_OUTLINE ) 4467 library->cur_renderer = renderer; 4468 4469 set_mode = renderer->clazz->set_mode; 4470 4471 for ( ; num_params > 0; num_params-- ) 4472 { 4473 error = set_mode( renderer, parameters->tag, parameters->data ); 4474 if ( error ) 4475 break; 4476 parameters++; 4477 } 4478 4479 Exit: 4480 return error; 4481 } 4482 4483 4484 FT_BASE_DEF( FT_Error ) 4485 FT_Render_Glyph_Internal( FT_Library library, 4486 FT_GlyphSlot slot, 4487 FT_Render_Mode render_mode ) 4488 { 4489 FT_Error error = FT_Err_Ok; 4490 FT_Renderer renderer; 4491 4492 4493 /* if it is already a bitmap, no need to do anything */ 4494 switch ( slot->format ) 4495 { 4496 case FT_GLYPH_FORMAT_BITMAP: /* already a bitmap, don't do anything */ 4497 break; 4498 4499 default: 4500 { 4501 FT_ListNode node = NULL; 4502 4503 4504 /* small shortcut for the very common case */ 4505 if ( slot->format == FT_GLYPH_FORMAT_OUTLINE ) 4506 { 4507 renderer = library->cur_renderer; 4508 node = library->renderers.head; 4509 } 4510 else 4511 renderer = FT_Lookup_Renderer( library, slot->format, &node ); 4512 4513 error = FT_ERR( Unimplemented_Feature ); 4514 while ( renderer ) 4515 { 4516 error = renderer->render( renderer, slot, render_mode, NULL ); 4517 if ( !error || 4518 FT_ERR_NEQ( error, Cannot_Render_Glyph ) ) 4519 break; 4520 4521 /* FT_Err_Cannot_Render_Glyph is returned if the render mode */ 4522 /* is unsupported by the current renderer for this glyph image */ 4523 /* format. */ 4524 4525 /* now, look for another renderer that supports the same */ 4526 /* format. */ 4527 renderer = FT_Lookup_Renderer( library, slot->format, &node ); 4528 } 4529 } 4530 } 4531 4532#ifdef FT_DEBUG_LEVEL_TRACE 4533 4534#undef FT_COMPONENT 4535#define FT_COMPONENT trace_bitmap 4536 4537 /* 4538 * Computing the MD5 checksum is expensive, unnecessarily distorting a 4539 * possible profiling of FreeType if compiled with tracing support. For 4540 * this reason, we execute the following code only if explicitly 4541 * requested. 4542 */ 4543 4544 /* we use FT_TRACE3 in this block */ 4545 if ( !error && 4546 ft_trace_levels[trace_bitmap] >= 3 && 4547 slot->bitmap.buffer ) 4548 { 4549 FT_Bitmap bitmap; 4550 FT_Error err; 4551 4552 4553 FT_Bitmap_Init( &bitmap ); 4554 4555 /* we convert to a single bitmap format for computing the checksum */ 4556 /* this also converts the bitmap flow to `down' (i.e., pitch > 0) */ 4557 err = FT_Bitmap_Convert( library, &slot->bitmap, &bitmap, 1 ); 4558 if ( !err ) 4559 { 4560 MD5_CTX ctx; 4561 unsigned char md5[16]; 4562 unsigned long coverage = 0; 4563 int i, j; 4564 int rows = (int)bitmap.rows; 4565 int pitch = bitmap.pitch; 4566 4567 4568 FT_TRACE3(( "FT_Render_Glyph: bitmap %dx%d, mode %d\n", 4569 rows, pitch, slot->bitmap.pixel_mode )); 4570 4571 for ( i = 0; i < rows; i++ ) 4572 for ( j = 0; j < pitch; j++ ) 4573 coverage += bitmap.buffer[i * pitch + j]; 4574 4575 FT_TRACE3(( " Total coverage: %lu\n", coverage )); 4576 4577 MD5_Init( &ctx ); 4578 if ( bitmap.buffer ) 4579 MD5_Update( &ctx, bitmap.buffer, 4580 (unsigned long)rows * (unsigned long)pitch ); 4581 MD5_Final( md5, &ctx ); 4582 4583 FT_TRACE3(( " MD5 checksum: " )); 4584 for ( i = 0; i < 16; i++ ) 4585 FT_TRACE3(( "%02X", md5[i] )); 4586 FT_TRACE3(( "\n" )); 4587 } 4588 4589 FT_Bitmap_Done( library, &bitmap ); 4590 } 4591 4592 /* 4593 * Dump bitmap in Netpbm format (PBM or PGM). 4594 */ 4595 4596 /* we use FT_TRACE7 in this block */ 4597 if ( !error && 4598 ft_trace_levels[trace_bitmap] >= 7 && 4599 slot->bitmap.rows < 128U && 4600 slot->bitmap.width < 128U && 4601 slot->bitmap.buffer ) 4602 { 4603 int rows = (int)slot->bitmap.rows; 4604 int width = (int)slot->bitmap.width; 4605 int pitch = slot->bitmap.pitch; 4606 int i, j, m; 4607 unsigned char* topleft = slot->bitmap.buffer; 4608 4609 if ( pitch < 0 ) 4610 topleft -= pitch * ( rows - 1 ); 4611 4612 FT_TRACE7(( "Netpbm image: start\n" )); 4613 switch ( slot->bitmap.pixel_mode ) 4614 { 4615 case FT_PIXEL_MODE_MONO: 4616 FT_TRACE7(( "P1 %d %d\n", width, rows )); 4617 for ( i = 0; i < rows; i++ ) 4618 { 4619 for ( j = 0; j < width; ) 4620 for ( m = 128; m > 0 && j < width; m >>= 1, j++ ) 4621 FT_TRACE7(( " %d", ( topleft[i * pitch + j / 8] & m ) != 0 )); 4622 FT_TRACE7(( "\n" )); 4623 } 4624 break; 4625 4626 default: 4627 FT_TRACE7(( "P2 %d %d 255\n", width, rows )); 4628 for ( i = 0; i < rows; i++ ) 4629 { 4630 for ( j = 0; j < width; j += 1 ) 4631 FT_TRACE7(( " %3u", topleft[i * pitch + j] )); 4632 FT_TRACE7(( "\n" )); 4633 } 4634 } 4635 FT_TRACE7(( "Netpbm image: end\n" )); 4636 } 4637 4638#undef FT_COMPONENT 4639#define FT_COMPONENT trace_objs 4640 4641#endif /* FT_DEBUG_LEVEL_TRACE */ 4642 4643 return error; 4644 } 4645 4646 4647 /* documentation is in freetype.h */ 4648 4649 FT_EXPORT_DEF( FT_Error ) 4650 FT_Render_Glyph( FT_GlyphSlot slot, 4651 FT_Render_Mode render_mode ) 4652 { 4653 FT_Library library; 4654 4655 4656 if ( !slot || !slot->face ) 4657 return FT_THROW( Invalid_Argument ); 4658 4659 library = FT_FACE_LIBRARY( slot->face ); 4660 4661 return FT_Render_Glyph_Internal( library, slot, render_mode ); 4662 } 4663 4664 4665 /*************************************************************************/ 4666 /*************************************************************************/ 4667 /*************************************************************************/ 4668 /**** ****/ 4669 /**** ****/ 4670 /**** M O D U L E S ****/ 4671 /**** ****/ 4672 /**** ****/ 4673 /*************************************************************************/ 4674 /*************************************************************************/ 4675 /*************************************************************************/ 4676 4677 4678 /*************************************************************************/ 4679 /* */ 4680 /* <Function> */ 4681 /* Destroy_Module */ 4682 /* */ 4683 /* <Description> */ 4684 /* Destroys a given module object. For drivers, this also destroys */ 4685 /* all child faces. */ 4686 /* */ 4687 /* <InOut> */ 4688 /* module :: A handle to the target driver object. */ 4689 /* */ 4690 /* <Note> */ 4691 /* The driver _must_ be LOCKED! */ 4692 /* */ 4693 static void 4694 Destroy_Module( FT_Module module ) 4695 { 4696 FT_Memory memory = module->memory; 4697 FT_Module_Class* clazz = module->clazz; 4698 FT_Library library = module->library; 4699 4700 4701 if ( library && library->auto_hinter == module ) 4702 library->auto_hinter = NULL; 4703 4704 /* if the module is a renderer */ 4705 if ( FT_MODULE_IS_RENDERER( module ) ) 4706 ft_remove_renderer( module ); 4707 4708 /* if the module is a font driver, add some steps */ 4709 if ( FT_MODULE_IS_DRIVER( module ) ) 4710 Destroy_Driver( FT_DRIVER( module ) ); 4711 4712 /* finalize the module object */ 4713 if ( clazz->module_done ) 4714 clazz->module_done( module ); 4715 4716 /* discard it */ 4717 FT_FREE( module ); 4718 } 4719 4720 4721 /* documentation is in ftmodapi.h */ 4722 4723 FT_EXPORT_DEF( FT_Error ) 4724 FT_Add_Module( FT_Library library, 4725 const FT_Module_Class* clazz ) 4726 { 4727 FT_Error error; 4728 FT_Memory memory; 4729 FT_Module module = NULL; 4730 FT_UInt nn; 4731 4732 4733#define FREETYPE_VER_FIXED ( ( (FT_Long)FREETYPE_MAJOR << 16 ) | \ 4734 FREETYPE_MINOR ) 4735 4736 if ( !library ) 4737 return FT_THROW( Invalid_Library_Handle ); 4738 4739 if ( !clazz ) 4740 return FT_THROW( Invalid_Argument ); 4741 4742 /* check FreeType version */ 4743 if ( clazz->module_requires > FREETYPE_VER_FIXED ) 4744 return FT_THROW( Invalid_Version ); 4745 4746 /* look for a module with the same name in the library's table */ 4747 for ( nn = 0; nn < library->num_modules; nn++ ) 4748 { 4749 module = library->modules[nn]; 4750 if ( ft_strcmp( module->clazz->module_name, clazz->module_name ) == 0 ) 4751 { 4752 /* this installed module has the same name, compare their versions */ 4753 if ( clazz->module_version <= module->clazz->module_version ) 4754 return FT_THROW( Lower_Module_Version ); 4755 4756 /* remove the module from our list, then exit the loop to replace */ 4757 /* it by our new version.. */ 4758 FT_Remove_Module( library, module ); 4759 break; 4760 } 4761 } 4762 4763 memory = library->memory; 4764 error = FT_Err_Ok; 4765 4766 if ( library->num_modules >= FT_MAX_MODULES ) 4767 { 4768 error = FT_THROW( Too_Many_Drivers ); 4769 goto Exit; 4770 } 4771 4772 /* allocate module object */ 4773 if ( FT_ALLOC( module, clazz->module_size ) ) 4774 goto Exit; 4775 4776 /* base initialization */ 4777 module->library = library; 4778 module->memory = memory; 4779 module->clazz = (FT_Module_Class*)clazz; 4780 4781 /* check whether the module is a renderer - this must be performed */ 4782 /* before the normal module initialization */ 4783 if ( FT_MODULE_IS_RENDERER( module ) ) 4784 { 4785 /* add to the renderers list */ 4786 error = ft_add_renderer( module ); 4787 if ( error ) 4788 goto Fail; 4789 } 4790 4791 /* is the module a auto-hinter? */ 4792 if ( FT_MODULE_IS_HINTER( module ) ) 4793 library->auto_hinter = module; 4794 4795 /* if the module is a font driver */ 4796 if ( FT_MODULE_IS_DRIVER( module ) ) 4797 { 4798 FT_Driver driver = FT_DRIVER( module ); 4799 4800 4801 driver->clazz = (FT_Driver_Class)module->clazz; 4802 } 4803 4804 if ( clazz->module_init ) 4805 { 4806 error = clazz->module_init( module ); 4807 if ( error ) 4808 goto Fail; 4809 } 4810 4811 /* add module to the library's table */ 4812 library->modules[library->num_modules++] = module; 4813 4814 Exit: 4815 return error; 4816 4817 Fail: 4818 if ( FT_MODULE_IS_RENDERER( module ) ) 4819 { 4820 FT_Renderer renderer = FT_RENDERER( module ); 4821 4822 4823 if ( renderer->clazz && 4824 renderer->clazz->glyph_format == FT_GLYPH_FORMAT_OUTLINE && 4825 renderer->raster ) 4826 renderer->clazz->raster_class->raster_done( renderer->raster ); 4827 } 4828 4829 FT_FREE( module ); 4830 goto Exit; 4831 } 4832 4833 4834 /* documentation is in ftmodapi.h */ 4835 4836 FT_EXPORT_DEF( FT_Module ) 4837 FT_Get_Module( FT_Library library, 4838 const char* module_name ) 4839 { 4840 FT_Module result = NULL; 4841 FT_Module* cur; 4842 FT_Module* limit; 4843 4844 4845 if ( !library || !module_name ) 4846 return result; 4847 4848 cur = library->modules; 4849 limit = cur + library->num_modules; 4850 4851 for ( ; cur < limit; cur++ ) 4852 if ( ft_strcmp( cur[0]->clazz->module_name, module_name ) == 0 ) 4853 { 4854 result = cur[0]; 4855 break; 4856 } 4857 4858 return result; 4859 } 4860 4861 4862 /* documentation is in ftobjs.h */ 4863 4864 FT_BASE_DEF( const void* ) 4865 FT_Get_Module_Interface( FT_Library library, 4866 const char* mod_name ) 4867 { 4868 FT_Module module; 4869 4870 4871 /* test for valid `library' delayed to FT_Get_Module() */ 4872 4873 module = FT_Get_Module( library, mod_name ); 4874 4875 return module ? module->clazz->module_interface : 0; 4876 } 4877 4878 4879 FT_BASE_DEF( FT_Pointer ) 4880 ft_module_get_service( FT_Module module, 4881 const char* service_id, 4882 FT_Bool global ) 4883 { 4884 FT_Pointer result = NULL; 4885 4886 4887 if ( module ) 4888 { 4889 FT_ASSERT( module->clazz && module->clazz->get_interface ); 4890 4891 /* first, look for the service in the module */ 4892 if ( module->clazz->get_interface ) 4893 result = module->clazz->get_interface( module, service_id ); 4894 4895 if ( global && !result ) 4896 { 4897 /* we didn't find it, look in all other modules then */ 4898 FT_Library library = module->library; 4899 FT_Module* cur = library->modules; 4900 FT_Module* limit = cur + library->num_modules; 4901 4902 4903 for ( ; cur < limit; cur++ ) 4904 { 4905 if ( cur[0] != module ) 4906 { 4907 FT_ASSERT( cur[0]->clazz ); 4908 4909 if ( cur[0]->clazz->get_interface ) 4910 { 4911 result = cur[0]->clazz->get_interface( cur[0], service_id ); 4912 if ( result ) 4913 break; 4914 } 4915 } 4916 } 4917 } 4918 } 4919 4920 return result; 4921 } 4922 4923 4924 /* documentation is in ftmodapi.h */ 4925 4926 FT_EXPORT_DEF( FT_Error ) 4927 FT_Remove_Module( FT_Library library, 4928 FT_Module module ) 4929 { 4930 /* try to find the module from the table, then remove it from there */ 4931 4932 if ( !library ) 4933 return FT_THROW( Invalid_Library_Handle ); 4934 4935 if ( module ) 4936 { 4937 FT_Module* cur = library->modules; 4938 FT_Module* limit = cur + library->num_modules; 4939 4940 4941 for ( ; cur < limit; cur++ ) 4942 { 4943 if ( cur[0] == module ) 4944 { 4945 /* remove it from the table */ 4946 library->num_modules--; 4947 limit--; 4948 while ( cur < limit ) 4949 { 4950 cur[0] = cur[1]; 4951 cur++; 4952 } 4953 limit[0] = NULL; 4954 4955 /* destroy the module */ 4956 Destroy_Module( module ); 4957 4958 return FT_Err_Ok; 4959 } 4960 } 4961 } 4962 return FT_THROW( Invalid_Driver_Handle ); 4963 } 4964 4965 4966 static FT_Error 4967 ft_property_do( FT_Library library, 4968 const FT_String* module_name, 4969 const FT_String* property_name, 4970 void* value, 4971 FT_Bool set, 4972 FT_Bool value_is_string ) 4973 { 4974 FT_Module* cur; 4975 FT_Module* limit; 4976 FT_Module_Interface interface; 4977 4978 FT_Service_Properties service; 4979 4980#ifdef FT_DEBUG_LEVEL_ERROR 4981 const FT_String* set_name = "FT_Property_Set"; 4982 const FT_String* get_name = "FT_Property_Get"; 4983 const FT_String* func_name = set ? set_name : get_name; 4984#endif 4985 4986 FT_Bool missing_func; 4987 4988 4989 if ( !library ) 4990 return FT_THROW( Invalid_Library_Handle ); 4991 4992 if ( !module_name || !property_name || !value ) 4993 return FT_THROW( Invalid_Argument ); 4994 4995 cur = library->modules; 4996 limit = cur + library->num_modules; 4997 4998 /* search module */ 4999 for ( ; cur < limit; cur++ ) 5000 if ( !ft_strcmp( cur[0]->clazz->module_name, module_name ) ) 5001 break; 5002 5003 if ( cur == limit ) 5004 { 5005 FT_ERROR(( "%s: can't find module `%s'\n", 5006 func_name, module_name )); 5007 return FT_THROW( Missing_Module ); 5008 } 5009 5010 /* check whether we have a service interface */ 5011 if ( !cur[0]->clazz->get_interface ) 5012 { 5013 FT_ERROR(( "%s: module `%s' doesn't support properties\n", 5014 func_name, module_name )); 5015 return FT_THROW( Unimplemented_Feature ); 5016 } 5017 5018 /* search property service */ 5019 interface = cur[0]->clazz->get_interface( cur[0], 5020 FT_SERVICE_ID_PROPERTIES ); 5021 if ( !interface ) 5022 { 5023 FT_ERROR(( "%s: module `%s' doesn't support properties\n", 5024 func_name, module_name )); 5025 return FT_THROW( Unimplemented_Feature ); 5026 } 5027 5028 service = (FT_Service_Properties)interface; 5029 5030 if ( set ) 5031 missing_func = (FT_Bool)( !service->set_property ); 5032 else 5033 missing_func = (FT_Bool)( !service->get_property ); 5034 5035 if ( missing_func ) 5036 { 5037 FT_ERROR(( "%s: property service of module `%s' is broken\n", 5038 func_name, module_name )); 5039 return FT_THROW( Unimplemented_Feature ); 5040 } 5041 5042 return set ? service->set_property( cur[0], 5043 property_name, 5044 value, 5045 value_is_string ) 5046 : service->get_property( cur[0], 5047 property_name, 5048 value ); 5049 } 5050 5051 5052 /* documentation is in ftmodapi.h */ 5053 5054 FT_EXPORT_DEF( FT_Error ) 5055 FT_Property_Set( FT_Library library, 5056 const FT_String* module_name, 5057 const FT_String* property_name, 5058 const void* value ) 5059 { 5060 return ft_property_do( library, 5061 module_name, 5062 property_name, 5063 (void*)value, 5064 TRUE, 5065 FALSE ); 5066 } 5067 5068 5069 /* documentation is in ftmodapi.h */ 5070 5071 FT_EXPORT_DEF( FT_Error ) 5072 FT_Property_Get( FT_Library library, 5073 const FT_String* module_name, 5074 const FT_String* property_name, 5075 void* value ) 5076 { 5077 return ft_property_do( library, 5078 module_name, 5079 property_name, 5080 value, 5081 FALSE, 5082 FALSE ); 5083 } 5084 5085 5086#ifdef FT_CONFIG_OPTION_ENVIRONMENT_PROPERTIES 5087 5088 /* this variant is used for handling the FREETYPE_PROPERTIES */ 5089 /* environment variable */ 5090 5091 FT_BASE_DEF( FT_Error ) 5092 ft_property_string_set( FT_Library library, 5093 const FT_String* module_name, 5094 const FT_String* property_name, 5095 FT_String* value ) 5096 { 5097 return ft_property_do( library, 5098 module_name, 5099 property_name, 5100 (void*)value, 5101 TRUE, 5102 TRUE ); 5103 } 5104 5105#endif 5106 5107 5108 /*************************************************************************/ 5109 /*************************************************************************/ 5110 /*************************************************************************/ 5111 /**** ****/ 5112 /**** ****/ 5113 /**** L I B R A R Y ****/ 5114 /**** ****/ 5115 /**** ****/ 5116 /*************************************************************************/ 5117 /*************************************************************************/ 5118 /*************************************************************************/ 5119 5120 5121 /* documentation is in ftmodapi.h */ 5122 5123 FT_EXPORT_DEF( FT_Error ) 5124 FT_Reference_Library( FT_Library library ) 5125 { 5126 if ( !library ) 5127 return FT_THROW( Invalid_Library_Handle ); 5128 5129 library->refcount++; 5130 5131 return FT_Err_Ok; 5132 } 5133 5134 5135 /* documentation is in ftmodapi.h */ 5136 5137 FT_EXPORT_DEF( FT_Error ) 5138 FT_New_Library( FT_Memory memory, 5139 FT_Library *alibrary ) 5140 { 5141 FT_Library library = NULL; 5142 FT_Error error; 5143 5144 5145 if ( !memory || !alibrary ) 5146 return FT_THROW( Invalid_Argument ); 5147 5148#ifdef FT_DEBUG_LEVEL_ERROR 5149 /* init debugging support */ 5150 ft_debug_init(); 5151#endif 5152 5153 /* first of all, allocate the library object */ 5154 if ( FT_NEW( library ) ) 5155 return error; 5156 5157 library->memory = memory; 5158 5159#ifdef FT_CONFIG_OPTION_PIC 5160 /* initialize position independent code containers */ 5161 error = ft_pic_container_init( library ); 5162 if ( error ) 5163 goto Fail; 5164#endif 5165 5166 library->version_major = FREETYPE_MAJOR; 5167 library->version_minor = FREETYPE_MINOR; 5168 library->version_patch = FREETYPE_PATCH; 5169 5170 library->refcount = 1; 5171 5172 /* That's ok now */ 5173 *alibrary = library; 5174 5175 return FT_Err_Ok; 5176 5177#ifdef FT_CONFIG_OPTION_PIC 5178 Fail: 5179 ft_pic_container_destroy( library ); 5180 FT_FREE( library ); 5181 return error; 5182#endif 5183 } 5184 5185 5186 /* documentation is in freetype.h */ 5187 5188 FT_EXPORT_DEF( void ) 5189 FT_Library_Version( FT_Library library, 5190 FT_Int *amajor, 5191 FT_Int *aminor, 5192 FT_Int *apatch ) 5193 { 5194 FT_Int major = 0; 5195 FT_Int minor = 0; 5196 FT_Int patch = 0; 5197 5198 5199 if ( library ) 5200 { 5201 major = library->version_major; 5202 minor = library->version_minor; 5203 patch = library->version_patch; 5204 } 5205 5206 if ( amajor ) 5207 *amajor = major; 5208 5209 if ( aminor ) 5210 *aminor = minor; 5211 5212 if ( apatch ) 5213 *apatch = patch; 5214 } 5215 5216 5217 /* documentation is in ftmodapi.h */ 5218 5219 FT_EXPORT_DEF( FT_Error ) 5220 FT_Done_Library( FT_Library library ) 5221 { 5222 FT_Memory memory; 5223 5224 5225 if ( !library ) 5226 return FT_THROW( Invalid_Library_Handle ); 5227 5228 library->refcount--; 5229 if ( library->refcount > 0 ) 5230 goto Exit; 5231 5232 memory = library->memory; 5233 5234 /* 5235 * Close all faces in the library. If we don't do this, we can have 5236 * some subtle memory leaks. 5237 * 5238 * Example: 5239 * 5240 * - the cff font driver uses the pshinter module in cff_size_done 5241 * - if the pshinter module is destroyed before the cff font driver, 5242 * opened FT_Face objects managed by the driver are not properly 5243 * destroyed, resulting in a memory leak 5244 * 5245 * Some faces are dependent on other faces, like Type42 faces that 5246 * depend on TrueType faces synthesized internally. 5247 * 5248 * The order of drivers should be specified in driver_name[]. 5249 */ 5250 { 5251 FT_UInt m, n; 5252 const char* driver_name[] = { "type42", NULL }; 5253 5254 5255 for ( m = 0; 5256 m < sizeof ( driver_name ) / sizeof ( driver_name[0] ); 5257 m++ ) 5258 { 5259 for ( n = 0; n < library->num_modules; n++ ) 5260 { 5261 FT_Module module = library->modules[n]; 5262 const char* module_name = module->clazz->module_name; 5263 FT_List faces; 5264 5265 5266 if ( driver_name[m] && 5267 ft_strcmp( module_name, driver_name[m] ) != 0 ) 5268 continue; 5269 5270 if ( ( module->clazz->module_flags & FT_MODULE_FONT_DRIVER ) == 0 ) 5271 continue; 5272 5273 FT_TRACE7(( "FT_Done_Library: close faces for %s\n", module_name )); 5274 5275 faces = &FT_DRIVER( module )->faces_list; 5276 while ( faces->head ) 5277 { 5278 FT_Done_Face( FT_FACE( faces->head->data ) ); 5279 if ( faces->head ) 5280 FT_TRACE0(( "FT_Done_Library: failed to free some faces\n" )); 5281 } 5282 } 5283 } 5284 } 5285 5286 /* Close all other modules in the library */ 5287#if 1 5288 /* XXX Modules are removed in the reversed order so that */ 5289 /* type42 module is removed before truetype module. This */ 5290 /* avoids double free in some occasions. It is a hack. */ 5291 while ( library->num_modules > 0 ) 5292 FT_Remove_Module( library, 5293 library->modules[library->num_modules - 1] ); 5294#else 5295 { 5296 FT_UInt n; 5297 5298 5299 for ( n = 0; n < library->num_modules; n++ ) 5300 { 5301 FT_Module module = library->modules[n]; 5302 5303 5304 if ( module ) 5305 { 5306 Destroy_Module( module ); 5307 library->modules[n] = NULL; 5308 } 5309 } 5310 } 5311#endif 5312 5313#ifdef FT_CONFIG_OPTION_PIC 5314 /* Destroy pic container contents */ 5315 ft_pic_container_destroy( library ); 5316#endif 5317 5318 FT_FREE( library ); 5319 5320 Exit: 5321 return FT_Err_Ok; 5322 } 5323 5324 5325 /* documentation is in ftmodapi.h */ 5326 5327 FT_EXPORT_DEF( void ) 5328 FT_Set_Debug_Hook( FT_Library library, 5329 FT_UInt hook_index, 5330 FT_DebugHook_Func debug_hook ) 5331 { 5332 if ( library && debug_hook && 5333 hook_index < 5334 ( sizeof ( library->debug_hooks ) / sizeof ( void* ) ) ) 5335 library->debug_hooks[hook_index] = debug_hook; 5336 } 5337 5338 5339 /* documentation is in ftmodapi.h */ 5340 5341 FT_EXPORT_DEF( FT_TrueTypeEngineType ) 5342 FT_Get_TrueType_Engine_Type( FT_Library library ) 5343 { 5344 FT_TrueTypeEngineType result = FT_TRUETYPE_ENGINE_TYPE_NONE; 5345 5346 5347 if ( library ) 5348 { 5349 FT_Module module = FT_Get_Module( library, "truetype" ); 5350 5351 5352 if ( module ) 5353 { 5354 FT_Service_TrueTypeEngine service; 5355 5356 5357 service = (FT_Service_TrueTypeEngine) 5358 ft_module_get_service( module, 5359 FT_SERVICE_ID_TRUETYPE_ENGINE, 5360 0 ); 5361 if ( service ) 5362 result = service->engine_type; 5363 } 5364 } 5365 5366 return result; 5367 } 5368 5369 5370 /* documentation is in freetype.h */ 5371 5372 FT_EXPORT_DEF( FT_Error ) 5373 FT_Get_SubGlyph_Info( FT_GlyphSlot glyph, 5374 FT_UInt sub_index, 5375 FT_Int *p_index, 5376 FT_UInt *p_flags, 5377 FT_Int *p_arg1, 5378 FT_Int *p_arg2, 5379 FT_Matrix *p_transform ) 5380 { 5381 FT_Error error = FT_ERR( Invalid_Argument ); 5382 5383 5384 if ( glyph && 5385 glyph->subglyphs && 5386 glyph->format == FT_GLYPH_FORMAT_COMPOSITE && 5387 sub_index < glyph->num_subglyphs ) 5388 { 5389 FT_SubGlyph subg = glyph->subglyphs + sub_index; 5390 5391 5392 *p_index = subg->index; 5393 *p_flags = subg->flags; 5394 *p_arg1 = subg->arg1; 5395 *p_arg2 = subg->arg2; 5396 *p_transform = subg->transform; 5397 5398 error = FT_Err_Ok; 5399 } 5400 5401 return error; 5402 } 5403 5404 5405/* END */ 5406