1/***************************************************************************/ 2/* */ 3/* ttsbit0.c */ 4/* */ 5/* TrueType and OpenType embedded bitmap support (body). */ 6/* This is a heap-optimized version. */ 7/* */ 8/* Copyright 2005, 2006, 2007, 2008, 2009 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 20/* This file is included by ttsbit.c */ 21 22 23#include <ft2build.h> 24#include FT_INTERNAL_DEBUG_H 25#include FT_INTERNAL_STREAM_H 26#include FT_TRUETYPE_TAGS_H 27#include "ttsbit.h" 28 29#include "sferrors.h" 30 31 32 /*************************************************************************/ 33 /* */ 34 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */ 35 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */ 36 /* messages during execution. */ 37 /* */ 38#undef FT_COMPONENT 39#define FT_COMPONENT trace_ttsbit 40 41 42 FT_LOCAL_DEF( FT_Error ) 43 tt_face_load_eblc( TT_Face face, 44 FT_Stream stream ) 45 { 46 FT_Error error = SFNT_Err_Ok; 47 FT_Fixed version; 48 FT_ULong num_strikes, table_size; 49 FT_Byte* p; 50 FT_Byte* p_limit; 51 FT_UInt count; 52 53 54 face->sbit_num_strikes = 0; 55 56 /* this table is optional */ 57 error = face->goto_table( face, TTAG_EBLC, stream, &table_size ); 58 if ( error ) 59 error = face->goto_table( face, TTAG_bloc, stream, &table_size ); 60 if ( error ) 61 goto Exit; 62 63 if ( table_size < 8 ) 64 { 65 FT_ERROR(( "tt_face_load_sbit_strikes: table too short\n" )); 66 error = SFNT_Err_Invalid_File_Format; 67 goto Exit; 68 } 69 70 if ( FT_FRAME_EXTRACT( table_size, face->sbit_table ) ) 71 goto Exit; 72 73 face->sbit_table_size = table_size; 74 75 p = face->sbit_table; 76 p_limit = p + table_size; 77 78 version = FT_NEXT_ULONG( p ); 79 num_strikes = FT_NEXT_ULONG( p ); 80 81 if ( version != 0x00020000UL || num_strikes >= 0x10000UL ) 82 { 83 FT_ERROR(( "tt_face_load_sbit_strikes: invalid table version\n" )); 84 error = SFNT_Err_Invalid_File_Format; 85 goto Fail; 86 } 87 88 /* 89 * Count the number of strikes available in the table. We are a bit 90 * paranoid there and don't trust the data. 91 */ 92 count = (FT_UInt)num_strikes; 93 if ( 8 + 48UL * count > table_size ) 94 count = (FT_UInt)( ( p_limit - p ) / 48 ); 95 96 face->sbit_num_strikes = count; 97 98 FT_TRACE3(( "sbit_num_strikes: %u\n", count )); 99 Exit: 100 return error; 101 102 Fail: 103 FT_FRAME_RELEASE( face->sbit_table ); 104 face->sbit_table_size = 0; 105 goto Exit; 106 } 107 108 109 FT_LOCAL_DEF( void ) 110 tt_face_free_eblc( TT_Face face ) 111 { 112 FT_Stream stream = face->root.stream; 113 114 115 FT_FRAME_RELEASE( face->sbit_table ); 116 face->sbit_table_size = 0; 117 face->sbit_num_strikes = 0; 118 } 119 120 121 FT_LOCAL_DEF( FT_Error ) 122 tt_face_set_sbit_strike( TT_Face face, 123 FT_Size_Request req, 124 FT_ULong* astrike_index ) 125 { 126 return FT_Match_Size( (FT_Face)face, req, 0, astrike_index ); 127 } 128 129 130 FT_LOCAL_DEF( FT_Error ) 131 tt_face_load_strike_metrics( TT_Face face, 132 FT_ULong strike_index, 133 FT_Size_Metrics* metrics ) 134 { 135 FT_Byte* strike; 136 137 138 if ( strike_index >= (FT_ULong)face->sbit_num_strikes ) 139 return SFNT_Err_Invalid_Argument; 140 141 strike = face->sbit_table + 8 + strike_index * 48; 142 143 metrics->x_ppem = (FT_UShort)strike[44]; 144 metrics->y_ppem = (FT_UShort)strike[45]; 145 146 metrics->ascender = (FT_Char)strike[16] << 6; /* hori.ascender */ 147 metrics->descender = (FT_Char)strike[17] << 6; /* hori.descender */ 148 metrics->height = metrics->ascender - metrics->descender; 149 150 /* XXX: Is this correct? */ 151 metrics->max_advance = ( (FT_Char)strike[22] + /* min_origin_SB */ 152 strike[18] + /* max_width */ 153 (FT_Char)strike[23] /* min_advance_SB */ 154 ) << 6; 155 156 return SFNT_Err_Ok; 157 } 158 159 160 typedef struct TT_SBitDecoderRec_ 161 { 162 TT_Face face; 163 FT_Stream stream; 164 FT_Bitmap* bitmap; 165 TT_SBit_Metrics metrics; 166 FT_Bool metrics_loaded; 167 FT_Bool bitmap_allocated; 168 FT_Byte bit_depth; 169 170 FT_ULong ebdt_start; 171 FT_ULong ebdt_size; 172 173 FT_ULong strike_index_array; 174 FT_ULong strike_index_count; 175 FT_Byte* eblc_base; 176 FT_Byte* eblc_limit; 177 178 } TT_SBitDecoderRec, *TT_SBitDecoder; 179 180 181 static FT_Error 182 tt_sbit_decoder_init( TT_SBitDecoder decoder, 183 TT_Face face, 184 FT_ULong strike_index, 185 TT_SBit_MetricsRec* metrics ) 186 { 187 FT_Error error; 188 FT_Stream stream = face->root.stream; 189 FT_ULong ebdt_size; 190 191 192 error = face->goto_table( face, TTAG_EBDT, stream, &ebdt_size ); 193 if ( error ) 194 error = face->goto_table( face, TTAG_bdat, stream, &ebdt_size ); 195 if ( error ) 196 goto Exit; 197 198 decoder->face = face; 199 decoder->stream = stream; 200 decoder->bitmap = &face->root.glyph->bitmap; 201 decoder->metrics = metrics; 202 203 decoder->metrics_loaded = 0; 204 decoder->bitmap_allocated = 0; 205 206 decoder->ebdt_start = FT_STREAM_POS(); 207 decoder->ebdt_size = ebdt_size; 208 209 decoder->eblc_base = face->sbit_table; 210 decoder->eblc_limit = face->sbit_table + face->sbit_table_size; 211 212 /* now find the strike corresponding to the index */ 213 { 214 FT_Byte* p; 215 216 217 if ( 8 + 48 * strike_index + 3 * 4 + 34 + 1 > face->sbit_table_size ) 218 { 219 error = SFNT_Err_Invalid_File_Format; 220 goto Exit; 221 } 222 223 p = decoder->eblc_base + 8 + 48 * strike_index; 224 225 decoder->strike_index_array = FT_NEXT_ULONG( p ); 226 p += 4; 227 decoder->strike_index_count = FT_NEXT_ULONG( p ); 228 p += 34; 229 decoder->bit_depth = *p; 230 231 if ( decoder->strike_index_array > face->sbit_table_size || 232 decoder->strike_index_array + 8 * decoder->strike_index_count > 233 face->sbit_table_size ) 234 error = SFNT_Err_Invalid_File_Format; 235 } 236 237 Exit: 238 return error; 239 } 240 241 242 static void 243 tt_sbit_decoder_done( TT_SBitDecoder decoder ) 244 { 245 FT_UNUSED( decoder ); 246 } 247 248 249 static FT_Error 250 tt_sbit_decoder_alloc_bitmap( TT_SBitDecoder decoder ) 251 { 252 FT_Error error = SFNT_Err_Ok; 253 FT_UInt width, height; 254 FT_Bitmap* map = decoder->bitmap; 255 FT_Long size; 256 257 258 if ( !decoder->metrics_loaded ) 259 { 260 error = SFNT_Err_Invalid_Argument; 261 goto Exit; 262 } 263 264 width = decoder->metrics->width; 265 height = decoder->metrics->height; 266 267 map->width = (int)width; 268 map->rows = (int)height; 269 270 switch ( decoder->bit_depth ) 271 { 272 case 1: 273 map->pixel_mode = FT_PIXEL_MODE_MONO; 274 map->pitch = ( map->width + 7 ) >> 3; 275 break; 276 277 case 2: 278 map->pixel_mode = FT_PIXEL_MODE_GRAY2; 279 map->pitch = ( map->width + 3 ) >> 2; 280 break; 281 282 case 4: 283 map->pixel_mode = FT_PIXEL_MODE_GRAY4; 284 map->pitch = ( map->width + 1 ) >> 1; 285 break; 286 287 case 8: 288 map->pixel_mode = FT_PIXEL_MODE_GRAY; 289 map->pitch = map->width; 290 break; 291 292 default: 293 error = SFNT_Err_Invalid_File_Format; 294 goto Exit; 295 } 296 297 size = map->rows * map->pitch; 298 299 /* check that there is no empty image */ 300 if ( size == 0 ) 301 goto Exit; /* exit successfully! */ 302 303 error = ft_glyphslot_alloc_bitmap( decoder->face->root.glyph, size ); 304 if ( error ) 305 goto Exit; 306 307 decoder->bitmap_allocated = 1; 308 309 Exit: 310 return error; 311 } 312 313 314 static FT_Error 315 tt_sbit_decoder_load_metrics( TT_SBitDecoder decoder, 316 FT_Byte* *pp, 317 FT_Byte* limit, 318 FT_Bool big ) 319 { 320 FT_Byte* p = *pp; 321 TT_SBit_Metrics metrics = decoder->metrics; 322 323 324 if ( p + 5 > limit ) 325 goto Fail; 326 327 metrics->height = p[0]; 328 metrics->width = p[1]; 329 metrics->horiBearingX = (FT_Char)p[2]; 330 metrics->horiBearingY = (FT_Char)p[3]; 331 metrics->horiAdvance = p[4]; 332 333 p += 5; 334 if ( big ) 335 { 336 if ( p + 3 > limit ) 337 goto Fail; 338 339 metrics->vertBearingX = (FT_Char)p[0]; 340 metrics->vertBearingY = (FT_Char)p[1]; 341 metrics->vertAdvance = p[2]; 342 343 p += 3; 344 } 345 346 decoder->metrics_loaded = 1; 347 *pp = p; 348 return SFNT_Err_Ok; 349 350 Fail: 351 return SFNT_Err_Invalid_Argument; 352 } 353 354 355 /* forward declaration */ 356 static FT_Error 357 tt_sbit_decoder_load_image( TT_SBitDecoder decoder, 358 FT_UInt glyph_index, 359 FT_Int x_pos, 360 FT_Int y_pos ); 361 362 typedef FT_Error (*TT_SBitDecoder_LoadFunc)( TT_SBitDecoder decoder, 363 FT_Byte* p, 364 FT_Byte* plimit, 365 FT_Int x_pos, 366 FT_Int y_pos ); 367 368 369 static FT_Error 370 tt_sbit_decoder_load_byte_aligned( TT_SBitDecoder decoder, 371 FT_Byte* p, 372 FT_Byte* limit, 373 FT_Int x_pos, 374 FT_Int y_pos ) 375 { 376 FT_Error error = SFNT_Err_Ok; 377 FT_Byte* line; 378 FT_Int bit_height, bit_width, pitch, width, height, h; 379 FT_Bitmap* bitmap; 380 381 382 if ( !decoder->bitmap_allocated ) 383 { 384 error = tt_sbit_decoder_alloc_bitmap( decoder ); 385 if ( error ) 386 goto Exit; 387 } 388 389 /* check that we can write the glyph into the bitmap */ 390 bitmap = decoder->bitmap; 391 bit_width = bitmap->width; 392 bit_height = bitmap->rows; 393 pitch = bitmap->pitch; 394 line = bitmap->buffer; 395 396 width = decoder->metrics->width; 397 height = decoder->metrics->height; 398 399 if ( x_pos < 0 || x_pos + width > bit_width || 400 y_pos < 0 || y_pos + height > bit_height ) 401 { 402 error = SFNT_Err_Invalid_File_Format; 403 goto Exit; 404 } 405 406 if ( p + ( ( width + 7 ) >> 3 ) * height > limit ) 407 { 408 error = SFNT_Err_Invalid_File_Format; 409 goto Exit; 410 } 411 412 /* now do the blit */ 413 line += y_pos * pitch + ( x_pos >> 3 ); 414 x_pos &= 7; 415 416 if ( x_pos == 0 ) /* the easy one */ 417 { 418 for ( h = height; h > 0; h--, line += pitch ) 419 { 420 FT_Byte* write = line; 421 FT_Int w; 422 423 424 for ( w = width; w >= 8; w -= 8 ) 425 { 426 write[0] = (FT_Byte)( write[0] | *p++ ); 427 write += 1; 428 } 429 430 if ( w > 0 ) 431 write[0] = (FT_Byte)( write[0] | ( *p++ & ( 0xFF00U >> w ) ) ); 432 } 433 } 434 else /* x_pos > 0 */ 435 { 436 for ( h = height; h > 0; h--, line += pitch ) 437 { 438 FT_Byte* write = line; 439 FT_Int w; 440 FT_UInt wval = 0; 441 442 443 for ( w = width; w >= 8; w -= 8 ) 444 { 445 wval = (FT_UInt)( wval | *p++ ); 446 write[0] = (FT_Byte)( write[0] | ( wval >> x_pos ) ); 447 write += 1; 448 wval <<= 8; 449 } 450 451 if ( w > 0 ) 452 wval = (FT_UInt)( wval | ( *p++ & ( 0xFF00U >> w ) ) ); 453 454 /* all bits read and there are `x_pos + w' bits to be written */ 455 456 write[0] = (FT_Byte)( write[0] | ( wval >> x_pos ) ); 457 458 if ( x_pos + w > 8 ) 459 { 460 write++; 461 wval <<= 8; 462 write[0] = (FT_Byte)( write[0] | ( wval >> x_pos ) ); 463 } 464 } 465 } 466 467 Exit: 468 return error; 469 } 470 471 472 /* 473 * Load a bit-aligned bitmap (with pointer `p') into a line-aligned bitmap 474 * (with pointer `write'). In the example below, the width is 3 pixel, 475 * and `x_pos' is 1 pixel. 476 * 477 * p p+1 478 * | | | 479 * | 7 6 5 4 3 2 1 0 | 7 6 5 4 3 2 1 0 |... 480 * | | | 481 * +-------+ +-------+ +-------+ ... 482 * . . . 483 * . . . 484 * v . . 485 * +-------+ . . 486 * | | . 487 * | 7 6 5 4 3 2 1 0 | . 488 * | | . 489 * write . . 490 * . . 491 * v . 492 * +-------+ . 493 * | | 494 * | 7 6 5 4 3 2 1 0 | 495 * | | 496 * write+1 . 497 * . 498 * v 499 * +-------+ 500 * | | 501 * | 7 6 5 4 3 2 1 0 | 502 * | | 503 * write+2 504 * 505 */ 506 507 static FT_Error 508 tt_sbit_decoder_load_bit_aligned( TT_SBitDecoder decoder, 509 FT_Byte* p, 510 FT_Byte* limit, 511 FT_Int x_pos, 512 FT_Int y_pos ) 513 { 514 FT_Error error = SFNT_Err_Ok; 515 FT_Byte* line; 516 FT_Int bit_height, bit_width, pitch, width, height, h, nbits; 517 FT_Bitmap* bitmap; 518 FT_UShort rval; 519 520 521 if ( !decoder->bitmap_allocated ) 522 { 523 error = tt_sbit_decoder_alloc_bitmap( decoder ); 524 if ( error ) 525 goto Exit; 526 } 527 528 /* check that we can write the glyph into the bitmap */ 529 bitmap = decoder->bitmap; 530 bit_width = bitmap->width; 531 bit_height = bitmap->rows; 532 pitch = bitmap->pitch; 533 line = bitmap->buffer; 534 535 width = decoder->metrics->width; 536 height = decoder->metrics->height; 537 538 if ( x_pos < 0 || x_pos + width > bit_width || 539 y_pos < 0 || y_pos + height > bit_height ) 540 { 541 error = SFNT_Err_Invalid_File_Format; 542 goto Exit; 543 } 544 545 if ( p + ( ( width * height + 7 ) >> 3 ) > limit ) 546 { 547 error = SFNT_Err_Invalid_File_Format; 548 goto Exit; 549 } 550 551 /* now do the blit */ 552 553 /* adjust `line' to point to the first byte of the bitmap */ 554 line += y_pos * pitch + ( x_pos >> 3 ); 555 x_pos &= 7; 556 557 /* the higher byte of `rval' is used as a buffer */ 558 rval = 0; 559 nbits = 0; 560 561 for ( h = height; h > 0; h--, line += pitch ) 562 { 563 FT_Byte* write = line; 564 FT_Int w = width; 565 566 567 /* handle initial byte (in target bitmap) specially if necessary */ 568 if ( x_pos ) 569 { 570 w = ( width < 8 - x_pos ) ? width : 8 - x_pos; 571 572 if ( h == height ) 573 { 574 rval = *p++; 575 nbits = x_pos; 576 } 577 else if ( nbits < w ) 578 { 579 if ( p < limit ) 580 rval |= *p++; 581 nbits += 8 - w; 582 } 583 else 584 { 585 rval >>= 8; 586 nbits -= w; 587 } 588 589 *write++ |= ( ( rval >> nbits ) & 0xFF ) & 590 ( ~( 0xFF << w ) << ( 8 - w - x_pos ) ); 591 rval <<= 8; 592 593 w = width - w; 594 } 595 596 /* handle medial bytes */ 597 for ( ; w >= 8; w -= 8 ) 598 { 599 rval |= *p++; 600 *write++ |= ( rval >> nbits ) & 0xFF; 601 602 rval <<= 8; 603 } 604 605 /* handle final byte if necessary */ 606 if ( w > 0 ) 607 { 608 if ( nbits < w ) 609 { 610 if ( p < limit ) 611 rval |= *p++; 612 *write |= ( ( rval >> nbits ) & 0xFF ) & ( 0xFF00U >> w ); 613 nbits += 8 - w; 614 615 rval <<= 8; 616 } 617 else 618 { 619 *write |= ( ( rval >> nbits ) & 0xFF ) & ( 0xFF00U >> w ); 620 nbits -= w; 621 } 622 } 623 } 624 625 Exit: 626 return error; 627 } 628 629 630 static FT_Error 631 tt_sbit_decoder_load_compound( TT_SBitDecoder decoder, 632 FT_Byte* p, 633 FT_Byte* limit, 634 FT_Int x_pos, 635 FT_Int y_pos ) 636 { 637 FT_Error error = SFNT_Err_Ok; 638 FT_UInt num_components, nn; 639 640 FT_Char horiBearingX = decoder->metrics->horiBearingX; 641 FT_Char horiBearingY = decoder->metrics->horiBearingY; 642 FT_Byte horiAdvance = decoder->metrics->horiAdvance; 643 FT_Char vertBearingX = decoder->metrics->vertBearingX; 644 FT_Char vertBearingY = decoder->metrics->vertBearingY; 645 FT_Byte vertAdvance = decoder->metrics->vertAdvance; 646 647 648 if ( p + 2 > limit ) 649 goto Fail; 650 651 num_components = FT_NEXT_USHORT( p ); 652 if ( p + 4 * num_components > limit ) 653 goto Fail; 654 655 if ( !decoder->bitmap_allocated ) 656 { 657 error = tt_sbit_decoder_alloc_bitmap( decoder ); 658 if ( error ) 659 goto Exit; 660 } 661 662 for ( nn = 0; nn < num_components; nn++ ) 663 { 664 FT_UInt gindex = FT_NEXT_USHORT( p ); 665 FT_Byte dx = FT_NEXT_BYTE( p ); 666 FT_Byte dy = FT_NEXT_BYTE( p ); 667 668 669 /* NB: a recursive call */ 670 error = tt_sbit_decoder_load_image( decoder, gindex, 671 x_pos + dx, y_pos + dy ); 672 if ( error ) 673 break; 674 } 675 676 decoder->metrics->horiBearingX = horiBearingX; 677 decoder->metrics->horiBearingY = horiBearingY; 678 decoder->metrics->horiAdvance = horiAdvance; 679 decoder->metrics->vertBearingX = vertBearingX; 680 decoder->metrics->vertBearingY = vertBearingY; 681 decoder->metrics->vertAdvance = vertAdvance; 682 decoder->metrics->width = (FT_UInt)decoder->bitmap->width; 683 decoder->metrics->height = (FT_UInt)decoder->bitmap->rows; 684 685 Exit: 686 return error; 687 688 Fail: 689 error = SFNT_Err_Invalid_File_Format; 690 goto Exit; 691 } 692 693 694 static FT_Error 695 tt_sbit_decoder_load_bitmap( TT_SBitDecoder decoder, 696 FT_UInt glyph_format, 697 FT_ULong glyph_start, 698 FT_ULong glyph_size, 699 FT_Int x_pos, 700 FT_Int y_pos ) 701 { 702 FT_Error error; 703 FT_Stream stream = decoder->stream; 704 FT_Byte* p; 705 FT_Byte* p_limit; 706 FT_Byte* data; 707 708 709 /* seek into the EBDT table now */ 710 if ( glyph_start + glyph_size > decoder->ebdt_size ) 711 { 712 error = SFNT_Err_Invalid_Argument; 713 goto Exit; 714 } 715 716 if ( FT_STREAM_SEEK( decoder->ebdt_start + glyph_start ) || 717 FT_FRAME_EXTRACT( glyph_size, data ) ) 718 goto Exit; 719 720 p = data; 721 p_limit = p + glyph_size; 722 723 /* read the data, depending on the glyph format */ 724 switch ( glyph_format ) 725 { 726 case 1: 727 case 2: 728 case 8: 729 error = tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 0 ); 730 break; 731 732 case 6: 733 case 7: 734 case 9: 735 error = tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 ); 736 break; 737 738 default: 739 error = SFNT_Err_Ok; 740 } 741 742 if ( error ) 743 goto Fail; 744 745 { 746 TT_SBitDecoder_LoadFunc loader; 747 748 749 switch ( glyph_format ) 750 { 751 case 1: 752 case 6: 753 loader = tt_sbit_decoder_load_byte_aligned; 754 break; 755 756 case 2: 757 case 5: 758 case 7: 759 loader = tt_sbit_decoder_load_bit_aligned; 760 break; 761 762 case 8: 763 if ( p + 1 > p_limit ) 764 goto Fail; 765 766 p += 1; /* skip padding */ 767 /* fall-through */ 768 769 case 9: 770 loader = tt_sbit_decoder_load_compound; 771 break; 772 773 default: 774 goto Fail; 775 } 776 777 error = loader( decoder, p, p_limit, x_pos, y_pos ); 778 } 779 780 Fail: 781 FT_FRAME_RELEASE( data ); 782 783 Exit: 784 return error; 785 } 786 787 788 static FT_Error 789 tt_sbit_decoder_load_image( TT_SBitDecoder decoder, 790 FT_UInt glyph_index, 791 FT_Int x_pos, 792 FT_Int y_pos ) 793 { 794 /* 795 * First, we find the correct strike range that applies to this 796 * glyph index. 797 */ 798 799 FT_Byte* p = decoder->eblc_base + decoder->strike_index_array; 800 FT_Byte* p_limit = decoder->eblc_limit; 801 FT_ULong num_ranges = decoder->strike_index_count; 802 FT_UInt start, end, index_format, image_format; 803 FT_ULong image_start = 0, image_end = 0, image_offset; 804 805 806 for ( ; num_ranges > 0; num_ranges-- ) 807 { 808 start = FT_NEXT_USHORT( p ); 809 end = FT_NEXT_USHORT( p ); 810 811 if ( glyph_index >= start && glyph_index <= end ) 812 goto FoundRange; 813 814 p += 4; /* ignore index offset */ 815 } 816 goto NoBitmap; 817 818 FoundRange: 819 image_offset = FT_NEXT_ULONG( p ); 820 821 /* overflow check */ 822 if ( decoder->eblc_base + decoder->strike_index_array + image_offset < 823 decoder->eblc_base ) 824 goto Failure; 825 826 p = decoder->eblc_base + decoder->strike_index_array + image_offset; 827 if ( p + 8 > p_limit ) 828 goto NoBitmap; 829 830 /* now find the glyph's location and extend within the ebdt table */ 831 index_format = FT_NEXT_USHORT( p ); 832 image_format = FT_NEXT_USHORT( p ); 833 image_offset = FT_NEXT_ULONG ( p ); 834 835 switch ( index_format ) 836 { 837 case 1: /* 4-byte offsets relative to `image_offset' */ 838 { 839 p += 4 * ( glyph_index - start ); 840 if ( p + 8 > p_limit ) 841 goto NoBitmap; 842 843 image_start = FT_NEXT_ULONG( p ); 844 image_end = FT_NEXT_ULONG( p ); 845 846 if ( image_start == image_end ) /* missing glyph */ 847 goto NoBitmap; 848 } 849 break; 850 851 case 2: /* big metrics, constant image size */ 852 { 853 FT_ULong image_size; 854 855 856 if ( p + 12 > p_limit ) 857 goto NoBitmap; 858 859 image_size = FT_NEXT_ULONG( p ); 860 861 if ( tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 ) ) 862 goto NoBitmap; 863 864 image_start = image_size * ( glyph_index - start ); 865 image_end = image_start + image_size; 866 } 867 break; 868 869 case 3: /* 2-byte offsets relative to 'image_offset' */ 870 { 871 p += 2 * ( glyph_index - start ); 872 if ( p + 4 > p_limit ) 873 goto NoBitmap; 874 875 image_start = FT_NEXT_USHORT( p ); 876 image_end = FT_NEXT_USHORT( p ); 877 878 if ( image_start == image_end ) /* missing glyph */ 879 goto NoBitmap; 880 } 881 break; 882 883 case 4: /* sparse glyph array with (glyph,offset) pairs */ 884 { 885 FT_ULong mm, num_glyphs; 886 887 888 if ( p + 4 > p_limit ) 889 goto NoBitmap; 890 891 num_glyphs = FT_NEXT_ULONG( p ); 892 893 /* overflow check */ 894 if ( p + ( num_glyphs + 1 ) * 4 < p ) 895 goto Failure; 896 897 if ( p + ( num_glyphs + 1 ) * 4 > p_limit ) 898 goto NoBitmap; 899 900 for ( mm = 0; mm < num_glyphs; mm++ ) 901 { 902 FT_UInt gindex = FT_NEXT_USHORT( p ); 903 904 905 if ( gindex == glyph_index ) 906 { 907 image_start = FT_NEXT_USHORT( p ); 908 p += 2; 909 image_end = FT_PEEK_USHORT( p ); 910 break; 911 } 912 p += 2; 913 } 914 915 if ( mm >= num_glyphs ) 916 goto NoBitmap; 917 } 918 break; 919 920 case 5: /* constant metrics with sparse glyph codes */ 921 { 922 FT_ULong image_size, mm, num_glyphs; 923 924 925 if ( p + 16 > p_limit ) 926 goto NoBitmap; 927 928 image_size = FT_NEXT_ULONG( p ); 929 930 if ( tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 ) ) 931 goto NoBitmap; 932 933 num_glyphs = FT_NEXT_ULONG( p ); 934 935 /* overflow check */ 936 if ( p + 2 * num_glyphs < p ) 937 goto Failure; 938 939 if ( p + 2 * num_glyphs > p_limit ) 940 goto NoBitmap; 941 942 for ( mm = 0; mm < num_glyphs; mm++ ) 943 { 944 FT_UInt gindex = FT_NEXT_USHORT( p ); 945 946 947 if ( gindex == glyph_index ) 948 break; 949 } 950 951 if ( mm >= num_glyphs ) 952 goto NoBitmap; 953 954 image_start = image_size * mm; 955 image_end = image_start + image_size; 956 } 957 break; 958 959 default: 960 goto NoBitmap; 961 } 962 963 if ( image_start > image_end ) 964 goto NoBitmap; 965 966 image_end -= image_start; 967 image_start = image_offset + image_start; 968 969 return tt_sbit_decoder_load_bitmap( decoder, 970 image_format, 971 image_start, 972 image_end, 973 x_pos, 974 y_pos ); 975 976 Failure: 977 return SFNT_Err_Invalid_Table; 978 979 NoBitmap: 980 return SFNT_Err_Invalid_Argument; 981 } 982 983 984 FT_LOCAL( FT_Error ) 985 tt_face_load_sbit_image( TT_Face face, 986 FT_ULong strike_index, 987 FT_UInt glyph_index, 988 FT_UInt load_flags, 989 FT_Stream stream, 990 FT_Bitmap *map, 991 TT_SBit_MetricsRec *metrics ) 992 { 993 TT_SBitDecoderRec decoder[1]; 994 FT_Error error; 995 996 FT_UNUSED( load_flags ); 997 FT_UNUSED( stream ); 998 FT_UNUSED( map ); 999 1000 1001 error = tt_sbit_decoder_init( decoder, face, strike_index, metrics ); 1002 if ( !error ) 1003 { 1004 error = tt_sbit_decoder_load_image( decoder, glyph_index, 0, 0 ); 1005 tt_sbit_decoder_done( decoder ); 1006 } 1007 1008 return error; 1009 } 1010 1011/* EOF */ 1012