1 /***************************************************************************/
2 /* */
3 /* ttsbit.c */
4 /* */
5 /* TrueType and OpenType embedded bitmap support (body). */
6 /* */
7 /* Copyright 2005-2018 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
28
29 #ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
30
31 #include "ttsbit.h"
32
33 #include "sferrors.h"
34
35 #include "ttmtx.h"
36 #include "pngshim.h"
37
38
39 /*************************************************************************/
40 /* */
41 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
42 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
43 /* messages during execution. */
44 /* */
45 #undef FT_COMPONENT
46 #define FT_COMPONENT trace_ttsbit
47
48
49 FT_LOCAL_DEF( FT_Error )
50 tt_face_load_sbit( TT_Face face,
51 FT_Stream stream )
52 {
53 FT_Error error;
54 FT_ULong table_size;
55 FT_ULong table_start;
56
57
58 face->sbit_table = NULL;
59 face->sbit_table_size = 0;
60 face->sbit_table_type = TT_SBIT_TABLE_TYPE_NONE;
61 face->sbit_num_strikes = 0;
62
63 error = face->goto_table( face, TTAG_CBLC, stream, &table_size );
64 if ( !error )
65 face->sbit_table_type = TT_SBIT_TABLE_TYPE_CBLC;
66 else
67 {
68 error = face->goto_table( face, TTAG_EBLC, stream, &table_size );
69 if ( error )
70 error = face->goto_table( face, TTAG_bloc, stream, &table_size );
71 if ( !error )
72 face->sbit_table_type = TT_SBIT_TABLE_TYPE_EBLC;
73 }
74
75 if ( error )
76 {
77 error = face->goto_table( face, TTAG_sbix, stream, &table_size );
78 if ( !error )
79 face->sbit_table_type = TT_SBIT_TABLE_TYPE_SBIX;
80 }
81 if ( error )
82 goto Exit;
83
84 if ( table_size < 8 )
85 {
86 FT_ERROR(( "tt_face_load_sbit_strikes: table too short\n" ));
87 error = FT_THROW( Invalid_File_Format );
88 goto Exit;
89 }
90
91 table_start = FT_STREAM_POS();
92
93 switch ( (FT_UInt)face->sbit_table_type )
94 {
95 case TT_SBIT_TABLE_TYPE_EBLC:
96 case TT_SBIT_TABLE_TYPE_CBLC:
97 {
98 FT_Byte* p;
99 FT_Fixed version;
100 FT_ULong num_strikes;
101 FT_UInt count;
102
103
104 if ( FT_FRAME_EXTRACT( table_size, face->sbit_table ) )
105 goto Exit;
106
107 face->sbit_table_size = table_size;
108
109 p = face->sbit_table;
110
111 version = FT_NEXT_LONG( p );
112 num_strikes = FT_NEXT_ULONG( p );
113
114 /* there's at least one font (FZShuSong-Z01, version 3) */
115 /* that uses the wrong byte order for the `version' field */
116 if ( ( (FT_ULong)version & 0xFFFF0000UL ) != 0x00020000UL &&
117 ( (FT_ULong)version & 0x0000FFFFUL ) != 0x00000200UL &&
118 ( (FT_ULong)version & 0xFFFF0000UL ) != 0x00030000UL &&
119 ( (FT_ULong)version & 0x0000FFFFUL ) != 0x00000300UL )
120 {
121 error = FT_THROW( Unknown_File_Format );
122 goto Exit;
123 }
124
125 if ( num_strikes >= 0x10000UL )
126 {
127 error = FT_THROW( Invalid_File_Format );
128 goto Exit;
129 }
130
131 /*
132 * Count the number of strikes available in the table. We are a bit
133 * paranoid there and don't trust the data.
134 */
135 count = (FT_UInt)num_strikes;
136 if ( 8 + 48UL * count > table_size )
137 count = (FT_UInt)( ( table_size - 8 ) / 48 );
138
139 face->sbit_num_strikes = count;
140 }
141 break;
142
143 case TT_SBIT_TABLE_TYPE_SBIX:
144 {
145 FT_UShort version;
146 FT_UShort flags;
147 FT_ULong num_strikes;
148 FT_UInt count;
149
150
151 if ( FT_FRAME_ENTER( 8 ) )
152 goto Exit;
153
154 version = FT_GET_USHORT();
155 flags = FT_GET_USHORT();
156 num_strikes = FT_GET_ULONG();
157
158 FT_FRAME_EXIT();
159
160 if ( version < 1 )
161 {
162 error = FT_THROW( Unknown_File_Format );
163 goto Exit;
164 }
165
166 /* Bit 0 must always be `1'. */
167 /* Bit 1 controls the overlay of bitmaps with outlines. */
168 /* All other bits should be zero. */
169 if ( !( flags == 1 || flags == 3 ) ||
170 num_strikes >= 0x10000UL )
171 {
172 error = FT_THROW( Invalid_File_Format );
173 goto Exit;
174 }
175
176 /* we currently don't support bit 1; however, it is better to */
177 /* draw at least something... */
178 if ( flags == 3 )
179 FT_TRACE1(( "tt_face_load_sbit_strikes:"
180 " sbix overlay not supported yet\n"
181 " "
182 " expect bad rendering results\n" ));
183
184 /*
185 * Count the number of strikes available in the table. We are a bit
186 * paranoid there and don't trust the data.
187 */
188 count = (FT_UInt)num_strikes;
189 if ( 8 + 4UL * count > table_size )
190 count = (FT_UInt)( ( table_size - 8 ) / 4 );
191
192 if ( FT_STREAM_SEEK( FT_STREAM_POS() - 8 ) )
193 goto Exit;
194
195 face->sbit_table_size = 8 + count * 4;
196 if ( FT_FRAME_EXTRACT( face->sbit_table_size, face->sbit_table ) )
197 goto Exit;
198
199 face->sbit_num_strikes = count;
200 }
201 break;
202
203 default:
204 /* we ignore unknown table formats */
205 error = FT_THROW( Unknown_File_Format );
206 break;
207 }
208
209 if ( !error )
210 FT_TRACE3(( "tt_face_load_sbit_strikes: found %u strikes\n",
211 face->sbit_num_strikes ));
212
213 face->ebdt_start = 0;
214 face->ebdt_size = 0;
215
216 if ( face->sbit_table_type == TT_SBIT_TABLE_TYPE_SBIX )
217 {
218 /* the `sbix' table is self-contained; */
219 /* it has no associated data table */
220 face->ebdt_start = table_start;
221 face->ebdt_size = table_size;
222 }
223 else if ( face->sbit_table_type != TT_SBIT_TABLE_TYPE_NONE )
224 {
225 FT_ULong ebdt_size;
226
227
228 error = face->goto_table( face, TTAG_CBDT, stream, &ebdt_size );
229 if ( error )
230 error = face->goto_table( face, TTAG_EBDT, stream, &ebdt_size );
231 if ( error )
232 error = face->goto_table( face, TTAG_bdat, stream, &ebdt_size );
233
234 if ( !error )
235 {
236 face->ebdt_start = FT_STREAM_POS();
237 face->ebdt_size = ebdt_size;
238 }
239 }
240
241 if ( !face->ebdt_size )
242 {
243 FT_TRACE2(( "tt_face_load_sbit_strikes:"
244 " no embedded bitmap data table found;\n"
245 " "
246 " resetting number of strikes to zero\n" ));
247 face->sbit_num_strikes = 0;
248 }
249
250 return FT_Err_Ok;
251
252 Exit:
253 if ( error )
254 {
255 if ( face->sbit_table )
256 FT_FRAME_RELEASE( face->sbit_table );
257 face->sbit_table_size = 0;
258 face->sbit_table_type = TT_SBIT_TABLE_TYPE_NONE;
259 }
260
261 return error;
262 }
263
264
265 FT_LOCAL_DEF( void )
266 tt_face_free_sbit( TT_Face face )
267 {
268 FT_Stream stream = face->root.stream;
269
270
271 FT_FRAME_RELEASE( face->sbit_table );
272 face->sbit_table_size = 0;
273 face->sbit_table_type = TT_SBIT_TABLE_TYPE_NONE;
274 face->sbit_num_strikes = 0;
275 }
276
277
278 FT_LOCAL_DEF( FT_Error )
279 tt_face_set_sbit_strike( TT_Face face,
280 FT_Size_Request req,
281 FT_ULong* astrike_index )
282 {
283 return FT_Match_Size( (FT_Face)face, req, 0, astrike_index );
284 }
285
286
287 FT_LOCAL_DEF( FT_Error )
288 tt_face_load_strike_metrics( TT_Face face,
289 FT_ULong strike_index,
290 FT_Size_Metrics* metrics )
291 {
292 /* we have to test for the existence of `sbit_strike_map' */
293 /* because the function gets also used at the very beginning */
294 /* to construct `sbit_strike_map' itself */
295 if ( face->sbit_strike_map )
296 {
297 if ( strike_index >= (FT_ULong)face->root.num_fixed_sizes )
298 return FT_THROW( Invalid_Argument );
299
300 /* map to real index */
301 strike_index = face->sbit_strike_map[strike_index];
302 }
303 else
304 {
305 if ( strike_index >= (FT_ULong)face->sbit_num_strikes )
306 return FT_THROW( Invalid_Argument );
307 }
308
309 switch ( (FT_UInt)face->sbit_table_type )
310 {
311 case TT_SBIT_TABLE_TYPE_EBLC:
312 case TT_SBIT_TABLE_TYPE_CBLC:
313 {
314 FT_Byte* strike;
315 FT_Char max_before_bl;
316 FT_Char min_after_bl;
317
318
319 strike = face->sbit_table + 8 + strike_index * 48;
320
321 metrics->x_ppem = (FT_UShort)strike[44];
322 metrics->y_ppem = (FT_UShort)strike[45];
323
324 metrics->ascender = (FT_Char)strike[16] * 64; /* hori.ascender */
325 metrics->descender = (FT_Char)strike[17] * 64; /* hori.descender */
326
327 /* Due to fuzzy wording in the EBLC documentation, we find both */
328 /* positive and negative values for `descender'. Additionally, */
329 /* many fonts have both `ascender' and `descender' set to zero */
330 /* (which is definitely wrong). MS Windows simply ignores all */
331 /* those values... For these reasons we apply some heuristics */
332 /* to get a reasonable, non-zero value for the height. */
333
334 max_before_bl = (FT_Char)strike[24];
335 min_after_bl = (FT_Char)strike[25];
336
337 if ( metrics->descender > 0 )
338 {
339 /* compare sign of descender with `min_after_bl' */
340 if ( min_after_bl < 0 )
341 metrics->descender = -metrics->descender;
342 }
343
344 else if ( metrics->descender == 0 )
345 {
346 if ( metrics->ascender == 0 )
347 {
348 FT_TRACE2(( "tt_face_load_strike_metrics:"
349 " sanitizing invalid ascender and descender\n"
350 " "
351 " values for strike %d (%dppem, %dppem)\n",
352 strike_index,
353 metrics->x_ppem, metrics->y_ppem ));
354
355 /* sanitize buggy ascender and descender values */
356 if ( max_before_bl || min_after_bl )
357 {
358 metrics->ascender = max_before_bl * 64;
359 metrics->descender = min_after_bl * 64;
360 }
361 else
362 {
363 metrics->ascender = metrics->y_ppem * 64;
364 metrics->descender = 0;
365 }
366 }
367 }
368
369 #if 0
370 else
371 ; /* if we have a negative descender, simply use it */
372 #endif
373
374 metrics->height = metrics->ascender - metrics->descender;
375 if ( metrics->height == 0 )
376 {
377 FT_TRACE2(( "tt_face_load_strike_metrics:"
378 " sanitizing invalid height value\n"
379 " "
380 " for strike (%d, %d)\n",
381 metrics->x_ppem, metrics->y_ppem ));
382 metrics->height = metrics->y_ppem * 64;
383 metrics->descender = metrics->ascender - metrics->height;
384 }
385
386 /* Is this correct? */
387 metrics->max_advance = ( (FT_Char)strike[22] + /* min_origin_SB */
388 strike[18] + /* max_width */
389 (FT_Char)strike[23] /* min_advance_SB */
390 ) * 64;
391
392 /* set the scale values (in 16.16 units) so advances */
393 /* from the hmtx and vmtx table are scaled correctly */
394 metrics->x_scale = FT_MulDiv( metrics->x_ppem,
395 64 * 0x10000,
396 face->header.Units_Per_EM );
397 metrics->y_scale = FT_MulDiv( metrics->y_ppem,
398 64 * 0x10000,
399 face->header.Units_Per_EM );
400
401 return FT_Err_Ok;
402 }
403
404 case TT_SBIT_TABLE_TYPE_SBIX:
405 {
406 FT_Stream stream = face->root.stream;
407 FT_UInt offset;
408 FT_UShort upem, ppem, resolution;
409 TT_HoriHeader *hori;
410 FT_Pos ppem_; /* to reduce casts */
411
412 FT_Error error;
413 FT_Byte* p;
414
415
416 p = face->sbit_table + 8 + 4 * strike_index;
417 offset = FT_NEXT_ULONG( p );
418
419 if ( offset + 4 > face->ebdt_size )
420 return FT_THROW( Invalid_File_Format );
421
422 if ( FT_STREAM_SEEK( face->ebdt_start + offset ) ||
423 FT_FRAME_ENTER( 4 ) )
424 return error;
425
426 ppem = FT_GET_USHORT();
427 resolution = FT_GET_USHORT();
428
429 FT_UNUSED( resolution ); /* What to do with this? */
430
431 FT_FRAME_EXIT();
432
433 upem = face->header.Units_Per_EM;
434 hori = &face->horizontal;
435
436 metrics->x_ppem = ppem;
437 metrics->y_ppem = ppem;
438
439 ppem_ = (FT_Pos)ppem;
440
441 metrics->ascender =
442 FT_MulDiv( hori->Ascender, ppem_ * 64, upem );
443 metrics->descender =
444 FT_MulDiv( hori->Descender, ppem_ * 64, upem );
445 metrics->height =
446 FT_MulDiv( hori->Ascender - hori->Descender + hori->Line_Gap,
447 ppem_ * 64, upem );
448 metrics->max_advance =
449 FT_MulDiv( hori->advance_Width_Max, ppem_ * 64, upem );
450
451 /* set the scale values (in 16.16 units) so advances */
452 /* from the hmtx and vmtx table are scaled correctly */
453 metrics->x_scale = FT_MulDiv( metrics->x_ppem,
454 64 * 0x10000,
455 face->header.Units_Per_EM );
456 metrics->y_scale = FT_MulDiv( metrics->y_ppem,
457 64 * 0x10000,
458 face->header.Units_Per_EM );
459
460 return error;
461 }
462
463 default:
464 return FT_THROW( Unknown_File_Format );
465 }
466 }
467
468
469 typedef struct TT_SBitDecoderRec_
470 {
471 TT_Face face;
472 FT_Stream stream;
473 FT_Bitmap* bitmap;
474 TT_SBit_Metrics metrics;
475 FT_Bool metrics_loaded;
476 FT_Bool bitmap_allocated;
477 FT_Byte bit_depth;
478
479 FT_ULong ebdt_start;
480 FT_ULong ebdt_size;
481
482 FT_ULong strike_index_array;
483 FT_ULong strike_index_count;
484 FT_Byte* eblc_base;
485 FT_Byte* eblc_limit;
486
487 } TT_SBitDecoderRec, *TT_SBitDecoder;
488
489
490 static FT_Error
491 tt_sbit_decoder_init( TT_SBitDecoder decoder,
492 TT_Face face,
493 FT_ULong strike_index,
494 TT_SBit_MetricsRec* metrics )
495 {
496 FT_Error error = FT_ERR( Table_Missing );
497 FT_Stream stream = face->root.stream;
498
499
500 strike_index = face->sbit_strike_map[strike_index];
501
502 if ( !face->ebdt_size )
503 goto Exit;
504 if ( FT_STREAM_SEEK( face->ebdt_start ) )
505 goto Exit;
506
507 decoder->face = face;
508 decoder->stream = stream;
509 decoder->bitmap = &face->root.glyph->bitmap;
510 decoder->metrics = metrics;
511
512 decoder->metrics_loaded = 0;
513 decoder->bitmap_allocated = 0;
514
515 decoder->ebdt_start = face->ebdt_start;
516 decoder->ebdt_size = face->ebdt_size;
517
518 decoder->eblc_base = face->sbit_table;
519 decoder->eblc_limit = face->sbit_table + face->sbit_table_size;
520
521 /* now find the strike corresponding to the index */
522 {
523 FT_Byte* p;
524
525
526 if ( 8 + 48 * strike_index + 3 * 4 + 34 + 1 > face->sbit_table_size )
527 {
528 error = FT_THROW( Invalid_File_Format );
529 goto Exit;
530 }
531
532 p = decoder->eblc_base + 8 + 48 * strike_index;
533
534 decoder->strike_index_array = FT_NEXT_ULONG( p );
535 p += 4;
536 decoder->strike_index_count = FT_NEXT_ULONG( p );
537 p += 34;
538 decoder->bit_depth = *p;
539
540 /* decoder->strike_index_array + */
541 /* 8 * decoder->strike_index_count > face->sbit_table_size ? */
542 if ( decoder->strike_index_array > face->sbit_table_size ||
543 decoder->strike_index_count >
544 ( face->sbit_table_size - decoder->strike_index_array ) / 8 )
545 error = FT_THROW( Invalid_File_Format );
546 }
547
548 Exit:
549 return error;
550 }
551
552
553 static void
554 tt_sbit_decoder_done( TT_SBitDecoder decoder )
555 {
556 FT_UNUSED( decoder );
557 }
558
559
560 static FT_Error
561 tt_sbit_decoder_alloc_bitmap( TT_SBitDecoder decoder,
562 FT_Bool metrics_only )
563 {
564 FT_Error error = FT_Err_Ok;
565 FT_UInt width, height;
566 FT_Bitmap* map = decoder->bitmap;
567 FT_ULong size;
568
569
570 if ( !decoder->metrics_loaded )
571 {
572 error = FT_THROW( Invalid_Argument );
573 goto Exit;
574 }
575
576 width = decoder->metrics->width;
577 height = decoder->metrics->height;
578
579 map->width = width;
580 map->rows = height;
581
582 switch ( decoder->bit_depth )
583 {
584 case 1:
585 map->pixel_mode = FT_PIXEL_MODE_MONO;
586 map->pitch = (int)( ( map->width + 7 ) >> 3 );
587 map->num_grays = 2;
588 break;
589
590 case 2:
591 map->pixel_mode = FT_PIXEL_MODE_GRAY2;
592 map->pitch = (int)( ( map->width + 3 ) >> 2 );
593 map->num_grays = 4;
594 break;
595
596 case 4:
597 map->pixel_mode = FT_PIXEL_MODE_GRAY4;
598 map->pitch = (int)( ( map->width + 1 ) >> 1 );
599 map->num_grays = 16;
600 break;
601
602 case 8:
603 map->pixel_mode = FT_PIXEL_MODE_GRAY;
604 map->pitch = (int)( map->width );
605 map->num_grays = 256;
606 break;
607
608 case 32:
609 map->pixel_mode = FT_PIXEL_MODE_BGRA;
610 map->pitch = (int)( map->width * 4 );
611 map->num_grays = 256;
612 break;
613
614 default:
615 error = FT_THROW( Invalid_File_Format );
616 goto Exit;
617 }
618
619 size = map->rows * (FT_ULong)map->pitch;
620
621 /* check that there is no empty image */
622 if ( size == 0 )
623 goto Exit; /* exit successfully! */
624
625 if ( metrics_only )
626 goto Exit; /* only metrics are requested */
627
628 error = ft_glyphslot_alloc_bitmap( decoder->face->root.glyph, size );
629 if ( error )
630 goto Exit;
631
632 decoder->bitmap_allocated = 1;
633
634 Exit:
635 return error;
636 }
637
638
639 static FT_Error
640 tt_sbit_decoder_load_metrics( TT_SBitDecoder decoder,
641 FT_Byte* *pp,
642 FT_Byte* limit,
643 FT_Bool big )
644 {
645 FT_Byte* p = *pp;
646 TT_SBit_Metrics metrics = decoder->metrics;
647
648
649 if ( p + 5 > limit )
650 goto Fail;
651
652 metrics->height = p[0];
653 metrics->width = p[1];
654 metrics->horiBearingX = (FT_Char)p[2];
655 metrics->horiBearingY = (FT_Char)p[3];
656 metrics->horiAdvance = p[4];
657
658 p += 5;
659 if ( big )
660 {
661 if ( p + 3 > limit )
662 goto Fail;
663
664 metrics->vertBearingX = (FT_Char)p[0];
665 metrics->vertBearingY = (FT_Char)p[1];
666 metrics->vertAdvance = p[2];
667
668 p += 3;
669 }
670 else
671 {
672 /* avoid uninitialized data in case there is no vertical info -- */
673 metrics->vertBearingX = 0;
674 metrics->vertBearingY = 0;
675 metrics->vertAdvance = 0;
676 }
677
678 decoder->metrics_loaded = 1;
679 *pp = p;
680 return FT_Err_Ok;
681
682 Fail:
683 FT_TRACE1(( "tt_sbit_decoder_load_metrics: broken table\n" ));
684 return FT_THROW( Invalid_Argument );
685 }
686
687
688 /* forward declaration */
689 static FT_Error
690 tt_sbit_decoder_load_image( TT_SBitDecoder decoder,
691 FT_UInt glyph_index,
692 FT_Int x_pos,
693 FT_Int y_pos,
694 FT_UInt recurse_count,
695 FT_Bool metrics_only );
696
697 typedef FT_Error (*TT_SBitDecoder_LoadFunc)(
698 TT_SBitDecoder decoder,
699 FT_Byte* p,
700 FT_Byte* plimit,
701 FT_Int x_pos,
702 FT_Int y_pos,
703 FT_UInt recurse_count );
704
705
706 static FT_Error
707 tt_sbit_decoder_load_byte_aligned( TT_SBitDecoder decoder,
708 FT_Byte* p,
709 FT_Byte* limit,
710 FT_Int x_pos,
711 FT_Int y_pos,
712 FT_UInt recurse_count )
713 {
714 FT_Error error = FT_Err_Ok;
715 FT_Byte* line;
716 FT_Int pitch, width, height, line_bits, h;
717 FT_UInt bit_height, bit_width;
718 FT_Bitmap* bitmap;
719
720 FT_UNUSED( recurse_count );
721
722
723 /* check that we can write the glyph into the bitmap */
724 bitmap = decoder->bitmap;
725 bit_width = bitmap->width;
726 bit_height = bitmap->rows;
727 pitch = bitmap->pitch;
728 line = bitmap->buffer;
729
730 width = decoder->metrics->width;
731 height = decoder->metrics->height;
732
733 line_bits = width * decoder->bit_depth;
734
735 if ( x_pos < 0 || (FT_UInt)( x_pos + width ) > bit_width ||
736 y_pos < 0 || (FT_UInt)( y_pos + height ) > bit_height )
737 {
738 FT_TRACE1(( "tt_sbit_decoder_load_byte_aligned:"
739 " invalid bitmap dimensions\n" ));
740 error = FT_THROW( Invalid_File_Format );
741 goto Exit;
742 }
743
744 if ( p + ( ( line_bits + 7 ) >> 3 ) * height > limit )
745 {
746 FT_TRACE1(( "tt_sbit_decoder_load_byte_aligned: broken bitmap\n" ));
747 error = FT_THROW( Invalid_File_Format );
748 goto Exit;
749 }
750
751 /* now do the blit */
752 line += y_pos * pitch + ( x_pos >> 3 );
753 x_pos &= 7;
754
755 if ( x_pos == 0 ) /* the easy one */
756 {
757 for ( h = height; h > 0; h--, line += pitch )
758 {
759 FT_Byte* pwrite = line;
760 FT_Int w;
761
762
763 for ( w = line_bits; w >= 8; w -= 8 )
764 {
765 pwrite[0] = (FT_Byte)( pwrite[0] | *p++ );
766 pwrite += 1;
767 }
768
769 if ( w > 0 )
770 pwrite[0] = (FT_Byte)( pwrite[0] | ( *p++ & ( 0xFF00U >> w ) ) );
771 }
772 }
773 else /* x_pos > 0 */
774 {
775 for ( h = height; h > 0; h--, line += pitch )
776 {
777 FT_Byte* pwrite = line;
778 FT_Int w;
779 FT_UInt wval = 0;
780
781
782 for ( w = line_bits; w >= 8; w -= 8 )
783 {
784 wval = (FT_UInt)( wval | *p++ );
785 pwrite[0] = (FT_Byte)( pwrite[0] | ( wval >> x_pos ) );
786 pwrite += 1;
787 wval <<= 8;
788 }
789
790 if ( w > 0 )
791 wval = (FT_UInt)( wval | ( *p++ & ( 0xFF00U >> w ) ) );
792
793 /* all bits read and there are `x_pos + w' bits to be written */
794
795 pwrite[0] = (FT_Byte)( pwrite[0] | ( wval >> x_pos ) );
796
797 if ( x_pos + w > 8 )
798 {
799 pwrite++;
800 wval <<= 8;
801 pwrite[0] = (FT_Byte)( pwrite[0] | ( wval >> x_pos ) );
802 }
803 }
804 }
805
806 Exit:
807 if ( !error )
808 FT_TRACE3(( "tt_sbit_decoder_load_byte_aligned: loaded\n" ));
809 return error;
810 }
811
812
813 /*
814 * Load a bit-aligned bitmap (with pointer `p') into a line-aligned bitmap
815 * (with pointer `pwrite'). In the example below, the width is 3 pixel,
816 * and `x_pos' is 1 pixel.
817 *
818 * p p+1
819 * | | |
820 * | 7 6 5 4 3 2 1 0 | 7 6 5 4 3 2 1 0 |...
821 * | | |
822 * +-------+ +-------+ +-------+ ...
823 * . . .
824 * . . .
825 * v . .
826 * +-------+ . .
827 * | | .
828 * | 7 6 5 4 3 2 1 0 | .
829 * | | .
830 * pwrite . .
831 * . .
832 * v .
833 * +-------+ .
834 * | |
835 * | 7 6 5 4 3 2 1 0 |
836 * | |
837 * pwrite+1 .
838 * .
839 * v
840 * +-------+
841 * | |
842 * | 7 6 5 4 3 2 1 0 |
843 * | |
844 * pwrite+2
845 *
846 */
847
848 static FT_Error
849 tt_sbit_decoder_load_bit_aligned( TT_SBitDecoder decoder,
850 FT_Byte* p,
851 FT_Byte* limit,
852 FT_Int x_pos,
853 FT_Int y_pos,
854 FT_UInt recurse_count )
855 {
856 FT_Error error = FT_Err_Ok;
857 FT_Byte* line;
858 FT_Int pitch, width, height, line_bits, h, nbits;
859 FT_UInt bit_height, bit_width;
860 FT_Bitmap* bitmap;
861 FT_UShort rval;
862
863 FT_UNUSED( recurse_count );
864
865
866 /* check that we can write the glyph into the bitmap */
867 bitmap = decoder->bitmap;
868 bit_width = bitmap->width;
869 bit_height = bitmap->rows;
870 pitch = bitmap->pitch;
871 line = bitmap->buffer;
872
873 width = decoder->metrics->width;
874 height = decoder->metrics->height;
875
876 line_bits = width * decoder->bit_depth;
877
878 if ( x_pos < 0 || (FT_UInt)( x_pos + width ) > bit_width ||
879 y_pos < 0 || (FT_UInt)( y_pos + height ) > bit_height )
880 {
881 FT_TRACE1(( "tt_sbit_decoder_load_bit_aligned:"
882 " invalid bitmap dimensions\n" ));
883 error = FT_THROW( Invalid_File_Format );
884 goto Exit;
885 }
886
887 if ( p + ( ( line_bits * height + 7 ) >> 3 ) > limit )
888 {
889 FT_TRACE1(( "tt_sbit_decoder_load_bit_aligned: broken bitmap\n" ));
890 error = FT_THROW( Invalid_File_Format );
891 goto Exit;
892 }
893
894 if ( !line_bits || !height )
895 {
896 /* nothing to do */
897 goto Exit;
898 }
899
900 /* now do the blit */
901
902 /* adjust `line' to point to the first byte of the bitmap */
903 line += y_pos * pitch + ( x_pos >> 3 );
904 x_pos &= 7;
905
906 /* the higher byte of `rval' is used as a buffer */
907 rval = 0;
908 nbits = 0;
909
910 for ( h = height; h > 0; h--, line += pitch )
911 {
912 FT_Byte* pwrite = line;
913 FT_Int w = line_bits;
914
915
916 /* handle initial byte (in target bitmap) specially if necessary */
917 if ( x_pos )
918 {
919 w = ( line_bits < 8 - x_pos ) ? line_bits : 8 - x_pos;
920
921 if ( h == height )
922 {
923 rval = *p++;
924 nbits = x_pos;
925 }
926 else if ( nbits < w )
927 {
928 if ( p < limit )
929 rval |= *p++;
930 nbits += 8 - w;
931 }
932 else
933 {
934 rval >>= 8;
935 nbits -= w;
936 }
937
938 *pwrite++ |= ( ( rval >> nbits ) & 0xFF ) &
939 ( ~( 0xFFU << w ) << ( 8 - w - x_pos ) );
940 rval <<= 8;
941
942 w = line_bits - w;
943 }
944
945 /* handle medial bytes */
946 for ( ; w >= 8; w -= 8 )
947 {
948 rval |= *p++;
949 *pwrite++ |= ( rval >> nbits ) & 0xFF;
950
951 rval <<= 8;
952 }
953
954 /* handle final byte if necessary */
955 if ( w > 0 )
956 {
957 if ( nbits < w )
958 {
959 if ( p < limit )
960 rval |= *p++;
961 *pwrite |= ( ( rval >> nbits ) & 0xFF ) & ( 0xFF00U >> w );
962 nbits += 8 - w;
963
964 rval <<= 8;
965 }
966 else
967 {
968 *pwrite |= ( ( rval >> nbits ) & 0xFF ) & ( 0xFF00U >> w );
969 nbits -= w;
970 }
971 }
972 }
973
974 Exit:
975 if ( !error )
976 FT_TRACE3(( "tt_sbit_decoder_load_bit_aligned: loaded\n" ));
977 return error;
978 }
979
980
981 static FT_Error
982 tt_sbit_decoder_load_compound( TT_SBitDecoder decoder,
983 FT_Byte* p,
984 FT_Byte* limit,
985 FT_Int x_pos,
986 FT_Int y_pos,
987 FT_UInt recurse_count )
988 {
989 FT_Error error = FT_Err_Ok;
990 FT_UInt num_components, nn;
991
992 FT_Char horiBearingX = (FT_Char)decoder->metrics->horiBearingX;
993 FT_Char horiBearingY = (FT_Char)decoder->metrics->horiBearingY;
994 FT_Byte horiAdvance = (FT_Byte)decoder->metrics->horiAdvance;
995 FT_Char vertBearingX = (FT_Char)decoder->metrics->vertBearingX;
996 FT_Char vertBearingY = (FT_Char)decoder->metrics->vertBearingY;
997 FT_Byte vertAdvance = (FT_Byte)decoder->metrics->vertAdvance;
998
999
1000 if ( p + 2 > limit )
1001 goto Fail;
1002
1003 num_components = FT_NEXT_USHORT( p );
1004 if ( p + 4 * num_components > limit )
1005 {
1006 FT_TRACE1(( "tt_sbit_decoder_load_compound: broken table\n" ));
1007 goto Fail;
1008 }
1009
1010 FT_TRACE3(( "tt_sbit_decoder_load_compound: loading %d component%s\n",
1011 num_components,
1012 num_components == 1 ? "" : "s" ));
1013
1014 for ( nn = 0; nn < num_components; nn++ )
1015 {
1016 FT_UInt gindex = FT_NEXT_USHORT( p );
1017 FT_Byte dx = FT_NEXT_BYTE( p );
1018 FT_Byte dy = FT_NEXT_BYTE( p );
1019
1020
1021 /* NB: a recursive call */
1022 error = tt_sbit_decoder_load_image( decoder,
1023 gindex,
1024 x_pos + dx,
1025 y_pos + dy,
1026 recurse_count + 1,
1027 /* request full bitmap image */
1028 FALSE );
1029 if ( error )
1030 break;
1031 }
1032
1033 FT_TRACE3(( "tt_sbit_decoder_load_compound: done\n" ));
1034
1035 decoder->metrics->horiBearingX = horiBearingX;
1036 decoder->metrics->horiBearingY = horiBearingY;
1037 decoder->metrics->horiAdvance = horiAdvance;
1038 decoder->metrics->vertBearingX = vertBearingX;
1039 decoder->metrics->vertBearingY = vertBearingY;
1040 decoder->metrics->vertAdvance = vertAdvance;
1041 decoder->metrics->width = (FT_Byte)decoder->bitmap->width;
1042 decoder->metrics->height = (FT_Byte)decoder->bitmap->rows;
1043
1044 Exit:
1045 return error;
1046
1047 Fail:
1048 error = FT_THROW( Invalid_File_Format );
1049 goto Exit;
1050 }
1051
1052
1053 #ifdef FT_CONFIG_OPTION_USE_PNG
1054
1055 static FT_Error
1056 tt_sbit_decoder_load_png( TT_SBitDecoder decoder,
1057 FT_Byte* p,
1058 FT_Byte* limit,
1059 FT_Int x_pos,
1060 FT_Int y_pos,
1061 FT_UInt recurse_count )
1062 {
1063 FT_Error error = FT_Err_Ok;
1064 FT_ULong png_len;
1065
1066 FT_UNUSED( recurse_count );
1067
1068
1069 if ( limit - p < 4 )
1070 {
1071 FT_TRACE1(( "tt_sbit_decoder_load_png: broken bitmap\n" ));
1072 error = FT_THROW( Invalid_File_Format );
1073 goto Exit;
1074 }
1075
1076 png_len = FT_NEXT_ULONG( p );
1077 if ( (FT_ULong)( limit - p ) < png_len )
1078 {
1079 FT_TRACE1(( "tt_sbit_decoder_load_png: broken bitmap\n" ));
1080 error = FT_THROW( Invalid_File_Format );
1081 goto Exit;
1082 }
1083
1084 error = Load_SBit_Png( decoder->face->root.glyph,
1085 x_pos,
1086 y_pos,
1087 decoder->bit_depth,
1088 decoder->metrics,
1089 decoder->stream->memory,
1090 p,
1091 png_len,
1092 FALSE,
1093 FALSE );
1094
1095 Exit:
1096 if ( !error )
1097 FT_TRACE3(( "tt_sbit_decoder_load_png: loaded\n" ));
1098 return error;
1099 }
1100
1101 #endif /* FT_CONFIG_OPTION_USE_PNG */
1102
1103
1104 static FT_Error
1105 tt_sbit_decoder_load_bitmap( TT_SBitDecoder decoder,
1106 FT_UInt glyph_format,
1107 FT_ULong glyph_start,
1108 FT_ULong glyph_size,
1109 FT_Int x_pos,
1110 FT_Int y_pos,
1111 FT_UInt recurse_count,
1112 FT_Bool metrics_only )
1113 {
1114 FT_Error error;
1115 FT_Stream stream = decoder->stream;
1116 FT_Byte* p;
1117 FT_Byte* p_limit;
1118 FT_Byte* data;
1119
1120
1121 /* seek into the EBDT table now */
1122 if ( !glyph_size ||
1123 glyph_start + glyph_size > decoder->ebdt_size )
1124 {
1125 error = FT_THROW( Invalid_Argument );
1126 goto Exit;
1127 }
1128
1129 if ( FT_STREAM_SEEK( decoder->ebdt_start + glyph_start ) ||
1130 FT_FRAME_EXTRACT( glyph_size, data ) )
1131 goto Exit;
1132
1133 p = data;
1134 p_limit = p + glyph_size;
1135
1136 /* read the data, depending on the glyph format */
1137 switch ( glyph_format )
1138 {
1139 case 1:
1140 case 2:
1141 case 8:
1142 case 17:
1143 error = tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 0 );
1144 break;
1145
1146 case 6:
1147 case 7:
1148 case 9:
1149 case 18:
1150 error = tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 );
1151 break;
1152
1153 default:
1154 error = FT_Err_Ok;
1155 }
1156
1157 if ( error )
1158 goto Fail;
1159
1160 {
1161 TT_SBitDecoder_LoadFunc loader;
1162
1163
1164 switch ( glyph_format )
1165 {
1166 case 1:
1167 case 6:
1168 loader = tt_sbit_decoder_load_byte_aligned;
1169 break;
1170
1171 case 2:
1172 case 7:
1173 {
1174 /* Don't trust `glyph_format'. For example, Apple's main Korean */
1175 /* system font, `AppleMyungJo.ttf' (version 7.0d2e6), uses glyph */
1176 /* format 7, but the data is format 6. We check whether we have */
1177 /* an excessive number of bytes in the image: If it is equal to */
1178 /* the value for a byte-aligned glyph, use the other loading */
1179 /* routine. */
1180 /* */
1181 /* Note that for some (width,height) combinations, where the */
1182 /* width is not a multiple of 8, the sizes for bit- and */
1183 /* byte-aligned data are equal, for example (7,7) or (15,6). We */
1184 /* then prefer what `glyph_format' specifies. */
1185
1186 FT_UInt width = decoder->metrics->width;
1187 FT_UInt height = decoder->metrics->height;
1188
1189 FT_UInt bit_size = ( width * height + 7 ) >> 3;
1190 FT_UInt byte_size = height * ( ( width + 7 ) >> 3 );
1191
1192
1193 if ( bit_size < byte_size &&
1194 byte_size == (FT_UInt)( p_limit - p ) )
1195 loader = tt_sbit_decoder_load_byte_aligned;
1196 else
1197 loader = tt_sbit_decoder_load_bit_aligned;
1198 }
1199 break;
1200
1201 case 5:
1202 loader = tt_sbit_decoder_load_bit_aligned;
1203 break;
1204
1205 case 8:
1206 if ( p + 1 > p_limit )
1207 goto Fail;
1208
1209 p += 1; /* skip padding */
1210 /* fall-through */
1211
1212 case 9:
1213 loader = tt_sbit_decoder_load_compound;
1214 break;
1215
1216 case 17: /* small metrics, PNG image data */
1217 case 18: /* big metrics, PNG image data */
1218 case 19: /* metrics in EBLC, PNG image data */
1219 #ifdef FT_CONFIG_OPTION_USE_PNG
1220 loader = tt_sbit_decoder_load_png;
1221 break;
1222 #else
1223 error = FT_THROW( Unimplemented_Feature );
1224 goto Fail;
1225 #endif /* FT_CONFIG_OPTION_USE_PNG */
1226
1227 default:
1228 error = FT_THROW( Invalid_Table );
1229 goto Fail;
1230 }
1231
1232 if ( !decoder->bitmap_allocated )
1233 {
1234 error = tt_sbit_decoder_alloc_bitmap( decoder, metrics_only );
1235
1236 if ( error )
1237 goto Fail;
1238 }
1239
1240 if ( metrics_only )
1241 goto Fail; /* this is not an error */
1242
1243 error = loader( decoder, p, p_limit, x_pos, y_pos, recurse_count );
1244 }
1245
1246 Fail:
1247 FT_FRAME_RELEASE( data );
1248
1249 Exit:
1250 return error;
1251 }
1252
1253
1254 static FT_Error
1255 tt_sbit_decoder_load_image( TT_SBitDecoder decoder,
1256 FT_UInt glyph_index,
1257 FT_Int x_pos,
1258 FT_Int y_pos,
1259 FT_UInt recurse_count,
1260 FT_Bool metrics_only )
1261 {
1262 FT_Byte* p = decoder->eblc_base + decoder->strike_index_array;
1263 FT_Byte* p_limit = decoder->eblc_limit;
1264 FT_ULong num_ranges = decoder->strike_index_count;
1265 FT_UInt start, end, index_format, image_format;
1266 FT_ULong image_start = 0, image_end = 0, image_offset;
1267
1268
1269 /* arbitrary recursion limit */
1270 if ( recurse_count > 100 )
1271 {
1272 FT_TRACE4(( "tt_sbit_decoder_load_image:"
1273 " recursion depth exceeded\n" ));
1274 goto Failure;
1275 }
1276
1277
1278 /* First, we find the correct strike range that applies to this */
1279 /* glyph index. */
1280 for ( ; num_ranges > 0; num_ranges-- )
1281 {
1282 start = FT_NEXT_USHORT( p );
1283 end = FT_NEXT_USHORT( p );
1284
1285 if ( glyph_index >= start && glyph_index <= end )
1286 goto FoundRange;
1287
1288 p += 4; /* ignore index offset */
1289 }
1290 goto NoBitmap;
1291
1292 FoundRange:
1293 image_offset = FT_NEXT_ULONG( p );
1294
1295 /* overflow check */
1296 p = decoder->eblc_base + decoder->strike_index_array;
1297 if ( image_offset > (FT_ULong)( p_limit - p ) )
1298 goto Failure;
1299
1300 p += image_offset;
1301 if ( p + 8 > p_limit )
1302 goto NoBitmap;
1303
1304 /* now find the glyph's location and extend within the ebdt table */
1305 index_format = FT_NEXT_USHORT( p );
1306 image_format = FT_NEXT_USHORT( p );
1307 image_offset = FT_NEXT_ULONG ( p );
1308
1309 switch ( index_format )
1310 {
1311 case 1: /* 4-byte offsets relative to `image_offset' */
1312 p += 4 * ( glyph_index - start );
1313 if ( p + 8 > p_limit )
1314 goto NoBitmap;
1315
1316 image_start = FT_NEXT_ULONG( p );
1317 image_end = FT_NEXT_ULONG( p );
1318
1319 if ( image_start == image_end ) /* missing glyph */
1320 goto NoBitmap;
1321 break;
1322
1323 case 2: /* big metrics, constant image size */
1324 {
1325 FT_ULong image_size;
1326
1327
1328 if ( p + 12 > p_limit )
1329 goto NoBitmap;
1330
1331 image_size = FT_NEXT_ULONG( p );
1332
1333 if ( tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 ) )
1334 goto NoBitmap;
1335
1336 image_start = image_size * ( glyph_index - start );
1337 image_end = image_start + image_size;
1338 }
1339 break;
1340
1341 case 3: /* 2-byte offsets relative to 'image_offset' */
1342 p += 2 * ( glyph_index - start );
1343 if ( p + 4 > p_limit )
1344 goto NoBitmap;
1345
1346 image_start = FT_NEXT_USHORT( p );
1347 image_end = FT_NEXT_USHORT( p );
1348
1349 if ( image_start == image_end ) /* missing glyph */
1350 goto NoBitmap;
1351 break;
1352
1353 case 4: /* sparse glyph array with (glyph,offset) pairs */
1354 {
1355 FT_ULong mm, num_glyphs;
1356
1357
1358 if ( p + 4 > p_limit )
1359 goto NoBitmap;
1360
1361 num_glyphs = FT_NEXT_ULONG( p );
1362
1363 /* overflow check for p + ( num_glyphs + 1 ) * 4 */
1364 if ( p + 4 > p_limit ||
1365 num_glyphs > (FT_ULong)( ( ( p_limit - p ) >> 2 ) - 1 ) )
1366 goto NoBitmap;
1367
1368 for ( mm = 0; mm < num_glyphs; mm++ )
1369 {
1370 FT_UInt gindex = FT_NEXT_USHORT( p );
1371
1372
1373 if ( gindex == glyph_index )
1374 {
1375 image_start = FT_NEXT_USHORT( p );
1376 p += 2;
1377 image_end = FT_PEEK_USHORT( p );
1378 break;
1379 }
1380 p += 2;
1381 }
1382
1383 if ( mm >= num_glyphs )
1384 goto NoBitmap;
1385 }
1386 break;
1387
1388 case 5: /* constant metrics with sparse glyph codes */
1389 case 19:
1390 {
1391 FT_ULong image_size, mm, num_glyphs;
1392
1393
1394 if ( p + 16 > p_limit )
1395 goto NoBitmap;
1396
1397 image_size = FT_NEXT_ULONG( p );
1398
1399 if ( tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 ) )
1400 goto NoBitmap;
1401
1402 num_glyphs = FT_NEXT_ULONG( p );
1403
1404 /* overflow check for p + 2 * num_glyphs */
1405 if ( num_glyphs > (FT_ULong)( ( p_limit - p ) >> 1 ) )
1406 goto NoBitmap;
1407
1408 for ( mm = 0; mm < num_glyphs; mm++ )
1409 {
1410 FT_UInt gindex = FT_NEXT_USHORT( p );
1411
1412
1413 if ( gindex == glyph_index )
1414 break;
1415 }
1416
1417 if ( mm >= num_glyphs )
1418 goto NoBitmap;
1419
1420 image_start = image_size * mm;
1421 image_end = image_start + image_size;
1422 }
1423 break;
1424
1425 default:
1426 goto NoBitmap;
1427 }
1428
1429 if ( image_start > image_end )
1430 goto NoBitmap;
1431
1432 image_end -= image_start;
1433 image_start = image_offset + image_start;
1434
1435 FT_TRACE3(( "tt_sbit_decoder_load_image:"
1436 " found sbit (format %d) for glyph index %d\n",
1437 image_format, glyph_index ));
1438
1439 return tt_sbit_decoder_load_bitmap( decoder,
1440 image_format,
1441 image_start,
1442 image_end,
1443 x_pos,
1444 y_pos,
1445 recurse_count,
1446 metrics_only );
1447
1448 Failure:
1449 return FT_THROW( Invalid_Table );
1450
1451 NoBitmap:
1452 if ( recurse_count )
1453 {
1454 FT_TRACE4(( "tt_sbit_decoder_load_image:"
1455 " missing subglyph sbit with glyph index %d\n",
1456 glyph_index ));
1457 return FT_THROW( Invalid_Composite );
1458 }
1459
1460 FT_TRACE4(( "tt_sbit_decoder_load_image:"
1461 " no sbit found for glyph index %d\n", glyph_index ));
1462 return FT_THROW( Missing_Bitmap );
1463 }
1464
1465
1466 static FT_Error
1467 tt_face_load_sbix_image( TT_Face face,
1468 FT_ULong strike_index,
1469 FT_UInt glyph_index,
1470 FT_Stream stream,
1471 FT_Bitmap *map,
1472 TT_SBit_MetricsRec *metrics,
1473 FT_Bool metrics_only )
1474 {
1475 FT_UInt strike_offset, glyph_start, glyph_end;
1476 FT_Int originOffsetX, originOffsetY;
1477 FT_Tag graphicType;
1478 FT_Int recurse_depth = 0;
1479
1480 FT_Error error;
1481 FT_Byte* p;
1482
1483 FT_UNUSED( map );
1484 #ifndef FT_CONFIG_OPTION_USE_PNG
1485 FT_UNUSED( metrics_only );
1486 #endif
1487
1488
1489 strike_index = face->sbit_strike_map[strike_index];
1490
1491 metrics->width = 0;
1492 metrics->height = 0;
1493
1494 p = face->sbit_table + 8 + 4 * strike_index;
1495 strike_offset = FT_NEXT_ULONG( p );
1496
1497 retry:
1498 if ( glyph_index > (FT_UInt)face->root.num_glyphs )
1499 return FT_THROW( Invalid_Argument );
1500
1501 if ( strike_offset >= face->ebdt_size ||
1502 face->ebdt_size - strike_offset < 4 + glyph_index * 4 + 8 )
1503 return FT_THROW( Invalid_File_Format );
1504
1505 if ( FT_STREAM_SEEK( face->ebdt_start +
1506 strike_offset + 4 +
1507 glyph_index * 4 ) ||
1508 FT_FRAME_ENTER( 8 ) )
1509 return error;
1510
1511 glyph_start = FT_GET_ULONG();
1512 glyph_end = FT_GET_ULONG();
1513
1514 FT_FRAME_EXIT();
1515
1516 if ( glyph_start == glyph_end )
1517 return FT_THROW( Missing_Bitmap );
1518 if ( glyph_start > glyph_end ||
1519 glyph_end - glyph_start < 8 ||
1520 face->ebdt_size - strike_offset < glyph_end )
1521 return FT_THROW( Invalid_File_Format );
1522
1523 if ( FT_STREAM_SEEK( face->ebdt_start + strike_offset + glyph_start ) ||
1524 FT_FRAME_ENTER( glyph_end - glyph_start ) )
1525 return error;
1526
1527 originOffsetX = FT_GET_SHORT();
1528 originOffsetY = FT_GET_SHORT();
1529
1530 graphicType = FT_GET_TAG4();
1531
1532 switch ( graphicType )
1533 {
1534 case FT_MAKE_TAG( 'd', 'u', 'p', 'e' ):
1535 if ( recurse_depth < 4 )
1536 {
1537 glyph_index = FT_GET_USHORT();
1538 FT_FRAME_EXIT();
1539 recurse_depth++;
1540 goto retry;
1541 }
1542 error = FT_THROW( Invalid_File_Format );
1543 break;
1544
1545 case FT_MAKE_TAG( 'p', 'n', 'g', ' ' ):
1546 #ifdef FT_CONFIG_OPTION_USE_PNG
1547 error = Load_SBit_Png( face->root.glyph,
1548 0,
1549 0,
1550 32,
1551 metrics,
1552 stream->memory,
1553 stream->cursor,
1554 glyph_end - glyph_start - 8,
1555 TRUE,
1556 metrics_only );
1557 #else
1558 error = FT_THROW( Unimplemented_Feature );
1559 #endif
1560 break;
1561
1562 case FT_MAKE_TAG( 'j', 'p', 'g', ' ' ):
1563 case FT_MAKE_TAG( 't', 'i', 'f', 'f' ):
1564 case FT_MAKE_TAG( 'r', 'g', 'b', 'l' ): /* used on iOS 7.1 */
1565 error = FT_THROW( Unknown_File_Format );
1566 break;
1567
1568 default:
1569 error = FT_THROW( Unimplemented_Feature );
1570 break;
1571 }
1572
1573 FT_FRAME_EXIT();
1574
1575 if ( !error )
1576 {
1577 FT_Short abearing;
1578 FT_UShort aadvance;
1579
1580
1581 tt_face_get_metrics( face, FALSE, glyph_index, &abearing, &aadvance );
1582
1583 metrics->horiBearingX = (FT_Short)originOffsetX;
1584 metrics->horiBearingY = (FT_Short)( -originOffsetY + metrics->height );
1585 metrics->horiAdvance = (FT_UShort)( aadvance *
1586 face->root.size->metrics.x_ppem /
1587 face->header.Units_Per_EM );
1588 }
1589
1590 return error;
1591 }
1592
1593 FT_LOCAL( FT_Error )
1594 tt_face_load_sbit_image( TT_Face face,
1595 FT_ULong strike_index,
1596 FT_UInt glyph_index,
1597 FT_UInt load_flags,
1598 FT_Stream stream,
1599 FT_Bitmap *map,
1600 TT_SBit_MetricsRec *metrics )
1601 {
1602 FT_Error error = FT_Err_Ok;
1603
1604
1605 switch ( (FT_UInt)face->sbit_table_type )
1606 {
1607 case TT_SBIT_TABLE_TYPE_EBLC:
1608 case TT_SBIT_TABLE_TYPE_CBLC:
1609 {
1610 TT_SBitDecoderRec decoder[1];
1611
1612
1613 error = tt_sbit_decoder_init( decoder, face, strike_index, metrics );
1614 if ( !error )
1615 {
1616 error = tt_sbit_decoder_load_image(
1617 decoder,
1618 glyph_index,
1619 0,
1620 0,
1621 0,
1622 ( load_flags & FT_LOAD_BITMAP_METRICS_ONLY ) != 0 );
1623 tt_sbit_decoder_done( decoder );
1624 }
1625 }
1626 break;
1627
1628 case TT_SBIT_TABLE_TYPE_SBIX:
1629 error = tt_face_load_sbix_image(
1630 face,
1631 strike_index,
1632 glyph_index,
1633 stream,
1634 map,
1635 metrics,
1636 ( load_flags & FT_LOAD_BITMAP_METRICS_ONLY ) != 0 );
1637 break;
1638
1639 default:
1640 error = FT_THROW( Unknown_File_Format );
1641 break;
1642 }
1643
1644 /* Flatten color bitmaps if color was not requested. */
1645 if ( !error &&
1646 !( load_flags & FT_LOAD_COLOR ) &&
1647 !( load_flags & FT_LOAD_BITMAP_METRICS_ONLY ) &&
1648 map->pixel_mode == FT_PIXEL_MODE_BGRA )
1649 {
1650 FT_Bitmap new_map;
1651 FT_Library library = face->root.glyph->library;
1652
1653
1654 FT_Bitmap_Init( &new_map );
1655
1656 /* Convert to 8bit grayscale. */
1657 error = FT_Bitmap_Convert( library, map, &new_map, 1 );
1658 if ( error )
1659 FT_Bitmap_Done( library, &new_map );
1660 else
1661 {
1662 map->pixel_mode = new_map.pixel_mode;
1663 map->pitch = new_map.pitch;
1664 map->num_grays = new_map.num_grays;
1665
1666 ft_glyphslot_set_bitmap( face->root.glyph, new_map.buffer );
1667 face->root.glyph->internal->flags |= FT_GLYPH_OWN_BITMAP;
1668 }
1669 }
1670
1671 return error;
1672 }
1673
1674 #else /* !TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
1675
1676 /* ANSI C doesn't like empty source files */
1677 typedef int _tt_sbit_dummy;
1678
1679 #endif /* !TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
1680
1681
1682 /* END */