1 /***************************************************************************/ 2 /* */ 3 /* ftbitmap.c */ 4 /* */ 5 /* FreeType utility functions for bitmaps (body). */ 6 /* */ 7 /* Copyright 2004-2018 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 <ft2build.h> 20 #include FT_INTERNAL_DEBUG_H 21 22 #include FT_BITMAP_H 23 #include FT_IMAGE_H 24 #include FT_INTERNAL_OBJECTS_H 25 26 27 static 28 const FT_Bitmap null_bitmap = { 0, 0, 0, 0, 0, 0, 0, 0 }; 29 30 31 /* documentation is in ftbitmap.h */ 32 33 FT_EXPORT_DEF( void ) 34 FT_Bitmap_Init( FT_Bitmap *abitmap ) 35 { 36 if ( abitmap ) 37 *abitmap = null_bitmap; 38 } 39 40 41 /* deprecated function name; retained for ABI compatibility */ 42 43 FT_EXPORT_DEF( void ) 44 FT_Bitmap_New( FT_Bitmap *abitmap ) 45 { 46 if ( abitmap ) 47 *abitmap = null_bitmap; 48 } 49 50 51 /* documentation is in ftbitmap.h */ 52 53 FT_EXPORT_DEF( FT_Error ) 54 FT_Bitmap_Copy( FT_Library library, 55 const FT_Bitmap *source, 56 FT_Bitmap *target) 57 { 58 FT_Memory memory; 59 FT_Error error = FT_Err_Ok; 60 61 FT_Int pitch; 62 FT_ULong size; 63 64 FT_Int source_pitch_sign, target_pitch_sign; 65 66 67 if ( !library ) 68 return FT_THROW( Invalid_Library_Handle ); 69 70 if ( !source || !target ) 71 return FT_THROW( Invalid_Argument ); 72 73 if ( source == target ) 74 return FT_Err_Ok; 75 76 source_pitch_sign = source->pitch < 0 ? -1 : 1; 77 target_pitch_sign = target->pitch < 0 ? -1 : 1; 78 79 if ( !source->buffer ) 80 { 81 *target = *source; 82 if ( source_pitch_sign != target_pitch_sign ) 83 target->pitch = -target->pitch; 84 85 return FT_Err_Ok; 86 } 87 88 memory = library->memory; 89 pitch = source->pitch; 90 91 if ( pitch < 0 ) 92 pitch = -pitch; 93 size = (FT_ULong)pitch * source->rows; 94 95 if ( target->buffer ) 96 { 97 FT_Int target_pitch = target->pitch; 98 FT_ULong target_size; 99 100 101 if ( target_pitch < 0 ) 102 target_pitch = -target_pitch; 103 target_size = (FT_ULong)target_pitch * target->rows; 104 105 if ( target_size != size ) 106 (void)FT_QREALLOC( target->buffer, target_size, size ); 107 } 108 else 109 (void)FT_QALLOC( target->buffer, size ); 110 111 if ( !error ) 112 { 113 unsigned char *p; 114 115 116 p = target->buffer; 117 *target = *source; 118 target->buffer = p; 119 120 if ( source_pitch_sign == target_pitch_sign ) 121 FT_MEM_COPY( target->buffer, source->buffer, size ); 122 else 123 { 124 /* take care of bitmap flow */ 125 FT_UInt i; 126 FT_Byte* s = source->buffer; 127 FT_Byte* t = target->buffer; 128 129 130 t += (FT_ULong)pitch * ( target->rows - 1 ); 131 132 for ( i = target->rows; i > 0; i-- ) 133 { 134 FT_ARRAY_COPY( t, s, pitch ); 135 136 s += pitch; 137 t -= pitch; 138 } 139 } 140 } 141 142 return error; 143 } 144 145 146 /* Enlarge `bitmap' horizontally and vertically by `xpixels' */ 147 /* and `ypixels', respectively. */ 148 149 static FT_Error 150 ft_bitmap_assure_buffer( FT_Memory memory, 151 FT_Bitmap* bitmap, 152 FT_UInt xpixels, 153 FT_UInt ypixels ) 154 { 155 FT_Error error; 156 unsigned int pitch; 157 unsigned int new_pitch; 158 FT_UInt bpp; 159 FT_UInt width, height; 160 unsigned char* buffer = NULL; 161 162 163 width = bitmap->width; 164 height = bitmap->rows; 165 pitch = (unsigned int)FT_ABS( bitmap->pitch ); 166 167 switch ( bitmap->pixel_mode ) 168 { 169 case FT_PIXEL_MODE_MONO: 170 bpp = 1; 171 new_pitch = ( width + xpixels + 7 ) >> 3; 172 break; 173 case FT_PIXEL_MODE_GRAY2: 174 bpp = 2; 175 new_pitch = ( width + xpixels + 3 ) >> 2; 176 break; 177 case FT_PIXEL_MODE_GRAY4: 178 bpp = 4; 179 new_pitch = ( width + xpixels + 1 ) >> 1; 180 break; 181 case FT_PIXEL_MODE_GRAY: 182 case FT_PIXEL_MODE_LCD: 183 case FT_PIXEL_MODE_LCD_V: 184 bpp = 8; 185 new_pitch = width + xpixels; 186 break; 187 default: 188 return FT_THROW( Invalid_Glyph_Format ); 189 } 190 191 /* if no need to allocate memory */ 192 if ( ypixels == 0 && new_pitch <= pitch ) 193 { 194 /* zero the padding */ 195 FT_UInt bit_width = pitch * 8; 196 FT_UInt bit_last = ( width + xpixels ) * bpp; 197 198 199 if ( bit_last < bit_width ) 200 { 201 FT_Byte* line = bitmap->buffer + ( bit_last >> 3 ); 202 FT_Byte* end = bitmap->buffer + pitch; 203 FT_UInt shift = bit_last & 7; 204 FT_UInt mask = 0xFF00U >> shift; 205 FT_UInt count = height; 206 207 208 for ( ; count > 0; count--, line += pitch, end += pitch ) 209 { 210 FT_Byte* write = line; 211 212 213 if ( shift > 0 ) 214 { 215 write[0] = (FT_Byte)( write[0] & mask ); 216 write++; 217 } 218 if ( write < end ) 219 FT_MEM_ZERO( write, end - write ); 220 } 221 } 222 223 return FT_Err_Ok; 224 } 225 226 /* otherwise allocate new buffer */ 227 if ( FT_QALLOC_MULT( buffer, bitmap->rows + ypixels, new_pitch ) ) 228 return error; 229 230 /* new rows get added at the top of the bitmap, */ 231 /* thus take care of the flow direction */ 232 if ( bitmap->pitch > 0 ) 233 { 234 FT_UInt len = ( width * bpp + 7 ) >> 3; 235 236 unsigned char* in = bitmap->buffer; 237 unsigned char* out = buffer; 238 239 unsigned char* limit = bitmap->buffer + pitch * bitmap->rows; 240 unsigned int delta = new_pitch - pitch; 241 242 243 FT_MEM_ZERO( out, new_pitch * ypixels ); 244 out += new_pitch * ypixels; 245 246 while ( in < limit ) 247 { 248 FT_MEM_COPY( out, in, len ); 249 in += pitch; 250 out += pitch; 251 252 FT_MEM_ZERO( out, delta ); 253 out += delta; 254 } 255 } 256 else 257 { 258 FT_UInt len = ( width * bpp + 7 ) >> 3; 259 260 unsigned char* in = bitmap->buffer; 261 unsigned char* out = buffer; 262 263 unsigned char* limit = bitmap->buffer + pitch * bitmap->rows; 264 unsigned int delta = new_pitch - pitch; 265 266 267 while ( in < limit ) 268 { 269 FT_MEM_COPY( out, in, len ); 270 in += pitch; 271 out += pitch; 272 273 FT_MEM_ZERO( out, delta ); 274 out += delta; 275 } 276 277 FT_MEM_ZERO( out, new_pitch * ypixels ); 278 } 279 280 FT_FREE( bitmap->buffer ); 281 bitmap->buffer = buffer; 282 283 /* set pitch only, width and height are left untouched */ 284 if ( bitmap->pitch < 0 ) 285 bitmap->pitch = -(int)new_pitch; 286 else 287 bitmap->pitch = (int)new_pitch; 288 289 return FT_Err_Ok; 290 } 291 292 293 /* documentation is in ftbitmap.h */ 294 295 FT_EXPORT_DEF( FT_Error ) 296 FT_Bitmap_Embolden( FT_Library library, 297 FT_Bitmap* bitmap, 298 FT_Pos xStrength, 299 FT_Pos yStrength ) 300 { 301 FT_Error error; 302 unsigned char* p; 303 FT_Int i, x, pitch; 304 FT_UInt y; 305 FT_Int xstr, ystr; 306 307 308 if ( !library ) 309 return FT_THROW( Invalid_Library_Handle ); 310 311 if ( !bitmap || !bitmap->buffer ) 312 return FT_THROW( Invalid_Argument ); 313 314 if ( ( ( FT_PIX_ROUND( xStrength ) >> 6 ) > FT_INT_MAX ) || 315 ( ( FT_PIX_ROUND( yStrength ) >> 6 ) > FT_INT_MAX ) ) 316 return FT_THROW( Invalid_Argument ); 317 318 xstr = (FT_Int)FT_PIX_ROUND( xStrength ) >> 6; 319 ystr = (FT_Int)FT_PIX_ROUND( yStrength ) >> 6; 320 321 if ( xstr == 0 && ystr == 0 ) 322 return FT_Err_Ok; 323 else if ( xstr < 0 || ystr < 0 ) 324 return FT_THROW( Invalid_Argument ); 325 326 switch ( bitmap->pixel_mode ) 327 { 328 case FT_PIXEL_MODE_GRAY2: 329 case FT_PIXEL_MODE_GRAY4: 330 { 331 FT_Bitmap tmp; 332 333 334 /* convert to 8bpp */ 335 FT_Bitmap_Init( &tmp ); 336 error = FT_Bitmap_Convert( library, bitmap, &tmp, 1 ); 337 if ( error ) 338 return error; 339 340 FT_Bitmap_Done( library, bitmap ); 341 *bitmap = tmp; 342 } 343 break; 344 345 case FT_PIXEL_MODE_MONO: 346 if ( xstr > 8 ) 347 xstr = 8; 348 break; 349 350 case FT_PIXEL_MODE_LCD: 351 xstr *= 3; 352 break; 353 354 case FT_PIXEL_MODE_LCD_V: 355 ystr *= 3; 356 break; 357 358 case FT_PIXEL_MODE_BGRA: 359 /* We don't embolden color glyphs. */ 360 return FT_Err_Ok; 361 } 362 363 error = ft_bitmap_assure_buffer( library->memory, bitmap, 364 (FT_UInt)xstr, (FT_UInt)ystr ); 365 if ( error ) 366 return error; 367 368 /* take care of bitmap flow */ 369 pitch = bitmap->pitch; 370 if ( pitch > 0 ) 371 p = bitmap->buffer + pitch * ystr; 372 else 373 { 374 pitch = -pitch; 375 p = bitmap->buffer + (FT_UInt)pitch * ( bitmap->rows - 1 ); 376 } 377 378 /* for each row */ 379 for ( y = 0; y < bitmap->rows; y++ ) 380 { 381 /* 382 * Horizontally: 383 * 384 * From the last pixel on, make each pixel or'ed with the 385 * `xstr' pixels before it. 386 */ 387 for ( x = pitch - 1; x >= 0; x-- ) 388 { 389 unsigned char tmp; 390 391 392 tmp = p[x]; 393 for ( i = 1; i <= xstr; i++ ) 394 { 395 if ( bitmap->pixel_mode == FT_PIXEL_MODE_MONO ) 396 { 397 p[x] |= tmp >> i; 398 399 /* the maximum value of 8 for `xstr' comes from here */ 400 if ( x > 0 ) 401 p[x] |= p[x - 1] << ( 8 - i ); 402 403 #if 0 404 if ( p[x] == 0xFF ) 405 break; 406 #endif 407 } 408 else 409 { 410 if ( x - i >= 0 ) 411 { 412 if ( p[x] + p[x - i] > bitmap->num_grays - 1 ) 413 { 414 p[x] = (unsigned char)( bitmap->num_grays - 1 ); 415 break; 416 } 417 else 418 { 419 p[x] = (unsigned char)( p[x] + p[x - i] ); 420 if ( p[x] == bitmap->num_grays - 1 ) 421 break; 422 } 423 } 424 else 425 break; 426 } 427 } 428 } 429 430 /* 431 * Vertically: 432 * 433 * Make the above `ystr' rows or'ed with it. 434 */ 435 for ( x = 1; x <= ystr; x++ ) 436 { 437 unsigned char* q; 438 439 440 q = p - bitmap->pitch * x; 441 for ( i = 0; i < pitch; i++ ) 442 q[i] |= p[i]; 443 } 444 445 p += bitmap->pitch; 446 } 447 448 bitmap->width += (FT_UInt)xstr; 449 bitmap->rows += (FT_UInt)ystr; 450 451 return FT_Err_Ok; 452 } 453 454 455 static FT_Byte 456 ft_gray_for_premultiplied_srgb_bgra( const FT_Byte* bgra ) 457 { 458 FT_UInt a = bgra[3]; 459 FT_UInt l; 460 461 462 /* Short-circuit transparent color to avoid division by zero. */ 463 if ( !a ) 464 return 0; 465 466 /* 467 * Luminosity for sRGB is defined using ~0.2126,0.7152,0.0722 468 * coefficients for RGB channels *on the linear colors*. 469 * A gamma of 2.2 is fair to assume. And then, we need to 470 * undo the premultiplication too. 471 * 472 * https://accessibility.kde.org/hsl-adjusted.php 473 * 474 * We do the computation with integers only, applying a gamma of 2.0. 475 * We guarantee 32-bit arithmetic to avoid overflow but the resulting 476 * luminosity fits into 16 bits. 477 * 478 */ 479 480 l = ( 4732UL /* 0.0722 * 65536 */ * bgra[0] * bgra[0] + 481 46871UL /* 0.7152 * 65536 */ * bgra[1] * bgra[1] + 482 13933UL /* 0.2126 * 65536 */ * bgra[2] * bgra[2] ) >> 16; 483 484 /* 485 * Final transparency can be determined as follows. 486 * 487 * - If alpha is zero, we want 0. 488 * - If alpha is zero and luminosity is zero, we want 255. 489 * - If alpha is zero and luminosity is one, we want 0. 490 * 491 * So the formula is a * (1 - l) = a - l * a. 492 * 493 * We still need to undo premultiplication by dividing l by a*a. 494 * 495 */ 496 497 return (FT_Byte)( a - l / a ); 498 } 499 500 501 /* documentation is in ftbitmap.h */ 502 503 FT_EXPORT_DEF( FT_Error ) 504 FT_Bitmap_Convert( FT_Library library, 505 const FT_Bitmap *source, 506 FT_Bitmap *target, 507 FT_Int alignment ) 508 { 509 FT_Error error = FT_Err_Ok; 510 FT_Memory memory; 511 512 FT_Byte* s; 513 FT_Byte* t; 514 515 516 if ( !library ) 517 return FT_THROW( Invalid_Library_Handle ); 518 519 if ( !source || !target ) 520 return FT_THROW( Invalid_Argument ); 521 522 memory = library->memory; 523 524 switch ( source->pixel_mode ) 525 { 526 case FT_PIXEL_MODE_MONO: 527 case FT_PIXEL_MODE_GRAY: 528 case FT_PIXEL_MODE_GRAY2: 529 case FT_PIXEL_MODE_GRAY4: 530 case FT_PIXEL_MODE_LCD: 531 case FT_PIXEL_MODE_LCD_V: 532 case FT_PIXEL_MODE_BGRA: 533 { 534 FT_Int pad, old_target_pitch, target_pitch; 535 FT_ULong old_size; 536 537 538 old_target_pitch = target->pitch; 539 if ( old_target_pitch < 0 ) 540 old_target_pitch = -old_target_pitch; 541 542 old_size = target->rows * (FT_UInt)old_target_pitch; 543 544 target->pixel_mode = FT_PIXEL_MODE_GRAY; 545 target->rows = source->rows; 546 target->width = source->width; 547 548 pad = 0; 549 if ( alignment > 0 ) 550 { 551 pad = (FT_Int)source->width % alignment; 552 if ( pad != 0 ) 553 pad = alignment - pad; 554 } 555 556 target_pitch = (FT_Int)source->width + pad; 557 558 if ( target_pitch > 0 && 559 (FT_ULong)target->rows > FT_ULONG_MAX / (FT_ULong)target_pitch ) 560 return FT_THROW( Invalid_Argument ); 561 562 if ( FT_QREALLOC( target->buffer, 563 old_size, target->rows * (FT_UInt)target_pitch ) ) 564 return error; 565 566 target->pitch = target->pitch < 0 ? -target_pitch : target_pitch; 567 } 568 break; 569 570 default: 571 error = FT_THROW( Invalid_Argument ); 572 } 573 574 s = source->buffer; 575 t = target->buffer; 576 577 /* take care of bitmap flow */ 578 if ( source->pitch < 0 ) 579 s -= source->pitch * (FT_Int)( source->rows - 1 ); 580 if ( target->pitch < 0 ) 581 t -= target->pitch * (FT_Int)( target->rows - 1 ); 582 583 switch ( source->pixel_mode ) 584 { 585 case FT_PIXEL_MODE_MONO: 586 { 587 FT_UInt i; 588 589 590 target->num_grays = 2; 591 592 for ( i = source->rows; i > 0; i-- ) 593 { 594 FT_Byte* ss = s; 595 FT_Byte* tt = t; 596 FT_UInt j; 597 598 599 /* get the full bytes */ 600 for ( j = source->width >> 3; j > 0; j-- ) 601 { 602 FT_Int val = ss[0]; /* avoid a byte->int cast on each line */ 603 604 605 tt[0] = (FT_Byte)( ( val & 0x80 ) >> 7 ); 606 tt[1] = (FT_Byte)( ( val & 0x40 ) >> 6 ); 607 tt[2] = (FT_Byte)( ( val & 0x20 ) >> 5 ); 608 tt[3] = (FT_Byte)( ( val & 0x10 ) >> 4 ); 609 tt[4] = (FT_Byte)( ( val & 0x08 ) >> 3 ); 610 tt[5] = (FT_Byte)( ( val & 0x04 ) >> 2 ); 611 tt[6] = (FT_Byte)( ( val & 0x02 ) >> 1 ); 612 tt[7] = (FT_Byte)( val & 0x01 ); 613 614 tt += 8; 615 ss += 1; 616 } 617 618 /* get remaining pixels (if any) */ 619 j = source->width & 7; 620 if ( j > 0 ) 621 { 622 FT_Int val = *ss; 623 624 625 for ( ; j > 0; j-- ) 626 { 627 tt[0] = (FT_Byte)( ( val & 0x80 ) >> 7); 628 val <<= 1; 629 tt += 1; 630 } 631 } 632 633 s += source->pitch; 634 t += target->pitch; 635 } 636 } 637 break; 638 639 640 case FT_PIXEL_MODE_GRAY: 641 case FT_PIXEL_MODE_LCD: 642 case FT_PIXEL_MODE_LCD_V: 643 { 644 FT_UInt width = source->width; 645 FT_UInt i; 646 647 648 target->num_grays = 256; 649 650 for ( i = source->rows; i > 0; i-- ) 651 { 652 FT_ARRAY_COPY( t, s, width ); 653 654 s += source->pitch; 655 t += target->pitch; 656 } 657 } 658 break; 659 660 661 case FT_PIXEL_MODE_GRAY2: 662 { 663 FT_UInt i; 664 665 666 target->num_grays = 4; 667 668 for ( i = source->rows; i > 0; i-- ) 669 { 670 FT_Byte* ss = s; 671 FT_Byte* tt = t; 672 FT_UInt j; 673 674 675 /* get the full bytes */ 676 for ( j = source->width >> 2; j > 0; j-- ) 677 { 678 FT_Int val = ss[0]; 679 680 681 tt[0] = (FT_Byte)( ( val & 0xC0 ) >> 6 ); 682 tt[1] = (FT_Byte)( ( val & 0x30 ) >> 4 ); 683 tt[2] = (FT_Byte)( ( val & 0x0C ) >> 2 ); 684 tt[3] = (FT_Byte)( ( val & 0x03 ) ); 685 686 ss += 1; 687 tt += 4; 688 } 689 690 j = source->width & 3; 691 if ( j > 0 ) 692 { 693 FT_Int val = ss[0]; 694 695 696 for ( ; j > 0; j-- ) 697 { 698 tt[0] = (FT_Byte)( ( val & 0xC0 ) >> 6 ); 699 val <<= 2; 700 tt += 1; 701 } 702 } 703 704 s += source->pitch; 705 t += target->pitch; 706 } 707 } 708 break; 709 710 711 case FT_PIXEL_MODE_GRAY4: 712 { 713 FT_UInt i; 714 715 716 target->num_grays = 16; 717 718 for ( i = source->rows; i > 0; i-- ) 719 { 720 FT_Byte* ss = s; 721 FT_Byte* tt = t; 722 FT_UInt j; 723 724 725 /* get the full bytes */ 726 for ( j = source->width >> 1; j > 0; j-- ) 727 { 728 FT_Int val = ss[0]; 729 730 731 tt[0] = (FT_Byte)( ( val & 0xF0 ) >> 4 ); 732 tt[1] = (FT_Byte)( ( val & 0x0F ) ); 733 734 ss += 1; 735 tt += 2; 736 } 737 738 if ( source->width & 1 ) 739 tt[0] = (FT_Byte)( ( ss[0] & 0xF0 ) >> 4 ); 740 741 s += source->pitch; 742 t += target->pitch; 743 } 744 } 745 break; 746 747 748 case FT_PIXEL_MODE_BGRA: 749 { 750 FT_UInt i; 751 752 753 target->num_grays = 256; 754 755 for ( i = source->rows; i > 0; i-- ) 756 { 757 FT_Byte* ss = s; 758 FT_Byte* tt = t; 759 FT_UInt j; 760 761 762 for ( j = source->width; j > 0; j-- ) 763 { 764 tt[0] = ft_gray_for_premultiplied_srgb_bgra( ss ); 765 766 ss += 4; 767 tt += 1; 768 } 769 770 s += source->pitch; 771 t += target->pitch; 772 } 773 } 774 break; 775 776 default: 777 ; 778 } 779 780 return error; 781 } 782 783 784 /* documentation is in ftbitmap.h */ 785 786 FT_EXPORT_DEF( FT_Error ) 787 FT_GlyphSlot_Own_Bitmap( FT_GlyphSlot slot ) 788 { 789 if ( slot && slot->format == FT_GLYPH_FORMAT_BITMAP && 790 !( slot->internal->flags & FT_GLYPH_OWN_BITMAP ) ) 791 { 792 FT_Bitmap bitmap; 793 FT_Error error; 794 795 796 FT_Bitmap_Init( &bitmap ); 797 error = FT_Bitmap_Copy( slot->library, &slot->bitmap, &bitmap ); 798 if ( error ) 799 return error; 800 801 slot->bitmap = bitmap; 802 slot->internal->flags |= FT_GLYPH_OWN_BITMAP; 803 } 804 805 return FT_Err_Ok; 806 } 807 808 809 /* documentation is in ftbitmap.h */ 810 811 FT_EXPORT_DEF( FT_Error ) 812 FT_Bitmap_Done( FT_Library library, 813 FT_Bitmap *bitmap ) 814 { 815 FT_Memory memory; 816 817 818 if ( !library ) 819 return FT_THROW( Invalid_Library_Handle ); 820 821 if ( !bitmap ) 822 return FT_THROW( Invalid_Argument ); 823 824 memory = library->memory; 825 826 FT_FREE( bitmap->buffer ); 827 *bitmap = null_bitmap; 828 829 return FT_Err_Ok; 830 } 831 832 833 /* END */ 834
