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 */