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