pfrsbit.c (21398B)
1 /**************************************************************************** 2 * 3 * pfrsbit.c 4 * 5 * FreeType PFR bitmap loader (body). 6 * 7 * Copyright (C) 2002-2025 by 8 * David Turner, Robert Wilhelm, and Werner Lemberg. 9 * 10 * This file is part of the FreeType project, and may only be used, 11 * modified, and distributed under the terms of the FreeType project 12 * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 * this file you indicate that you have read the license and 14 * understand and accept it fully. 15 * 16 */ 17 18 19 #include "pfrsbit.h" 20 #include "pfrload.h" 21 #include <freetype/internal/ftdebug.h> 22 #include <freetype/internal/ftstream.h> 23 24 #include "pfrerror.h" 25 26 #undef FT_COMPONENT 27 #define FT_COMPONENT pfr 28 29 30 /*************************************************************************/ 31 /*************************************************************************/ 32 /***** *****/ 33 /***** PFR BIT WRITER *****/ 34 /***** *****/ 35 /*************************************************************************/ 36 /*************************************************************************/ 37 38 typedef struct PFR_BitWriter_ 39 { 40 FT_Byte* line; /* current line start */ 41 FT_Int pitch; /* line size in bytes */ 42 FT_UInt width; /* width in pixels/bits */ 43 FT_UInt rows; /* number of remaining rows to scan */ 44 FT_UInt total; /* total number of bits to draw */ 45 46 } PFR_BitWriterRec, *PFR_BitWriter; 47 48 49 static void 50 pfr_bitwriter_init( PFR_BitWriter writer, 51 FT_Bitmap* target, 52 FT_Bool decreasing ) 53 { 54 writer->line = target->buffer; 55 writer->pitch = target->pitch; 56 writer->width = target->width; 57 writer->rows = target->rows; 58 writer->total = writer->width * writer->rows; 59 60 if ( !decreasing ) 61 { 62 writer->line += writer->pitch * (FT_Int)( target->rows - 1 ); 63 writer->pitch = -writer->pitch; 64 } 65 } 66 67 68 static void 69 pfr_bitwriter_decode_bytes( PFR_BitWriter writer, 70 FT_Byte* p, 71 FT_Byte* limit ) 72 { 73 FT_UInt n, reload; 74 FT_UInt left = writer->width; 75 FT_Byte* cur = writer->line; 76 FT_UInt mask = 0x80; 77 FT_UInt val = 0; 78 FT_UInt c = 0; 79 80 81 n = (FT_UInt)( limit - p ) * 8; 82 if ( n > writer->total ) 83 n = writer->total; 84 85 reload = n & 7; 86 87 for ( ; n > 0; n-- ) 88 { 89 if ( ( n & 7 ) == reload ) 90 val = *p++; 91 92 if ( val & 0x80 ) 93 c |= mask; 94 95 val <<= 1; 96 mask >>= 1; 97 98 if ( --left <= 0 ) 99 { 100 cur[0] = (FT_Byte)c; 101 left = writer->width; 102 mask = 0x80; 103 104 writer->line += writer->pitch; 105 cur = writer->line; 106 c = 0; 107 } 108 else if ( mask == 0 ) 109 { 110 cur[0] = (FT_Byte)c; 111 mask = 0x80; 112 c = 0; 113 cur++; 114 } 115 } 116 117 if ( mask != 0x80 ) 118 cur[0] = (FT_Byte)c; 119 } 120 121 122 static void 123 pfr_bitwriter_decode_rle1( PFR_BitWriter writer, 124 FT_Byte* p, 125 FT_Byte* limit ) 126 { 127 FT_Int phase, count, counts[2]; 128 FT_UInt n, reload; 129 FT_UInt left = writer->width; 130 FT_Byte* cur = writer->line; 131 FT_UInt mask = 0x80; 132 FT_UInt c = 0; 133 134 135 n = writer->total; 136 137 phase = 1; 138 counts[0] = 0; 139 counts[1] = 0; 140 count = 0; 141 reload = 1; 142 143 for ( ; n > 0; n-- ) 144 { 145 if ( reload ) 146 { 147 do 148 { 149 if ( phase ) 150 { 151 FT_Int v; 152 153 154 if ( p >= limit ) 155 break; 156 157 v = *p++; 158 counts[0] = v >> 4; 159 counts[1] = v & 15; 160 phase = 0; 161 count = counts[0]; 162 } 163 else 164 { 165 phase = 1; 166 count = counts[1]; 167 } 168 169 } while ( count == 0 ); 170 } 171 172 if ( phase ) 173 c |= mask; 174 175 mask >>= 1; 176 177 if ( --left <= 0 ) 178 { 179 cur[0] = (FT_Byte)c; 180 left = writer->width; 181 mask = 0x80; 182 183 writer->line += writer->pitch; 184 cur = writer->line; 185 c = 0; 186 } 187 else if ( mask == 0 ) 188 { 189 cur[0] = (FT_Byte)c; 190 mask = 0x80; 191 c = 0; 192 cur++; 193 } 194 195 reload = ( --count <= 0 ); 196 } 197 198 if ( mask != 0x80 ) 199 cur[0] = (FT_Byte) c; 200 } 201 202 203 static void 204 pfr_bitwriter_decode_rle2( PFR_BitWriter writer, 205 FT_Byte* p, 206 FT_Byte* limit ) 207 { 208 FT_Int phase, count; 209 FT_UInt n, reload; 210 FT_UInt left = writer->width; 211 FT_Byte* cur = writer->line; 212 FT_UInt mask = 0x80; 213 FT_UInt c = 0; 214 215 216 n = writer->total; 217 218 phase = 1; 219 count = 0; 220 reload = 1; 221 222 for ( ; n > 0; n-- ) 223 { 224 if ( reload ) 225 { 226 do 227 { 228 if ( p >= limit ) 229 break; 230 231 count = *p++; 232 phase = phase ^ 1; 233 234 } while ( count == 0 ); 235 } 236 237 if ( phase ) 238 c |= mask; 239 240 mask >>= 1; 241 242 if ( --left <= 0 ) 243 { 244 cur[0] = (FT_Byte)c; 245 c = 0; 246 mask = 0x80; 247 left = writer->width; 248 249 writer->line += writer->pitch; 250 cur = writer->line; 251 } 252 else if ( mask == 0 ) 253 { 254 cur[0] = (FT_Byte)c; 255 c = 0; 256 mask = 0x80; 257 cur++; 258 } 259 260 reload = ( --count <= 0 ); 261 } 262 263 if ( mask != 0x80 ) 264 cur[0] = (FT_Byte) c; 265 } 266 267 268 /*************************************************************************/ 269 /*************************************************************************/ 270 /***** *****/ 271 /***** BITMAP DATA DECODING *****/ 272 /***** *****/ 273 /*************************************************************************/ 274 /*************************************************************************/ 275 276 static void 277 pfr_lookup_bitmap_data( FT_Byte* base, 278 FT_Byte* limit, 279 FT_UInt count, 280 FT_UInt* flags, 281 FT_UInt char_code, 282 FT_ULong* found_offset, 283 FT_ULong* found_size ) 284 { 285 FT_UInt min, max, mid, char_len; 286 FT_Bool two = FT_BOOL( *flags & PFR_BITMAP_2BYTE_CHARCODE ); 287 FT_Byte* buff; 288 289 290 char_len = 4; 291 if ( two ) 292 char_len += 1; 293 if ( *flags & PFR_BITMAP_2BYTE_SIZE ) 294 char_len += 1; 295 if ( *flags & PFR_BITMAP_3BYTE_OFFSET ) 296 char_len += 1; 297 298 if ( !( *flags & PFR_BITMAP_CHARCODES_VALIDATED ) ) 299 { 300 FT_Byte* p; 301 FT_Byte* lim; 302 FT_UInt code; 303 FT_Long prev_code; 304 305 306 *flags |= PFR_BITMAP_VALID_CHARCODES; 307 prev_code = -1; 308 lim = base + count * char_len; 309 310 if ( lim > limit ) 311 { 312 FT_TRACE0(( "pfr_lookup_bitmap_data:" 313 " number of bitmap records too large,\n" )); 314 FT_TRACE0(( " " 315 " thus ignoring all bitmaps in this strike\n" )); 316 *flags &= ~PFR_BITMAP_VALID_CHARCODES; 317 } 318 else 319 { 320 /* check whether records are sorted by code */ 321 for ( p = base; p < lim; p += char_len ) 322 { 323 if ( two ) 324 code = FT_PEEK_USHORT( p ); 325 else 326 code = *p; 327 328 if ( (FT_Long)code <= prev_code ) 329 { 330 FT_TRACE0(( "pfr_lookup_bitmap_data:" 331 " bitmap records are not sorted,\n" )); 332 FT_TRACE0(( " " 333 " thus ignoring all bitmaps in this strike\n" )); 334 *flags &= ~PFR_BITMAP_VALID_CHARCODES; 335 break; 336 } 337 338 prev_code = code; 339 } 340 } 341 342 *flags |= PFR_BITMAP_CHARCODES_VALIDATED; 343 } 344 345 /* ignore bitmaps in case table is not valid */ 346 /* (this might be sanitized, but PFR is dead...) */ 347 if ( !( *flags & PFR_BITMAP_VALID_CHARCODES ) ) 348 goto Fail; 349 350 min = 0; 351 max = count; 352 mid = min + ( max - min ) / 2; 353 354 /* binary search */ 355 while ( min < max ) 356 { 357 FT_UInt code; 358 359 360 buff = base + mid * char_len; 361 362 if ( two ) 363 code = PFR_NEXT_USHORT( buff ); 364 else 365 code = PFR_NEXT_BYTE( buff ); 366 367 if ( char_code < code ) 368 max = mid; 369 else if ( char_code > code ) 370 min = mid + 1; 371 else 372 goto Found_It; 373 374 /* reasonable prediction in a continuous block */ 375 mid += char_code - code; 376 if ( mid >= max || mid < min ) 377 mid = min + ( max - min ) / 2; 378 } 379 380 Fail: 381 /* Not found */ 382 *found_size = 0; 383 *found_offset = 0; 384 return; 385 386 Found_It: 387 if ( *flags & PFR_BITMAP_2BYTE_SIZE ) 388 *found_size = PFR_NEXT_USHORT( buff ); 389 else 390 *found_size = PFR_NEXT_BYTE( buff ); 391 392 if ( *flags & PFR_BITMAP_3BYTE_OFFSET ) 393 *found_offset = PFR_NEXT_ULONG( buff ); 394 else 395 *found_offset = PFR_NEXT_USHORT( buff ); 396 } 397 398 399 /* load bitmap metrics. `*aadvance' must be set to the default value */ 400 /* before calling this function */ 401 /* */ 402 static FT_Error 403 pfr_load_bitmap_metrics( FT_Byte** pdata, 404 FT_Byte* limit, 405 FT_Long scaled_advance, 406 FT_Long *axpos, 407 FT_Long *aypos, 408 FT_UInt *axsize, 409 FT_UInt *aysize, 410 FT_Long *aadvance, 411 FT_UInt *aformat ) 412 { 413 FT_Error error = FT_Err_Ok; 414 FT_Byte flags; 415 FT_Byte b; 416 FT_Byte* p = *pdata; 417 FT_Long xpos, ypos, advance; 418 FT_UInt xsize, ysize; 419 420 421 PFR_CHECK( 1 ); 422 flags = PFR_NEXT_BYTE( p ); 423 424 xpos = 0; 425 ypos = 0; 426 xsize = 0; 427 ysize = 0; 428 advance = 0; 429 430 switch ( flags & 3 ) 431 { 432 case 0: 433 PFR_CHECK( 1 ); 434 b = PFR_NEXT_BYTE( p ); 435 xpos = (FT_Char)b >> 4; 436 ypos = ( (FT_Char)( b << 4 ) ) >> 4; 437 break; 438 439 case 1: 440 PFR_CHECK( 2 ); 441 xpos = PFR_NEXT_INT8( p ); 442 ypos = PFR_NEXT_INT8( p ); 443 break; 444 445 case 2: 446 PFR_CHECK( 4 ); 447 xpos = PFR_NEXT_SHORT( p ); 448 ypos = PFR_NEXT_SHORT( p ); 449 break; 450 451 case 3: 452 PFR_CHECK( 6 ); 453 xpos = PFR_NEXT_LONG( p ); 454 ypos = PFR_NEXT_LONG( p ); 455 break; 456 457 default: 458 ; 459 } 460 461 flags >>= 2; 462 switch ( flags & 3 ) 463 { 464 case 0: 465 /* blank image */ 466 xsize = 0; 467 ysize = 0; 468 break; 469 470 case 1: 471 PFR_CHECK( 1 ); 472 b = PFR_NEXT_BYTE( p ); 473 xsize = ( b >> 4 ) & 0xF; 474 ysize = b & 0xF; 475 break; 476 477 case 2: 478 PFR_CHECK( 2 ); 479 xsize = PFR_NEXT_BYTE( p ); 480 ysize = PFR_NEXT_BYTE( p ); 481 break; 482 483 case 3: 484 PFR_CHECK( 4 ); 485 xsize = PFR_NEXT_USHORT( p ); 486 ysize = PFR_NEXT_USHORT( p ); 487 break; 488 489 default: 490 ; 491 } 492 493 flags >>= 2; 494 switch ( flags & 3 ) 495 { 496 case 0: 497 advance = scaled_advance; 498 break; 499 500 case 1: 501 PFR_CHECK( 1 ); 502 advance = PFR_NEXT_INT8( p ) * 256; 503 break; 504 505 case 2: 506 PFR_CHECK( 2 ); 507 advance = PFR_NEXT_SHORT( p ); 508 break; 509 510 case 3: 511 PFR_CHECK( 3 ); 512 advance = PFR_NEXT_LONG( p ); 513 break; 514 515 default: 516 ; 517 } 518 519 *axpos = xpos; 520 *aypos = ypos; 521 *axsize = xsize; 522 *aysize = ysize; 523 *aadvance = advance; 524 *aformat = flags >> 2; 525 *pdata = p; 526 527 Exit: 528 return error; 529 530 Too_Short: 531 error = FT_THROW( Invalid_Table ); 532 FT_ERROR(( "pfr_load_bitmap_metrics: invalid glyph data\n" )); 533 goto Exit; 534 } 535 536 537 static FT_Error 538 pfr_load_bitmap_bits( FT_Byte* p, 539 FT_Byte* limit, 540 FT_UInt format, 541 FT_Bool decreasing, 542 FT_Bitmap* target ) 543 { 544 FT_Error error = FT_Err_Ok; 545 PFR_BitWriterRec writer; 546 547 548 if ( target->rows > 0 && target->width > 0 ) 549 { 550 pfr_bitwriter_init( &writer, target, decreasing ); 551 552 switch ( format ) 553 { 554 case 0: /* packed bits */ 555 pfr_bitwriter_decode_bytes( &writer, p, limit ); 556 break; 557 558 case 1: /* RLE1 */ 559 pfr_bitwriter_decode_rle1( &writer, p, limit ); 560 break; 561 562 case 2: /* RLE2 */ 563 pfr_bitwriter_decode_rle2( &writer, p, limit ); 564 break; 565 566 default: 567 ; 568 } 569 } 570 571 return error; 572 } 573 574 575 /*************************************************************************/ 576 /*************************************************************************/ 577 /***** *****/ 578 /***** BITMAP LOADING *****/ 579 /***** *****/ 580 /*************************************************************************/ 581 /*************************************************************************/ 582 583 FT_LOCAL_DEF( FT_Error ) 584 pfr_slot_load_bitmap( PFR_Slot glyph, 585 PFR_Size size, 586 FT_UInt glyph_index, 587 FT_Bool metrics_only ) 588 { 589 FT_Error error; 590 PFR_Face face = (PFR_Face) glyph->root.face; 591 FT_Stream stream = face->root.stream; 592 PFR_PhyFont phys = &face->phy_font; 593 FT_ULong gps_offset; 594 FT_ULong gps_size; 595 PFR_Char character; 596 PFR_Strike strike; 597 598 599 character = &phys->chars[glyph_index]; 600 601 /* look up a bitmap strike corresponding to the current */ 602 /* character dimensions */ 603 { 604 FT_UInt n; 605 606 607 strike = phys->strikes; 608 for ( n = 0; n < phys->num_strikes; n++ ) 609 { 610 if ( strike->x_ppm == (FT_UInt)size->root.metrics.x_ppem && 611 strike->y_ppm == (FT_UInt)size->root.metrics.y_ppem ) 612 goto Found_Strike; 613 614 strike++; 615 } 616 617 /* couldn't find it */ 618 return FT_THROW( Invalid_Argument ); 619 } 620 621 Found_Strike: 622 623 /* now look up the glyph's position within the file */ 624 { 625 FT_UInt char_len; 626 627 628 char_len = 4; 629 if ( strike->flags & PFR_BITMAP_2BYTE_CHARCODE ) 630 char_len += 1; 631 if ( strike->flags & PFR_BITMAP_2BYTE_SIZE ) 632 char_len += 1; 633 if ( strike->flags & PFR_BITMAP_3BYTE_OFFSET ) 634 char_len += 1; 635 636 /* access data directly in the frame to speed up lookups */ 637 if ( FT_STREAM_SEEK( phys->bct_offset + strike->bct_offset ) || 638 FT_FRAME_ENTER( char_len * strike->num_bitmaps ) ) 639 goto Exit; 640 641 pfr_lookup_bitmap_data( stream->cursor, 642 stream->limit, 643 strike->num_bitmaps, 644 &strike->flags, 645 character->char_code, 646 &gps_offset, 647 &gps_size ); 648 649 FT_FRAME_EXIT(); 650 651 if ( gps_size == 0 ) 652 { 653 /* could not find a bitmap program string for this glyph */ 654 error = FT_THROW( Invalid_Argument ); 655 goto Exit; 656 } 657 } 658 659 /* get the bitmap metrics */ 660 { 661 FT_Long xpos = 0, ypos = 0, advance = 0; 662 FT_UInt xsize = 0, ysize = 0, format = 0; 663 FT_Byte* p; 664 665 666 /* compute linear advance */ 667 advance = character->advance; 668 if ( phys->metrics_resolution != phys->outline_resolution ) 669 advance = FT_MulDiv( advance, 670 (FT_Long)phys->outline_resolution, 671 (FT_Long)phys->metrics_resolution ); 672 673 glyph->root.linearHoriAdvance = advance; 674 675 /* compute default advance, i.e., scaled advance; this can be */ 676 /* overridden in the bitmap header of certain glyphs */ 677 advance = FT_MulDiv( (FT_Fixed)size->root.metrics.x_ppem << 8, 678 character->advance, 679 (FT_Long)phys->metrics_resolution ); 680 681 if ( FT_STREAM_SEEK( face->header.gps_section_offset + gps_offset ) || 682 FT_FRAME_ENTER( gps_size ) ) 683 goto Exit; 684 685 p = stream->cursor; 686 error = pfr_load_bitmap_metrics( &p, stream->limit, 687 advance, 688 &xpos, &ypos, 689 &xsize, &ysize, 690 &advance, &format ); 691 if ( error ) 692 goto Exit1; 693 694 /* 695 * Before allocating the target bitmap, we check whether the given 696 * bitmap dimensions are valid, depending on the image format. 697 * 698 * Format 0: We have a stream of pixels (with 8 pixels per byte). 699 * 700 * (xsize * ysize + 7) / 8 <= gps_size 701 * 702 * Format 1: Run-length encoding; the high nibble holds the number of 703 * white bits, the low nibble the number of black bits. In 704 * other words, a single byte can represent at most 15 705 * pixels. 706 * 707 * xsize * ysize <= 15 * gps_size 708 * 709 * Format 2: Run-length encoding; the high byte holds the number of 710 * white bits, the low byte the number of black bits. In 711 * other words, two bytes can represent at most 255 pixels. 712 * 713 * xsize * ysize <= 255 * (gps_size + 1) / 2 714 */ 715 switch ( format ) 716 { 717 case 0: 718 if ( ( (FT_ULong)xsize * ysize + 7 ) / 8 > gps_size ) 719 error = FT_THROW( Invalid_Table ); 720 break; 721 case 1: 722 if ( (FT_ULong)xsize * ysize > 15 * gps_size ) 723 error = FT_THROW( Invalid_Table ); 724 break; 725 case 2: 726 if ( (FT_ULong)xsize * ysize > 255 * ( ( gps_size + 1 ) / 2 ) ) 727 error = FT_THROW( Invalid_Table ); 728 break; 729 default: 730 FT_ERROR(( "pfr_slot_load_bitmap: invalid image type\n" )); 731 error = FT_THROW( Invalid_Table ); 732 } 733 734 if ( error ) 735 { 736 if ( FT_ERR_EQ( error, Invalid_Table ) ) 737 FT_ERROR(( "pfr_slot_load_bitmap: invalid bitmap dimensions\n" )); 738 goto Exit1; 739 } 740 741 /* 742 * XXX: on 16bit systems we return an error for huge bitmaps 743 * that cause size truncation, because truncated 744 * size properties make bitmap glyphs broken. 745 */ 746 if ( xpos > FT_INT_MAX || 747 xpos < FT_INT_MIN || 748 ysize > FT_INT_MAX || 749 ypos > FT_INT_MAX - (FT_Long)ysize || 750 ypos + (FT_Long)ysize < FT_INT_MIN ) 751 { 752 FT_TRACE1(( "pfr_slot_load_bitmap:" 753 " huge bitmap glyph %ldx%ld over FT_GlyphSlot\n", 754 xpos, ypos )); 755 error = FT_THROW( Invalid_Pixel_Size ); 756 } 757 758 if ( !error ) 759 { 760 glyph->root.format = FT_GLYPH_FORMAT_BITMAP; 761 762 /* Set up glyph bitmap and metrics */ 763 764 /* XXX: needs casts to fit FT_Bitmap.{width|rows|pitch} */ 765 glyph->root.bitmap.width = xsize; 766 glyph->root.bitmap.rows = ysize; 767 glyph->root.bitmap.pitch = (FT_Int)( xsize + 7 ) >> 3; 768 glyph->root.bitmap.pixel_mode = FT_PIXEL_MODE_MONO; 769 770 /* XXX: needs casts to fit FT_Glyph_Metrics.{width|height} */ 771 glyph->root.metrics.width = (FT_Pos)xsize << 6; 772 glyph->root.metrics.height = (FT_Pos)ysize << 6; 773 glyph->root.metrics.horiBearingX = xpos * 64; 774 glyph->root.metrics.horiBearingY = ypos * 64; 775 glyph->root.metrics.horiAdvance = FT_PIX_ROUND( ( advance >> 2 ) ); 776 glyph->root.metrics.vertBearingX = - glyph->root.metrics.width >> 1; 777 glyph->root.metrics.vertBearingY = 0; 778 glyph->root.metrics.vertAdvance = size->root.metrics.height; 779 780 /* XXX: needs casts fit FT_GlyphSlotRec.bitmap_{left|top} */ 781 glyph->root.bitmap_left = (FT_Int)xpos; 782 glyph->root.bitmap_top = (FT_Int)( ypos + (FT_Long)ysize ); 783 784 if ( metrics_only ) 785 goto Exit1; 786 787 /* Allocate and read bitmap data */ 788 { 789 FT_ULong len = (FT_ULong)glyph->root.bitmap.pitch * ysize; 790 791 792 error = ft_glyphslot_alloc_bitmap( &glyph->root, len ); 793 if ( !error ) 794 error = pfr_load_bitmap_bits( 795 p, 796 stream->limit, 797 format, 798 FT_BOOL( face->header.color_flags & 799 PFR_FLAG_INVERT_BITMAP ), 800 &glyph->root.bitmap ); 801 } 802 } 803 804 Exit1: 805 FT_FRAME_EXIT(); 806 } 807 808 Exit: 809 return error; 810 } 811 812 813 /* END */