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