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