projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[FREETYPE] Update to v2.7.1. Patch by Katayama Hirofumi MZ, verified by me. CORE...
[reactos.git] / reactos / sdk / lib / 3rdparty / freetype / src / sfnt / ttsbit.c
1 /***************************************************************************/
2 /* */
3 /* ttsbit.c */
4 /* */
5 /* TrueType and OpenType embedded bitmap support (body). */
6 /* */
7 /* Copyright 2005-2016 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 <ft2build.h>
23 #include FT_INTERNAL_DEBUG_H
24 #include FT_INTERNAL_STREAM_H
25 #include FT_TRUETYPE_TAGS_H
26 #include FT_BITMAP_H
27 #include "ttsbit.h"
28
29 #include "sferrors.h"
30
31 #include "ttmtx.h"
32 #include "pngshim.h"
33
34
35 /*************************************************************************/
36 /* */
37 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
38 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
39 /* messages during execution. */
40 /* */
41 #undef FT_COMPONENT
42 #define FT_COMPONENT trace_ttsbit
43
44
45 FT_LOCAL_DEF( FT_Error )
46 tt_face_load_sbit( TT_Face face,
47 FT_Stream stream )
48 {
49 FT_Error error;
50 FT_ULong table_size;
51 FT_ULong table_start;
52
53
54 face->sbit_table = NULL;
55 face->sbit_table_size = 0;
56 face->sbit_table_type = TT_SBIT_TABLE_TYPE_NONE;
57 face->sbit_num_strikes = 0;
58
59 error = face->goto_table( face, TTAG_CBLC, stream, &table_size );
60 if ( !error )
61 face->sbit_table_type = TT_SBIT_TABLE_TYPE_CBLC;
62 else
63 {
64 error = face->goto_table( face, TTAG_EBLC, stream, &table_size );
65 if ( error )
66 error = face->goto_table( face, TTAG_bloc, stream, &table_size );
67 if ( !error )
68 face->sbit_table_type = TT_SBIT_TABLE_TYPE_EBLC;
69 }
70
71 if ( error )
72 {
73 error = face->goto_table( face, TTAG_sbix, stream, &table_size );
74 if ( !error )
75 face->sbit_table_type = TT_SBIT_TABLE_TYPE_SBIX;
76 }
77 if ( error )
78 goto Exit;
79
80 if ( table_size < 8 )
81 {
82 FT_ERROR(( "tt_face_load_sbit_strikes: table too short\n" ));
83 error = FT_THROW( Invalid_File_Format );
84 goto Exit;
85 }
86
87 table_start = FT_STREAM_POS();
88
89 switch ( (FT_UInt)face->sbit_table_type )
90 {
91 case TT_SBIT_TABLE_TYPE_EBLC:
92 case TT_SBIT_TABLE_TYPE_CBLC:
93 {
94 FT_Byte* p;
95 FT_Fixed version;
96 FT_ULong num_strikes;
97 FT_UInt count;
98
99
100 if ( FT_FRAME_EXTRACT( table_size, face->sbit_table ) )
101 goto Exit;
102
103 face->sbit_table_size = table_size;
104
105 p = face->sbit_table;
106
107 version = FT_NEXT_LONG( p );
108 num_strikes = FT_NEXT_ULONG( p );
109
110 /* there's at least one font (FZShuSong-Z01, version 3) */
111 /* that uses the wrong byte order for the `version' field */
112 if ( ( (FT_ULong)version & 0xFFFF0000UL ) != 0x00020000UL &&
113 ( (FT_ULong)version & 0x0000FFFFUL ) != 0x00000200UL &&
114 ( (FT_ULong)version & 0xFFFF0000UL ) != 0x00030000UL &&
115 ( (FT_ULong)version & 0x0000FFFFUL ) != 0x00000300UL )
116 {
117 error = FT_THROW( Unknown_File_Format );
118 goto Exit;
119 }
120
121 if ( num_strikes >= 0x10000UL )
122 {
123 error = FT_THROW( Invalid_File_Format );
124 goto Exit;
125 }
126
127 /*
128 * Count the number of strikes available in the table. We are a bit
129 * paranoid there and don't trust the data.
130 */
131 count = (FT_UInt)num_strikes;
132 if ( 8 + 48UL * count > table_size )
133 count = (FT_UInt)( ( table_size - 8 ) / 48 );
134
135 face->sbit_num_strikes = count;
136 }
137 break;
138
139 case TT_SBIT_TABLE_TYPE_SBIX:
140 {
141 FT_UShort version;
142 FT_UShort flags;
143 FT_ULong num_strikes;
144 FT_UInt count;
145
146
147 if ( FT_FRAME_ENTER( 8 ) )
148 goto Exit;
149
150 version = FT_GET_USHORT();
151 flags = FT_GET_USHORT();
152 num_strikes = FT_GET_ULONG();
153
154 FT_FRAME_EXIT();
155
156 if ( version < 1 )
157 {
158 error = FT_THROW( Unknown_File_Format );
159 goto Exit;
160 }
161
162 /* Bit 0 must always be `1'. */
163 /* Bit 1 controls the overlay of bitmaps with outlines. */
164 /* All other bits should be zero. */
165 if ( !( flags == 1 || flags == 3 ) ||
166 num_strikes >= 0x10000UL )
167 {
168 error = FT_THROW( Invalid_File_Format );
169 goto Exit;
170 }
171
172 /* we currently don't support bit 1; however, it is better to */
173 /* draw at least something... */
174 if ( flags == 3 )
175 FT_TRACE1(( "tt_face_load_sbit_strikes:"
176 " sbix overlay not supported yet\n"
177 " "
178 " expect bad rendering results\n" ));
179
180 /*
181 * Count the number of strikes available in the table. We are a bit
182 * paranoid there and don't trust the data.
183 */
184 count = (FT_UInt)num_strikes;
185 if ( 8 + 4UL * count > table_size )
186 count = (FT_UInt)( ( table_size - 8 ) / 4 );
187
188 if ( FT_STREAM_SEEK( FT_STREAM_POS() - 8 ) )
189 goto Exit;
190
191 face->sbit_table_size = 8 + count * 4;
192 if ( FT_FRAME_EXTRACT( face->sbit_table_size, face->sbit_table ) )
193 goto Exit;
194
195 face->sbit_num_strikes = count;
196 }
197 break;
198
199 default:
200 /* we ignore unknown table formats */
201 error = FT_THROW( Unknown_File_Format );
202 break;
203 }
204
205 if ( !error )
206 FT_TRACE3(( "tt_face_load_sbit_strikes: found %u strikes\n",
207 face->sbit_num_strikes ));
208
209 face->ebdt_start = 0;
210 face->ebdt_size = 0;
211
212 if ( face->sbit_table_type == TT_SBIT_TABLE_TYPE_SBIX )
213 {
214 /* the `sbix' table is self-contained; */
215 /* it has no associated data table */
216 face->ebdt_start = table_start;
217 face->ebdt_size = table_size;
218 }
219 else if ( face->sbit_table_type != TT_SBIT_TABLE_TYPE_NONE )
220 {
221 FT_ULong ebdt_size;
222
223
224 error = face->goto_table( face, TTAG_CBDT, stream, &ebdt_size );
225 if ( error )
226 error = face->goto_table( face, TTAG_EBDT, stream, &ebdt_size );
227 if ( error )
228 error = face->goto_table( face, TTAG_bdat, stream, &ebdt_size );
229
230 if ( !error )
231 {
232 face->ebdt_start = FT_STREAM_POS();
233 face->ebdt_size = ebdt_size;
234 }
235 }
236
237 if ( !face->ebdt_size )
238 {
239 FT_TRACE2(( "tt_face_load_sbit_strikes:"
240 " no embedded bitmap data table found;\n"
241 " "
242 " resetting number of strikes to zero\n" ));
243 face->sbit_num_strikes = 0;
244 }
245
246 return FT_Err_Ok;
247
248 Exit:
249 if ( error )
250 {
251 if ( face->sbit_table )
252 FT_FRAME_RELEASE( face->sbit_table );
253 face->sbit_table_size = 0;
254 face->sbit_table_type = TT_SBIT_TABLE_TYPE_NONE;
255 }
256
257 return error;
258 }
259
260
261 FT_LOCAL_DEF( void )
262 tt_face_free_sbit( TT_Face face )
263 {
264 FT_Stream stream = face->root.stream;
265
266
267 FT_FRAME_RELEASE( face->sbit_table );
268 face->sbit_table_size = 0;
269 face->sbit_table_type = TT_SBIT_TABLE_TYPE_NONE;
270 face->sbit_num_strikes = 0;
271 }
272
273
274 FT_LOCAL_DEF( FT_Error )
275 tt_face_set_sbit_strike( TT_Face face,
276 FT_Size_Request req,
277 FT_ULong* astrike_index )
278 {
279 return FT_Match_Size( (FT_Face)face, req, 0, astrike_index );
280 }
281
282
283 FT_LOCAL_DEF( FT_Error )
284 tt_face_load_strike_metrics( TT_Face face,
285 FT_ULong strike_index,
286 FT_Size_Metrics* metrics )
287 {
288 /* we have to test for the existence of `sbit_strike_map' */
289 /* because the function gets also used at the very beginning */
290 /* to construct `sbit_strike_map' itself */
291 if ( face->sbit_strike_map )
292 {
293 if ( strike_index >= (FT_ULong)face->root.num_fixed_sizes )
294 return FT_THROW( Invalid_Argument );
295
296 /* map to real index */
297 strike_index = face->sbit_strike_map[strike_index];
298 }
299 else
300 {
301 if ( strike_index >= (FT_ULong)face->sbit_num_strikes )
302 return FT_THROW( Invalid_Argument );
303 }
304
305 switch ( (FT_UInt)face->sbit_table_type )
306 {
307 case TT_SBIT_TABLE_TYPE_EBLC:
308 case TT_SBIT_TABLE_TYPE_CBLC:
309 {
310 FT_Byte* strike;
311 FT_Char max_before_bl;
312 FT_Char min_after_bl;
313
314
315 strike = face->sbit_table + 8 + strike_index * 48;
316
317 metrics->x_ppem = (FT_UShort)strike[44];
318 metrics->y_ppem = (FT_UShort)strike[45];
319
320 metrics->ascender = (FT_Char)strike[16] * 64; /* hori.ascender */
321 metrics->descender = (FT_Char)strike[17] * 64; /* hori.descender */
322
323 /* Due to fuzzy wording in the EBLC documentation, we find both */
324 /* positive and negative values for `descender'. Additionally, */
325 /* many fonts have both `ascender' and `descender' set to zero */
326 /* (which is definitely wrong). MS Windows simply ignores all */
327 /* those values... For these reasons we apply some heuristics */
328 /* to get a reasonable, non-zero value for the height. */
329
330 max_before_bl = (FT_Char)strike[24];
331 min_after_bl = (FT_Char)strike[25];
332
333 if ( metrics->descender > 0 )
334 {
335 /* compare sign of descender with `min_after_bl' */
336 if ( min_after_bl < 0 )
337 metrics->descender = -metrics->descender;
338 }
339
340 else if ( metrics->descender == 0 )
341 {
342 if ( metrics->ascender == 0 )
343 {
344 FT_TRACE2(( "tt_face_load_strike_metrics:"
345 " sanitizing invalid ascender and descender\n"
346 " "
347 " values for strike %d (%dppem, %dppem)\n",
348 strike_index,
349 metrics->x_ppem, metrics->y_ppem ));
350
351 /* sanitize buggy ascender and descender values */
352 if ( max_before_bl || min_after_bl )
353 {
354 metrics->ascender = max_before_bl * 64;
355 metrics->descender = min_after_bl * 64;
356 }
357 else
358 {
359 metrics->ascender = metrics->y_ppem * 64;
360 metrics->descender = 0;
361 }
362 }
363 }
364
365 #if 0
366 else
367 ; /* if we have a negative descender, simply use it */
368 #endif
369
370 metrics->height = metrics->ascender - metrics->descender;
371 if ( metrics->height == 0 )
372 {
373 FT_TRACE2(( "tt_face_load_strike_metrics:"
374 " sanitizing invalid height value\n"
375 " "
376 " for strike (%d, %d)\n",
377 metrics->x_ppem, metrics->y_ppem ));
378 metrics->height = metrics->y_ppem * 64;
379 metrics->descender = metrics->ascender - metrics->height;
380 }
381
382 /* Is this correct? */
383 metrics->max_advance = ( (FT_Char)strike[22] + /* min_origin_SB */
384 strike[18] + /* max_width */
385 (FT_Char)strike[23] /* min_advance_SB */
386 ) * 64;
387
388 /* set the scale values (in 16.16 units) so advances */
389 /* from the hmtx and vmtx table are scaled correctly */
390 metrics->x_scale = FT_MulDiv( metrics->x_ppem,
391 64 * 0x10000,
392 face->header.Units_Per_EM );
393 metrics->y_scale = FT_MulDiv( metrics->y_ppem,
394 64 * 0x10000,
395 face->header.Units_Per_EM );
396
397 return FT_Err_Ok;
398 }
399
400 case TT_SBIT_TABLE_TYPE_SBIX:
401 {
402 FT_Stream stream = face->root.stream;
403 FT_UInt offset;
404 FT_UShort upem, ppem, resolution;
405 TT_HoriHeader *hori;
406 FT_Pos ppem_; /* to reduce casts */
407
408 FT_Error error;
409 FT_Byte* p;
410
411
412 p = face->sbit_table + 8 + 4 * strike_index;
413 offset = FT_NEXT_ULONG( p );
414
415 if ( offset + 4 > face->ebdt_size )
416 return FT_THROW( Invalid_File_Format );
417
418 if ( FT_STREAM_SEEK( face->ebdt_start + offset ) ||
419 FT_FRAME_ENTER( 4 ) )
420 return error;
421
422 ppem = FT_GET_USHORT();
423 resolution = FT_GET_USHORT();
424
425 FT_UNUSED( resolution ); /* What to do with this? */
426
427 FT_FRAME_EXIT();
428
429 upem = face->header.Units_Per_EM;
430 hori = &face->horizontal;
431
432 metrics->x_ppem = ppem;
433 metrics->y_ppem = ppem;
434
435 ppem_ = (FT_Pos)ppem;
436
437 metrics->ascender =
438 FT_MulDiv( hori->Ascender, ppem_ * 64, upem );
439 metrics->descender =
440 FT_MulDiv( hori->Descender, ppem_ * 64, upem );
441 metrics->height =
442 FT_MulDiv( hori->Ascender - hori->Descender + hori->Line_Gap,
443 ppem_ * 64, upem );
444 metrics->max_advance =
445 FT_MulDiv( hori->advance_Width_Max, ppem_ * 64, upem );
446
447 return error;
448 }
449
450 default:
451 return FT_THROW( Unknown_File_Format );
452 }
453 }
454
455
456 typedef struct TT_SBitDecoderRec_
457 {
458 TT_Face face;
459 FT_Stream stream;
460 FT_Bitmap* bitmap;
461 TT_SBit_Metrics metrics;
462 FT_Bool metrics_loaded;
463 FT_Bool bitmap_allocated;
464 FT_Byte bit_depth;
465
466 FT_ULong ebdt_start;
467 FT_ULong ebdt_size;
468
469 FT_ULong strike_index_array;
470 FT_ULong strike_index_count;
471 FT_Byte* eblc_base;
472 FT_Byte* eblc_limit;
473
474 } TT_SBitDecoderRec, *TT_SBitDecoder;
475
476
477 static FT_Error
478 tt_sbit_decoder_init( TT_SBitDecoder decoder,
479 TT_Face face,
480 FT_ULong strike_index,
481 TT_SBit_MetricsRec* metrics )
482 {
483 FT_Error error = FT_ERR( Table_Missing );
484 FT_Stream stream = face->root.stream;
485
486
487 strike_index = face->sbit_strike_map[strike_index];
488
489 if ( !face->ebdt_size )
490 goto Exit;
491 if ( FT_STREAM_SEEK( face->ebdt_start ) )
492 goto Exit;
493
494 decoder->face = face;
495 decoder->stream = stream;
496 decoder->bitmap = &face->root.glyph->bitmap;
497 decoder->metrics = metrics;
498
499 decoder->metrics_loaded = 0;
500 decoder->bitmap_allocated = 0;
501
502 decoder->ebdt_start = face->ebdt_start;
503 decoder->ebdt_size = face->ebdt_size;
504
505 decoder->eblc_base = face->sbit_table;
506 decoder->eblc_limit = face->sbit_table + face->sbit_table_size;
507
508 /* now find the strike corresponding to the index */
509 {
510 FT_Byte* p;
511
512
513 if ( 8 + 48 * strike_index + 3 * 4 + 34 + 1 > face->sbit_table_size )
514 {
515 error = FT_THROW( Invalid_File_Format );
516 goto Exit;
517 }
518
519 p = decoder->eblc_base + 8 + 48 * strike_index;
520
521 decoder->strike_index_array = FT_NEXT_ULONG( p );
522 p += 4;
523 decoder->strike_index_count = FT_NEXT_ULONG( p );
524 p += 34;
525 decoder->bit_depth = *p;
526
527 /* decoder->strike_index_array + */
528 /* 8 * decoder->strike_index_count > face->sbit_table_size ? */
529 if ( decoder->strike_index_array > face->sbit_table_size ||
530 decoder->strike_index_count >
531 ( face->sbit_table_size - decoder->strike_index_array ) / 8 )
532 error = FT_THROW( Invalid_File_Format );
533 }
534
535 Exit:
536 return error;
537 }
538
539
540 static void
541 tt_sbit_decoder_done( TT_SBitDecoder decoder )
542 {
543 FT_UNUSED( decoder );
544 }
545
546
547 static FT_Error
548 tt_sbit_decoder_alloc_bitmap( TT_SBitDecoder decoder,
549 FT_Bool metrics_only )
550 {
551 FT_Error error = FT_Err_Ok;
552 FT_UInt width, height;
553 FT_Bitmap* map = decoder->bitmap;
554 FT_ULong size;
555
556
557 if ( !decoder->metrics_loaded )
558 {
559 error = FT_THROW( Invalid_Argument );
560 goto Exit;
561 }
562
563 width = decoder->metrics->width;
564 height = decoder->metrics->height;
565
566 map->width = width;
567 map->rows = height;
568
569 switch ( decoder->bit_depth )
570 {
571 case 1:
572 map->pixel_mode = FT_PIXEL_MODE_MONO;
573 map->pitch = (int)( ( map->width + 7 ) >> 3 );
574 map->num_grays = 2;
575 break;
576
577 case 2:
578 map->pixel_mode = FT_PIXEL_MODE_GRAY2;
579 map->pitch = (int)( ( map->width + 3 ) >> 2 );
580 map->num_grays = 4;
581 break;
582
583 case 4:
584 map->pixel_mode = FT_PIXEL_MODE_GRAY4;
585 map->pitch = (int)( ( map->width + 1 ) >> 1 );
586 map->num_grays = 16;
587 break;
588
589 case 8:
590 map->pixel_mode = FT_PIXEL_MODE_GRAY;
591 map->pitch = (int)( map->width );
592 map->num_grays = 256;
593 break;
594
595 case 32:
596 map->pixel_mode = FT_PIXEL_MODE_BGRA;
597 map->pitch = (int)( map->width * 4 );
598 map->num_grays = 256;
599 break;
600
601 default:
602 error = FT_THROW( Invalid_File_Format );
603 goto Exit;
604 }
605
606 size = map->rows * (FT_ULong)map->pitch;
607
608 /* check that there is no empty image */
609 if ( size == 0 )
610 goto Exit; /* exit successfully! */
611
612 if ( metrics_only )
613 goto Exit; /* only metrics are requested */
614
615 error = ft_glyphslot_alloc_bitmap( decoder->face->root.glyph, size );
616 if ( error )
617 goto Exit;
618
619 decoder->bitmap_allocated = 1;
620
621 Exit:
622 return error;
623 }
624
625
626 static FT_Error
627 tt_sbit_decoder_load_metrics( TT_SBitDecoder decoder,
628 FT_Byte* *pp,
629 FT_Byte* limit,
630 FT_Bool big )
631 {
632 FT_Byte* p = *pp;
633 TT_SBit_Metrics metrics = decoder->metrics;
634
635
636 if ( p + 5 > limit )
637 goto Fail;
638
639 metrics->height = p[0];
640 metrics->width = p[1];
641 metrics->horiBearingX = (FT_Char)p[2];
642 metrics->horiBearingY = (FT_Char)p[3];
643 metrics->horiAdvance = p[4];
644
645 p += 5;
646 if ( big )
647 {
648 if ( p + 3 > limit )
649 goto Fail;
650
651 metrics->vertBearingX = (FT_Char)p[0];
652 metrics->vertBearingY = (FT_Char)p[1];
653 metrics->vertAdvance = p[2];
654
655 p += 3;
656 }
657 else
658 {
659 /* avoid uninitialized data in case there is no vertical info -- */
660 metrics->vertBearingX = 0;
661 metrics->vertBearingY = 0;
662 metrics->vertAdvance = 0;
663 }
664
665 decoder->metrics_loaded = 1;
666 *pp = p;
667 return FT_Err_Ok;
668
669 Fail:
670 FT_TRACE1(( "tt_sbit_decoder_load_metrics: broken table\n" ));
671 return FT_THROW( Invalid_Argument );
672 }
673
674
675 /* forward declaration */
676 static FT_Error
677 tt_sbit_decoder_load_image( TT_SBitDecoder decoder,
678 FT_UInt glyph_index,
679 FT_Int x_pos,
680 FT_Int y_pos,
681 FT_UInt recurse_count,
682 FT_Bool metrics_only );
683
684 typedef FT_Error (*TT_SBitDecoder_LoadFunc)(
685 TT_SBitDecoder decoder,
686 FT_Byte* p,
687 FT_Byte* plimit,
688 FT_Int x_pos,
689 FT_Int y_pos,
690 FT_UInt recurse_count );
691
692
693 static FT_Error
694 tt_sbit_decoder_load_byte_aligned( TT_SBitDecoder decoder,
695 FT_Byte* p,
696 FT_Byte* limit,
697 FT_Int x_pos,
698 FT_Int y_pos,
699 FT_UInt recurse_count )
700 {
701 FT_Error error = FT_Err_Ok;
702 FT_Byte* line;
703 FT_Int pitch, width, height, line_bits, h;
704 FT_UInt bit_height, bit_width;
705 FT_Bitmap* bitmap;
706
707 FT_UNUSED( recurse_count );
708
709
710 /* check that we can write the glyph into the bitmap */
711 bitmap = decoder->bitmap;
712 bit_width = bitmap->width;
713 bit_height = bitmap->rows;
714 pitch = bitmap->pitch;
715 line = bitmap->buffer;
716
717 width = decoder->metrics->width;
718 height = decoder->metrics->height;
719
720 line_bits = width * decoder->bit_depth;
721
722 if ( x_pos < 0 || (FT_UInt)( x_pos + width ) > bit_width ||
723 y_pos < 0 || (FT_UInt)( y_pos + height ) > bit_height )
724 {
725 FT_TRACE1(( "tt_sbit_decoder_load_byte_aligned:"
726 " invalid bitmap dimensions\n" ));
727 error = FT_THROW( Invalid_File_Format );
728 goto Exit;
729 }
730
731 if ( p + ( ( line_bits + 7 ) >> 3 ) * height > limit )
732 {
733 FT_TRACE1(( "tt_sbit_decoder_load_byte_aligned: broken bitmap\n" ));
734 error = FT_THROW( Invalid_File_Format );
735 goto Exit;
736 }
737
738 /* now do the blit */
739 line += y_pos * pitch + ( x_pos >> 3 );
740 x_pos &= 7;
741
742 if ( x_pos == 0 ) /* the easy one */
743 {
744 for ( h = height; h > 0; h--, line += pitch )
745 {
746 FT_Byte* pwrite = line;
747 FT_Int w;
748
749
750 for ( w = line_bits; w >= 8; w -= 8 )
751 {
752 pwrite[0] = (FT_Byte)( pwrite[0] | *p++ );
753 pwrite += 1;
754 }
755
756 if ( w > 0 )
757 pwrite[0] = (FT_Byte)( pwrite[0] | ( *p++ & ( 0xFF00U >> w ) ) );
758 }
759 }
760 else /* x_pos > 0 */
761 {
762 for ( h = height; h > 0; h--, line += pitch )
763 {
764 FT_Byte* pwrite = line;
765 FT_Int w;
766 FT_UInt wval = 0;
767
768
769 for ( w = line_bits; w >= 8; w -= 8 )
770 {
771 wval = (FT_UInt)( wval | *p++ );
772 pwrite[0] = (FT_Byte)( pwrite[0] | ( wval >> x_pos ) );
773 pwrite += 1;
774 wval <<= 8;
775 }
776
777 if ( w > 0 )
778 wval = (FT_UInt)( wval | ( *p++ & ( 0xFF00U >> w ) ) );
779
780 /* all bits read and there are `x_pos + w' bits to be written */
781
782 pwrite[0] = (FT_Byte)( pwrite[0] | ( wval >> x_pos ) );
783
784 if ( x_pos + w > 8 )
785 {
786 pwrite++;
787 wval <<= 8;
788 pwrite[0] = (FT_Byte)( pwrite[0] | ( wval >> x_pos ) );
789 }
790 }
791 }
792
793 Exit:
794 if ( !error )
795 FT_TRACE3(( "tt_sbit_decoder_load_byte_aligned: loaded\n" ));
796 return error;
797 }
798
799
800 /*
801 * Load a bit-aligned bitmap (with pointer `p') into a line-aligned bitmap
802 * (with pointer `pwrite'). In the example below, the width is 3 pixel,
803 * and `x_pos' is 1 pixel.
804 *
805 * p p+1
806 * | | |
807 * | 7 6 5 4 3 2 1 0 | 7 6 5 4 3 2 1 0 |...
808 * | | |
809 * +-------+ +-------+ +-------+ ...
810 * . . .
811 * . . .
812 * v . .
813 * +-------+ . .
814 * | | .
815 * | 7 6 5 4 3 2 1 0 | .
816 * | | .
817 * pwrite . .
818 * . .
819 * v .
820 * +-------+ .
821 * | |
822 * | 7 6 5 4 3 2 1 0 |
823 * | |
824 * pwrite+1 .
825 * .
826 * v
827 * +-------+
828 * | |
829 * | 7 6 5 4 3 2 1 0 |
830 * | |
831 * pwrite+2
832 *
833 */
834
835 static FT_Error
836 tt_sbit_decoder_load_bit_aligned( TT_SBitDecoder decoder,
837 FT_Byte* p,
838 FT_Byte* limit,
839 FT_Int x_pos,
840 FT_Int y_pos,
841 FT_UInt recurse_count )
842 {
843 FT_Error error = FT_Err_Ok;
844 FT_Byte* line;
845 FT_Int pitch, width, height, line_bits, h, nbits;
846 FT_UInt bit_height, bit_width;
847 FT_Bitmap* bitmap;
848 FT_UShort rval;
849
850 FT_UNUSED( recurse_count );
851
852
853 /* check that we can write the glyph into the bitmap */
854 bitmap = decoder->bitmap;
855 bit_width = bitmap->width;
856 bit_height = bitmap->rows;
857 pitch = bitmap->pitch;
858 line = bitmap->buffer;
859
860 width = decoder->metrics->width;
861 height = decoder->metrics->height;
862
863 line_bits = width * decoder->bit_depth;
864
865 if ( x_pos < 0 || (FT_UInt)( x_pos + width ) > bit_width ||
866 y_pos < 0 || (FT_UInt)( y_pos + height ) > bit_height )
867 {
868 FT_TRACE1(( "tt_sbit_decoder_load_bit_aligned:"
869 " invalid bitmap dimensions\n" ));
870 error = FT_THROW( Invalid_File_Format );
871 goto Exit;
872 }
873
874 if ( p + ( ( line_bits * height + 7 ) >> 3 ) > limit )
875 {
876 FT_TRACE1(( "tt_sbit_decoder_load_bit_aligned: broken bitmap\n" ));
877 error = FT_THROW( Invalid_File_Format );
878 goto Exit;
879 }
880
881 if ( !line_bits || !height )
882 {
883 /* nothing to do */
884 goto Exit;
885 }
886
887 /* now do the blit */
888
889 /* adjust `line' to point to the first byte of the bitmap */
890 line += y_pos * pitch + ( x_pos >> 3 );
891 x_pos &= 7;
892
893 /* the higher byte of `rval' is used as a buffer */
894 rval = 0;
895 nbits = 0;
896
897 for ( h = height; h > 0; h--, line += pitch )
898 {
899 FT_Byte* pwrite = line;
900 FT_Int w = line_bits;
901
902
903 /* handle initial byte (in target bitmap) specially if necessary */
904 if ( x_pos )
905 {
906 w = ( line_bits < 8 - x_pos ) ? line_bits : 8 - x_pos;
907
908 if ( h == height )
909 {
910 rval = *p++;
911 nbits = x_pos;
912 }
913 else if ( nbits < w )
914 {
915 if ( p < limit )
916 rval |= *p++;
917 nbits += 8 - w;
918 }
919 else
920 {
921 rval >>= 8;
922 nbits -= w;
923 }
924
925 *pwrite++ |= ( ( rval >> nbits ) & 0xFF ) &
926 ( ~( 0xFFU << w ) << ( 8 - w - x_pos ) );
927 rval <<= 8;
928
929 w = line_bits - w;
930 }
931
932 /* handle medial bytes */
933 for ( ; w >= 8; w -= 8 )
934 {
935 rval |= *p++;
936 *pwrite++ |= ( rval >> nbits ) & 0xFF;
937
938 rval <<= 8;
939 }
940
941 /* handle final byte if necessary */
942 if ( w > 0 )
943 {
944 if ( nbits < w )
945 {
946 if ( p < limit )
947 rval |= *p++;
948 *pwrite |= ( ( rval >> nbits ) & 0xFF ) & ( 0xFF00U >> w );
949 nbits += 8 - w;
950
951 rval <<= 8;
952 }
953 else
954 {
955 *pwrite |= ( ( rval >> nbits ) & 0xFF ) & ( 0xFF00U >> w );
956 nbits -= w;
957 }
958 }
959 }
960
961 Exit:
962 if ( !error )
963 FT_TRACE3(( "tt_sbit_decoder_load_bit_aligned: loaded\n" ));
964 return error;
965 }
966
967
968 static FT_Error
969 tt_sbit_decoder_load_compound( TT_SBitDecoder decoder,
970 FT_Byte* p,
971 FT_Byte* limit,
972 FT_Int x_pos,
973 FT_Int y_pos,
974 FT_UInt recurse_count )
975 {
976 FT_Error error = FT_Err_Ok;
977 FT_UInt num_components, nn;
978
979 FT_Char horiBearingX = (FT_Char)decoder->metrics->horiBearingX;
980 FT_Char horiBearingY = (FT_Char)decoder->metrics->horiBearingY;
981 FT_Byte horiAdvance = (FT_Byte)decoder->metrics->horiAdvance;
982 FT_Char vertBearingX = (FT_Char)decoder->metrics->vertBearingX;
983 FT_Char vertBearingY = (FT_Char)decoder->metrics->vertBearingY;
984 FT_Byte vertAdvance = (FT_Byte)decoder->metrics->vertAdvance;
985
986
987 if ( p + 2 > limit )
988 goto Fail;
989
990 num_components = FT_NEXT_USHORT( p );
991 if ( p + 4 * num_components > limit )
992 {
993 FT_TRACE1(( "tt_sbit_decoder_load_compound: broken table\n" ));
994 goto Fail;
995 }
996
997 FT_TRACE3(( "tt_sbit_decoder_load_compound: loading %d components\n",
998 num_components ));
999
1000 for ( nn = 0; nn < num_components; nn++ )
1001 {
1002 FT_UInt gindex = FT_NEXT_USHORT( p );
1003 FT_Byte dx = FT_NEXT_BYTE( p );
1004 FT_Byte dy = FT_NEXT_BYTE( 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 %d) for glyph index %d\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 FT_TRACE4(( "tt_sbit_decoder_load_image:"
1439 " no sbit found for glyph index %d\n", glyph_index ));
1440
1441 return FT_THROW( Invalid_Argument );
1442 }
1443
1444
1445 static FT_Error
1446 tt_face_load_sbix_image( TT_Face face,
1447 FT_ULong strike_index,
1448 FT_UInt glyph_index,
1449 FT_Stream stream,
1450 FT_Bitmap *map,
1451 TT_SBit_MetricsRec *metrics,
1452 FT_Bool metrics_only )
1453 {
1454 FT_UInt strike_offset, glyph_start, glyph_end;
1455 FT_Int originOffsetX, originOffsetY;
1456 FT_Tag graphicType;
1457 FT_Int recurse_depth = 0;
1458
1459 FT_Error error;
1460 FT_Byte* p;
1461
1462 FT_UNUSED( map );
1463
1464
1465 strike_index = face->sbit_strike_map[strike_index];
1466
1467 metrics->width = 0;
1468 metrics->height = 0;
1469
1470 p = face->sbit_table + 8 + 4 * strike_index;
1471 strike_offset = FT_NEXT_ULONG( p );
1472
1473 retry:
1474 if ( glyph_index > (FT_UInt)face->root.num_glyphs )
1475 return FT_THROW( Invalid_Argument );
1476
1477 if ( strike_offset >= face->ebdt_size ||
1478 face->ebdt_size - strike_offset < 4 + glyph_index * 4 + 8 )
1479 return FT_THROW( Invalid_File_Format );
1480
1481 if ( FT_STREAM_SEEK( face->ebdt_start +
1482 strike_offset + 4 +
1483 glyph_index * 4 ) ||
1484 FT_FRAME_ENTER( 8 ) )
1485 return error;
1486
1487 glyph_start = FT_GET_ULONG();
1488 glyph_end = FT_GET_ULONG();
1489
1490 FT_FRAME_EXIT();
1491
1492 if ( glyph_start == glyph_end )
1493 return FT_THROW( Invalid_Argument );
1494 if ( glyph_start > glyph_end ||
1495 glyph_end - glyph_start < 8 ||
1496 face->ebdt_size - strike_offset < glyph_end )
1497 return FT_THROW( Invalid_File_Format );
1498
1499 if ( FT_STREAM_SEEK( face->ebdt_start + strike_offset + glyph_start ) ||
1500 FT_FRAME_ENTER( glyph_end - glyph_start ) )
1501 return error;
1502
1503 originOffsetX = FT_GET_SHORT();
1504 originOffsetY = FT_GET_SHORT();
1505
1506 graphicType = FT_GET_TAG4();
1507
1508 switch ( graphicType )
1509 {
1510 case FT_MAKE_TAG( 'd', 'u', 'p', 'e' ):
1511 if ( recurse_depth < 4 )
1512 {
1513 glyph_index = FT_GET_USHORT();
1514 FT_FRAME_EXIT();
1515 recurse_depth++;
1516 goto retry;
1517 }
1518 error = FT_THROW( Invalid_File_Format );
1519 break;
1520
1521 case FT_MAKE_TAG( 'p', 'n', 'g', ' ' ):
1522 #ifdef FT_CONFIG_OPTION_USE_PNG
1523 error = Load_SBit_Png( face->root.glyph,
1524 0,
1525 0,
1526 32,
1527 metrics,
1528 stream->memory,
1529 stream->cursor,
1530 glyph_end - glyph_start - 8,
1531 TRUE,
1532 metrics_only );
1533 #else
1534 error = FT_THROW( Unimplemented_Feature );
1535 #endif
1536 break;
1537
1538 case FT_MAKE_TAG( 'j', 'p', 'g', ' ' ):
1539 case FT_MAKE_TAG( 't', 'i', 'f', 'f' ):
1540 case FT_MAKE_TAG( 'r', 'g', 'b', 'l' ): /* used on iOS 7.1 */
1541 error = FT_THROW( Unknown_File_Format );
1542 break;
1543
1544 default:
1545 error = FT_THROW( Unimplemented_Feature );
1546 break;
1547 }
1548
1549 FT_FRAME_EXIT();
1550
1551 if ( !error )
1552 {
1553 FT_Short abearing;
1554 FT_UShort aadvance;
1555
1556
1557 tt_face_get_metrics( face, FALSE, glyph_index, &abearing, &aadvance );
1558
1559 metrics->horiBearingX = (FT_Short)originOffsetX;
1560 metrics->horiBearingY = (FT_Short)( -originOffsetY + metrics->height );
1561 metrics->horiAdvance = (FT_UShort)( aadvance *
1562 face->root.size->metrics.x_ppem /
1563 face->header.Units_Per_EM );
1564 }
1565
1566 return error;
1567 }
1568
1569 FT_LOCAL( FT_Error )
1570 tt_face_load_sbit_image( TT_Face face,
1571 FT_ULong strike_index,
1572 FT_UInt glyph_index,
1573 FT_UInt load_flags,
1574 FT_Stream stream,
1575 FT_Bitmap *map,
1576 TT_SBit_MetricsRec *metrics )
1577 {
1578 FT_Error error = FT_Err_Ok;
1579
1580
1581 switch ( (FT_UInt)face->sbit_table_type )
1582 {
1583 case TT_SBIT_TABLE_TYPE_EBLC:
1584 case TT_SBIT_TABLE_TYPE_CBLC:
1585 {
1586 TT_SBitDecoderRec decoder[1];
1587
1588
1589 error = tt_sbit_decoder_init( decoder, face, strike_index, metrics );
1590 if ( !error )
1591 {
1592 error = tt_sbit_decoder_load_image(
1593 decoder,
1594 glyph_index,
1595 0,
1596 0,
1597 0,
1598 ( load_flags & FT_LOAD_BITMAP_METRICS_ONLY ) != 0 );
1599 tt_sbit_decoder_done( decoder );
1600 }
1601 }
1602 break;
1603
1604 case TT_SBIT_TABLE_TYPE_SBIX:
1605 error = tt_face_load_sbix_image(
1606 face,
1607 strike_index,
1608 glyph_index,
1609 stream,
1610 map,
1611 metrics,
1612 ( load_flags & FT_LOAD_BITMAP_METRICS_ONLY ) != 0 );
1613 break;
1614
1615 default:
1616 error = FT_THROW( Unknown_File_Format );
1617 break;
1618 }
1619
1620 /* Flatten color bitmaps if color was not requested. */
1621 if ( !error &&
1622 !( load_flags & FT_LOAD_COLOR ) &&
1623 !( load_flags & FT_LOAD_BITMAP_METRICS_ONLY ) &&
1624 map->pixel_mode == FT_PIXEL_MODE_BGRA )
1625 {
1626 FT_Bitmap new_map;
1627 FT_Library library = face->root.glyph->library;
1628
1629
1630 FT_Bitmap_Init( &new_map );
1631
1632 /* Convert to 8bit grayscale. */
1633 error = FT_Bitmap_Convert( library, map, &new_map, 1 );
1634 if ( error )
1635 FT_Bitmap_Done( library, &new_map );
1636 else
1637 {
1638 map->pixel_mode = new_map.pixel_mode;
1639 map->pitch = new_map.pitch;
1640 map->num_grays = new_map.num_grays;
1641
1642 ft_glyphslot_set_bitmap( face->root.glyph, new_map.buffer );
1643 face->root.glyph->internal->flags |= FT_GLYPH_OWN_BITMAP;
1644 }
1645 }
1646
1647 return error;
1648 }
1649
1650
1651 /* EOF */
A free Windows-compatible Operating System