1/***************************************************************************/ 2/* */ 3/* ttsbit.c */ 4/* */ 5/* TrueType and OpenType embedded bitmap support (body). */ 6/* */ 7/* Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, */ 8/* 2010 by */ 9/* David Turner, Robert Wilhelm, and Werner Lemberg. */ 10/* */ 11/* This file is part of the FreeType project, and may only be used, */ 12/* modified, and distributed under the terms of the FreeType project */ 13/* license, LICENSE.TXT. By continuing to use, modify, or distribute */ 14/* this file you indicate that you have read the license and */ 15/* understand and accept it fully. */ 16/* */ 17/***************************************************************************/ 18 19#include <ft2build.h> 20#include FT_INTERNAL_DEBUG_H 21#include FT_INTERNAL_STREAM_H 22#include FT_TRUETYPE_TAGS_H 23 24 /* 25 * Alas, the memory-optimized sbit loader can't be used when implementing 26 * the `old internals' hack 27 */ 28#ifndef FT_CONFIG_OPTION_OLD_INTERNALS 29 30#include "ttsbit0.c" 31 32#else /* FT_CONFIG_OPTION_OLD_INTERNALS */ 33 34#include <ft2build.h> 35#include FT_INTERNAL_DEBUG_H 36#include FT_INTERNAL_STREAM_H 37#include FT_TRUETYPE_TAGS_H 38#include "ttsbit.h" 39 40#include "sferrors.h" 41 42 43 /*************************************************************************/ 44 /* */ 45 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */ 46 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */ 47 /* messages during execution. */ 48 /* */ 49#undef FT_COMPONENT 50#define FT_COMPONENT trace_ttsbit 51 52 53 /*************************************************************************/ 54 /* */ 55 /* <Function> */ 56 /* blit_sbit */ 57 /* */ 58 /* <Description> */ 59 /* Blits a bitmap from an input stream into a given target. Supports */ 60 /* x and y offsets as well as byte padded lines. */ 61 /* */ 62 /* <Input> */ 63 /* target :: The target bitmap/pixmap. */ 64 /* */ 65 /* source :: The input packed bitmap data. */ 66 /* */ 67 /* line_bits :: The number of bits per line. */ 68 /* */ 69 /* byte_padded :: A flag which is true if lines are byte-padded. */ 70 /* */ 71 /* x_offset :: The horizontal offset. */ 72 /* */ 73 /* y_offset :: The vertical offset. */ 74 /* */ 75 /* <Note> */ 76 /* IMPORTANT: The x and y offsets are relative to the top corner of */ 77 /* the target bitmap (unlike the normal TrueType */ 78 /* convention). A positive y offset indicates a downwards */ 79 /* direction! */ 80 /* */ 81 static void 82 blit_sbit( FT_Bitmap* target, 83 FT_Byte* source, 84 FT_Int line_bits, 85 FT_Bool byte_padded, 86 FT_Int x_offset, 87 FT_Int y_offset, 88 FT_Int source_height ) 89 { 90 FT_Byte* line_buff; 91 FT_Int line_incr; 92 FT_Int height; 93 94 FT_UShort acc; 95 FT_UInt loaded; 96 97 98 /* first of all, compute starting write position */ 99 line_incr = target->pitch; 100 line_buff = target->buffer; 101 102 if ( line_incr < 0 ) 103 line_buff -= line_incr * ( target->rows - 1 ); 104 105 line_buff += ( x_offset >> 3 ) + y_offset * line_incr; 106 107 /***********************************************************************/ 108 /* */ 109 /* We use the extra-classic `accumulator' trick to extract the bits */ 110 /* from the source byte stream. */ 111 /* */ 112 /* Namely, the variable `acc' is a 16-bit accumulator containing the */ 113 /* last `loaded' bits from the input stream. The bits are shifted to */ 114 /* the upmost position in `acc'. */ 115 /* */ 116 /***********************************************************************/ 117 118 acc = 0; /* clear accumulator */ 119 loaded = 0; /* no bits were loaded */ 120 121 for ( height = source_height; height > 0; height-- ) 122 { 123 FT_Byte* cur = line_buff; /* current write cursor */ 124 FT_Int count = line_bits; /* # of bits to extract per line */ 125 FT_Byte shift = (FT_Byte)( x_offset & 7 ); /* current write shift */ 126 FT_Byte space = (FT_Byte)( 8 - shift ); 127 128 129 /* first of all, read individual source bytes */ 130 if ( count >= 8 ) 131 { 132 count -= 8; 133 { 134 do 135 { 136 FT_Byte val; 137 138 139 /* ensure that there are at least 8 bits in the accumulator */ 140 if ( loaded < 8 ) 141 { 142 acc |= (FT_UShort)((FT_UShort)*source++ << ( 8 - loaded )); 143 loaded += 8; 144 } 145 146 /* now write one byte */ 147 val = (FT_Byte)( acc >> 8 ); 148 if ( shift ) 149 { 150 cur[0] |= (FT_Byte)( val >> shift ); 151 cur[1] |= (FT_Byte)( val << space ); 152 } 153 else 154 cur[0] |= val; 155 156 cur++; 157 acc <<= 8; /* remove bits from accumulator */ 158 loaded -= 8; 159 count -= 8; 160 161 } while ( count >= 0 ); 162 } 163 164 /* restore `count' to correct value */ 165 count += 8; 166 } 167 168 /* now write remaining bits (count < 8) */ 169 if ( count > 0 ) 170 { 171 FT_Byte val; 172 173 174 /* ensure that there are at least `count' bits in the accumulator */ 175 if ( (FT_Int)loaded < count ) 176 { 177 acc |= (FT_UShort)((FT_UShort)*source++ << ( 8 - loaded )); 178 loaded += 8; 179 } 180 181 /* now write remaining bits */ 182 val = (FT_Byte)( ( (FT_Byte)( acc >> 8 ) ) & ~( 0xFF >> count ) ); 183 cur[0] |= (FT_Byte)( val >> shift ); 184 185 if ( count > space ) 186 cur[1] |= (FT_Byte)( val << space ); 187 188 acc <<= count; 189 loaded -= count; 190 } 191 192 /* now, skip to next line */ 193 if ( byte_padded ) 194 { 195 acc = 0; 196 loaded = 0; /* clear accumulator on byte-padded lines */ 197 } 198 199 line_buff += line_incr; 200 } 201 } 202 203 204 static const FT_Frame_Field sbit_metrics_fields[] = 205 { 206#undef FT_STRUCTURE 207#define FT_STRUCTURE TT_SBit_MetricsRec 208 209 FT_FRAME_START( 8 ), 210 FT_FRAME_BYTE( height ), 211 FT_FRAME_BYTE( width ), 212 213 FT_FRAME_CHAR( horiBearingX ), 214 FT_FRAME_CHAR( horiBearingY ), 215 FT_FRAME_BYTE( horiAdvance ), 216 217 FT_FRAME_CHAR( vertBearingX ), 218 FT_FRAME_CHAR( vertBearingY ), 219 FT_FRAME_BYTE( vertAdvance ), 220 FT_FRAME_END 221 }; 222 223 224 /*************************************************************************/ 225 /* */ 226 /* <Function> */ 227 /* Load_SBit_Const_Metrics */ 228 /* */ 229 /* <Description> */ 230 /* Loads the metrics for `EBLC' index tables format 2 and 5. */ 231 /* */ 232 /* <Input> */ 233 /* range :: The target range. */ 234 /* */ 235 /* stream :: The input stream. */ 236 /* */ 237 /* <Return> */ 238 /* FreeType error code. 0 means success. */ 239 /* */ 240 static FT_Error 241 Load_SBit_Const_Metrics( TT_SBit_Range range, 242 FT_Stream stream ) 243 { 244 FT_Error error; 245 246 247 if ( FT_READ_ULONG( range->image_size ) ) 248 return error; 249 250 return FT_STREAM_READ_FIELDS( sbit_metrics_fields, &range->metrics ); 251 } 252 253 254 /*************************************************************************/ 255 /* */ 256 /* <Function> */ 257 /* Load_SBit_Range_Codes */ 258 /* */ 259 /* <Description> */ 260 /* Loads the range codes for `EBLC' index tables format 4 and 5. */ 261 /* */ 262 /* <Input> */ 263 /* range :: The target range. */ 264 /* */ 265 /* stream :: The input stream. */ 266 /* */ 267 /* load_offsets :: A flag whether to load the glyph offset table. */ 268 /* */ 269 /* <Return> */ 270 /* FreeType error code. 0 means success. */ 271 /* */ 272 static FT_Error 273 Load_SBit_Range_Codes( TT_SBit_Range range, 274 FT_Stream stream, 275 FT_Bool load_offsets ) 276 { 277 FT_Error error; 278 FT_ULong count, n, size; 279 FT_Memory memory = stream->memory; 280 281 282 if ( FT_READ_ULONG( count ) ) 283 goto Exit; 284 285 range->num_glyphs = count; 286 287 /* Allocate glyph offsets table if needed */ 288 if ( load_offsets ) 289 { 290 if ( FT_NEW_ARRAY( range->glyph_offsets, count ) ) 291 goto Exit; 292 293 size = count * 4L; 294 } 295 else 296 size = count * 2L; 297 298 /* Allocate glyph codes table and access frame */ 299 if ( FT_NEW_ARRAY ( range->glyph_codes, count ) || 300 FT_FRAME_ENTER( size ) ) 301 goto Exit; 302 303 for ( n = 0; n < count; n++ ) 304 { 305 range->glyph_codes[n] = FT_GET_USHORT(); 306 307 if ( load_offsets ) 308 range->glyph_offsets[n] = (FT_ULong)range->image_offset + 309 FT_GET_USHORT(); 310 } 311 312 FT_FRAME_EXIT(); 313 314 Exit: 315 return error; 316 } 317 318 319 /*************************************************************************/ 320 /* */ 321 /* <Function> */ 322 /* Load_SBit_Range */ 323 /* */ 324 /* <Description> */ 325 /* Loads a given `EBLC' index/range table. */ 326 /* */ 327 /* <Input> */ 328 /* range :: The target range. */ 329 /* */ 330 /* stream :: The input stream. */ 331 /* */ 332 /* <Return> */ 333 /* FreeType error code. 0 means success. */ 334 /* */ 335 static FT_Error 336 Load_SBit_Range( TT_SBit_Range range, 337 FT_Stream stream ) 338 { 339 FT_Error error; 340 FT_Memory memory = stream->memory; 341 342 343 switch( range->index_format ) 344 { 345 case 1: /* variable metrics with 4-byte offsets */ 346 case 3: /* variable metrics with 2-byte offsets */ 347 { 348 FT_ULong num_glyphs, n; 349 FT_Int size_elem; 350 FT_Bool large = FT_BOOL( range->index_format == 1 ); 351 352 353 354 if ( range->last_glyph < range->first_glyph ) 355 { 356 error = SFNT_Err_Invalid_File_Format; 357 goto Exit; 358 } 359 360 num_glyphs = range->last_glyph - range->first_glyph + 1L; 361 range->num_glyphs = num_glyphs; 362 num_glyphs++; /* XXX: BEWARE - see spec */ 363 364 size_elem = large ? 4 : 2; 365 366 if ( FT_NEW_ARRAY( range->glyph_offsets, num_glyphs ) || 367 FT_FRAME_ENTER( num_glyphs * size_elem ) ) 368 goto Exit; 369 370 for ( n = 0; n < num_glyphs; n++ ) 371 range->glyph_offsets[n] = (FT_ULong)( range->image_offset + 372 ( large ? FT_GET_ULONG() 373 : FT_GET_USHORT() ) ); 374 FT_FRAME_EXIT(); 375 } 376 break; 377 378 case 2: /* all glyphs have identical metrics */ 379 error = Load_SBit_Const_Metrics( range, stream ); 380 break; 381 382 case 4: 383 error = Load_SBit_Range_Codes( range, stream, 1 ); 384 break; 385 386 case 5: 387 error = Load_SBit_Const_Metrics( range, stream ); 388 if ( !error ) 389 error = Load_SBit_Range_Codes( range, stream, 0 ); 390 break; 391 392 default: 393 error = SFNT_Err_Invalid_File_Format; 394 } 395 396 Exit: 397 return error; 398 } 399 400 401 /*************************************************************************/ 402 /* */ 403 /* <Function> */ 404 /* tt_face_load_eblc */ 405 /* */ 406 /* <Description> */ 407 /* Loads the table of embedded bitmap sizes for this face. */ 408 /* */ 409 /* <Input> */ 410 /* face :: The target face object. */ 411 /* */ 412 /* stream :: The input stream. */ 413 /* */ 414 /* <Return> */ 415 /* FreeType error code. 0 means success. */ 416 /* */ 417 FT_LOCAL_DEF( FT_Error ) 418 tt_face_load_eblc( TT_Face face, 419 FT_Stream stream ) 420 { 421 FT_Error error = SFNT_Err_Ok; 422 FT_Memory memory = stream->memory; 423 FT_Fixed version; 424 FT_ULong num_strikes; 425 FT_ULong table_base; 426 427 static const FT_Frame_Field sbit_line_metrics_fields[] = 428 { 429#undef FT_STRUCTURE 430#define FT_STRUCTURE TT_SBit_LineMetricsRec 431 432 /* no FT_FRAME_START */ 433 FT_FRAME_CHAR( ascender ), 434 FT_FRAME_CHAR( descender ), 435 FT_FRAME_BYTE( max_width ), 436 437 FT_FRAME_CHAR( caret_slope_numerator ), 438 FT_FRAME_CHAR( caret_slope_denominator ), 439 FT_FRAME_CHAR( caret_offset ), 440 441 FT_FRAME_CHAR( min_origin_SB ), 442 FT_FRAME_CHAR( min_advance_SB ), 443 FT_FRAME_CHAR( max_before_BL ), 444 FT_FRAME_CHAR( min_after_BL ), 445 FT_FRAME_CHAR( pads[0] ), 446 FT_FRAME_CHAR( pads[1] ), 447 FT_FRAME_END 448 }; 449 450 static const FT_Frame_Field strike_start_fields[] = 451 { 452#undef FT_STRUCTURE 453#define FT_STRUCTURE TT_SBit_StrikeRec 454 455 /* no FT_FRAME_START */ 456 FT_FRAME_ULONG( ranges_offset ), 457 FT_FRAME_SKIP_LONG, 458 FT_FRAME_ULONG( num_ranges ), 459 FT_FRAME_ULONG( color_ref ), 460 FT_FRAME_END 461 }; 462 463 static const FT_Frame_Field strike_end_fields[] = 464 { 465 /* no FT_FRAME_START */ 466 FT_FRAME_USHORT( start_glyph ), 467 FT_FRAME_USHORT( end_glyph ), 468 FT_FRAME_BYTE ( x_ppem ), 469 FT_FRAME_BYTE ( y_ppem ), 470 FT_FRAME_BYTE ( bit_depth ), 471 FT_FRAME_CHAR ( flags ), 472 FT_FRAME_END 473 }; 474 475 476 face->num_sbit_strikes = 0; 477 478 /* this table is optional */ 479 error = face->goto_table( face, TTAG_EBLC, stream, 0 ); 480 if ( error ) 481 error = face->goto_table( face, TTAG_bloc, stream, 0 ); 482 if ( error ) 483 goto Exit; 484 485 table_base = FT_STREAM_POS(); 486 if ( FT_FRAME_ENTER( 8L ) ) 487 goto Exit; 488 489 version = FT_GET_LONG(); 490 num_strikes = FT_GET_ULONG(); 491 492 FT_FRAME_EXIT(); 493 494 /* check version number and strike count */ 495 if ( version != 0x00020000L || 496 num_strikes >= 0x10000L ) 497 { 498 FT_ERROR(( "tt_face_load_sbit_strikes: invalid table version\n" )); 499 error = SFNT_Err_Invalid_File_Format; 500 501 goto Exit; 502 } 503 504 /* allocate the strikes table */ 505 if ( FT_NEW_ARRAY( face->sbit_strikes, num_strikes ) ) 506 goto Exit; 507 508 face->num_sbit_strikes = num_strikes; 509 510 /* now read each strike table separately */ 511 { 512 TT_SBit_Strike strike = face->sbit_strikes; 513 FT_ULong count = num_strikes; 514 515 516 if ( FT_FRAME_ENTER( 48L * num_strikes ) ) 517 goto Exit; 518 519 while ( count > 0 ) 520 { 521 if ( FT_STREAM_READ_FIELDS( strike_start_fields, strike ) || 522 FT_STREAM_READ_FIELDS( sbit_line_metrics_fields, &strike->hori ) || 523 FT_STREAM_READ_FIELDS( sbit_line_metrics_fields, &strike->vert ) || 524 FT_STREAM_READ_FIELDS( strike_end_fields, strike ) ) 525 break; 526 527 count--; 528 strike++; 529 } 530 531 FT_FRAME_EXIT(); 532 } 533 534 /* allocate the index ranges for each strike table */ 535 { 536 TT_SBit_Strike strike = face->sbit_strikes; 537 FT_ULong count = num_strikes; 538 539 540 while ( count > 0 ) 541 { 542 TT_SBit_Range range; 543 FT_ULong count2 = strike->num_ranges; 544 545 546 /* read each range */ 547 if ( FT_STREAM_SEEK( table_base + strike->ranges_offset ) || 548 FT_FRAME_ENTER( strike->num_ranges * 8L ) ) 549 goto Exit; 550 551 if ( FT_NEW_ARRAY( strike->sbit_ranges, strike->num_ranges ) ) 552 goto Exit; 553 554 range = strike->sbit_ranges; 555 while ( count2 > 0 ) 556 { 557 range->first_glyph = FT_GET_USHORT(); 558 range->last_glyph = FT_GET_USHORT(); 559 range->table_offset = table_base + strike->ranges_offset + 560 FT_GET_ULONG(); 561 count2--; 562 range++; 563 } 564 565 FT_FRAME_EXIT(); 566 567 /* Now, read each index table */ 568 count2 = strike->num_ranges; 569 range = strike->sbit_ranges; 570 while ( count2 > 0 ) 571 { 572 /* Read the header */ 573 if ( FT_STREAM_SEEK( range->table_offset ) || 574 FT_FRAME_ENTER( 8L ) ) 575 goto Exit; 576 577 range->index_format = FT_GET_USHORT(); 578 range->image_format = FT_GET_USHORT(); 579 range->image_offset = FT_GET_ULONG(); 580 581 FT_FRAME_EXIT(); 582 583 error = Load_SBit_Range( range, stream ); 584 if ( error ) 585 goto Exit; 586 587 count2--; 588 range++; 589 } 590 591 count--; 592 strike++; 593 } 594 } 595 596 Exit: 597 return error; 598 } 599 600 601 /*************************************************************************/ 602 /* */ 603 /* <Function> */ 604 /* tt_face_free_eblc */ 605 /* */ 606 /* <Description> */ 607 /* Releases the embedded bitmap tables. */ 608 /* */ 609 /* <Input> */ 610 /* face :: The target face object. */ 611 /* */ 612 FT_LOCAL_DEF( void ) 613 tt_face_free_eblc( TT_Face face ) 614 { 615 FT_Memory memory = face->root.memory; 616 TT_SBit_Strike strike = face->sbit_strikes; 617 TT_SBit_Strike strike_limit = strike + face->num_sbit_strikes; 618 619 620 if ( strike ) 621 { 622 for ( ; strike < strike_limit; strike++ ) 623 { 624 TT_SBit_Range range = strike->sbit_ranges; 625 TT_SBit_Range range_limit = range + strike->num_ranges; 626 627 628 if ( range ) 629 { 630 for ( ; range < range_limit; range++ ) 631 { 632 /* release the glyph offsets and codes tables */ 633 /* where appropriate */ 634 FT_FREE( range->glyph_offsets ); 635 FT_FREE( range->glyph_codes ); 636 } 637 } 638 FT_FREE( strike->sbit_ranges ); 639 strike->num_ranges = 0; 640 } 641 FT_FREE( face->sbit_strikes ); 642 } 643 face->num_sbit_strikes = 0; 644 } 645 646 647 FT_LOCAL_DEF( FT_Error ) 648 tt_face_set_sbit_strike( TT_Face face, 649 FT_Size_Request req, 650 FT_ULong* astrike_index ) 651 { 652 return FT_Match_Size( (FT_Face)face, req, 0, astrike_index ); 653 } 654 655 656 FT_LOCAL_DEF( FT_Error ) 657 tt_face_load_strike_metrics( TT_Face face, 658 FT_ULong strike_index, 659 FT_Size_Metrics* metrics ) 660 { 661 TT_SBit_Strike strike; 662 663 664 if ( strike_index >= face->num_sbit_strikes ) 665 return SFNT_Err_Invalid_Argument; 666 667 strike = face->sbit_strikes + strike_index; 668 669 metrics->x_ppem = strike->x_ppem; 670 metrics->y_ppem = strike->y_ppem; 671 672 metrics->ascender = strike->hori.ascender << 6; 673 metrics->descender = strike->hori.descender << 6; 674 675 /* XXX: Is this correct? */ 676 metrics->max_advance = ( strike->hori.min_origin_SB + 677 strike->hori.max_width + 678 strike->hori.min_advance_SB ) << 6; 679 680 metrics->height = metrics->ascender - metrics->descender; 681 682 return SFNT_Err_Ok; 683 } 684 685 686 /*************************************************************************/ 687 /* */ 688 /* <Function> */ 689 /* find_sbit_range */ 690 /* */ 691 /* <Description> */ 692 /* Scans a given strike's ranges and return, for a given glyph */ 693 /* index, the corresponding sbit range, and `EBDT' offset. */ 694 /* */ 695 /* <Input> */ 696 /* glyph_index :: The glyph index. */ 697 /* */ 698 /* strike :: The source/current sbit strike. */ 699 /* */ 700 /* <Output> */ 701 /* arange :: The sbit range containing the glyph index. */ 702 /* */ 703 /* aglyph_offset :: The offset of the glyph data in `EBDT' table. */ 704 /* */ 705 /* <Return> */ 706 /* FreeType error code. 0 means the glyph index was found. */ 707 /* */ 708 static FT_Error 709 find_sbit_range( FT_UInt glyph_index, 710 TT_SBit_Strike strike, 711 TT_SBit_Range *arange, 712 FT_ULong *aglyph_offset ) 713 { 714 TT_SBit_RangeRec *range, *range_limit; 715 716 717 /* check whether the glyph index is within this strike's */ 718 /* glyph range */ 719 if ( glyph_index < (FT_UInt)strike->start_glyph || 720 glyph_index > (FT_UInt)strike->end_glyph ) 721 goto Fail; 722 723 /* scan all ranges in strike */ 724 range = strike->sbit_ranges; 725 range_limit = range + strike->num_ranges; 726 if ( !range ) 727 goto Fail; 728 729 for ( ; range < range_limit; range++ ) 730 { 731 if ( glyph_index >= (FT_UInt)range->first_glyph && 732 glyph_index <= (FT_UInt)range->last_glyph ) 733 { 734 FT_UShort delta = (FT_UShort)( glyph_index - range->first_glyph ); 735 736 737 switch ( range->index_format ) 738 { 739 case 1: 740 case 3: 741 *aglyph_offset = range->glyph_offsets[delta]; 742 break; 743 744 case 2: 745 *aglyph_offset = range->image_offset + 746 range->image_size * delta; 747 break; 748 749 case 4: 750 case 5: 751 { 752 FT_ULong n; 753 754 755 for ( n = 0; n < range->num_glyphs; n++ ) 756 { 757 if ( (FT_UInt)range->glyph_codes[n] == glyph_index ) 758 { 759 if ( range->index_format == 4 ) 760 *aglyph_offset = range->glyph_offsets[n]; 761 else 762 *aglyph_offset = range->image_offset + 763 n * range->image_size; 764 goto Found; 765 } 766 } 767 } 768 769 /* fall-through */ 770 default: 771 goto Fail; 772 } 773 774 Found: 775 /* return successfully! */ 776 *arange = range; 777 return SFNT_Err_Ok; 778 } 779 } 780 781 Fail: 782 *arange = 0; 783 *aglyph_offset = 0; 784 785 return SFNT_Err_Invalid_Argument; 786 } 787 788 789 /*************************************************************************/ 790 /* */ 791 /* <Function> */ 792 /* tt_find_sbit_image */ 793 /* */ 794 /* <Description> */ 795 /* Checks whether an embedded bitmap (an `sbit') exists for a given */ 796 /* glyph, at a given strike. */ 797 /* */ 798 /* <Input> */ 799 /* face :: The target face object. */ 800 /* */ 801 /* glyph_index :: The glyph index. */ 802 /* */ 803 /* strike_index :: The current strike index. */ 804 /* */ 805 /* <Output> */ 806 /* arange :: The SBit range containing the glyph index. */ 807 /* */ 808 /* astrike :: The SBit strike containing the glyph index. */ 809 /* */ 810 /* aglyph_offset :: The offset of the glyph data in `EBDT' table. */ 811 /* */ 812 /* <Return> */ 813 /* FreeType error code. 0 means success. Returns */ 814 /* SFNT_Err_Invalid_Argument if no sbit exists for the requested */ 815 /* glyph. */ 816 /* */ 817 FT_LOCAL( FT_Error ) 818 tt_find_sbit_image( TT_Face face, 819 FT_UInt glyph_index, 820 FT_ULong strike_index, 821 TT_SBit_Range *arange, 822 TT_SBit_Strike *astrike, 823 FT_ULong *aglyph_offset ) 824 { 825 FT_Error error; 826 TT_SBit_Strike strike; 827 828 829 if ( !face->sbit_strikes || 830 ( face->num_sbit_strikes <= strike_index ) ) 831 goto Fail; 832 833 strike = &face->sbit_strikes[strike_index]; 834 835 error = find_sbit_range( glyph_index, strike, 836 arange, aglyph_offset ); 837 if ( error ) 838 goto Fail; 839 840 *astrike = strike; 841 842 return SFNT_Err_Ok; 843 844 Fail: 845 /* no embedded bitmap for this glyph in face */ 846 *arange = 0; 847 *astrike = 0; 848 *aglyph_offset = 0; 849 850 return SFNT_Err_Invalid_Argument; 851 } 852 853 854 /*************************************************************************/ 855 /* */ 856 /* <Function> */ 857 /* tt_load_sbit_metrics */ 858 /* */ 859 /* <Description> */ 860 /* Gets the big metrics for a given SBit. */ 861 /* */ 862 /* <Input> */ 863 /* stream :: The input stream. */ 864 /* */ 865 /* range :: The SBit range containing the glyph. */ 866 /* */ 867 /* <Output> */ 868 /* big_metrics :: A big SBit metrics structure for the glyph. */ 869 /* */ 870 /* <Return> */ 871 /* FreeType error code. 0 means success. */ 872 /* */ 873 /* <Note> */ 874 /* The stream cursor must be positioned at the glyph's offset within */ 875 /* the `EBDT' table before the call. */ 876 /* */ 877 /* If the image format uses variable metrics, the stream cursor is */ 878 /* positioned just after the metrics header in the `EBDT' table on */ 879 /* function exit. */ 880 /* */ 881 FT_LOCAL( FT_Error ) 882 tt_load_sbit_metrics( FT_Stream stream, 883 TT_SBit_Range range, 884 TT_SBit_Metrics metrics ) 885 { 886 FT_Error error = SFNT_Err_Ok; 887 888 889 switch ( range->image_format ) 890 { 891 case 1: 892 case 2: 893 case 8: 894 /* variable small metrics */ 895 { 896 TT_SBit_SmallMetricsRec smetrics; 897 898 static const FT_Frame_Field sbit_small_metrics_fields[] = 899 { 900#undef FT_STRUCTURE 901#define FT_STRUCTURE TT_SBit_SmallMetricsRec 902 903 FT_FRAME_START( 5 ), 904 FT_FRAME_BYTE( height ), 905 FT_FRAME_BYTE( width ), 906 FT_FRAME_CHAR( bearingX ), 907 FT_FRAME_CHAR( bearingY ), 908 FT_FRAME_BYTE( advance ), 909 FT_FRAME_END 910 }; 911 912 913 /* read small metrics */ 914 if ( FT_STREAM_READ_FIELDS( sbit_small_metrics_fields, &smetrics ) ) 915 goto Exit; 916 917 /* convert it to a big metrics */ 918 metrics->height = smetrics.height; 919 metrics->width = smetrics.width; 920 metrics->horiBearingX = smetrics.bearingX; 921 metrics->horiBearingY = smetrics.bearingY; 922 metrics->horiAdvance = smetrics.advance; 923 924 /* these metrics are made up at a higher level when */ 925 /* needed. */ 926 metrics->vertBearingX = 0; 927 metrics->vertBearingY = 0; 928 metrics->vertAdvance = 0; 929 } 930 break; 931 932 case 6: 933 case 7: 934 case 9: 935 /* variable big metrics */ 936 if ( FT_STREAM_READ_FIELDS( sbit_metrics_fields, metrics ) ) 937 goto Exit; 938 break; 939 940 case 5: 941 default: /* constant metrics */ 942 if ( range->index_format == 2 || range->index_format == 5 ) 943 *metrics = range->metrics; 944 else 945 return SFNT_Err_Invalid_File_Format; 946 } 947 948 Exit: 949 return error; 950 } 951 952 953 /*************************************************************************/ 954 /* */ 955 /* <Function> */ 956 /* crop_bitmap */ 957 /* */ 958 /* <Description> */ 959 /* Crops a bitmap to its tightest bounding box, and adjusts its */ 960 /* metrics. */ 961 /* */ 962 /* <InOut> */ 963 /* map :: The bitmap. */ 964 /* */ 965 /* metrics :: The corresponding metrics structure. */ 966 /* */ 967 static void 968 crop_bitmap( FT_Bitmap* map, 969 TT_SBit_Metrics metrics ) 970 { 971 /***********************************************************************/ 972 /* */ 973 /* In this situation, some bounding boxes of embedded bitmaps are too */ 974 /* large. We need to crop it to a reasonable size. */ 975 /* */ 976 /* --------- */ 977 /* | | ----- */ 978 /* | *** | |***| */ 979 /* | * | | * | */ 980 /* | * | ------> | * | */ 981 /* | * | | * | */ 982 /* | * | | * | */ 983 /* | *** | |***| */ 984 /* --------- ----- */ 985 /* */ 986 /***********************************************************************/ 987 988 FT_Int rows, count; 989 FT_Long line_len; 990 FT_Byte* line; 991 992 993 /***********************************************************************/ 994 /* */ 995 /* first of all, check the top-most lines of the bitmap, and remove */ 996 /* them if they're empty. */ 997 /* */ 998 { 999 line = (FT_Byte*)map->buffer; 1000 rows = map->rows; 1001 line_len = map->pitch; 1002 1003 1004 for ( count = 0; count < rows; count++ ) 1005 { 1006 FT_Byte* cur = line; 1007 FT_Byte* limit = line + line_len; 1008 1009 1010 for ( ; cur < limit; cur++ ) 1011 if ( cur[0] ) 1012 goto Found_Top; 1013 1014 /* the current line was empty - skip to next one */ 1015 line = limit; 1016 } 1017 1018 Found_Top: 1019 /* check that we have at least one filled line */ 1020 if ( count >= rows ) 1021 goto Empty_Bitmap; 1022 1023 /* now, crop the empty upper lines */ 1024 if ( count > 0 ) 1025 { 1026 line = (FT_Byte*)map->buffer; 1027 1028 FT_MEM_MOVE( line, line + count * line_len, 1029 ( rows - count ) * line_len ); 1030 1031 metrics->height = (FT_Byte)( metrics->height - count ); 1032 metrics->horiBearingY = (FT_Char)( metrics->horiBearingY - count ); 1033 metrics->vertBearingY = (FT_Char)( metrics->vertBearingY - count ); 1034 1035 map->rows -= count; 1036 rows -= count; 1037 } 1038 } 1039 1040 /***********************************************************************/ 1041 /* */ 1042 /* second, crop the lower lines */ 1043 /* */ 1044 { 1045 line = (FT_Byte*)map->buffer + ( rows - 1 ) * line_len; 1046 1047 for ( count = 0; count < rows; count++ ) 1048 { 1049 FT_Byte* cur = line; 1050 FT_Byte* limit = line + line_len; 1051 1052 1053 for ( ; cur < limit; cur++ ) 1054 if ( cur[0] ) 1055 goto Found_Bottom; 1056 1057 /* the current line was empty - skip to previous one */ 1058 line -= line_len; 1059 } 1060 1061 Found_Bottom: 1062 if ( count > 0 ) 1063 { 1064 metrics->height = (FT_Byte)( metrics->height - count ); 1065 rows -= count; 1066 map->rows -= count; 1067 } 1068 } 1069 1070 /***********************************************************************/ 1071 /* */ 1072 /* third, get rid of the space on the left side of the glyph */ 1073 /* */ 1074 do 1075 { 1076 FT_Byte* limit; 1077 1078 1079 line = (FT_Byte*)map->buffer; 1080 limit = line + rows * line_len; 1081 1082 for ( ; line < limit; line += line_len ) 1083 if ( line[0] & 0x80 ) 1084 goto Found_Left; 1085 1086 /* shift the whole glyph one pixel to the left */ 1087 line = (FT_Byte*)map->buffer; 1088 limit = line + rows * line_len; 1089 1090 for ( ; line < limit; line += line_len ) 1091 { 1092 FT_Int n, width = map->width; 1093 FT_Byte old; 1094 FT_Byte* cur = line; 1095 1096 1097 old = (FT_Byte)(cur[0] << 1); 1098 for ( n = 8; n < width; n += 8 ) 1099 { 1100 FT_Byte val; 1101 1102 1103 val = cur[1]; 1104 cur[0] = (FT_Byte)( old | ( val >> 7 ) ); 1105 old = (FT_Byte)( val << 1 ); 1106 cur++; 1107 } 1108 cur[0] = old; 1109 } 1110 1111 map->width--; 1112 metrics->horiBearingX++; 1113 metrics->vertBearingX++; 1114 metrics->width--; 1115 1116 } while ( map->width > 0 ); 1117 1118 Found_Left: 1119 1120 /***********************************************************************/ 1121 /* */ 1122 /* finally, crop the bitmap width to get rid of the space on the right */ 1123 /* side of the glyph. */ 1124 /* */ 1125 do 1126 { 1127 FT_Int right = map->width - 1; 1128 FT_Byte* limit; 1129 FT_Byte mask; 1130 1131 1132 line = (FT_Byte*)map->buffer + ( right >> 3 ); 1133 limit = line + rows * line_len; 1134 mask = (FT_Byte)( 0x80 >> ( right & 7 ) ); 1135 1136 for ( ; line < limit; line += line_len ) 1137 if ( line[0] & mask ) 1138 goto Found_Right; 1139 1140 /* crop the whole glyph to the right */ 1141 map->width--; 1142 metrics->width--; 1143 1144 } while ( map->width > 0 ); 1145 1146 Found_Right: 1147 /* all right, the bitmap was cropped */ 1148 return; 1149 1150 Empty_Bitmap: 1151 map->width = 0; 1152 map->rows = 0; 1153 map->pitch = 0; 1154 map->pixel_mode = FT_PIXEL_MODE_MONO; 1155 } 1156 1157 1158 static FT_Error 1159 Load_SBit_Single( FT_Bitmap* map, 1160 FT_Int x_offset, 1161 FT_Int y_offset, 1162 FT_Int pix_bits, 1163 FT_UShort image_format, 1164 TT_SBit_Metrics metrics, 1165 FT_Stream stream ) 1166 { 1167 FT_Error error; 1168 1169 1170 /* check that the source bitmap fits into the target pixmap */ 1171 if ( x_offset < 0 || x_offset + metrics->width > map->width || 1172 y_offset < 0 || y_offset + metrics->height > map->rows ) 1173 { 1174 error = SFNT_Err_Invalid_Argument; 1175 1176 goto Exit; 1177 } 1178 1179 { 1180 FT_Int glyph_width = metrics->width; 1181 FT_Int glyph_height = metrics->height; 1182 FT_Int glyph_size; 1183 FT_Int line_bits = pix_bits * glyph_width; 1184 FT_Bool pad_bytes = 0; 1185 1186 1187 /* compute size of glyph image */ 1188 switch ( image_format ) 1189 { 1190 case 1: /* byte-padded formats */ 1191 case 6: 1192 { 1193 FT_Int line_length; 1194 1195 1196 switch ( pix_bits ) 1197 { 1198 case 1: 1199 line_length = ( glyph_width + 7 ) >> 3; 1200 break; 1201 case 2: 1202 line_length = ( glyph_width + 3 ) >> 2; 1203 break; 1204 case 4: 1205 line_length = ( glyph_width + 1 ) >> 1; 1206 break; 1207 default: 1208 line_length = glyph_width; 1209 } 1210 1211 glyph_size = glyph_height * line_length; 1212 pad_bytes = 1; 1213 } 1214 break; 1215 1216 case 2: 1217 case 5: 1218 case 7: 1219 line_bits = glyph_width * pix_bits; 1220 glyph_size = ( glyph_height * line_bits + 7 ) >> 3; 1221 break; 1222 1223 default: /* invalid format */ 1224 return SFNT_Err_Invalid_File_Format; 1225 } 1226 1227 /* Now read data and draw glyph into target pixmap */ 1228 if ( FT_FRAME_ENTER( glyph_size ) ) 1229 goto Exit; 1230 1231 /* don't forget to multiply `x_offset' by `map->pix_bits' as */ 1232 /* the sbit blitter doesn't make a difference between pixmap */ 1233 /* depths. */ 1234 blit_sbit( map, (FT_Byte*)stream->cursor, line_bits, pad_bytes, 1235 x_offset * pix_bits, y_offset, metrics->height ); 1236 1237 FT_FRAME_EXIT(); 1238 } 1239 1240 Exit: 1241 return error; 1242 } 1243 1244 1245 static FT_Error 1246 Load_SBit_Image( TT_SBit_Strike strike, 1247 TT_SBit_Range range, 1248 FT_ULong ebdt_pos, 1249 FT_ULong glyph_offset, 1250 FT_GlyphSlot slot, 1251 FT_Int x_offset, 1252 FT_Int y_offset, 1253 FT_Stream stream, 1254 TT_SBit_Metrics metrics, 1255 FT_Int depth ) 1256 { 1257 FT_Memory memory = stream->memory; 1258 FT_Bitmap* map = &slot->bitmap; 1259 FT_Error error; 1260 1261 1262 /* place stream at beginning of glyph data and read metrics */ 1263 if ( FT_STREAM_SEEK( ebdt_pos + glyph_offset ) ) 1264 goto Exit; 1265 1266 error = tt_load_sbit_metrics( stream, range, metrics ); 1267 if ( error ) 1268 goto Exit; 1269 1270 /* This function is recursive. At the top-level call, we */ 1271 /* compute the dimensions of the higher-level glyph to */ 1272 /* allocate the final pixmap buffer. */ 1273 if ( depth == 0 ) 1274 { 1275 FT_Long size; 1276 1277 1278 map->width = metrics->width; 1279 map->rows = metrics->height; 1280 1281 switch ( strike->bit_depth ) 1282 { 1283 case 1: 1284 map->pixel_mode = FT_PIXEL_MODE_MONO; 1285 map->pitch = ( map->width + 7 ) >> 3; 1286 break; 1287 1288 case 2: 1289 map->pixel_mode = FT_PIXEL_MODE_GRAY2; 1290 map->pitch = ( map->width + 3 ) >> 2; 1291 break; 1292 1293 case 4: 1294 map->pixel_mode = FT_PIXEL_MODE_GRAY4; 1295 map->pitch = ( map->width + 1 ) >> 1; 1296 break; 1297 1298 case 8: 1299 map->pixel_mode = FT_PIXEL_MODE_GRAY; 1300 map->pitch = map->width; 1301 break; 1302 1303 default: 1304 return SFNT_Err_Invalid_File_Format; 1305 } 1306 1307 size = map->rows * map->pitch; 1308 1309 /* check that there is no empty image */ 1310 if ( size == 0 ) 1311 goto Exit; /* exit successfully! */ 1312 1313 error = ft_glyphslot_alloc_bitmap( slot, size ); 1314 if (error) 1315 goto Exit; 1316 } 1317 1318 switch ( range->image_format ) 1319 { 1320 case 1: /* single sbit image - load it */ 1321 case 2: 1322 case 5: 1323 case 6: 1324 case 7: 1325 return Load_SBit_Single( map, x_offset, y_offset, strike->bit_depth, 1326 range->image_format, metrics, stream ); 1327 1328 case 8: /* compound format */ 1329 if ( FT_STREAM_SKIP( 1L ) ) 1330 { 1331 error = SFNT_Err_Invalid_Stream_Skip; 1332 goto Exit; 1333 } 1334 /* fallthrough */ 1335 1336 case 9: 1337 break; 1338 1339 default: /* invalid image format */ 1340 return SFNT_Err_Invalid_File_Format; 1341 } 1342 1343 /* All right, we have a compound format. First of all, read */ 1344 /* the array of elements. */ 1345 { 1346 TT_SBit_Component components = NULL; 1347 TT_SBit_Component comp; 1348 FT_UShort num_components, count; 1349 1350 1351 if ( FT_READ_USHORT( num_components ) || 1352 FT_NEW_ARRAY( components, num_components ) ) 1353 goto Exit; 1354 1355 count = num_components; 1356 1357 if ( FT_FRAME_ENTER( 4L * num_components ) ) 1358 goto Fail_Memory; 1359 1360 for ( comp = components; count > 0; count--, comp++ ) 1361 { 1362 comp->glyph_code = FT_GET_USHORT(); 1363 comp->x_offset = FT_GET_CHAR(); 1364 comp->y_offset = FT_GET_CHAR(); 1365 } 1366 1367 FT_FRAME_EXIT(); 1368 1369 /* Now recursively load each element glyph */ 1370 count = num_components; 1371 comp = components; 1372 for ( ; count > 0; count--, comp++ ) 1373 { 1374 TT_SBit_Range elem_range; 1375 TT_SBit_MetricsRec elem_metrics; 1376 FT_ULong elem_offset; 1377 1378 1379 /* find the range for this element */ 1380 error = find_sbit_range( comp->glyph_code, 1381 strike, 1382 &elem_range, 1383 &elem_offset ); 1384 if ( error ) 1385 goto Fail_Memory; 1386 1387 /* now load the element, recursively */ 1388 error = Load_SBit_Image( strike, 1389 elem_range, 1390 ebdt_pos, 1391 elem_offset, 1392 slot, 1393 x_offset + comp->x_offset, 1394 y_offset + comp->y_offset, 1395 stream, 1396 &elem_metrics, 1397 depth + 1 ); 1398 if ( error ) 1399 goto Fail_Memory; 1400 } 1401 1402 Fail_Memory: 1403 FT_FREE( components ); 1404 } 1405 1406 Exit: 1407 return error; 1408 } 1409 1410 1411 /*************************************************************************/ 1412 /* */ 1413 /* <Function> */ 1414 /* tt_face_load_sbit_image */ 1415 /* */ 1416 /* <Description> */ 1417 /* Loads a given glyph sbit image from the font resource. This also */ 1418 /* returns its metrics. */ 1419 /* */ 1420 /* <Input> */ 1421 /* face :: The target face object. */ 1422 /* */ 1423 /* strike_index :: The current strike index. */ 1424 /* */ 1425 /* glyph_index :: The current glyph index. */ 1426 /* */ 1427 /* load_flags :: The glyph load flags (the code checks for the flag */ 1428 /* FT_LOAD_CROP_BITMAP). */ 1429 /* */ 1430 /* stream :: The input stream. */ 1431 /* */ 1432 /* <Output> */ 1433 /* map :: The target pixmap. */ 1434 /* */ 1435 /* metrics :: A big sbit metrics structure for the glyph image. */ 1436 /* */ 1437 /* <Return> */ 1438 /* FreeType error code. 0 means success. Returns an error if no */ 1439 /* glyph sbit exists for the index. */ 1440 /* */ 1441 /* <Note> */ 1442 /* The `map.buffer' field is always freed before the glyph is loaded. */ 1443 /* */ 1444 FT_LOCAL_DEF( FT_Error ) 1445 tt_face_load_sbit_image( TT_Face face, 1446 FT_ULong strike_index, 1447 FT_UInt glyph_index, 1448 FT_UInt load_flags, 1449 FT_Stream stream, 1450 FT_Bitmap *map, 1451 TT_SBit_MetricsRec *metrics ) 1452 { 1453 FT_Error error; 1454 FT_ULong ebdt_pos, glyph_offset; 1455 1456 TT_SBit_Strike strike; 1457 TT_SBit_Range range; 1458 1459 1460 /* Check whether there is a glyph sbit for the current index */ 1461 error = tt_find_sbit_image( face, glyph_index, strike_index, 1462 &range, &strike, &glyph_offset ); 1463 if ( error ) 1464 goto Exit; 1465 1466 /* now, find the location of the `EBDT' table in */ 1467 /* the font file */ 1468 error = face->goto_table( face, TTAG_EBDT, stream, 0 ); 1469 if ( error ) 1470 error = face->goto_table( face, TTAG_bdat, stream, 0 ); 1471 if ( error ) 1472 goto Exit; 1473 1474 ebdt_pos = FT_STREAM_POS(); 1475 1476 error = Load_SBit_Image( strike, range, ebdt_pos, glyph_offset, 1477 face->root.glyph, 0, 0, stream, metrics, 0 ); 1478 if ( error ) 1479 goto Exit; 1480 1481 /* setup vertical metrics if needed */ 1482 if ( strike->flags & 1 ) 1483 { 1484 /* in case of a horizontal strike only */ 1485 FT_Int advance; 1486 1487 1488 advance = strike->hori.ascender - strike->hori.descender; 1489 1490 /* some heuristic values */ 1491 1492 metrics->vertBearingX = (FT_Char)(-metrics->width / 2 ); 1493 metrics->vertBearingY = (FT_Char)( ( advance - metrics->height ) / 2 ); 1494 metrics->vertAdvance = (FT_Char)( advance * 12 / 10 ); 1495 } 1496 1497 /* Crop the bitmap now, unless specified otherwise */ 1498 if ( load_flags & FT_LOAD_CROP_BITMAP ) 1499 crop_bitmap( map, metrics ); 1500 1501 Exit: 1502 return error; 1503 } 1504 1505#endif /* FT_CONFIG_OPTION_OLD_INTERNALS */ 1506 1507 1508/* END */ 1509