projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Sync trunk.
[reactos.git] / lib / 3rdparty / freetype / src / sfnt / ttsbit0.c
1 /***************************************************************************/
2 /* */
3 /* ttsbit0.c */
4 /* */
5 /* TrueType and OpenType embedded bitmap support (body). */
6 /* This is a heap-optimized version. */
7 /* */
8 /* Copyright 2005, 2006, 2007, 2008, 2009 by */
9 /* David Turner, Robert Wilhelm, and Werner Lemberg. */
10 /* */
11 /* This file is part of the FreeType project, and may only be used, */
12 /* modified, and distributed under the terms of the FreeType project */
13 /* license, LICENSE.TXT. By continuing to use, modify, or distribute */
14 /* this file you indicate that you have read the license and */
15 /* understand and accept it fully. */
16 /* */
17 /***************************************************************************/
18
19
20 /* This file is included by ttsbit.c */
21
22
23 #include <ft2build.h>
24 #include FT_INTERNAL_DEBUG_H
25 #include FT_INTERNAL_STREAM_H
26 #include FT_TRUETYPE_TAGS_H
27 #include "ttsbit.h"
28
29 #include "sferrors.h"
30
31
32 /*************************************************************************/
33 /* */
34 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
35 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
36 /* messages during execution. */
37 /* */
38 #undef FT_COMPONENT
39 #define FT_COMPONENT trace_ttsbit
40
41
42 FT_LOCAL_DEF( FT_Error )
43 tt_face_load_eblc( TT_Face face,
44 FT_Stream stream )
45 {
46 FT_Error error = SFNT_Err_Ok;
47 FT_Fixed version;
48 FT_ULong num_strikes, table_size;
49 FT_Byte* p;
50 FT_Byte* p_limit;
51 FT_UInt count;
52
53
54 face->sbit_num_strikes = 0;
55
56 /* this table is optional */
57 error = face->goto_table( face, TTAG_EBLC, stream, &table_size );
58 if ( error )
59 error = face->goto_table( face, TTAG_bloc, stream, &table_size );
60 if ( error )
61 goto Exit;
62
63 if ( table_size < 8 )
64 {
65 FT_ERROR(( "tt_face_load_sbit_strikes: table too short\n" ));
66 error = SFNT_Err_Invalid_File_Format;
67 goto Exit;
68 }
69
70 if ( FT_FRAME_EXTRACT( table_size, face->sbit_table ) )
71 goto Exit;
72
73 face->sbit_table_size = table_size;
74
75 p = face->sbit_table;
76 p_limit = p + table_size;
77
78 version = FT_NEXT_ULONG( p );
79 num_strikes = FT_NEXT_ULONG( p );
80
81 if ( version != 0x00020000UL || num_strikes >= 0x10000UL )
82 {
83 FT_ERROR(( "tt_face_load_sbit_strikes: invalid table version\n" ));
84 error = SFNT_Err_Invalid_File_Format;
85 goto Fail;
86 }
87
88 /*
89 * Count the number of strikes available in the table. We are a bit
90 * paranoid there and don't trust the data.
91 */
92 count = (FT_UInt)num_strikes;
93 if ( 8 + 48UL * count > table_size )
94 count = (FT_UInt)( ( p_limit - p ) / 48 );
95
96 face->sbit_num_strikes = count;
97
98 FT_TRACE3(( "sbit_num_strikes: %u\n", count ));
99 Exit:
100 return error;
101
102 Fail:
103 FT_FRAME_RELEASE( face->sbit_table );
104 face->sbit_table_size = 0;
105 goto Exit;
106 }
107
108
109 FT_LOCAL_DEF( void )
110 tt_face_free_eblc( TT_Face face )
111 {
112 FT_Stream stream = face->root.stream;
113
114
115 FT_FRAME_RELEASE( face->sbit_table );
116 face->sbit_table_size = 0;
117 face->sbit_num_strikes = 0;
118 }
119
120
121 FT_LOCAL_DEF( FT_Error )
122 tt_face_set_sbit_strike( TT_Face face,
123 FT_Size_Request req,
124 FT_ULong* astrike_index )
125 {
126 return FT_Match_Size( (FT_Face)face, req, 0, astrike_index );
127 }
128
129
130 FT_LOCAL_DEF( FT_Error )
131 tt_face_load_strike_metrics( TT_Face face,
132 FT_ULong strike_index,
133 FT_Size_Metrics* metrics )
134 {
135 FT_Byte* strike;
136
137
138 if ( strike_index >= (FT_ULong)face->sbit_num_strikes )
139 return SFNT_Err_Invalid_Argument;
140
141 strike = face->sbit_table + 8 + strike_index * 48;
142
143 metrics->x_ppem = (FT_UShort)strike[44];
144 metrics->y_ppem = (FT_UShort)strike[45];
145
146 metrics->ascender = (FT_Char)strike[16] << 6; /* hori.ascender */
147 metrics->descender = (FT_Char)strike[17] << 6; /* hori.descender */
148 metrics->height = metrics->ascender - metrics->descender;
149
150 /* XXX: Is this correct? */
151 metrics->max_advance = ( (FT_Char)strike[22] + /* min_origin_SB */
152 strike[18] + /* max_width */
153 (FT_Char)strike[23] /* min_advance_SB */
154 ) << 6;
155
156 return SFNT_Err_Ok;
157 }
158
159
160 typedef struct TT_SBitDecoderRec_
161 {
162 TT_Face face;
163 FT_Stream stream;
164 FT_Bitmap* bitmap;
165 TT_SBit_Metrics metrics;
166 FT_Bool metrics_loaded;
167 FT_Bool bitmap_allocated;
168 FT_Byte bit_depth;
169
170 FT_ULong ebdt_start;
171 FT_ULong ebdt_size;
172
173 FT_ULong strike_index_array;
174 FT_ULong strike_index_count;
175 FT_Byte* eblc_base;
176 FT_Byte* eblc_limit;
177
178 } TT_SBitDecoderRec, *TT_SBitDecoder;
179
180
181 static FT_Error
182 tt_sbit_decoder_init( TT_SBitDecoder decoder,
183 TT_Face face,
184 FT_ULong strike_index,
185 TT_SBit_MetricsRec* metrics )
186 {
187 FT_Error error;
188 FT_Stream stream = face->root.stream;
189 FT_ULong ebdt_size;
190
191
192 error = face->goto_table( face, TTAG_EBDT, stream, &ebdt_size );
193 if ( error )
194 error = face->goto_table( face, TTAG_bdat, stream, &ebdt_size );
195 if ( error )
196 goto Exit;
197
198 decoder->face = face;
199 decoder->stream = stream;
200 decoder->bitmap = &face->root.glyph->bitmap;
201 decoder->metrics = metrics;
202
203 decoder->metrics_loaded = 0;
204 decoder->bitmap_allocated = 0;
205
206 decoder->ebdt_start = FT_STREAM_POS();
207 decoder->ebdt_size = ebdt_size;
208
209 decoder->eblc_base = face->sbit_table;
210 decoder->eblc_limit = face->sbit_table + face->sbit_table_size;
211
212 /* now find the strike corresponding to the index */
213 {
214 FT_Byte* p;
215
216
217 if ( 8 + 48 * strike_index + 3 * 4 + 34 + 1 > face->sbit_table_size )
218 {
219 error = SFNT_Err_Invalid_File_Format;
220 goto Exit;
221 }
222
223 p = decoder->eblc_base + 8 + 48 * strike_index;
224
225 decoder->strike_index_array = FT_NEXT_ULONG( p );
226 p += 4;
227 decoder->strike_index_count = FT_NEXT_ULONG( p );
228 p += 34;
229 decoder->bit_depth = *p;
230
231 if ( decoder->strike_index_array > face->sbit_table_size ||
232 decoder->strike_index_array + 8 * decoder->strike_index_count >
233 face->sbit_table_size )
234 error = SFNT_Err_Invalid_File_Format;
235 }
236
237 Exit:
238 return error;
239 }
240
241
242 static void
243 tt_sbit_decoder_done( TT_SBitDecoder decoder )
244 {
245 FT_UNUSED( decoder );
246 }
247
248
249 static FT_Error
250 tt_sbit_decoder_alloc_bitmap( TT_SBitDecoder decoder )
251 {
252 FT_Error error = SFNT_Err_Ok;
253 FT_UInt width, height;
254 FT_Bitmap* map = decoder->bitmap;
255 FT_Long size;
256
257
258 if ( !decoder->metrics_loaded )
259 {
260 error = SFNT_Err_Invalid_Argument;
261 goto Exit;
262 }
263
264 width = decoder->metrics->width;
265 height = decoder->metrics->height;
266
267 map->width = (int)width;
268 map->rows = (int)height;
269
270 switch ( decoder->bit_depth )
271 {
272 case 1:
273 map->pixel_mode = FT_PIXEL_MODE_MONO;
274 map->pitch = ( map->width + 7 ) >> 3;
275 break;
276
277 case 2:
278 map->pixel_mode = FT_PIXEL_MODE_GRAY2;
279 map->pitch = ( map->width + 3 ) >> 2;
280 break;
281
282 case 4:
283 map->pixel_mode = FT_PIXEL_MODE_GRAY4;
284 map->pitch = ( map->width + 1 ) >> 1;
285 break;
286
287 case 8:
288 map->pixel_mode = FT_PIXEL_MODE_GRAY;
289 map->pitch = map->width;
290 break;
291
292 default:
293 error = SFNT_Err_Invalid_File_Format;
294 goto Exit;
295 }
296
297 size = map->rows * map->pitch;
298
299 /* check that there is no empty image */
300 if ( size == 0 )
301 goto Exit; /* exit successfully! */
302
303 error = ft_glyphslot_alloc_bitmap( decoder->face->root.glyph, size );
304 if ( error )
305 goto Exit;
306
307 decoder->bitmap_allocated = 1;
308
309 Exit:
310 return error;
311 }
312
313
314 static FT_Error
315 tt_sbit_decoder_load_metrics( TT_SBitDecoder decoder,
316 FT_Byte* *pp,
317 FT_Byte* limit,
318 FT_Bool big )
319 {
320 FT_Byte* p = *pp;
321 TT_SBit_Metrics metrics = decoder->metrics;
322
323
324 if ( p + 5 > limit )
325 goto Fail;
326
327 metrics->height = p[0];
328 metrics->width = p[1];
329 metrics->horiBearingX = (FT_Char)p[2];
330 metrics->horiBearingY = (FT_Char)p[3];
331 metrics->horiAdvance = p[4];
332
333 p += 5;
334 if ( big )
335 {
336 if ( p + 3 > limit )
337 goto Fail;
338
339 metrics->vertBearingX = (FT_Char)p[0];
340 metrics->vertBearingY = (FT_Char)p[1];
341 metrics->vertAdvance = p[2];
342
343 p += 3;
344 }
345
346 decoder->metrics_loaded = 1;
347 *pp = p;
348 return SFNT_Err_Ok;
349
350 Fail:
351 return SFNT_Err_Invalid_Argument;
352 }
353
354
355 /* forward declaration */
356 static FT_Error
357 tt_sbit_decoder_load_image( TT_SBitDecoder decoder,
358 FT_UInt glyph_index,
359 FT_Int x_pos,
360 FT_Int y_pos );
361
362 typedef FT_Error (*TT_SBitDecoder_LoadFunc)( TT_SBitDecoder decoder,
363 FT_Byte* p,
364 FT_Byte* plimit,
365 FT_Int x_pos,
366 FT_Int y_pos );
367
368
369 static FT_Error
370 tt_sbit_decoder_load_byte_aligned( TT_SBitDecoder decoder,
371 FT_Byte* p,
372 FT_Byte* limit,
373 FT_Int x_pos,
374 FT_Int y_pos )
375 {
376 FT_Error error = SFNT_Err_Ok;
377 FT_Byte* line;
378 FT_Int bit_height, bit_width, pitch, width, height, h;
379 FT_Bitmap* bitmap;
380
381
382 if ( !decoder->bitmap_allocated )
383 {
384 error = tt_sbit_decoder_alloc_bitmap( decoder );
385 if ( error )
386 goto Exit;
387 }
388
389 /* check that we can write the glyph into the bitmap */
390 bitmap = decoder->bitmap;
391 bit_width = bitmap->width;
392 bit_height = bitmap->rows;
393 pitch = bitmap->pitch;
394 line = bitmap->buffer;
395
396 width = decoder->metrics->width;
397 height = decoder->metrics->height;
398
399 if ( x_pos < 0 || x_pos + width > bit_width ||
400 y_pos < 0 || y_pos + height > bit_height )
401 {
402 error = SFNT_Err_Invalid_File_Format;
403 goto Exit;
404 }
405
406 if ( p + ( ( width + 7 ) >> 3 ) * height > limit )
407 {
408 error = SFNT_Err_Invalid_File_Format;
409 goto Exit;
410 }
411
412 /* now do the blit */
413 line += y_pos * pitch + ( x_pos >> 3 );
414 x_pos &= 7;
415
416 if ( x_pos == 0 ) /* the easy one */
417 {
418 for ( h = height; h > 0; h--, line += pitch )
419 {
420 FT_Byte* write = line;
421 FT_Int w;
422
423
424 for ( w = width; w >= 8; w -= 8 )
425 {
426 write[0] = (FT_Byte)( write[0] | *p++ );
427 write += 1;
428 }
429
430 if ( w > 0 )
431 write[0] = (FT_Byte)( write[0] | ( *p++ & ( 0xFF00U >> w ) ) );
432 }
433 }
434 else /* x_pos > 0 */
435 {
436 for ( h = height; h > 0; h--, line += pitch )
437 {
438 FT_Byte* write = line;
439 FT_Int w;
440 FT_UInt wval = 0;
441
442
443 for ( w = width; w >= 8; w -= 8 )
444 {
445 wval = (FT_UInt)( wval | *p++ );
446 write[0] = (FT_Byte)( write[0] | ( wval >> x_pos ) );
447 write += 1;
448 wval <<= 8;
449 }
450
451 if ( w > 0 )
452 wval = (FT_UInt)( wval | ( *p++ & ( 0xFF00U >> w ) ) );
453
454 /* all bits read and there are `x_pos + w' bits to be written */
455
456 write[0] = (FT_Byte)( write[0] | ( wval >> x_pos ) );
457
458 if ( x_pos + w > 8 )
459 {
460 write++;
461 wval <<= 8;
462 write[0] = (FT_Byte)( write[0] | ( wval >> x_pos ) );
463 }
464 }
465 }
466
467 Exit:
468 return error;
469 }
470
471
472 /*
473 * Load a bit-aligned bitmap (with pointer `p') into a line-aligned bitmap
474 * (with pointer `write'). In the example below, the width is 3 pixel,
475 * and `x_pos' is 1 pixel.
476 *
477 * p p+1
478 * | | |
479 * | 7 6 5 4 3 2 1 0 | 7 6 5 4 3 2 1 0 |...
480 * | | |
481 * +-------+ +-------+ +-------+ ...
482 * . . .
483 * . . .
484 * v . .
485 * +-------+ . .
486 * | | .
487 * | 7 6 5 4 3 2 1 0 | .
488 * | | .
489 * write . .
490 * . .
491 * v .
492 * +-------+ .
493 * | |
494 * | 7 6 5 4 3 2 1 0 |
495 * | |
496 * write+1 .
497 * .
498 * v
499 * +-------+
500 * | |
501 * | 7 6 5 4 3 2 1 0 |
502 * | |
503 * write+2
504 *
505 */
506
507 static FT_Error
508 tt_sbit_decoder_load_bit_aligned( TT_SBitDecoder decoder,
509 FT_Byte* p,
510 FT_Byte* limit,
511 FT_Int x_pos,
512 FT_Int y_pos )
513 {
514 FT_Error error = SFNT_Err_Ok;
515 FT_Byte* line;
516 FT_Int bit_height, bit_width, pitch, width, height, h, nbits;
517 FT_Bitmap* bitmap;
518 FT_UShort rval;
519
520
521 if ( !decoder->bitmap_allocated )
522 {
523 error = tt_sbit_decoder_alloc_bitmap( decoder );
524 if ( error )
525 goto Exit;
526 }
527
528 /* check that we can write the glyph into the bitmap */
529 bitmap = decoder->bitmap;
530 bit_width = bitmap->width;
531 bit_height = bitmap->rows;
532 pitch = bitmap->pitch;
533 line = bitmap->buffer;
534
535 width = decoder->metrics->width;
536 height = decoder->metrics->height;
537
538 if ( x_pos < 0 || x_pos + width > bit_width ||
539 y_pos < 0 || y_pos + height > bit_height )
540 {
541 error = SFNT_Err_Invalid_File_Format;
542 goto Exit;
543 }
544
545 if ( p + ( ( width * height + 7 ) >> 3 ) > limit )
546 {
547 error = SFNT_Err_Invalid_File_Format;
548 goto Exit;
549 }
550
551 /* now do the blit */
552
553 /* adjust `line' to point to the first byte of the bitmap */
554 line += y_pos * pitch + ( x_pos >> 3 );
555 x_pos &= 7;
556
557 /* the higher byte of `rval' is used as a buffer */
558 rval = 0;
559 nbits = 0;
560
561 for ( h = height; h > 0; h--, line += pitch )
562 {
563 FT_Byte* write = line;
564 FT_Int w = width;
565
566
567 /* handle initial byte (in target bitmap) specially if necessary */
568 if ( x_pos )
569 {
570 w = ( width < 8 - x_pos ) ? width : 8 - x_pos;
571
572 if ( h == height )
573 {
574 rval = *p++;
575 nbits = x_pos;
576 }
577 else if ( nbits < w )
578 {
579 if ( p < limit )
580 rval |= *p++;
581 nbits += 8 - w;
582 }
583 else
584 {
585 rval >>= 8;
586 nbits -= w;
587 }
588
589 *write++ |= ( ( rval >> nbits ) & 0xFF ) &
590 ( ~( 0xFF << w ) << ( 8 - w - x_pos ) );
591 rval <<= 8;
592
593 w = width - w;
594 }
595
596 /* handle medial bytes */
597 for ( ; w >= 8; w -= 8 )
598 {
599 rval |= *p++;
600 *write++ |= ( rval >> nbits ) & 0xFF;
601
602 rval <<= 8;
603 }
604
605 /* handle final byte if necessary */
606 if ( w > 0 )
607 {
608 if ( nbits < w )
609 {
610 if ( p < limit )
611 rval |= *p++;
612 *write |= ( ( rval >> nbits ) & 0xFF ) & ( 0xFF00U >> w );
613 nbits += 8 - w;
614
615 rval <<= 8;
616 }
617 else
618 {
619 *write |= ( ( rval >> nbits ) & 0xFF ) & ( 0xFF00U >> w );
620 nbits -= w;
621 }
622 }
623 }
624
625 Exit:
626 return error;
627 }
628
629
630 static FT_Error
631 tt_sbit_decoder_load_compound( TT_SBitDecoder decoder,
632 FT_Byte* p,
633 FT_Byte* limit,
634 FT_Int x_pos,
635 FT_Int y_pos )
636 {
637 FT_Error error = SFNT_Err_Ok;
638 FT_UInt num_components, nn;
639
640 FT_Char horiBearingX = decoder->metrics->horiBearingX;
641 FT_Char horiBearingY = decoder->metrics->horiBearingY;
642 FT_Byte horiAdvance = decoder->metrics->horiAdvance;
643 FT_Char vertBearingX = decoder->metrics->vertBearingX;
644 FT_Char vertBearingY = decoder->metrics->vertBearingY;
645 FT_Byte vertAdvance = decoder->metrics->vertAdvance;
646
647
648 if ( p + 2 > limit )
649 goto Fail;
650
651 num_components = FT_NEXT_USHORT( p );
652 if ( p + 4 * num_components > limit )
653 goto Fail;
654
655 if ( !decoder->bitmap_allocated )
656 {
657 error = tt_sbit_decoder_alloc_bitmap( decoder );
658 if ( error )
659 goto Exit;
660 }
661
662 for ( nn = 0; nn < num_components; nn++ )
663 {
664 FT_UInt gindex = FT_NEXT_USHORT( p );
665 FT_Byte dx = FT_NEXT_BYTE( p );
666 FT_Byte dy = FT_NEXT_BYTE( p );
667
668
669 /* NB: a recursive call */
670 error = tt_sbit_decoder_load_image( decoder, gindex,
671 x_pos + dx, y_pos + dy );
672 if ( error )
673 break;
674 }
675
676 decoder->metrics->horiBearingX = horiBearingX;
677 decoder->metrics->horiBearingY = horiBearingY;
678 decoder->metrics->horiAdvance = horiAdvance;
679 decoder->metrics->vertBearingX = vertBearingX;
680 decoder->metrics->vertBearingY = vertBearingY;
681 decoder->metrics->vertAdvance = vertAdvance;
682 decoder->metrics->width = (FT_UInt)decoder->bitmap->width;
683 decoder->metrics->height = (FT_UInt)decoder->bitmap->rows;
684
685 Exit:
686 return error;
687
688 Fail:
689 error = SFNT_Err_Invalid_File_Format;
690 goto Exit;
691 }
692
693
694 static FT_Error
695 tt_sbit_decoder_load_bitmap( TT_SBitDecoder decoder,
696 FT_UInt glyph_format,
697 FT_ULong glyph_start,
698 FT_ULong glyph_size,
699 FT_Int x_pos,
700 FT_Int y_pos )
701 {
702 FT_Error error;
703 FT_Stream stream = decoder->stream;
704 FT_Byte* p;
705 FT_Byte* p_limit;
706 FT_Byte* data;
707
708
709 /* seek into the EBDT table now */
710 if ( glyph_start + glyph_size > decoder->ebdt_size )
711 {
712 error = SFNT_Err_Invalid_Argument;
713 goto Exit;
714 }
715
716 if ( FT_STREAM_SEEK( decoder->ebdt_start + glyph_start ) ||
717 FT_FRAME_EXTRACT( glyph_size, data ) )
718 goto Exit;
719
720 p = data;
721 p_limit = p + glyph_size;
722
723 /* read the data, depending on the glyph format */
724 switch ( glyph_format )
725 {
726 case 1:
727 case 2:
728 case 8:
729 error = tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 0 );
730 break;
731
732 case 6:
733 case 7:
734 case 9:
735 error = tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 );
736 break;
737
738 default:
739 error = SFNT_Err_Ok;
740 }
741
742 if ( error )
743 goto Fail;
744
745 {
746 TT_SBitDecoder_LoadFunc loader;
747
748
749 switch ( glyph_format )
750 {
751 case 1:
752 case 6:
753 loader = tt_sbit_decoder_load_byte_aligned;
754 break;
755
756 case 2:
757 case 5:
758 case 7:
759 loader = tt_sbit_decoder_load_bit_aligned;
760 break;
761
762 case 8:
763 if ( p + 1 > p_limit )
764 goto Fail;
765
766 p += 1; /* skip padding */
767 /* fall-through */
768
769 case 9:
770 loader = tt_sbit_decoder_load_compound;
771 break;
772
773 default:
774 goto Fail;
775 }
776
777 error = loader( decoder, p, p_limit, x_pos, y_pos );
778 }
779
780 Fail:
781 FT_FRAME_RELEASE( data );
782
783 Exit:
784 return error;
785 }
786
787
788 static FT_Error
789 tt_sbit_decoder_load_image( TT_SBitDecoder decoder,
790 FT_UInt glyph_index,
791 FT_Int x_pos,
792 FT_Int y_pos )
793 {
794 /*
795 * First, we find the correct strike range that applies to this
796 * glyph index.
797 */
798
799 FT_Byte* p = decoder->eblc_base + decoder->strike_index_array;
800 FT_Byte* p_limit = decoder->eblc_limit;
801 FT_ULong num_ranges = decoder->strike_index_count;
802 FT_UInt start, end, index_format, image_format;
803 FT_ULong image_start = 0, image_end = 0, image_offset;
804
805
806 for ( ; num_ranges > 0; num_ranges-- )
807 {
808 start = FT_NEXT_USHORT( p );
809 end = FT_NEXT_USHORT( p );
810
811 if ( glyph_index >= start && glyph_index <= end )
812 goto FoundRange;
813
814 p += 4; /* ignore index offset */
815 }
816 goto NoBitmap;
817
818 FoundRange:
819 image_offset = FT_NEXT_ULONG( p );
820
821 /* overflow check */
822 if ( decoder->eblc_base + decoder->strike_index_array + image_offset <
823 decoder->eblc_base )
824 goto Failure;
825
826 p = decoder->eblc_base + decoder->strike_index_array + image_offset;
827 if ( p + 8 > p_limit )
828 goto NoBitmap;
829
830 /* now find the glyph's location and extend within the ebdt table */
831 index_format = FT_NEXT_USHORT( p );
832 image_format = FT_NEXT_USHORT( p );
833 image_offset = FT_NEXT_ULONG ( p );
834
835 switch ( index_format )
836 {
837 case 1: /* 4-byte offsets relative to `image_offset' */
838 {
839 p += 4 * ( glyph_index - start );
840 if ( p + 8 > p_limit )
841 goto NoBitmap;
842
843 image_start = FT_NEXT_ULONG( p );
844 image_end = FT_NEXT_ULONG( p );
845
846 if ( image_start == image_end ) /* missing glyph */
847 goto NoBitmap;
848 }
849 break;
850
851 case 2: /* big metrics, constant image size */
852 {
853 FT_ULong image_size;
854
855
856 if ( p + 12 > p_limit )
857 goto NoBitmap;
858
859 image_size = FT_NEXT_ULONG( p );
860
861 if ( tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 ) )
862 goto NoBitmap;
863
864 image_start = image_size * ( glyph_index - start );
865 image_end = image_start + image_size;
866 }
867 break;
868
869 case 3: /* 2-byte offsets relative to 'image_offset' */
870 {
871 p += 2 * ( glyph_index - start );
872 if ( p + 4 > p_limit )
873 goto NoBitmap;
874
875 image_start = FT_NEXT_USHORT( p );
876 image_end = FT_NEXT_USHORT( p );
877
878 if ( image_start == image_end ) /* missing glyph */
879 goto NoBitmap;
880 }
881 break;
882
883 case 4: /* sparse glyph array with (glyph,offset) pairs */
884 {
885 FT_ULong mm, num_glyphs;
886
887
888 if ( p + 4 > p_limit )
889 goto NoBitmap;
890
891 num_glyphs = FT_NEXT_ULONG( p );
892
893 /* overflow check */
894 if ( p + ( num_glyphs + 1 ) * 4 < p )
895 goto Failure;
896
897 if ( p + ( num_glyphs + 1 ) * 4 > p_limit )
898 goto NoBitmap;
899
900 for ( mm = 0; mm < num_glyphs; mm++ )
901 {
902 FT_UInt gindex = FT_NEXT_USHORT( p );
903
904
905 if ( gindex == glyph_index )
906 {
907 image_start = FT_NEXT_USHORT( p );
908 p += 2;
909 image_end = FT_PEEK_USHORT( p );
910 break;
911 }
912 p += 2;
913 }
914
915 if ( mm >= num_glyphs )
916 goto NoBitmap;
917 }
918 break;
919
920 case 5: /* constant metrics with sparse glyph codes */
921 {
922 FT_ULong image_size, mm, num_glyphs;
923
924
925 if ( p + 16 > p_limit )
926 goto NoBitmap;
927
928 image_size = FT_NEXT_ULONG( p );
929
930 if ( tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 ) )
931 goto NoBitmap;
932
933 num_glyphs = FT_NEXT_ULONG( p );
934
935 /* overflow check */
936 if ( p + 2 * num_glyphs < p )
937 goto Failure;
938
939 if ( p + 2 * num_glyphs > p_limit )
940 goto NoBitmap;
941
942 for ( mm = 0; mm < num_glyphs; mm++ )
943 {
944 FT_UInt gindex = FT_NEXT_USHORT( p );
945
946
947 if ( gindex == glyph_index )
948 break;
949 }
950
951 if ( mm >= num_glyphs )
952 goto NoBitmap;
953
954 image_start = image_size * mm;
955 image_end = image_start + image_size;
956 }
957 break;
958
959 default:
960 goto NoBitmap;
961 }
962
963 if ( image_start > image_end )
964 goto NoBitmap;
965
966 image_end -= image_start;
967 image_start = image_offset + image_start;
968
969 return tt_sbit_decoder_load_bitmap( decoder,
970 image_format,
971 image_start,
972 image_end,
973 x_pos,
974 y_pos );
975
976 Failure:
977 return SFNT_Err_Invalid_Table;
978
979 NoBitmap:
980 return SFNT_Err_Invalid_Argument;
981 }
982
983
984 FT_LOCAL( FT_Error )
985 tt_face_load_sbit_image( TT_Face face,
986 FT_ULong strike_index,
987 FT_UInt glyph_index,
988 FT_UInt load_flags,
989 FT_Stream stream,
990 FT_Bitmap *map,
991 TT_SBit_MetricsRec *metrics )
992 {
993 TT_SBitDecoderRec decoder[1];
994 FT_Error error;
995
996 FT_UNUSED( load_flags );
997 FT_UNUSED( stream );
998 FT_UNUSED( map );
999
1000
1001 error = tt_sbit_decoder_init( decoder, face, strike_index, metrics );
1002 if ( !error )
1003 {
1004 error = tt_sbit_decoder_load_image( decoder, glyph_index, 0, 0 );
1005 tt_sbit_decoder_done( decoder );
1006 }
1007
1008 return error;
1009 }
1010
1011 /* EOF */
A free Windows-compatible Operating System