ttsbit.c (49150B)
1 /**************************************************************************** 2 * 3 * ttsbit.c 4 * 5 * TrueType and OpenType embedded bitmap support (body). 6 * 7 * Copyright (C) 2005-2025 by 8 * David Turner, Robert Wilhelm, and Werner Lemberg. 9 * 10 * Copyright 2013 by Google, Inc. 11 * Google Author(s): Behdad Esfahbod. 12 * 13 * This file is part of the FreeType project, and may only be used, 14 * modified, and distributed under the terms of the FreeType project 15 * license, LICENSE.TXT. By continuing to use, modify, or distribute 16 * this file you indicate that you have read the license and 17 * understand and accept it fully. 18 * 19 */ 20 21 22 #include <freetype/internal/ftdebug.h> 23 #include <freetype/internal/ftstream.h> 24 #include <freetype/tttags.h> 25 #include <freetype/ftbitmap.h> 26 27 28 #ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS 29 30 #include "ttsbit.h" 31 32 #include "sferrors.h" 33 34 #include "ttmtx.h" 35 #include "pngshim.h" 36 37 38 /************************************************************************** 39 * 40 * The macro FT_COMPONENT is used in trace mode. It is an implicit 41 * parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log 42 * messages during execution. 43 */ 44 #undef FT_COMPONENT 45 #define FT_COMPONENT ttsbit 46 47 48 FT_LOCAL_DEF( FT_Error ) 49 tt_face_load_sbit( TT_Face face, 50 FT_Stream stream ) 51 { 52 FT_Error error; 53 FT_ULong table_size; 54 FT_ULong table_start; 55 56 57 face->sbit_table = NULL; 58 face->sbit_table_size = 0; 59 face->sbit_table_type = TT_SBIT_TABLE_TYPE_NONE; 60 face->sbit_num_strikes = 0; 61 62 error = face->goto_table( face, TTAG_CBLC, stream, &table_size ); 63 if ( !error ) 64 face->sbit_table_type = TT_SBIT_TABLE_TYPE_CBLC; 65 else 66 { 67 error = face->goto_table( face, TTAG_EBLC, stream, &table_size ); 68 if ( error ) 69 error = face->goto_table( face, TTAG_bloc, stream, &table_size ); 70 if ( !error ) 71 face->sbit_table_type = TT_SBIT_TABLE_TYPE_EBLC; 72 } 73 74 if ( error ) 75 { 76 error = face->goto_table( face, TTAG_sbix, stream, &table_size ); 77 if ( !error ) 78 face->sbit_table_type = TT_SBIT_TABLE_TYPE_SBIX; 79 } 80 if ( error ) 81 goto Exit; 82 83 if ( table_size < 8 ) 84 { 85 FT_ERROR(( "tt_face_load_sbit_strikes: table too short\n" )); 86 error = FT_THROW( Invalid_File_Format ); 87 goto Exit; 88 } 89 90 table_start = FT_STREAM_POS(); 91 92 switch ( (FT_UInt)face->sbit_table_type ) 93 { 94 case TT_SBIT_TABLE_TYPE_EBLC: 95 case TT_SBIT_TABLE_TYPE_CBLC: 96 { 97 FT_Byte* p; 98 FT_Fixed version; 99 FT_ULong num_strikes; 100 FT_UInt count; 101 102 103 if ( FT_FRAME_EXTRACT( table_size, face->sbit_table ) ) 104 goto Exit; 105 106 face->sbit_table_size = table_size; 107 108 p = face->sbit_table; 109 110 version = FT_NEXT_LONG( p ); 111 num_strikes = FT_NEXT_ULONG( p ); 112 113 /* there's at least one font (FZShuSong-Z01, version 3) */ 114 /* that uses the wrong byte order for the `version' field */ 115 if ( ( (FT_ULong)version & 0xFFFF0000UL ) != 0x00020000UL && 116 ( (FT_ULong)version & 0x0000FFFFUL ) != 0x00000200UL && 117 ( (FT_ULong)version & 0xFFFF0000UL ) != 0x00030000UL && 118 ( (FT_ULong)version & 0x0000FFFFUL ) != 0x00000300UL ) 119 { 120 error = FT_THROW( Unknown_File_Format ); 121 goto Exit; 122 } 123 124 if ( num_strikes >= 0x10000UL ) 125 { 126 error = FT_THROW( Invalid_File_Format ); 127 goto Exit; 128 } 129 130 /* 131 * Count the number of strikes available in the table. We are a bit 132 * paranoid there and don't trust the data. 133 */ 134 count = (FT_UInt)num_strikes; 135 if ( 8 + 48UL * count > table_size ) 136 count = (FT_UInt)( ( table_size - 8 ) / 48 ); 137 138 face->sbit_num_strikes = count; 139 } 140 break; 141 142 case TT_SBIT_TABLE_TYPE_SBIX: 143 { 144 FT_UShort version; 145 FT_UShort flags; 146 FT_ULong num_strikes; 147 FT_UInt count; 148 149 150 if ( FT_FRAME_ENTER( 8 ) ) 151 goto Exit; 152 153 version = FT_GET_USHORT(); 154 flags = FT_GET_USHORT(); 155 num_strikes = FT_GET_ULONG(); 156 157 FT_FRAME_EXIT(); 158 159 if ( version < 1 ) 160 { 161 error = FT_THROW( Unknown_File_Format ); 162 goto Exit; 163 } 164 165 /* Bit 0 must always be `1'. */ 166 /* Bit 1 controls the overlay of bitmaps with outlines. */ 167 /* All other bits should be zero. */ 168 if ( !( flags == 1 || flags == 3 ) || 169 num_strikes >= 0x10000UL ) 170 { 171 error = FT_THROW( Invalid_File_Format ); 172 goto Exit; 173 } 174 175 if ( flags == 3 ) 176 face->root.face_flags |= FT_FACE_FLAG_SBIX_OVERLAY; 177 178 /* 179 * Count the number of strikes available in the table. We are a bit 180 * paranoid there and don't trust the data. 181 */ 182 count = (FT_UInt)num_strikes; 183 if ( 8 + 4UL * count > table_size ) 184 count = (FT_UInt)( ( table_size - 8 ) / 4 ); 185 186 if ( FT_STREAM_SEEK( FT_STREAM_POS() - 8 ) ) 187 goto Exit; 188 189 face->sbit_table_size = 8 + count * 4; 190 if ( FT_FRAME_EXTRACT( face->sbit_table_size, face->sbit_table ) ) 191 goto Exit; 192 193 face->sbit_num_strikes = count; 194 } 195 break; 196 197 default: 198 /* we ignore unknown table formats */ 199 error = FT_THROW( Unknown_File_Format ); 200 break; 201 } 202 203 if ( !error ) 204 FT_TRACE3(( "tt_face_load_sbit_strikes: found %u strikes\n", 205 face->sbit_num_strikes )); 206 207 face->ebdt_start = 0; 208 face->ebdt_size = 0; 209 210 if ( face->sbit_table_type == TT_SBIT_TABLE_TYPE_SBIX ) 211 { 212 /* the `sbix' table is self-contained; */ 213 /* it has no associated data table */ 214 face->ebdt_start = table_start; 215 face->ebdt_size = table_size; 216 } 217 else if ( face->sbit_table_type != TT_SBIT_TABLE_TYPE_NONE ) 218 { 219 FT_ULong ebdt_size; 220 221 222 error = face->goto_table( face, TTAG_CBDT, stream, &ebdt_size ); 223 if ( error ) 224 error = face->goto_table( face, TTAG_EBDT, stream, &ebdt_size ); 225 if ( error ) 226 error = face->goto_table( face, TTAG_bdat, stream, &ebdt_size ); 227 228 if ( !error ) 229 { 230 face->ebdt_start = FT_STREAM_POS(); 231 face->ebdt_size = ebdt_size; 232 } 233 } 234 235 if ( !face->ebdt_size ) 236 { 237 FT_TRACE2(( "tt_face_load_sbit_strikes:" 238 " no embedded bitmap data table found;\n" )); 239 FT_TRACE2(( " " 240 " resetting number of strikes to zero\n" )); 241 face->sbit_num_strikes = 0; 242 } 243 244 return FT_Err_Ok; 245 246 Exit: 247 if ( error ) 248 { 249 if ( face->sbit_table ) 250 FT_FRAME_RELEASE( face->sbit_table ); 251 face->sbit_table_size = 0; 252 face->sbit_table_type = TT_SBIT_TABLE_TYPE_NONE; 253 } 254 255 return error; 256 } 257 258 259 FT_LOCAL_DEF( void ) 260 tt_face_free_sbit( TT_Face face ) 261 { 262 FT_Stream stream = face->root.stream; 263 264 265 FT_FRAME_RELEASE( face->sbit_table ); 266 face->sbit_table_size = 0; 267 face->sbit_table_type = TT_SBIT_TABLE_TYPE_NONE; 268 face->sbit_num_strikes = 0; 269 } 270 271 272 FT_LOCAL_DEF( FT_Error ) 273 tt_face_set_sbit_strike( TT_Face face, 274 FT_Size_Request req, 275 FT_ULong* astrike_index ) 276 { 277 return FT_Match_Size( (FT_Face)face, req, 0, astrike_index ); 278 } 279 280 281 FT_LOCAL_DEF( FT_Error ) 282 tt_face_load_strike_metrics( TT_Face face, 283 FT_ULong strike_index, 284 FT_Size_Metrics* metrics ) 285 { 286 /* we have to test for the existence of `sbit_strike_map' */ 287 /* because the function gets also used at the very beginning */ 288 /* to construct `sbit_strike_map' itself */ 289 if ( face->sbit_strike_map ) 290 { 291 if ( strike_index >= (FT_ULong)face->root.num_fixed_sizes ) 292 return FT_THROW( Invalid_Argument ); 293 294 /* map to real index */ 295 strike_index = face->sbit_strike_map[strike_index]; 296 } 297 else 298 { 299 if ( strike_index >= (FT_ULong)face->sbit_num_strikes ) 300 return FT_THROW( Invalid_Argument ); 301 } 302 303 switch ( (FT_UInt)face->sbit_table_type ) 304 { 305 case TT_SBIT_TABLE_TYPE_EBLC: 306 case TT_SBIT_TABLE_TYPE_CBLC: 307 { 308 FT_Byte* strike; 309 FT_Char max_before_bl; 310 FT_Char min_after_bl; 311 312 313 strike = face->sbit_table + 8 + strike_index * 48; 314 315 metrics->x_ppem = (FT_UShort)strike[44]; 316 metrics->y_ppem = (FT_UShort)strike[45]; 317 318 metrics->ascender = (FT_Char)strike[16] * 64; /* hori.ascender */ 319 metrics->descender = (FT_Char)strike[17] * 64; /* hori.descender */ 320 321 /* Due to fuzzy wording in the EBLC documentation, we find both */ 322 /* positive and negative values for `descender'. Additionally, */ 323 /* many fonts have both `ascender' and `descender' set to zero */ 324 /* (which is definitely wrong). MS Windows simply ignores all */ 325 /* those values... For these reasons we apply some heuristics */ 326 /* to get a reasonable, non-zero value for the height. */ 327 328 max_before_bl = (FT_Char)strike[24]; 329 min_after_bl = (FT_Char)strike[25]; 330 331 if ( metrics->descender > 0 ) 332 { 333 /* compare sign of descender with `min_after_bl' */ 334 if ( min_after_bl < 0 ) 335 metrics->descender = -metrics->descender; 336 } 337 338 else if ( metrics->descender == 0 ) 339 { 340 if ( metrics->ascender == 0 ) 341 { 342 FT_TRACE2(( "tt_face_load_strike_metrics:" 343 " sanitizing invalid ascender and descender\n" )); 344 FT_TRACE2(( " " 345 " values for strike %lu (%dppem, %dppem)\n", 346 strike_index, 347 metrics->x_ppem, metrics->y_ppem )); 348 349 /* sanitize buggy ascender and descender values */ 350 if ( max_before_bl || min_after_bl ) 351 { 352 metrics->ascender = max_before_bl * 64; 353 metrics->descender = min_after_bl * 64; 354 } 355 else 356 { 357 metrics->ascender = metrics->y_ppem * 64; 358 metrics->descender = 0; 359 } 360 } 361 } 362 363 #if 0 364 else 365 ; /* if we have a negative descender, simply use it */ 366 #endif 367 368 metrics->height = metrics->ascender - metrics->descender; 369 if ( metrics->height == 0 ) 370 { 371 FT_TRACE2(( "tt_face_load_strike_metrics:" 372 " sanitizing invalid height value\n" )); 373 FT_TRACE2(( " " 374 " for strike (%d, %d)\n", 375 metrics->x_ppem, metrics->y_ppem )); 376 metrics->height = metrics->y_ppem * 64; 377 metrics->descender = metrics->ascender - metrics->height; 378 } 379 380 /* Is this correct? */ 381 metrics->max_advance = ( (FT_Char)strike[22] + /* min_origin_SB */ 382 strike[18] + /* max_width */ 383 (FT_Char)strike[23] /* min_advance_SB */ 384 ) * 64; 385 386 /* set the scale values (in 16.16 units) so advances */ 387 /* from the hmtx and vmtx table are scaled correctly */ 388 metrics->x_scale = FT_DivFix( metrics->x_ppem * 64, 389 face->header.Units_Per_EM ); 390 metrics->y_scale = FT_DivFix( metrics->y_ppem * 64, 391 face->header.Units_Per_EM ); 392 393 return FT_Err_Ok; 394 } 395 396 case TT_SBIT_TABLE_TYPE_SBIX: 397 { 398 FT_Stream stream = face->root.stream; 399 FT_UInt offset; 400 FT_UShort ppem, resolution; 401 TT_HoriHeader *hori; 402 FT_Fixed scale; 403 404 FT_Error error; 405 FT_Byte* p; 406 407 408 p = face->sbit_table + 8 + 4 * strike_index; 409 offset = FT_NEXT_ULONG( p ); 410 411 if ( offset + 4 > face->ebdt_size ) 412 return FT_THROW( Invalid_File_Format ); 413 414 if ( FT_STREAM_SEEK( face->ebdt_start + offset ) || 415 FT_FRAME_ENTER( 4 ) ) 416 return error; 417 418 ppem = FT_GET_USHORT(); 419 resolution = FT_GET_USHORT(); 420 421 FT_UNUSED( resolution ); /* What to do with this? */ 422 423 FT_FRAME_EXIT(); 424 425 metrics->x_ppem = ppem; 426 metrics->y_ppem = ppem; 427 428 scale = FT_DivFix( ppem * 64, face->header.Units_Per_EM ); 429 hori = &face->horizontal; 430 431 metrics->ascender = FT_MulFix( hori->Ascender, scale ); 432 metrics->descender = FT_MulFix( hori->Descender, scale ); 433 metrics->height = 434 FT_MulFix( hori->Ascender - hori->Descender + hori->Line_Gap, 435 scale ); 436 metrics->max_advance = FT_MulFix( hori->advance_Width_Max, scale ); 437 438 /* set the scale values (in 16.16 units) so advances */ 439 /* from the hmtx and vmtx table are scaled correctly */ 440 metrics->x_scale = scale; 441 metrics->y_scale = scale; 442 443 return error; 444 } 445 446 default: 447 return FT_THROW( Unknown_File_Format ); 448 } 449 } 450 451 452 typedef struct TT_SBitDecoderRec_ 453 { 454 TT_Face face; 455 FT_Stream stream; 456 FT_Bitmap* bitmap; 457 TT_SBit_Metrics metrics; 458 FT_Bool metrics_loaded; 459 FT_Bool bitmap_allocated; 460 FT_Byte bit_depth; 461 462 FT_ULong ebdt_start; 463 FT_ULong ebdt_size; 464 465 FT_ULong strike_index_array; 466 FT_ULong strike_index_count; 467 FT_Byte* eblc_base; 468 FT_Byte* eblc_limit; 469 470 } TT_SBitDecoderRec, *TT_SBitDecoder; 471 472 473 static FT_Error 474 tt_sbit_decoder_init( TT_SBitDecoder decoder, 475 TT_Face face, 476 FT_ULong strike_index, 477 TT_SBit_MetricsRec* metrics ) 478 { 479 FT_Error error = FT_ERR( Table_Missing ); 480 FT_Stream stream = face->root.stream; 481 482 483 strike_index = face->sbit_strike_map[strike_index]; 484 485 if ( !face->ebdt_size ) 486 goto Exit; 487 if ( FT_STREAM_SEEK( face->ebdt_start ) ) 488 goto Exit; 489 490 decoder->face = face; 491 decoder->stream = stream; 492 decoder->bitmap = &face->root.glyph->bitmap; 493 decoder->metrics = metrics; 494 495 decoder->metrics_loaded = 0; 496 decoder->bitmap_allocated = 0; 497 498 decoder->ebdt_start = face->ebdt_start; 499 decoder->ebdt_size = face->ebdt_size; 500 501 decoder->eblc_base = face->sbit_table; 502 decoder->eblc_limit = face->sbit_table + face->sbit_table_size; 503 504 /* now find the strike corresponding to the index */ 505 { 506 FT_Byte* p; 507 508 509 if ( 8 + 48 * strike_index + 3 * 4 + 34 + 1 > face->sbit_table_size ) 510 { 511 error = FT_THROW( Invalid_File_Format ); 512 goto Exit; 513 } 514 515 p = decoder->eblc_base + 8 + 48 * strike_index; 516 517 decoder->strike_index_array = FT_NEXT_ULONG( p ); 518 p += 4; 519 decoder->strike_index_count = FT_NEXT_ULONG( p ); 520 p += 34; 521 decoder->bit_depth = *p; 522 523 /* decoder->strike_index_array + */ 524 /* 8 * decoder->strike_index_count > face->sbit_table_size ? */ 525 if ( decoder->strike_index_array > face->sbit_table_size || 526 decoder->strike_index_count > 527 ( face->sbit_table_size - decoder->strike_index_array ) / 8 ) 528 error = FT_THROW( Invalid_File_Format ); 529 } 530 531 Exit: 532 return error; 533 } 534 535 536 static void 537 tt_sbit_decoder_done( TT_SBitDecoder decoder ) 538 { 539 FT_UNUSED( decoder ); 540 } 541 542 543 static FT_Error 544 tt_sbit_decoder_alloc_bitmap( TT_SBitDecoder decoder, 545 FT_Bool metrics_only ) 546 { 547 FT_Error error = FT_Err_Ok; 548 FT_UInt width, height; 549 FT_Bitmap* map = decoder->bitmap; 550 FT_ULong size; 551 552 553 if ( !decoder->metrics_loaded ) 554 { 555 error = FT_THROW( Invalid_Argument ); 556 goto Exit; 557 } 558 559 width = decoder->metrics->width; 560 height = decoder->metrics->height; 561 562 map->width = width; 563 map->rows = height; 564 565 switch ( decoder->bit_depth ) 566 { 567 case 1: 568 map->pixel_mode = FT_PIXEL_MODE_MONO; 569 map->pitch = (int)( ( map->width + 7 ) >> 3 ); 570 map->num_grays = 2; 571 break; 572 573 case 2: 574 map->pixel_mode = FT_PIXEL_MODE_GRAY2; 575 map->pitch = (int)( ( map->width + 3 ) >> 2 ); 576 map->num_grays = 4; 577 break; 578 579 case 4: 580 map->pixel_mode = FT_PIXEL_MODE_GRAY4; 581 map->pitch = (int)( ( map->width + 1 ) >> 1 ); 582 map->num_grays = 16; 583 break; 584 585 case 8: 586 map->pixel_mode = FT_PIXEL_MODE_GRAY; 587 map->pitch = (int)( map->width ); 588 map->num_grays = 256; 589 break; 590 591 case 32: 592 map->pixel_mode = FT_PIXEL_MODE_BGRA; 593 map->pitch = (int)( map->width * 4 ); 594 map->num_grays = 256; 595 break; 596 597 default: 598 error = FT_THROW( Invalid_File_Format ); 599 goto Exit; 600 } 601 602 size = map->rows * (FT_ULong)map->pitch; 603 604 /* check that there is no empty image */ 605 if ( size == 0 ) 606 goto Exit; /* exit successfully! */ 607 608 if ( metrics_only ) 609 goto Exit; /* only metrics are requested */ 610 611 error = ft_glyphslot_alloc_bitmap( decoder->face->root.glyph, size ); 612 if ( error ) 613 goto Exit; 614 615 decoder->bitmap_allocated = 1; 616 617 Exit: 618 return error; 619 } 620 621 622 static FT_Error 623 tt_sbit_decoder_load_metrics( TT_SBitDecoder decoder, 624 FT_Byte* *pp, 625 FT_Byte* limit, 626 FT_Bool big ) 627 { 628 FT_Byte* p = *pp; 629 TT_SBit_Metrics metrics = decoder->metrics; 630 631 632 if ( p + 5 > limit ) 633 goto Fail; 634 635 metrics->height = p[0]; 636 metrics->width = p[1]; 637 metrics->horiBearingX = (FT_Char)p[2]; 638 metrics->horiBearingY = (FT_Char)p[3]; 639 metrics->horiAdvance = p[4]; 640 641 p += 5; 642 if ( big ) 643 { 644 if ( p + 3 > limit ) 645 goto Fail; 646 647 metrics->vertBearingX = (FT_Char)p[0]; 648 metrics->vertBearingY = (FT_Char)p[1]; 649 metrics->vertAdvance = p[2]; 650 651 p += 3; 652 } 653 else 654 { 655 /* avoid uninitialized data in case there is no vertical info -- */ 656 metrics->vertBearingX = 0; 657 metrics->vertBearingY = 0; 658 metrics->vertAdvance = 0; 659 } 660 661 decoder->metrics_loaded = 1; 662 *pp = p; 663 return FT_Err_Ok; 664 665 Fail: 666 FT_TRACE1(( "tt_sbit_decoder_load_metrics: broken table\n" )); 667 return FT_THROW( Invalid_Argument ); 668 } 669 670 671 /* forward declaration */ 672 static FT_Error 673 tt_sbit_decoder_load_image( TT_SBitDecoder decoder, 674 FT_UInt glyph_index, 675 FT_Int x_pos, 676 FT_Int y_pos, 677 FT_UInt recurse_count, 678 FT_Bool metrics_only ); 679 680 typedef FT_Error (*TT_SBitDecoder_LoadFunc)( 681 TT_SBitDecoder decoder, 682 FT_Byte* p, 683 FT_Byte* plimit, 684 FT_Int x_pos, 685 FT_Int y_pos, 686 FT_UInt recurse_count ); 687 688 689 static FT_Error 690 tt_sbit_decoder_load_byte_aligned( TT_SBitDecoder decoder, 691 FT_Byte* p, 692 FT_Byte* limit, 693 FT_Int x_pos, 694 FT_Int y_pos, 695 FT_UInt recurse_count ) 696 { 697 FT_Error error = FT_Err_Ok; 698 FT_Byte* line; 699 FT_Int pitch, width, height, line_bits, h; 700 FT_UInt bit_height, bit_width; 701 FT_Bitmap* bitmap; 702 703 FT_UNUSED( recurse_count ); 704 705 706 /* check that we can write the glyph into the bitmap */ 707 bitmap = decoder->bitmap; 708 bit_width = bitmap->width; 709 bit_height = bitmap->rows; 710 pitch = bitmap->pitch; 711 line = bitmap->buffer; 712 713 if ( !line ) 714 goto Exit; 715 716 width = decoder->metrics->width; 717 height = decoder->metrics->height; 718 719 line_bits = width * decoder->bit_depth; 720 721 if ( x_pos < 0 || (FT_UInt)( x_pos + width ) > bit_width || 722 y_pos < 0 || (FT_UInt)( y_pos + height ) > bit_height ) 723 { 724 FT_TRACE1(( "tt_sbit_decoder_load_byte_aligned:" 725 " invalid bitmap dimensions\n" )); 726 error = FT_THROW( Invalid_File_Format ); 727 goto Exit; 728 } 729 730 if ( p + ( ( line_bits + 7 ) >> 3 ) * height > limit ) 731 { 732 FT_TRACE1(( "tt_sbit_decoder_load_byte_aligned: broken bitmap\n" )); 733 error = FT_THROW( Invalid_File_Format ); 734 goto Exit; 735 } 736 737 /* now do the blit */ 738 line += y_pos * pitch + ( x_pos >> 3 ); 739 x_pos &= 7; 740 741 if ( x_pos == 0 ) /* the easy one */ 742 { 743 for ( h = height; h > 0; h--, line += pitch ) 744 { 745 FT_Byte* pwrite = line; 746 FT_Int w; 747 748 749 for ( w = line_bits; w >= 8; w -= 8 ) 750 { 751 pwrite[0] = (FT_Byte)( pwrite[0] | *p++ ); 752 pwrite += 1; 753 } 754 755 if ( w > 0 ) 756 pwrite[0] = (FT_Byte)( pwrite[0] | ( *p++ & ( 0xFF00U >> w ) ) ); 757 } 758 } 759 else /* x_pos > 0 */ 760 { 761 for ( h = height; h > 0; h--, line += pitch ) 762 { 763 FT_Byte* pwrite = line; 764 FT_Int w; 765 FT_UInt wval = 0; 766 767 768 for ( w = line_bits; w >= 8; w -= 8 ) 769 { 770 wval = (FT_UInt)( wval | *p++ ); 771 pwrite[0] = (FT_Byte)( pwrite[0] | ( wval >> x_pos ) ); 772 pwrite += 1; 773 wval <<= 8; 774 } 775 776 if ( w > 0 ) 777 wval = (FT_UInt)( wval | ( *p++ & ( 0xFF00U >> w ) ) ); 778 779 /* all bits read and there are `x_pos + w' bits to be written */ 780 781 pwrite[0] = (FT_Byte)( pwrite[0] | ( wval >> x_pos ) ); 782 783 if ( x_pos + w > 8 ) 784 { 785 pwrite++; 786 wval <<= 8; 787 pwrite[0] = (FT_Byte)( pwrite[0] | ( wval >> x_pos ) ); 788 } 789 } 790 } 791 792 Exit: 793 if ( !error ) 794 FT_TRACE3(( "tt_sbit_decoder_load_byte_aligned: loaded\n" )); 795 return error; 796 } 797 798 799 /* 800 * Load a bit-aligned bitmap (with pointer `p') into a line-aligned bitmap 801 * (with pointer `pwrite'). In the example below, the width is 3 pixel, 802 * and `x_pos' is 1 pixel. 803 * 804 * p p+1 805 * | | | 806 * | 7 6 5 4 3 2 1 0 | 7 6 5 4 3 2 1 0 |... 807 * | | | 808 * +-------+ +-------+ +-------+ ... 809 * . . . 810 * . . . 811 * v . . 812 * +-------+ . . 813 * | | . 814 * | 7 6 5 4 3 2 1 0 | . 815 * | | . 816 * pwrite . . 817 * . . 818 * v . 819 * +-------+ . 820 * | | 821 * | 7 6 5 4 3 2 1 0 | 822 * | | 823 * pwrite+1 . 824 * . 825 * v 826 * +-------+ 827 * | | 828 * | 7 6 5 4 3 2 1 0 | 829 * | | 830 * pwrite+2 831 * 832 */ 833 834 static FT_Error 835 tt_sbit_decoder_load_bit_aligned( TT_SBitDecoder decoder, 836 FT_Byte* p, 837 FT_Byte* limit, 838 FT_Int x_pos, 839 FT_Int y_pos, 840 FT_UInt recurse_count ) 841 { 842 FT_Error error = FT_Err_Ok; 843 FT_Byte* line; 844 FT_Int pitch, width, height, line_bits, h, nbits; 845 FT_UInt bit_height, bit_width; 846 FT_Bitmap* bitmap; 847 FT_UShort rval; 848 849 FT_UNUSED( recurse_count ); 850 851 852 /* check that we can write the glyph into the bitmap */ 853 bitmap = decoder->bitmap; 854 bit_width = bitmap->width; 855 bit_height = bitmap->rows; 856 pitch = bitmap->pitch; 857 line = bitmap->buffer; 858 859 width = decoder->metrics->width; 860 height = decoder->metrics->height; 861 862 line_bits = width * decoder->bit_depth; 863 864 if ( x_pos < 0 || (FT_UInt)( x_pos + width ) > bit_width || 865 y_pos < 0 || (FT_UInt)( y_pos + height ) > bit_height ) 866 { 867 FT_TRACE1(( "tt_sbit_decoder_load_bit_aligned:" 868 " invalid bitmap dimensions\n" )); 869 error = FT_THROW( Invalid_File_Format ); 870 goto Exit; 871 } 872 873 if ( p + ( ( line_bits * height + 7 ) >> 3 ) > limit ) 874 { 875 FT_TRACE1(( "tt_sbit_decoder_load_bit_aligned: broken bitmap\n" )); 876 error = FT_THROW( Invalid_File_Format ); 877 goto Exit; 878 } 879 880 if ( !line_bits || !height ) 881 { 882 /* nothing to do */ 883 goto Exit; 884 } 885 886 /* now do the blit */ 887 888 /* adjust `line' to point to the first byte of the bitmap */ 889 line += y_pos * pitch + ( x_pos >> 3 ); 890 x_pos &= 7; 891 892 /* the higher byte of `rval' is used as a buffer */ 893 rval = 0; 894 nbits = 0; 895 896 for ( h = height; h > 0; h--, line += pitch ) 897 { 898 FT_Byte* pwrite = line; 899 FT_Int w = line_bits; 900 901 902 /* handle initial byte (in target bitmap) specially if necessary */ 903 if ( x_pos ) 904 { 905 w = ( line_bits < 8 - x_pos ) ? line_bits : 8 - x_pos; 906 907 if ( h == height ) 908 { 909 rval = *p++; 910 nbits = x_pos; 911 } 912 else if ( nbits < w ) 913 { 914 if ( p < limit ) 915 rval |= *p++; 916 nbits += 8 - w; 917 } 918 else 919 { 920 rval >>= 8; 921 nbits -= w; 922 } 923 924 *pwrite++ |= ( ( rval >> nbits ) & 0xFF ) & 925 ( ~( 0xFFU << w ) << ( 8 - w - x_pos ) ); 926 rval <<= 8; 927 928 w = line_bits - w; 929 } 930 931 /* handle medial bytes */ 932 for ( ; w >= 8; w -= 8 ) 933 { 934 rval |= *p++; 935 *pwrite++ |= ( rval >> nbits ) & 0xFF; 936 937 rval <<= 8; 938 } 939 940 /* handle final byte if necessary */ 941 if ( w > 0 ) 942 { 943 if ( nbits < w ) 944 { 945 if ( p < limit ) 946 rval |= *p++; 947 *pwrite |= ( ( rval >> nbits ) & 0xFF ) & ( 0xFF00U >> w ); 948 nbits += 8 - w; 949 950 rval <<= 8; 951 } 952 else 953 { 954 *pwrite |= ( ( rval >> nbits ) & 0xFF ) & ( 0xFF00U >> w ); 955 nbits -= w; 956 } 957 } 958 } 959 960 Exit: 961 if ( !error ) 962 FT_TRACE3(( "tt_sbit_decoder_load_bit_aligned: loaded\n" )); 963 return error; 964 } 965 966 967 static FT_Error 968 tt_sbit_decoder_load_compound( TT_SBitDecoder decoder, 969 FT_Byte* p, 970 FT_Byte* limit, 971 FT_Int x_pos, 972 FT_Int y_pos, 973 FT_UInt recurse_count ) 974 { 975 FT_Error error = FT_Err_Ok; 976 FT_UInt num_components, nn; 977 978 FT_Char horiBearingX = (FT_Char)decoder->metrics->horiBearingX; 979 FT_Char horiBearingY = (FT_Char)decoder->metrics->horiBearingY; 980 FT_Byte horiAdvance = (FT_Byte)decoder->metrics->horiAdvance; 981 FT_Char vertBearingX = (FT_Char)decoder->metrics->vertBearingX; 982 FT_Char vertBearingY = (FT_Char)decoder->metrics->vertBearingY; 983 FT_Byte vertAdvance = (FT_Byte)decoder->metrics->vertAdvance; 984 985 986 if ( p + 2 > limit ) 987 goto Fail; 988 989 num_components = FT_NEXT_USHORT( p ); 990 if ( p + 4 * num_components > limit ) 991 { 992 FT_TRACE1(( "tt_sbit_decoder_load_compound: broken table\n" )); 993 goto Fail; 994 } 995 996 FT_TRACE3(( "tt_sbit_decoder_load_compound: loading %u component%s\n", 997 num_components, 998 num_components == 1 ? "" : "s" )); 999 1000 for ( nn = 0; nn < num_components; nn++ ) 1001 { 1002 FT_UInt gindex = FT_NEXT_USHORT( p ); 1003 FT_Char dx = FT_NEXT_CHAR( p ); 1004 FT_Char dy = FT_NEXT_CHAR( p ); 1005 1006 1007 /* NB: a recursive call */ 1008 error = tt_sbit_decoder_load_image( decoder, 1009 gindex, 1010 x_pos + dx, 1011 y_pos + dy, 1012 recurse_count + 1, 1013 /* request full bitmap image */ 1014 FALSE ); 1015 if ( error ) 1016 break; 1017 } 1018 1019 FT_TRACE3(( "tt_sbit_decoder_load_compound: done\n" )); 1020 1021 decoder->metrics->horiBearingX = horiBearingX; 1022 decoder->metrics->horiBearingY = horiBearingY; 1023 decoder->metrics->horiAdvance = horiAdvance; 1024 decoder->metrics->vertBearingX = vertBearingX; 1025 decoder->metrics->vertBearingY = vertBearingY; 1026 decoder->metrics->vertAdvance = vertAdvance; 1027 decoder->metrics->width = (FT_Byte)decoder->bitmap->width; 1028 decoder->metrics->height = (FT_Byte)decoder->bitmap->rows; 1029 1030 Exit: 1031 return error; 1032 1033 Fail: 1034 error = FT_THROW( Invalid_File_Format ); 1035 goto Exit; 1036 } 1037 1038 1039 #ifdef FT_CONFIG_OPTION_USE_PNG 1040 1041 static FT_Error 1042 tt_sbit_decoder_load_png( TT_SBitDecoder decoder, 1043 FT_Byte* p, 1044 FT_Byte* limit, 1045 FT_Int x_pos, 1046 FT_Int y_pos, 1047 FT_UInt recurse_count ) 1048 { 1049 FT_Error error = FT_Err_Ok; 1050 FT_ULong png_len; 1051 1052 FT_UNUSED( recurse_count ); 1053 1054 1055 if ( limit - p < 4 ) 1056 { 1057 FT_TRACE1(( "tt_sbit_decoder_load_png: broken bitmap\n" )); 1058 error = FT_THROW( Invalid_File_Format ); 1059 goto Exit; 1060 } 1061 1062 png_len = FT_NEXT_ULONG( p ); 1063 if ( (FT_ULong)( limit - p ) < png_len ) 1064 { 1065 FT_TRACE1(( "tt_sbit_decoder_load_png: broken bitmap\n" )); 1066 error = FT_THROW( Invalid_File_Format ); 1067 goto Exit; 1068 } 1069 1070 error = Load_SBit_Png( decoder->face->root.glyph, 1071 x_pos, 1072 y_pos, 1073 decoder->bit_depth, 1074 decoder->metrics, 1075 decoder->stream->memory, 1076 p, 1077 png_len, 1078 FALSE, 1079 FALSE ); 1080 1081 Exit: 1082 if ( !error ) 1083 FT_TRACE3(( "tt_sbit_decoder_load_png: loaded\n" )); 1084 return error; 1085 } 1086 1087 #endif /* FT_CONFIG_OPTION_USE_PNG */ 1088 1089 1090 static FT_Error 1091 tt_sbit_decoder_load_bitmap( TT_SBitDecoder decoder, 1092 FT_UInt glyph_format, 1093 FT_ULong glyph_start, 1094 FT_ULong glyph_size, 1095 FT_Int x_pos, 1096 FT_Int y_pos, 1097 FT_UInt recurse_count, 1098 FT_Bool metrics_only ) 1099 { 1100 FT_Error error; 1101 FT_Stream stream = decoder->stream; 1102 FT_Byte* p; 1103 FT_Byte* p_limit; 1104 FT_Byte* data; 1105 1106 1107 /* seek into the EBDT table now */ 1108 if ( !glyph_size || 1109 glyph_start + glyph_size > decoder->ebdt_size ) 1110 { 1111 error = FT_THROW( Invalid_Argument ); 1112 goto Exit; 1113 } 1114 1115 if ( FT_STREAM_SEEK( decoder->ebdt_start + glyph_start ) || 1116 FT_FRAME_EXTRACT( glyph_size, data ) ) 1117 goto Exit; 1118 1119 p = data; 1120 p_limit = p + glyph_size; 1121 1122 /* read the data, depending on the glyph format */ 1123 switch ( glyph_format ) 1124 { 1125 case 1: 1126 case 2: 1127 case 8: 1128 case 17: 1129 error = tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 0 ); 1130 break; 1131 1132 case 6: 1133 case 7: 1134 case 9: 1135 case 18: 1136 error = tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 ); 1137 break; 1138 1139 default: 1140 error = FT_Err_Ok; 1141 } 1142 1143 if ( error ) 1144 goto Fail; 1145 1146 { 1147 TT_SBitDecoder_LoadFunc loader; 1148 1149 1150 switch ( glyph_format ) 1151 { 1152 case 1: 1153 case 6: 1154 loader = tt_sbit_decoder_load_byte_aligned; 1155 break; 1156 1157 case 2: 1158 case 7: 1159 { 1160 /* Don't trust `glyph_format'. For example, Apple's main Korean */ 1161 /* system font, `AppleMyungJo.ttf' (version 7.0d2e6), uses glyph */ 1162 /* format 7, but the data is format 6. We check whether we have */ 1163 /* an excessive number of bytes in the image: If it is equal to */ 1164 /* the value for a byte-aligned glyph, use the other loading */ 1165 /* routine. */ 1166 /* */ 1167 /* Note that for some (width,height) combinations, where the */ 1168 /* width is not a multiple of 8, the sizes for bit- and */ 1169 /* byte-aligned data are equal, for example (7,7) or (15,6). We */ 1170 /* then prefer what `glyph_format' specifies. */ 1171 1172 FT_UInt width = decoder->metrics->width; 1173 FT_UInt height = decoder->metrics->height; 1174 1175 FT_UInt bit_size = ( width * height + 7 ) >> 3; 1176 FT_UInt byte_size = height * ( ( width + 7 ) >> 3 ); 1177 1178 1179 if ( bit_size < byte_size && 1180 byte_size == (FT_UInt)( p_limit - p ) ) 1181 loader = tt_sbit_decoder_load_byte_aligned; 1182 else 1183 loader = tt_sbit_decoder_load_bit_aligned; 1184 } 1185 break; 1186 1187 case 5: 1188 loader = tt_sbit_decoder_load_bit_aligned; 1189 break; 1190 1191 case 8: 1192 if ( p + 1 > p_limit ) 1193 goto Fail; 1194 1195 p += 1; /* skip padding */ 1196 FALL_THROUGH; 1197 1198 case 9: 1199 loader = tt_sbit_decoder_load_compound; 1200 break; 1201 1202 case 17: /* small metrics, PNG image data */ 1203 case 18: /* big metrics, PNG image data */ 1204 case 19: /* metrics in EBLC, PNG image data */ 1205 #ifdef FT_CONFIG_OPTION_USE_PNG 1206 loader = tt_sbit_decoder_load_png; 1207 break; 1208 #else 1209 error = FT_THROW( Unimplemented_Feature ); 1210 goto Fail; 1211 #endif /* FT_CONFIG_OPTION_USE_PNG */ 1212 1213 default: 1214 error = FT_THROW( Invalid_Table ); 1215 goto Fail; 1216 } 1217 1218 if ( !decoder->bitmap_allocated ) 1219 { 1220 error = tt_sbit_decoder_alloc_bitmap( decoder, metrics_only ); 1221 1222 if ( error ) 1223 goto Fail; 1224 } 1225 1226 if ( metrics_only ) 1227 goto Fail; /* this is not an error */ 1228 1229 error = loader( decoder, p, p_limit, x_pos, y_pos, recurse_count ); 1230 } 1231 1232 Fail: 1233 FT_FRAME_RELEASE( data ); 1234 1235 Exit: 1236 return error; 1237 } 1238 1239 1240 static FT_Error 1241 tt_sbit_decoder_load_image( TT_SBitDecoder decoder, 1242 FT_UInt glyph_index, 1243 FT_Int x_pos, 1244 FT_Int y_pos, 1245 FT_UInt recurse_count, 1246 FT_Bool metrics_only ) 1247 { 1248 FT_Byte* p = decoder->eblc_base + decoder->strike_index_array; 1249 FT_Byte* p_limit = decoder->eblc_limit; 1250 FT_ULong num_ranges = decoder->strike_index_count; 1251 FT_UInt start, end, index_format, image_format; 1252 FT_ULong image_start = 0, image_end = 0, image_offset; 1253 1254 1255 /* arbitrary recursion limit */ 1256 if ( recurse_count > 100 ) 1257 { 1258 FT_TRACE4(( "tt_sbit_decoder_load_image:" 1259 " recursion depth exceeded\n" )); 1260 goto Failure; 1261 } 1262 1263 1264 /* First, we find the correct strike range that applies to this */ 1265 /* glyph index. */ 1266 for ( ; num_ranges > 0; num_ranges-- ) 1267 { 1268 start = FT_NEXT_USHORT( p ); 1269 end = FT_NEXT_USHORT( p ); 1270 1271 if ( glyph_index >= start && glyph_index <= end ) 1272 goto FoundRange; 1273 1274 p += 4; /* ignore index offset */ 1275 } 1276 goto NoBitmap; 1277 1278 FoundRange: 1279 image_offset = FT_NEXT_ULONG( p ); 1280 1281 /* overflow check */ 1282 p = decoder->eblc_base + decoder->strike_index_array; 1283 if ( image_offset > (FT_ULong)( p_limit - p ) ) 1284 goto Failure; 1285 1286 p += image_offset; 1287 if ( p + 8 > p_limit ) 1288 goto NoBitmap; 1289 1290 /* now find the glyph's location and extend within the ebdt table */ 1291 index_format = FT_NEXT_USHORT( p ); 1292 image_format = FT_NEXT_USHORT( p ); 1293 image_offset = FT_NEXT_ULONG ( p ); 1294 1295 switch ( index_format ) 1296 { 1297 case 1: /* 4-byte offsets relative to `image_offset' */ 1298 p += 4 * ( glyph_index - start ); 1299 if ( p + 8 > p_limit ) 1300 goto NoBitmap; 1301 1302 image_start = FT_NEXT_ULONG( p ); 1303 image_end = FT_NEXT_ULONG( p ); 1304 1305 if ( image_start == image_end ) /* missing glyph */ 1306 goto NoBitmap; 1307 break; 1308 1309 case 2: /* big metrics, constant image size */ 1310 { 1311 FT_ULong image_size; 1312 1313 1314 if ( p + 12 > p_limit ) 1315 goto NoBitmap; 1316 1317 image_size = FT_NEXT_ULONG( p ); 1318 1319 if ( tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 ) ) 1320 goto NoBitmap; 1321 1322 image_start = image_size * ( glyph_index - start ); 1323 image_end = image_start + image_size; 1324 } 1325 break; 1326 1327 case 3: /* 2-byte offsets relative to 'image_offset' */ 1328 p += 2 * ( glyph_index - start ); 1329 if ( p + 4 > p_limit ) 1330 goto NoBitmap; 1331 1332 image_start = FT_NEXT_USHORT( p ); 1333 image_end = FT_NEXT_USHORT( p ); 1334 1335 if ( image_start == image_end ) /* missing glyph */ 1336 goto NoBitmap; 1337 break; 1338 1339 case 4: /* sparse glyph array with (glyph,offset) pairs */ 1340 { 1341 FT_ULong mm, num_glyphs; 1342 1343 1344 if ( p + 4 > p_limit ) 1345 goto NoBitmap; 1346 1347 num_glyphs = FT_NEXT_ULONG( p ); 1348 1349 /* overflow check for p + ( num_glyphs + 1 ) * 4 */ 1350 if ( p + 4 > p_limit || 1351 num_glyphs > (FT_ULong)( ( ( p_limit - p ) >> 2 ) - 1 ) ) 1352 goto NoBitmap; 1353 1354 for ( mm = 0; mm < num_glyphs; mm++ ) 1355 { 1356 FT_UInt gindex = FT_NEXT_USHORT( p ); 1357 1358 1359 if ( gindex == glyph_index ) 1360 { 1361 image_start = FT_NEXT_USHORT( p ); 1362 p += 2; 1363 image_end = FT_PEEK_USHORT( p ); 1364 break; 1365 } 1366 p += 2; 1367 } 1368 1369 if ( mm >= num_glyphs ) 1370 goto NoBitmap; 1371 } 1372 break; 1373 1374 case 5: /* constant metrics with sparse glyph codes */ 1375 case 19: 1376 { 1377 FT_ULong image_size, mm, num_glyphs; 1378 1379 1380 if ( p + 16 > p_limit ) 1381 goto NoBitmap; 1382 1383 image_size = FT_NEXT_ULONG( p ); 1384 1385 if ( tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 ) ) 1386 goto NoBitmap; 1387 1388 num_glyphs = FT_NEXT_ULONG( p ); 1389 1390 /* overflow check for p + 2 * num_glyphs */ 1391 if ( num_glyphs > (FT_ULong)( ( p_limit - p ) >> 1 ) ) 1392 goto NoBitmap; 1393 1394 for ( mm = 0; mm < num_glyphs; mm++ ) 1395 { 1396 FT_UInt gindex = FT_NEXT_USHORT( p ); 1397 1398 1399 if ( gindex == glyph_index ) 1400 break; 1401 } 1402 1403 if ( mm >= num_glyphs ) 1404 goto NoBitmap; 1405 1406 image_start = image_size * mm; 1407 image_end = image_start + image_size; 1408 } 1409 break; 1410 1411 default: 1412 goto NoBitmap; 1413 } 1414 1415 if ( image_start > image_end ) 1416 goto NoBitmap; 1417 1418 image_end -= image_start; 1419 image_start = image_offset + image_start; 1420 1421 FT_TRACE3(( "tt_sbit_decoder_load_image:" 1422 " found sbit (format %u) for glyph index %u\n", 1423 image_format, glyph_index )); 1424 1425 return tt_sbit_decoder_load_bitmap( decoder, 1426 image_format, 1427 image_start, 1428 image_end, 1429 x_pos, 1430 y_pos, 1431 recurse_count, 1432 metrics_only ); 1433 1434 Failure: 1435 return FT_THROW( Invalid_Table ); 1436 1437 NoBitmap: 1438 if ( recurse_count ) 1439 { 1440 FT_TRACE4(( "tt_sbit_decoder_load_image:" 1441 " missing subglyph sbit with glyph index %u\n", 1442 glyph_index )); 1443 return FT_THROW( Invalid_Composite ); 1444 } 1445 1446 FT_TRACE4(( "tt_sbit_decoder_load_image:" 1447 " no sbit found for glyph index %u\n", glyph_index )); 1448 return FT_THROW( Missing_Bitmap ); 1449 } 1450 1451 1452 static FT_Error 1453 tt_face_load_sbix_image( TT_Face face, 1454 FT_ULong strike_index, 1455 FT_UInt glyph_index, 1456 FT_Stream stream, 1457 FT_Bitmap *map, 1458 TT_SBit_MetricsRec *metrics, 1459 FT_Bool metrics_only ) 1460 { 1461 FT_UInt strike_offset, glyph_start, glyph_end; 1462 FT_Int originOffsetX, originOffsetY; 1463 FT_Tag graphicType; 1464 FT_Int recurse_depth = 0; 1465 FT_Bool flipped = FALSE; 1466 1467 FT_Error error; 1468 FT_Byte* p; 1469 1470 #ifndef FT_CONFIG_OPTION_USE_PNG 1471 FT_UNUSED( map ); 1472 FT_UNUSED( metrics_only ); 1473 #endif 1474 1475 1476 strike_index = face->sbit_strike_map[strike_index]; 1477 1478 metrics->width = 0; 1479 metrics->height = 0; 1480 1481 p = face->sbit_table + 8 + 4 * strike_index; 1482 strike_offset = FT_NEXT_ULONG( p ); 1483 1484 retry: 1485 if ( glyph_index > (FT_UInt)face->root.num_glyphs ) 1486 return FT_THROW( Invalid_Argument ); 1487 1488 if ( strike_offset >= face->ebdt_size || 1489 face->ebdt_size - strike_offset < 4 + glyph_index * 4 + 8 ) 1490 return FT_THROW( Invalid_File_Format ); 1491 1492 if ( FT_STREAM_SEEK( face->ebdt_start + 1493 strike_offset + 4 + 1494 glyph_index * 4 ) || 1495 FT_FRAME_ENTER( 8 ) ) 1496 return error; 1497 1498 glyph_start = FT_GET_ULONG(); 1499 glyph_end = FT_GET_ULONG(); 1500 1501 FT_FRAME_EXIT(); 1502 1503 if ( glyph_start == glyph_end ) 1504 return FT_THROW( Missing_Bitmap ); 1505 if ( glyph_start > glyph_end || 1506 glyph_end - glyph_start < 8 || 1507 face->ebdt_size - strike_offset < glyph_end ) 1508 return FT_THROW( Invalid_File_Format ); 1509 1510 if ( FT_STREAM_SEEK( face->ebdt_start + strike_offset + glyph_start ) || 1511 FT_FRAME_ENTER( glyph_end - glyph_start ) ) 1512 return error; 1513 1514 originOffsetX = FT_GET_SHORT(); 1515 originOffsetY = FT_GET_SHORT(); 1516 1517 graphicType = FT_GET_TAG4(); 1518 1519 switch ( graphicType ) 1520 { 1521 case FT_MAKE_TAG( 'f', 'l', 'i', 'p' ): 1522 flipped = !flipped; 1523 FALL_THROUGH; 1524 1525 case FT_MAKE_TAG( 'd', 'u', 'p', 'e' ): 1526 if ( recurse_depth++ < 4 ) 1527 { 1528 glyph_index = FT_GET_USHORT(); 1529 FT_FRAME_EXIT(); 1530 1531 goto retry; 1532 } 1533 error = FT_THROW( Invalid_File_Format ); 1534 break; 1535 1536 case FT_MAKE_TAG( 'p', 'n', 'g', ' ' ): 1537 #ifdef FT_CONFIG_OPTION_USE_PNG 1538 error = Load_SBit_Png( face->root.glyph, 1539 0, 1540 0, 1541 32, 1542 metrics, 1543 stream->memory, 1544 stream->cursor, 1545 glyph_end - glyph_start - 8, 1546 TRUE, 1547 metrics_only ); 1548 if ( flipped && !metrics_only && !error ) 1549 { 1550 FT_UInt32* curr_pos = (FT_UInt32*)map->buffer; 1551 1552 /* `Load_SBit_Png` always returns a pixmap with 32 bits per pixel */ 1553 /* and no extra pitch bytes. */ 1554 FT_UInt width = map->width; 1555 FT_UInt y; 1556 1557 1558 for ( y = 0; y < map->rows; y++ ) 1559 { 1560 FT_UInt32* left = curr_pos; 1561 FT_UInt32* right = curr_pos + width - 1; 1562 1563 1564 while ( left < right ) 1565 { 1566 FT_UInt32 value; 1567 1568 1569 value = *right; 1570 *right = *left; 1571 *left = value; 1572 1573 left++; 1574 right--; 1575 } 1576 1577 curr_pos += width; 1578 } 1579 } 1580 #else 1581 error = FT_THROW( Unimplemented_Feature ); 1582 #endif 1583 break; 1584 1585 case FT_MAKE_TAG( 'j', 'p', 'g', ' ' ): 1586 case FT_MAKE_TAG( 't', 'i', 'f', 'f' ): 1587 case FT_MAKE_TAG( 'r', 'g', 'b', 'l' ): /* used on iOS 7.1 */ 1588 error = FT_THROW( Unknown_File_Format ); 1589 break; 1590 1591 default: 1592 error = FT_THROW( Unimplemented_Feature ); 1593 break; 1594 } 1595 1596 FT_FRAME_EXIT(); 1597 1598 if ( !error ) 1599 { 1600 FT_Short abearing; /* not used here */ 1601 FT_UShort aadvance; 1602 1603 1604 tt_face_get_metrics( face, FALSE, glyph_index, &abearing, &aadvance ); 1605 1606 metrics->horiBearingX = (FT_Short)originOffsetX; 1607 metrics->vertBearingX = (FT_Short)originOffsetX; 1608 1609 metrics->horiBearingY = (FT_Short)( originOffsetY + metrics->height ); 1610 metrics->vertBearingY = (FT_Short)originOffsetY; 1611 1612 metrics->horiAdvance = (FT_UShort)( aadvance * 1613 face->root.size->metrics.x_ppem / 1614 face->header.Units_Per_EM ); 1615 1616 if ( face->vertical_info ) 1617 tt_face_get_metrics( face, TRUE, glyph_index, &abearing, &aadvance ); 1618 else if ( face->os2.version != 0xFFFFU ) 1619 aadvance = (FT_UShort)FT_ABS( face->os2.sTypoAscender - 1620 face->os2.sTypoDescender ); 1621 else 1622 aadvance = (FT_UShort)FT_ABS( face->horizontal.Ascender - 1623 face->horizontal.Descender ); 1624 1625 metrics->vertAdvance = (FT_UShort)( aadvance * 1626 face->root.size->metrics.x_ppem / 1627 face->header.Units_Per_EM ); 1628 } 1629 1630 return error; 1631 } 1632 1633 FT_LOCAL_DEF( FT_Error ) 1634 tt_face_load_sbit_image( TT_Face face, 1635 FT_ULong strike_index, 1636 FT_UInt glyph_index, 1637 FT_UInt load_flags, 1638 FT_Stream stream, 1639 FT_Bitmap *map, 1640 TT_SBit_MetricsRec *metrics ) 1641 { 1642 FT_Error error = FT_Err_Ok; 1643 1644 1645 switch ( (FT_UInt)face->sbit_table_type ) 1646 { 1647 case TT_SBIT_TABLE_TYPE_EBLC: 1648 case TT_SBIT_TABLE_TYPE_CBLC: 1649 { 1650 TT_SBitDecoderRec decoder[1]; 1651 1652 1653 error = tt_sbit_decoder_init( decoder, face, strike_index, metrics ); 1654 if ( !error ) 1655 { 1656 error = tt_sbit_decoder_load_image( 1657 decoder, 1658 glyph_index, 1659 0, 1660 0, 1661 0, 1662 ( load_flags & FT_LOAD_BITMAP_METRICS_ONLY ) != 0 ); 1663 tt_sbit_decoder_done( decoder ); 1664 } 1665 } 1666 break; 1667 1668 case TT_SBIT_TABLE_TYPE_SBIX: 1669 error = tt_face_load_sbix_image( 1670 face, 1671 strike_index, 1672 glyph_index, 1673 stream, 1674 map, 1675 metrics, 1676 ( load_flags & FT_LOAD_BITMAP_METRICS_ONLY ) != 0 ); 1677 break; 1678 1679 default: 1680 error = FT_THROW( Unknown_File_Format ); 1681 break; 1682 } 1683 1684 /* Flatten color bitmaps if color was not requested. */ 1685 if ( !error && 1686 !( load_flags & FT_LOAD_COLOR ) && 1687 !( load_flags & FT_LOAD_BITMAP_METRICS_ONLY ) && 1688 map->pixel_mode == FT_PIXEL_MODE_BGRA ) 1689 { 1690 FT_Bitmap new_map; 1691 FT_Library library = face->root.glyph->library; 1692 1693 1694 FT_Bitmap_Init( &new_map ); 1695 1696 /* Convert to 8bit grayscale. */ 1697 error = FT_Bitmap_Convert( library, map, &new_map, 1 ); 1698 if ( error ) 1699 FT_Bitmap_Done( library, &new_map ); 1700 else 1701 { 1702 map->pixel_mode = new_map.pixel_mode; 1703 map->pitch = new_map.pitch; 1704 map->num_grays = new_map.num_grays; 1705 1706 ft_glyphslot_set_bitmap( face->root.glyph, new_map.buffer ); 1707 face->root.glyph->internal->flags |= FT_GLYPH_OWN_BITMAP; 1708 } 1709 } 1710 1711 return error; 1712 } 1713 1714 #else /* !TT_CONFIG_OPTION_EMBEDDED_BITMAPS */ 1715 1716 /* ANSI C doesn't like empty source files */ 1717 typedef int tt_sbit_dummy_; 1718 1719 #endif /* !TT_CONFIG_OPTION_EMBEDDED_BITMAPS */ 1720 1721 1722 /* END */