zenilib: zenilib/jni/external/freetype2/src/sfnt/ttsbit.c Source File

zenilib 0.5.3.0

- Main Page
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
ttsbit.c
Go to the documentation of this file.
1 /***************************************************************************/
2 /* */
3 /* ttsbit.c */
4 /* */
5 /* TrueType and OpenType embedded bitmap support (body). */
6 /* */
7 /* Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, */
8 /* 2010 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 #include <ft2build.h>
20 #include FT_INTERNAL_DEBUG_H
21 #include FT_INTERNAL_STREAM_H
22 #include FT_TRUETYPE_TAGS_H
23
24 /*
25 * Alas, the memory-optimized sbit loader can't be used when implementing
26 * the `old internals' hack
27 */
28 #ifndef FT_CONFIG_OPTION_OLD_INTERNALS
29
30 #include "ttsbit0.c"
31
32 #else /* FT_CONFIG_OPTION_OLD_INTERNALS */
33
34 #include <ft2build.h>
35 #include FT_INTERNAL_DEBUG_H
36 #include FT_INTERNAL_STREAM_H
37 #include FT_TRUETYPE_TAGS_H
38 #include "ttsbit.h"
39
40 #include "sferrors.h"
41
42
43 /*************************************************************************/
44 /* */
45 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
46 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
47 /* messages during execution. */
48 /* */
49 #undef FT_COMPONENT
50 #define FT_COMPONENT trace_ttsbit
51
52
53 /*************************************************************************/
54 /* */
55 /* <Function> */
56 /* blit_sbit */
57 /* */
58 /* <Description> */
59 /* Blits a bitmap from an input stream into a given target. Supports */
60 /* x and y offsets as well as byte padded lines. */
61 /* */
62 /* <Input> */
63 /* target :: The target bitmap/pixmap. */
64 /* */
65 /* source :: The input packed bitmap data. */
66 /* */
67 /* line_bits :: The number of bits per line. */
68 /* */
69 /* byte_padded :: A flag which is true if lines are byte-padded. */
70 /* */
71 /* x_offset :: The horizontal offset. */
72 /* */
73 /* y_offset :: The vertical offset. */
74 /* */
75 /* <Note> */
76 /* IMPORTANT: The x and y offsets are relative to the top corner of */
77 /* the target bitmap (unlike the normal TrueType */
78 /* convention). A positive y offset indicates a downwards */
79 /* direction! */
80 /* */
81 static void
82 blit_sbit( FT_Bitmap* target,
83 FT_Byte* source,
84 FT_Int line_bits,
85 FT_Bool byte_padded,
86 FT_Int x_offset,
87 FT_Int y_offset,
88 FT_Int source_height )
89 {
90 FT_Byte* line_buff;
91 FT_Int line_incr;
92 FT_Int height;
93
94 FT_UShort acc;
95 FT_UInt loaded;
96
97
98 /* first of all, compute starting write position */
99 line_incr = target->pitch;
100 line_buff = target->buffer;
101
102 if ( line_incr < 0 )
103 line_buff -= line_incr * ( target->rows - 1 );
104
105 line_buff += ( x_offset >> 3 ) + y_offset * line_incr;
106
107 /***********************************************************************/
108 /* */
109 /* We use the extra-classic `accumulator' trick to extract the bits */
110 /* from the source byte stream. */
111 /* */
112 /* Namely, the variable `acc' is a 16-bit accumulator containing the */
113 /* last `loaded' bits from the input stream. The bits are shifted to */
114 /* the upmost position in `acc'. */
115 /* */
116 /***********************************************************************/
117
118 acc = 0; /* clear accumulator */
119 loaded = 0; /* no bits were loaded */
120
121 for ( height = source_height; height > 0; height-- )
122 {
123 FT_Byte* cur = line_buff; /* current write cursor */
124 FT_Int count = line_bits; /* # of bits to extract per line */
125 FT_Byte shift = (FT_Byte)( x_offset & 7 ); /* current write shift */
126 FT_Byte space = (FT_Byte)( 8 - shift );
127
128
129 /* first of all, read individual source bytes */
130 if ( count >= 8 )
131 {
132 count -= 8;
133 {
134 do
135 {
136 FT_Byte val;
137
138
139 /* ensure that there are at least 8 bits in the accumulator */
140 if ( loaded < 8 )
141 {
142 acc |= (FT_UShort)((FT_UShort)*source++ << ( 8 - loaded ));
143 loaded += 8;
144 }
145
146 /* now write one byte */
147 val = (FT_Byte)( acc >> 8 );
148 if ( shift )
149 {
150 cur[0] |= (FT_Byte)( val >> shift );
151 cur[1] |= (FT_Byte)( val << space );
152 }
153 else
154 cur[0] |= val;
155
156 cur++;
157 acc <<= 8; /* remove bits from accumulator */
158 loaded -= 8;
159 count -= 8;
160
161 } while ( count >= 0 );
162 }
163
164 /* restore `count' to correct value */
165 count += 8;
166 }
167
168 /* now write remaining bits (count < 8) */
169 if ( count > 0 )
170 {
171 FT_Byte val;
172
173
174 /* ensure that there are at least `count' bits in the accumulator */
175 if ( (FT_Int)loaded < count )
176 {
177 acc |= (FT_UShort)((FT_UShort)*source++ << ( 8 - loaded ));
178 loaded += 8;
179 }
180
181 /* now write remaining bits */
182 val = (FT_Byte)( ( (FT_Byte)( acc >> 8 ) ) & ~( 0xFF >> count ) );
183 cur[0] |= (FT_Byte)( val >> shift );
184
185 if ( count > space )
186 cur[1] |= (FT_Byte)( val << space );
187
188 acc <<= count;
189 loaded -= count;
190 }
191
192 /* now, skip to next line */
193 if ( byte_padded )
194 {
195 acc = 0;
196 loaded = 0; /* clear accumulator on byte-padded lines */
197 }
198
199 line_buff += line_incr;
200 }
201 }
202
203
204 static const FT_Frame_Field sbit_metrics_fields[] =
205 {
206 #undef FT_STRUCTURE
207 #define FT_STRUCTURE TT_SBit_MetricsRec
208
209 FT_FRAME_START( 8 ),
210 FT_FRAME_BYTE( height ),
211 FT_FRAME_BYTE( width ),
212
213 FT_FRAME_CHAR( horiBearingX ),
214 FT_FRAME_CHAR( horiBearingY ),
215 FT_FRAME_BYTE( horiAdvance ),
216
217 FT_FRAME_CHAR( vertBearingX ),
218 FT_FRAME_CHAR( vertBearingY ),
219 FT_FRAME_BYTE( vertAdvance ),
220 FT_FRAME_END
221 };
222
223
224 /*************************************************************************/
225 /* */
226 /* <Function> */
227 /* Load_SBit_Const_Metrics */
228 /* */
229 /* <Description> */
230 /* Loads the metrics for `EBLC' index tables format 2 and 5. */
231 /* */
232 /* <Input> */
233 /* range :: The target range. */
234 /* */
235 /* stream :: The input stream. */
236 /* */
237 /* <Return> */
238 /* FreeType error code. 0 means success. */
239 /* */
240 static FT_Error
241 Load_SBit_Const_Metrics( TT_SBit_Range range,
242 FT_Stream stream )
243 {
244 FT_Error error;
245
246
247 if ( FT_READ_ULONG( range->image_size ) )
248 return error;
249
250 return FT_STREAM_READ_FIELDS( sbit_metrics_fields, &range->metrics );
251 }
252
253
254 /*************************************************************************/
255 /* */
256 /* <Function> */
257 /* Load_SBit_Range_Codes */
258 /* */
259 /* <Description> */
260 /* Loads the range codes for `EBLC' index tables format 4 and 5. */
261 /* */
262 /* <Input> */
263 /* range :: The target range. */
264 /* */
265 /* stream :: The input stream. */
266 /* */
267 /* load_offsets :: A flag whether to load the glyph offset table. */
268 /* */
269 /* <Return> */
270 /* FreeType error code. 0 means success. */
271 /* */
272 static FT_Error
273 Load_SBit_Range_Codes( TT_SBit_Range range,
274 FT_Stream stream,
275 FT_Bool load_offsets )
276 {
277 FT_Error error;
278 FT_ULong count, n, size;
279 FT_Memory memory = stream->memory;
280
281
282 if ( FT_READ_ULONG( count ) )
283 goto Exit;
284
285 range->num_glyphs = count;
286
287 /* Allocate glyph offsets table if needed */
288 if ( load_offsets )
289 {
290 if ( FT_NEW_ARRAY( range->glyph_offsets, count ) )
291 goto Exit;
292
293 size = count * 4L;
294 }
295 else
296 size = count * 2L;
297
298 /* Allocate glyph codes table and access frame */
299 if ( FT_NEW_ARRAY ( range->glyph_codes, count ) ||
300 FT_FRAME_ENTER( size ) )
301 goto Exit;
302
303 for ( n = 0; n < count; n++ )
304 {
305 range->glyph_codes[n] = FT_GET_USHORT();
306
307 if ( load_offsets )
308 range->glyph_offsets[n] = (FT_ULong)range->image_offset +
309 FT_GET_USHORT();
310 }
311
312 FT_FRAME_EXIT();
313
314 Exit:
315 return error;
316 }
317
318
319 /*************************************************************************/
320 /* */
321 /* <Function> */
322 /* Load_SBit_Range */
323 /* */
324 /* <Description> */
325 /* Loads a given `EBLC' index/range table. */
326 /* */
327 /* <Input> */
328 /* range :: The target range. */
329 /* */
330 /* stream :: The input stream. */
331 /* */
332 /* <Return> */
333 /* FreeType error code. 0 means success. */
334 /* */
335 static FT_Error
336 Load_SBit_Range( TT_SBit_Range range,
337 FT_Stream stream )
338 {
339 FT_Error error;
340 FT_Memory memory = stream->memory;
341
342
343 switch( range->index_format )
344 {
345 case 1: /* variable metrics with 4-byte offsets */
346 case 3: /* variable metrics with 2-byte offsets */
347 {
348 FT_ULong num_glyphs, n;
349 FT_Int size_elem;
350 FT_Bool large = FT_BOOL( range->index_format == 1 );
351
352
353
354 if ( range->last_glyph < range->first_glyph )
355 {
356 error = SFNT_Err_Invalid_File_Format;
357 goto Exit;
358 }
359
360 num_glyphs = range->last_glyph - range->first_glyph + 1L;
361 range->num_glyphs = num_glyphs;
362 num_glyphs++; /* XXX: BEWARE - see spec */
363
364 size_elem = large ? 4 : 2;
365
366 if ( FT_NEW_ARRAY( range->glyph_offsets, num_glyphs ) ||
367 FT_FRAME_ENTER( num_glyphs * size_elem ) )
368 goto Exit;
369
370 for ( n = 0; n < num_glyphs; n++ )
371 range->glyph_offsets[n] = (FT_ULong)( range->image_offset +
372 ( large ? FT_GET_ULONG()
373 : FT_GET_USHORT() ) );
374 FT_FRAME_EXIT();
375 }
376 break;
377
378 case 2: /* all glyphs have identical metrics */
379 error = Load_SBit_Const_Metrics( range, stream );
380 break;
381
382 case 4:
383 error = Load_SBit_Range_Codes( range, stream, 1 );
384 break;
385
386 case 5:
387 error = Load_SBit_Const_Metrics( range, stream );
388 if ( !error )
389 error = Load_SBit_Range_Codes( range, stream, 0 );
390 break;
391
392 default:
393 error = SFNT_Err_Invalid_File_Format;
394 }
395
396 Exit:
397 return error;
398 }
399
400
401 /*************************************************************************/
402 /* */
403 /* <Function> */
404 /* tt_face_load_eblc */
405 /* */
406 /* <Description> */
407 /* Loads the table of embedded bitmap sizes for this face. */
408 /* */
409 /* <Input> */
410 /* face :: The target face object. */
411 /* */
412 /* stream :: The input stream. */
413 /* */
414 /* <Return> */
415 /* FreeType error code. 0 means success. */
416 /* */
417 FT_LOCAL_DEF( FT_Error )
418 tt_face_load_eblc( TT_Face face,
419 FT_Stream stream )
420 {
421 FT_Error error = SFNT_Err_Ok;
422 FT_Memory memory = stream->memory;
423 FT_Fixed version;
424 FT_ULong num_strikes;
425 FT_ULong table_base;
426
427 static const FT_Frame_Field sbit_line_metrics_fields[] =
428 {
429 #undef FT_STRUCTURE
430 #define FT_STRUCTURE TT_SBit_LineMetricsRec
431
432 /* no FT_FRAME_START */
433 FT_FRAME_CHAR( ascender ),
434 FT_FRAME_CHAR( descender ),
435 FT_FRAME_BYTE( max_width ),
436
437 FT_FRAME_CHAR( caret_slope_numerator ),
438 FT_FRAME_CHAR( caret_slope_denominator ),
439 FT_FRAME_CHAR( caret_offset ),
440
441 FT_FRAME_CHAR( min_origin_SB ),
442 FT_FRAME_CHAR( min_advance_SB ),
443 FT_FRAME_CHAR( max_before_BL ),
444 FT_FRAME_CHAR( min_after_BL ),
445 FT_FRAME_CHAR( pads[0] ),
446 FT_FRAME_CHAR( pads[1] ),
447 FT_FRAME_END
448 };
449
450 static const FT_Frame_Field strike_start_fields[] =
451 {
452 #undef FT_STRUCTURE
453 #define FT_STRUCTURE TT_SBit_StrikeRec
454
455 /* no FT_FRAME_START */
456 FT_FRAME_ULONG( ranges_offset ),
457 FT_FRAME_SKIP_LONG,
458 FT_FRAME_ULONG( num_ranges ),
459 FT_FRAME_ULONG( color_ref ),
460 FT_FRAME_END
461 };
462
463 static const FT_Frame_Field strike_end_fields[] =
464 {
465 /* no FT_FRAME_START */
466 FT_FRAME_USHORT( start_glyph ),
467 FT_FRAME_USHORT( end_glyph ),
468 FT_FRAME_BYTE ( x_ppem ),
469 FT_FRAME_BYTE ( y_ppem ),
470 FT_FRAME_BYTE ( bit_depth ),
471 FT_FRAME_CHAR ( flags ),
472 FT_FRAME_END
473 };
474
475
476 face->num_sbit_strikes = 0;
477
478 /* this table is optional */
479 error = face->goto_table( face, TTAG_EBLC, stream, 0 );
480 if ( error )
481 error = face->goto_table( face, TTAG_bloc, stream, 0 );
482 if ( error )
483 goto Exit;
484
485 table_base = FT_STREAM_POS();
486 if ( FT_FRAME_ENTER( 8L ) )
487 goto Exit;
488
489 version = FT_GET_LONG();
490 num_strikes = FT_GET_ULONG();
491
492 FT_FRAME_EXIT();
493
494 /* check version number and strike count */
495 if ( version != 0x00020000L ||
496 num_strikes >= 0x10000L )
497 {
498 FT_ERROR(( "tt_face_load_sbit_strikes: invalid table version\n" ));
499 error = SFNT_Err_Invalid_File_Format;
500
501 goto Exit;
502 }
503
504 /* allocate the strikes table */
505 if ( FT_NEW_ARRAY( face->sbit_strikes, num_strikes ) )
506 goto Exit;
507
508 face->num_sbit_strikes = num_strikes;
509
510 /* now read each strike table separately */
511 {
512 TT_SBit_Strike strike = face->sbit_strikes;
513 FT_ULong count = num_strikes;
514
515
516 if ( FT_FRAME_ENTER( 48L * num_strikes ) )
517 goto Exit;
518
519 while ( count > 0 )
520 {
521 if ( FT_STREAM_READ_FIELDS( strike_start_fields, strike ) ||
522 FT_STREAM_READ_FIELDS( sbit_line_metrics_fields, &strike->hori ) ||
523 FT_STREAM_READ_FIELDS( sbit_line_metrics_fields, &strike->vert ) ||
524 FT_STREAM_READ_FIELDS( strike_end_fields, strike ) )
525 break;
526
527 count--;
528 strike++;
529 }
530
531 FT_FRAME_EXIT();
532 }
533
534 /* allocate the index ranges for each strike table */
535 {
536 TT_SBit_Strike strike = face->sbit_strikes;
537 FT_ULong count = num_strikes;
538
539
540 while ( count > 0 )
541 {
542 TT_SBit_Range range;
543 FT_ULong count2 = strike->num_ranges;
544
545
546 /* read each range */
547 if ( FT_STREAM_SEEK( table_base + strike->ranges_offset ) ||
548 FT_FRAME_ENTER( strike->num_ranges * 8L ) )
549 goto Exit;
550
551 if ( FT_NEW_ARRAY( strike->sbit_ranges, strike->num_ranges ) )
552 goto Exit;
553
554 range = strike->sbit_ranges;
555 while ( count2 > 0 )
556 {
557 range->first_glyph = FT_GET_USHORT();
558 range->last_glyph = FT_GET_USHORT();
559 range->table_offset = table_base + strike->ranges_offset +
560 FT_GET_ULONG();
561 count2--;
562 range++;
563 }
564
565 FT_FRAME_EXIT();
566
567 /* Now, read each index table */
568 count2 = strike->num_ranges;
569 range = strike->sbit_ranges;
570 while ( count2 > 0 )
571 {
572 /* Read the header */
573 if ( FT_STREAM_SEEK( range->table_offset ) ||
574 FT_FRAME_ENTER( 8L ) )
575 goto Exit;
576
577 range->index_format = FT_GET_USHORT();
578 range->image_format = FT_GET_USHORT();
579 range->image_offset = FT_GET_ULONG();
580
581 FT_FRAME_EXIT();
582
583 error = Load_SBit_Range( range, stream );
584 if ( error )
585 goto Exit;
586
587 count2--;
588 range++;
589 }
590
591 count--;
592 strike++;
593 }
594 }
595
596 Exit:
597 return error;
598 }
599
600
601 /*************************************************************************/
602 /* */
603 /* <Function> */
604 /* tt_face_free_eblc */
605 /* */
606 /* <Description> */
607 /* Releases the embedded bitmap tables. */
608 /* */
609 /* <Input> */
610 /* face :: The target face object. */
611 /* */
612 FT_LOCAL_DEF( void )
613 tt_face_free_eblc( TT_Face face )
614 {
615 FT_Memory memory = face->root.memory;
616 TT_SBit_Strike strike = face->sbit_strikes;
617 TT_SBit_Strike strike_limit = strike + face->num_sbit_strikes;
618
619
620 if ( strike )
621 {
622 for ( ; strike < strike_limit; strike++ )
623 {
624 TT_SBit_Range range = strike->sbit_ranges;
625 TT_SBit_Range range_limit = range + strike->num_ranges;
626
627
628 if ( range )
629 {
630 for ( ; range < range_limit; range++ )
631 {
632 /* release the glyph offsets and codes tables */
633 /* where appropriate */
634 FT_FREE( range->glyph_offsets );
635 FT_FREE( range->glyph_codes );
636 }
637 }
638 FT_FREE( strike->sbit_ranges );
639 strike->num_ranges = 0;
640 }
641 FT_FREE( face->sbit_strikes );
642 }
643 face->num_sbit_strikes = 0;
644 }
645
646
647 FT_LOCAL_DEF( FT_Error )
648 tt_face_set_sbit_strike( TT_Face face,
649 FT_Size_Request req,
650 FT_ULong* astrike_index )
651 {
652 return FT_Match_Size( (FT_Face)face, req, 0, astrike_index );
653 }
654
655
656 FT_LOCAL_DEF( FT_Error )
657 tt_face_load_strike_metrics( TT_Face face,
658 FT_ULong strike_index,
659 FT_Size_Metrics* metrics )
660 {
661 TT_SBit_Strike strike;
662
663
664 if ( strike_index >= face->num_sbit_strikes )
665 return SFNT_Err_Invalid_Argument;
666
667 strike = face->sbit_strikes + strike_index;
668
669 metrics->x_ppem = strike->x_ppem;
670 metrics->y_ppem = strike->y_ppem;
671
672 metrics->ascender = strike->hori.ascender << 6;
673 metrics->descender = strike->hori.descender << 6;
674
675 /* XXX: Is this correct? */
676 metrics->max_advance = ( strike->hori.min_origin_SB +
677 strike->hori.max_width +
678 strike->hori.min_advance_SB ) << 6;
679
680 metrics->height = metrics->ascender - metrics->descender;
681
682 return SFNT_Err_Ok;
683 }
684
685
686 /*************************************************************************/
687 /* */
688 /* <Function> */
689 /* find_sbit_range */
690 /* */
691 /* <Description> */
692 /* Scans a given strike's ranges and return, for a given glyph */
693 /* index, the corresponding sbit range, and `EBDT' offset. */
694 /* */
695 /* <Input> */
696 /* glyph_index :: The glyph index. */
697 /* */
698 /* strike :: The source/current sbit strike. */
699 /* */
700 /* <Output> */
701 /* arange :: The sbit range containing the glyph index. */
702 /* */
703 /* aglyph_offset :: The offset of the glyph data in `EBDT' table. */
704 /* */
705 /* <Return> */
706 /* FreeType error code. 0 means the glyph index was found. */
707 /* */
708 static FT_Error
709 find_sbit_range( FT_UInt glyph_index,
710 TT_SBit_Strike strike,
711 TT_SBit_Range *arange,
712 FT_ULong *aglyph_offset )
713 {
714 TT_SBit_RangeRec *range, *range_limit;
715
716
717 /* check whether the glyph index is within this strike's */
718 /* glyph range */
719 if ( glyph_index < (FT_UInt)strike->start_glyph ||
720 glyph_index > (FT_UInt)strike->end_glyph )
721 goto Fail;
722
723 /* scan all ranges in strike */
724 range = strike->sbit_ranges;
725 range_limit = range + strike->num_ranges;
726 if ( !range )
727 goto Fail;
728
729 for ( ; range < range_limit; range++ )
730 {
731 if ( glyph_index >= (FT_UInt)range->first_glyph &&
732 glyph_index <= (FT_UInt)range->last_glyph )
733 {
734 FT_UShort delta = (FT_UShort)( glyph_index - range->first_glyph );
735
736
737 switch ( range->index_format )
738 {
739 case 1:
740 case 3:
741 *aglyph_offset = range->glyph_offsets[delta];
742 break;
743
744 case 2:
745 *aglyph_offset = range->image_offset +
746 range->image_size * delta;
747 break;
748
749 case 4:
750 case 5:
751 {
752 FT_ULong n;
753
754
755 for ( n = 0; n < range->num_glyphs; n++ )
756 {
757 if ( (FT_UInt)range->glyph_codes[n] == glyph_index )
758 {
759 if ( range->index_format == 4 )
760 *aglyph_offset = range->glyph_offsets[n];
761 else
762 *aglyph_offset = range->image_offset +
763 n * range->image_size;
764 goto Found;
765 }
766 }
767 }
768
769 /* fall-through */
770 default:
771 goto Fail;
772 }
773
774 Found:
775 /* return successfully! */
776 *arange = range;
777 return SFNT_Err_Ok;
778 }
779 }
780
781 Fail:
782 *arange = 0;
783 *aglyph_offset = 0;
784
785 return SFNT_Err_Invalid_Argument;
786 }
787
788
789 /*************************************************************************/
790 /* */
791 /* <Function> */
792 /* tt_find_sbit_image */
793 /* */
794 /* <Description> */
795 /* Checks whether an embedded bitmap (an `sbit') exists for a given */
796 /* glyph, at a given strike. */
797 /* */
798 /* <Input> */
799 /* face :: The target face object. */
800 /* */
801 /* glyph_index :: The glyph index. */
802 /* */
803 /* strike_index :: The current strike index. */
804 /* */
805 /* <Output> */
806 /* arange :: The SBit range containing the glyph index. */
807 /* */
808 /* astrike :: The SBit strike containing the glyph index. */
809 /* */
810 /* aglyph_offset :: The offset of the glyph data in `EBDT' table. */
811 /* */
812 /* <Return> */
813 /* FreeType error code. 0 means success. Returns */
814 /* SFNT_Err_Invalid_Argument if no sbit exists for the requested */
815 /* glyph. */
816 /* */
817 FT_LOCAL( FT_Error )
818 tt_find_sbit_image( TT_Face face,
819 FT_UInt glyph_index,
820 FT_ULong strike_index,
821 TT_SBit_Range *arange,
822 TT_SBit_Strike *astrike,
823 FT_ULong *aglyph_offset )
824 {
825 FT_Error error;
826 TT_SBit_Strike strike;
827
828
829 if ( !face->sbit_strikes ||
830 ( face->num_sbit_strikes <= strike_index ) )
831 goto Fail;
832
833 strike = &face->sbit_strikes[strike_index];
834
835 error = find_sbit_range( glyph_index, strike,
836 arange, aglyph_offset );
837 if ( error )
838 goto Fail;
839
840 *astrike = strike;
841
842 return SFNT_Err_Ok;
843
844 Fail:
845 /* no embedded bitmap for this glyph in face */
846 *arange = 0;
847 *astrike = 0;
848 *aglyph_offset = 0;
849
850 return SFNT_Err_Invalid_Argument;
851 }
852
853
854 /*************************************************************************/
855 /* */
856 /* <Function> */
857 /* tt_load_sbit_metrics */
858 /* */
859 /* <Description> */
860 /* Gets the big metrics for a given SBit. */
861 /* */
862 /* <Input> */
863 /* stream :: The input stream. */
864 /* */
865 /* range :: The SBit range containing the glyph. */
866 /* */
867 /* <Output> */
868 /* big_metrics :: A big SBit metrics structure for the glyph. */
869 /* */
870 /* <Return> */
871 /* FreeType error code. 0 means success. */
872 /* */
873 /* <Note> */
874 /* The stream cursor must be positioned at the glyph's offset within */
875 /* the `EBDT' table before the call. */
876 /* */
877 /* If the image format uses variable metrics, the stream cursor is */
878 /* positioned just after the metrics header in the `EBDT' table on */
879 /* function exit. */
880 /* */
881 FT_LOCAL( FT_Error )
882 tt_load_sbit_metrics( FT_Stream stream,
883 TT_SBit_Range range,
884 TT_SBit_Metrics metrics )
885 {
886 FT_Error error = SFNT_Err_Ok;
887
888
889 switch ( range->image_format )
890 {
891 case 1:
892 case 2:
893 case 8:
894 /* variable small metrics */
895 {
896 TT_SBit_SmallMetricsRec smetrics;
897
898 static const FT_Frame_Field sbit_small_metrics_fields[] =
899 {
900 #undef FT_STRUCTURE
901 #define FT_STRUCTURE TT_SBit_SmallMetricsRec
902
903 FT_FRAME_START( 5 ),
904 FT_FRAME_BYTE( height ),
905 FT_FRAME_BYTE( width ),
906 FT_FRAME_CHAR( bearingX ),
907 FT_FRAME_CHAR( bearingY ),
908 FT_FRAME_BYTE( advance ),
909 FT_FRAME_END
910 };
911
912
913 /* read small metrics */
914 if ( FT_STREAM_READ_FIELDS( sbit_small_metrics_fields, &smetrics ) )
915 goto Exit;
916
917 /* convert it to a big metrics */
918 metrics->height = smetrics.height;
919 metrics->width = smetrics.width;
920 metrics->horiBearingX = smetrics.bearingX;
921 metrics->horiBearingY = smetrics.bearingY;
922 metrics->horiAdvance = smetrics.advance;
923
924 /* these metrics are made up at a higher level when */
925 /* needed. */
926 metrics->vertBearingX = 0;
927 metrics->vertBearingY = 0;
928 metrics->vertAdvance = 0;
929 }
930 break;
931
932 case 6:
933 case 7:
934 case 9:
935 /* variable big metrics */
936 if ( FT_STREAM_READ_FIELDS( sbit_metrics_fields, metrics ) )
937 goto Exit;
938 break;
939
940 case 5:
941 default: /* constant metrics */
942 if ( range->index_format == 2 || range->index_format == 5 )
943 *metrics = range->metrics;
944 else
945 return SFNT_Err_Invalid_File_Format;
946 }
947
948 Exit:
949 return error;
950 }
951
952
953 /*************************************************************************/
954 /* */
955 /* <Function> */
956 /* crop_bitmap */
957 /* */
958 /* <Description> */
959 /* Crops a bitmap to its tightest bounding box, and adjusts its */
960 /* metrics. */
961 /* */
962 /* <InOut> */
963 /* map :: The bitmap. */
964 /* */
965 /* metrics :: The corresponding metrics structure. */
966 /* */
967 static void
968 crop_bitmap( FT_Bitmap* map,
969 TT_SBit_Metrics metrics )
970 {
971 /***********************************************************************/
972 /* */
973 /* In this situation, some bounding boxes of embedded bitmaps are too */
974 /* large. We need to crop it to a reasonable size. */
975 /* */
976 /* --------- */
977 /* | | ----- */
978 /* | *** | |***| */
979 /* | * | | * | */
980 /* | * | ------> | * | */
981 /* | * | | * | */
982 /* | * | | * | */
983 /* | *** | |***| */
984 /* --------- ----- */
985 /* */
986 /***********************************************************************/
987
988 FT_Int rows, count;
989 FT_Long line_len;
990 FT_Byte* line;
991
992
993 /***********************************************************************/
994 /* */
995 /* first of all, check the top-most lines of the bitmap, and remove */
996 /* them if they're empty. */
997 /* */
998 {
999 line = (FT_Byte*)map->buffer;
1000 rows = map->rows;
1001 line_len = map->pitch;
1002
1003
1004 for ( count = 0; count < rows; count++ )
1005 {
1006 FT_Byte* cur = line;
1007 FT_Byte* limit = line + line_len;
1008
1009
1010 for ( ; cur < limit; cur++ )
1011 if ( cur[0] )
1012 goto Found_Top;
1013
1014 /* the current line was empty - skip to next one */
1015 line = limit;
1016 }
1017
1018 Found_Top:
1019 /* check that we have at least one filled line */
1020 if ( count >= rows )
1021 goto Empty_Bitmap;
1022
1023 /* now, crop the empty upper lines */
1024 if ( count > 0 )
1025 {
1026 line = (FT_Byte*)map->buffer;
1027
1028 FT_MEM_MOVE( line, line + count * line_len,
1029 ( rows - count ) * line_len );
1030
1031 metrics->height = (FT_Byte)( metrics->height - count );
1032 metrics->horiBearingY = (FT_Char)( metrics->horiBearingY - count );
1033 metrics->vertBearingY = (FT_Char)( metrics->vertBearingY - count );
1034
1035 map->rows -= count;
1036 rows -= count;
1037 }
1038 }
1039
1040 /***********************************************************************/
1041 /* */
1042 /* second, crop the lower lines */
1043 /* */
1044 {
1045 line = (FT_Byte*)map->buffer + ( rows - 1 ) * line_len;
1046
1047 for ( count = 0; count < rows; count++ )
1048 {
1049 FT_Byte* cur = line;
1050 FT_Byte* limit = line + line_len;
1051
1052
1053 for ( ; cur < limit; cur++ )
1054 if ( cur[0] )
1055 goto Found_Bottom;
1056
1057 /* the current line was empty - skip to previous one */
1058 line -= line_len;
1059 }
1060
1061 Found_Bottom:
1062 if ( count > 0 )
1063 {
1064 metrics->height = (FT_Byte)( metrics->height - count );
1065 rows -= count;
1066 map->rows -= count;
1067 }
1068 }
1069
1070 /***********************************************************************/
1071 /* */
1072 /* third, get rid of the space on the left side of the glyph */
1073 /* */
1074 do
1075 {
1076 FT_Byte* limit;
1077
1078
1079 line = (FT_Byte*)map->buffer;
1080 limit = line + rows * line_len;
1081
1082 for ( ; line < limit; line += line_len )
1083 if ( line[0] & 0x80 )
1084 goto Found_Left;
1085
1086 /* shift the whole glyph one pixel to the left */
1087 line = (FT_Byte*)map->buffer;
1088 limit = line + rows * line_len;
1089
1090 for ( ; line < limit; line += line_len )
1091 {
1092 FT_Int n, width = map->width;
1093 FT_Byte old;
1094 FT_Byte* cur = line;
1095
1096
1097 old = (FT_Byte)(cur[0] << 1);
1098 for ( n = 8; n < width; n += 8 )
1099 {
1100 FT_Byte val;
1101
1102
1103 val = cur[1];
1104 cur[0] = (FT_Byte)( old | ( val >> 7 ) );
1105 old = (FT_Byte)( val << 1 );
1106 cur++;
1107 }
1108 cur[0] = old;
1109 }
1110
1111 map->width--;
1112 metrics->horiBearingX++;
1113 metrics->vertBearingX++;
1114 metrics->width--;
1115
1116 } while ( map->width > 0 );
1117
1118 Found_Left:
1119
1120 /***********************************************************************/
1121 /* */
1122 /* finally, crop the bitmap width to get rid of the space on the right */
1123 /* side of the glyph. */
1124 /* */
1125 do
1126 {
1127 FT_Int right = map->width - 1;
1128 FT_Byte* limit;
1129 FT_Byte mask;
1130
1131
1132 line = (FT_Byte*)map->buffer + ( right >> 3 );
1133 limit = line + rows * line_len;
1134 mask = (FT_Byte)( 0x80 >> ( right & 7 ) );
1135
1136 for ( ; line < limit; line += line_len )
1137 if ( line[0] & mask )
1138 goto Found_Right;
1139
1140 /* crop the whole glyph to the right */
1141 map->width--;
1142 metrics->width--;
1143
1144 } while ( map->width > 0 );
1145
1146 Found_Right:
1147 /* all right, the bitmap was cropped */
1148 return;
1149
1150 Empty_Bitmap:
1151 map->width = 0;
1152 map->rows = 0;
1153 map->pitch = 0;
1154 map->pixel_mode = FT_PIXEL_MODE_MONO;
1155 }
1156
1157
1158 static FT_Error
1159 Load_SBit_Single( FT_Bitmap* map,
1160 FT_Int x_offset,
1161 FT_Int y_offset,
1162 FT_Int pix_bits,
1163 FT_UShort image_format,
1164 TT_SBit_Metrics metrics,
1165 FT_Stream stream )
1166 {
1167 FT_Error error;
1168
1169
1170 /* check that the source bitmap fits into the target pixmap */
1171 if ( x_offset < 0 || x_offset + metrics->width > map->width ||
1172 y_offset < 0 || y_offset + metrics->height > map->rows )
1173 {
1174 error = SFNT_Err_Invalid_Argument;
1175
1176 goto Exit;
1177 }
1178
1179 {
1180 FT_Int glyph_width = metrics->width;
1181 FT_Int glyph_height = metrics->height;
1182 FT_Int glyph_size;
1183 FT_Int line_bits = pix_bits * glyph_width;
1184 FT_Bool pad_bytes = 0;
1185
1186
1187 /* compute size of glyph image */
1188 switch ( image_format )
1189 {
1190 case 1: /* byte-padded formats */
1191 case 6:
1192 {
1193 FT_Int line_length;
1194
1195
1196 switch ( pix_bits )
1197 {
1198 case 1:
1199 line_length = ( glyph_width + 7 ) >> 3;
1200 break;
1201 case 2:
1202 line_length = ( glyph_width + 3 ) >> 2;
1203 break;
1204 case 4:
1205 line_length = ( glyph_width + 1 ) >> 1;
1206 break;
1207 default:
1208 line_length = glyph_width;
1209 }
1210
1211 glyph_size = glyph_height * line_length;
1212 pad_bytes = 1;
1213 }
1214 break;
1215
1216 case 2:
1217 case 5:
1218 case 7:
1219 line_bits = glyph_width * pix_bits;
1220 glyph_size = ( glyph_height * line_bits + 7 ) >> 3;
1221 break;
1222
1223 default: /* invalid format */
1224 return SFNT_Err_Invalid_File_Format;
1225 }
1226
1227 /* Now read data and draw glyph into target pixmap */
1228 if ( FT_FRAME_ENTER( glyph_size ) )
1229 goto Exit;
1230
1231 /* don't forget to multiply `x_offset' by `map->pix_bits' as */
1232 /* the sbit blitter doesn't make a difference between pixmap */
1233 /* depths. */
1234 blit_sbit( map, (FT_Byte*)stream->cursor, line_bits, pad_bytes,
1235 x_offset * pix_bits, y_offset, metrics->height );
1236
1237 FT_FRAME_EXIT();
1238 }
1239
1240 Exit:
1241 return error;
1242 }
1243
1244
1245 static FT_Error
1246 Load_SBit_Image( TT_SBit_Strike strike,
1247 TT_SBit_Range range,
1248 FT_ULong ebdt_pos,
1249 FT_ULong glyph_offset,
1250 FT_GlyphSlot slot,
1251 FT_Int x_offset,
1252 FT_Int y_offset,
1253 FT_Stream stream,
1254 TT_SBit_Metrics metrics,
1255 FT_Int depth )
1256 {
1257 FT_Memory memory = stream->memory;
1258 FT_Bitmap* map = &slot->bitmap;
1259 FT_Error error;
1260
1261
1262 /* place stream at beginning of glyph data and read metrics */
1263 if ( FT_STREAM_SEEK( ebdt_pos + glyph_offset ) )
1264 goto Exit;
1265
1266 error = tt_load_sbit_metrics( stream, range, metrics );
1267 if ( error )
1268 goto Exit;
1269
1270 /* This function is recursive. At the top-level call, we */
1271 /* compute the dimensions of the higher-level glyph to */
1272 /* allocate the final pixmap buffer. */
1273 if ( depth == 0 )
1274 {
1275 FT_Long size;
1276
1277
1278 map->width = metrics->width;
1279 map->rows = metrics->height;
1280
1281 switch ( strike->bit_depth )
1282 {
1283 case 1:
1284 map->pixel_mode = FT_PIXEL_MODE_MONO;
1285 map->pitch = ( map->width + 7 ) >> 3;
1286 break;
1287
1288 case 2:
1289 map->pixel_mode = FT_PIXEL_MODE_GRAY2;
1290 map->pitch = ( map->width + 3 ) >> 2;
1291 break;
1292
1293 case 4:
1294 map->pixel_mode = FT_PIXEL_MODE_GRAY4;
1295 map->pitch = ( map->width + 1 ) >> 1;
1296 break;
1297
1298 case 8:
1299 map->pixel_mode = FT_PIXEL_MODE_GRAY;
1300 map->pitch = map->width;
1301 break;
1302
1303 default:
1304 return SFNT_Err_Invalid_File_Format;
1305 }
1306
1307 size = map->rows * map->pitch;
1308
1309 /* check that there is no empty image */
1310 if ( size == 0 )
1311 goto Exit; /* exit successfully! */
1312
1313 error = ft_glyphslot_alloc_bitmap( slot, size );
1314 if (error)
1315 goto Exit;
1316 }
1317
1318 switch ( range->image_format )
1319 {
1320 case 1: /* single sbit image - load it */
1321 case 2:
1322 case 5:
1323 case 6:
1324 case 7:
1325 return Load_SBit_Single( map, x_offset, y_offset, strike->bit_depth,
1326 range->image_format, metrics, stream );
1327
1328 case 8: /* compound format */
1329 if ( FT_STREAM_SKIP( 1L ) )
1330 {
1331 error = SFNT_Err_Invalid_Stream_Skip;
1332 goto Exit;
1333 }
1334 /* fallthrough */
1335
1336 case 9:
1337 break;
1338
1339 default: /* invalid image format */
1340 return SFNT_Err_Invalid_File_Format;
1341 }
1342
1343 /* All right, we have a compound format. First of all, read */
1344 /* the array of elements. */
1345 {
1346 TT_SBit_Component components = NULL;
1347 TT_SBit_Component comp;
1348 FT_UShort num_components, count;
1349
1350
1351 if ( FT_READ_USHORT( num_components ) ||
1352 FT_NEW_ARRAY( components, num_components ) )
1353 goto Exit;
1354
1355 count = num_components;
1356
1357 if ( FT_FRAME_ENTER( 4L * num_components ) )
1358 goto Fail_Memory;
1359
1360 for ( comp = components; count > 0; count--, comp++ )
1361 {
1362 comp->glyph_code = FT_GET_USHORT();
1363 comp->x_offset = FT_GET_CHAR();
1364 comp->y_offset = FT_GET_CHAR();
1365 }
1366
1367 FT_FRAME_EXIT();
1368
1369 /* Now recursively load each element glyph */
1370 count = num_components;
1371 comp = components;
1372 for ( ; count > 0; count--, comp++ )
1373 {
1374 TT_SBit_Range elem_range;
1375 TT_SBit_MetricsRec elem_metrics;
1376 FT_ULong elem_offset;
1377
1378
1379 /* find the range for this element */
1380 error = find_sbit_range( comp->glyph_code,
1381 strike,
1382 &elem_range,
1383 &elem_offset );
1384 if ( error )
1385 goto Fail_Memory;
1386
1387 /* now load the element, recursively */
1388 error = Load_SBit_Image( strike,
1389 elem_range,
1390 ebdt_pos,
1391 elem_offset,
1392 slot,
1393 x_offset + comp->x_offset,
1394 y_offset + comp->y_offset,
1395 stream,
1396 &elem_metrics,
1397 depth + 1 );
1398 if ( error )
1399 goto Fail_Memory;
1400 }
1401
1402 Fail_Memory:
1403 FT_FREE( components );
1404 }
1405
1406 Exit:
1407 return error;
1408 }
1409
1410
1411 /*************************************************************************/
1412 /* */
1413 /* <Function> */
1414 /* tt_face_load_sbit_image */
1415 /* */
1416 /* <Description> */
1417 /* Loads a given glyph sbit image from the font resource. This also */
1418 /* returns its metrics. */
1419 /* */
1420 /* <Input> */
1421 /* face :: The target face object. */
1422 /* */
1423 /* strike_index :: The current strike index. */
1424 /* */
1425 /* glyph_index :: The current glyph index. */
1426 /* */
1427 /* load_flags :: The glyph load flags (the code checks for the flag */
1428 /* FT_LOAD_CROP_BITMAP). */
1429 /* */
1430 /* stream :: The input stream. */
1431 /* */
1432 /* <Output> */
1433 /* map :: The target pixmap. */
1434 /* */
1435 /* metrics :: A big sbit metrics structure for the glyph image. */
1436 /* */
1437 /* <Return> */
1438 /* FreeType error code. 0 means success. Returns an error if no */
1439 /* glyph sbit exists for the index. */
1440 /* */
1441 /* <Note> */
1442 /* The `map.buffer' field is always freed before the glyph is loaded. */
1443 /* */
1444 FT_LOCAL_DEF( FT_Error )
1445 tt_face_load_sbit_image( TT_Face face,
1446 FT_ULong strike_index,
1447 FT_UInt glyph_index,
1448 FT_UInt load_flags,
1449 FT_Stream stream,
1450 FT_Bitmap *map,
1451 TT_SBit_MetricsRec *metrics )
1452 {
1453 FT_Error error;
1454 FT_ULong ebdt_pos, glyph_offset;
1455
1456 TT_SBit_Strike strike;
1457 TT_SBit_Range range;
1458
1459
1460 /* Check whether there is a glyph sbit for the current index */
1461 error = tt_find_sbit_image( face, glyph_index, strike_index,
1462 &range, &strike, &glyph_offset );
1463 if ( error )
1464 goto Exit;
1465
1466 /* now, find the location of the `EBDT' table in */
1467 /* the font file */
1468 error = face->goto_table( face, TTAG_EBDT, stream, 0 );
1469 if ( error )
1470 error = face->goto_table( face, TTAG_bdat, stream, 0 );
1471 if ( error )
1472 goto Exit;
1473
1474 ebdt_pos = FT_STREAM_POS();
1475
1476 error = Load_SBit_Image( strike, range, ebdt_pos, glyph_offset,
1477 face->root.glyph, 0, 0, stream, metrics, 0 );
1478 if ( error )
1479 goto Exit;
1480
1481 /* setup vertical metrics if needed */
1482 if ( strike->flags & 1 )
1483 {
1484 /* in case of a horizontal strike only */
1485 FT_Int advance;
1486
1487
1488 advance = strike->hori.ascender - strike->hori.descender;
1489
1490 /* some heuristic values */
1491
1492 metrics->vertBearingX = (FT_Char)(-metrics->width / 2 );
1493 metrics->vertBearingY = (FT_Char)( ( advance - metrics->height ) / 2 );
1494 metrics->vertAdvance = (FT_Char)( advance * 12 / 10 );
1495 }
1496
1497 /* Crop the bitmap now, unless specified otherwise */
1498 if ( load_flags & FT_LOAD_CROP_BITMAP )
1499 crop_bitmap( map, metrics );
1500
1501 Exit:
1502 return error;
1503 }
1504
1505 #endif /* FT_CONFIG_OPTION_OLD_INTERNALS */
1506
1507
1508 /* END */
FT_Error
int FT_Error
Definition: fttypes.h:296
TT_SBit_RangeRec_::glyph_offsets
FT_ULong * glyph_offsets
Definition: tttypes.h:602
val
GLuint const GLfloat * val
Definition: glew.h:2715
TT_SBit_Small_Metrics_
Definition: tttypes.h:472
FT_Long
signed long FT_Long
Definition: fttypes.h:238
FT_ULong
unsigned long FT_ULong
Definition: fttypes.h:249
FT_GlyphSlotRec_
Definition: freetype.h:1605
TT_SBit_MetricsRec_::horiBearingY
FT_Char horiBearingY
Definition: tttypes.h:441
NULL
#define NULL
Definition: ftobjs.h:61
FT_Int
signed int FT_Int
Definition: fttypes.h:216
FT_Bitmap_::rows
int rows
Definition: ftimage.h:312
FT_Frame_Field_
Definition: ftstream.h:86
FT_StreamRec_::cursor
unsigned char * cursor
Definition: ftsystem.h:333
TT_SBit_LineMetricsRec_::descender
FT_Char descender
Definition: tttypes.h:538
stream
GLuint GLuint stream
Definition: glew.h:6573
n
GLclampd n
Definition: glew.h:7287
TT_SBit_StrikeRec_::y_ppem
FT_Byte y_ppem
Definition: tttypes.h:668
FT_GET_CHAR
#define FT_GET_CHAR()
Definition: ftstream.h:293
TT_SBit_RangeRec_::first_glyph
FT_UShort first_glyph
Definition: tttypes.h:591
FT_Bitmap_::buffer
unsigned char * buffer
Definition: ftimage.h:315
metrics
GLuint GLsizei GLsizei GLfloat * metrics
Definition: glew.h:12394
TT_SBit_LineMetricsRec_::ascender
FT_Char ascender
Definition: tttypes.h:537
FT_Char
signed char FT_Char
Definition: fttypes.h:139
TT_SBit_StrikeRec_::start_glyph
FT_UShort start_glyph
Definition: tttypes.h:664
version
int const char * version
Definition: zlib.h:813
TT_SBit_LineMetricsRec_::min_origin_SB
FT_Char min_origin_SB
Definition: tttypes.h:543
height
EGLSurface EGLint EGLint EGLint EGLint height
Definition: eglext.h:293
tt_face_set_sbit_strike
tt_face_set_sbit_strike(TT_Face face, FT_Size_Request req, FT_ULong *astrike_index)
Definition: ttsbit0.c:122
FT_Bitmap_::pitch
int pitch
Definition: ftimage.h:314
TT_SBit_Small_Metrics_::width
FT_Byte width
Definition: tttypes.h:475
TT_SBit_StrikeRec_::bit_depth
FT_Byte bit_depth
Definition: tttypes.h:670
FT_READ_USHORT
#define FT_READ_USHORT(var)
Definition: ftstream.h:316
comp
static int comp(const void *a, const void *b)
Definition: lsp.c:298
FT_PIXEL_MODE_GRAY
Definition: ftimage.h:176
TTAG_EBLC
#define TTAG_EBLC
Definition: tttags.h:50
TT_SBit_StrikeRec_::hori
TT_SBit_LineMetricsRec hori
Definition: tttypes.h:661
tt_face_load_sbit_image
tt_face_load_sbit_image(TT_Face face, FT_ULong strike_index, FT_UInt glyph_index, FT_UInt load_flags, FT_Stream stream, FT_Bitmap *map, TT_SBit_MetricsRec *metrics)
Definition: ttsbit0.c:985
FT_Bool
FT_BEGIN_HEADER typedef unsigned char FT_Bool
Definition: fttypes.h:104
TT_SBit_RangeRec_::last_glyph
FT_UShort last_glyph
Definition: tttypes.h:592
TT_SBit_StrikeRec_::ranges_offset
FT_ULong ranges_offset
Definition: tttypes.h:657
TT_SBit_RangeRec_::num_glyphs
FT_ULong num_glyphs
Definition: tttypes.h:600
TT_SBit_RangeRec_
Definition: tttypes.h:589
TT_SBit_StrikeRec_::x_ppem
FT_Byte x_ppem
Definition: tttypes.h:667
FT_ERROR
#define FT_ERROR(varformat)
Definition: ftdebug.h:181
FT_Byte
unsigned char FT_Byte
Definition: fttypes.h:150
TT_SBit_StrikeRec_::vert
TT_SBit_LineMetricsRec vert
Definition: tttypes.h:662
FT_LOCAL
#define FT_LOCAL(x)
Definition: ftconfig.h:466
target
EGLContext EGLenum target
Definition: eglext.h:87
range
GLenum GLint * range
Definition: glew.h:3391
FT_GlyphSlotRec_::bitmap
FT_Bitmap bitmap
Definition: freetype.h:1620
FT_STREAM_READ_FIELDS
#define FT_STREAM_READ_FIELDS(fields, object)
Definition: ftstream.h:513
TT_SBit_ComponentRec_
Definition: tttypes.h:691
FT_Match_Size
FT_Match_Size(FT_Face face, FT_Size_Request req, FT_Bool ignore_width, FT_ULong *size_index)
Definition: ftobjs.c:2479
TT_SBit_MetricsRec_::horiBearingX
FT_Char horiBearingX
Definition: tttypes.h:440
FT_StreamRec_::memory
FT_Memory memory
Definition: ftsystem.h:332
FT_GET_USHORT
#define FT_GET_USHORT()
Definition: ftstream.h:296
FT_FREE
#define FT_FREE(ptr)
Definition: ftmemory.h:286
FT_FRAME_END
#define FT_FRAME_END
Definition: ftstream.h:118
FT_STREAM_SKIP
#define FT_STREAM_SKIP(distance)
Definition: ftstream.h:499
FT_FRAME_USHORT
#define FT_FRAME_USHORT(f)
Definition: ftstream.h:123
FT_LOCAL_DEF
#define FT_LOCAL_DEF(x)
Definition: ftconfig.h:467
ttsbit0.c
TT_SBit_MetricsRec_::height
FT_Byte height
Definition: tttypes.h:437
TT_SBit_Small_Metrics_::height
FT_Byte height
Definition: tttypes.h:474
FT_FaceRec_
Definition: freetype.h:912
FT_PIXEL_MODE_GRAY2
Definition: ftimage.h:177
for
for(;;)
Definition: glslang_tab.cpp:4773
FT_LOAD_CROP_BITMAP
#define FT_LOAD_CROP_BITMAP
Definition: freetype.h:2518
error
FT_Error error
Definition: cffdrivr.c:407
width
EGLSurface EGLint EGLint EGLint width
Definition: eglext.h:293
TT_SBit_MetricsRec_::vertBearingX
FT_Char vertBearingX
Definition: tttypes.h:444
TT_SBit_StrikeRec_::flags
FT_Char flags
Definition: tttypes.h:671
ft_glyphslot_alloc_bitmap
ft_glyphslot_alloc_bitmap(FT_GlyphSlot slot, FT_ULong size)
Definition: ftobjs.c:295
FT_READ_ULONG
#define FT_READ_ULONG(var)
Definition: ftstream.h:320
FT_Bitmap_
Definition: ftimage.h:310
count
GLint GLsizei count
Definition: gl2ext.h:1011
face
GLenum face
Definition: gl2ext.h:1490
FT_Size_RequestRec_
Definition: freetype.h:2185
sferrors.h
TT_SBit_RangeRec_::metrics
TT_SBit_MetricsRec metrics
Definition: tttypes.h:599
TTAG_bdat
#define TTAG_bdat
Definition: tttags.h:38
TTAG_bloc
#define TTAG_bloc
Definition: tttags.h:41
TT_SBit_MetricsRec_::vertBearingY
FT_Char vertBearingY
Definition: tttypes.h:445
FT_PIXEL_MODE_GRAY4
Definition: ftimage.h:178
ttsbit.h
TT_SBit_ComponentRec_::glyph_code
FT_UShort glyph_code
Definition: tttypes.h:693
limit
GLint limit
Definition: glew.h:11829
depth
GLint GLenum GLsizei GLsizei GLsizei depth
Definition: gl2ext.h:845
TT_SBit_StrikeRec_::end_glyph
FT_UShort end_glyph
Definition: tttypes.h:665
TT_SBit_Small_Metrics_::bearingY
FT_Char bearingY
Definition: tttypes.h:478
TT_SBit_RangeRec_::image_format
FT_UShort image_format
Definition: tttypes.h:595
TT_SBit_MetricsRec_::width
FT_Byte width
Definition: tttypes.h:438
TT_SBit_StrikeRec_::num_ranges
FT_Int num_ranges
Definition: tttypes.h:655
tt_face_load_eblc
FT_BEGIN_HEADER tt_face_load_eblc(TT_Face face, FT_Stream stream)
Definition: ttsbit0.c:43
TT_SBit_Small_Metrics_::advance
FT_Byte advance
Definition: tttypes.h:479
FT_Memory
typedefFT_BEGIN_HEADER struct FT_MemoryRec_ * FT_Memory
Definition: ftsystem.h:66
FT_Bitmap_::width
int width
Definition: ftimage.h:313
TT_SBit_StrikeRec_
Definition: tttypes.h:653
FT_BOOL
#define FT_BOOL(x)
Definition: fttypes.h:581
FT_FRAME_EXIT
#define FT_FRAME_EXIT()
Definition: ftstream.h:521
TT_SBit_RangeRec_::table_offset
FT_ULong table_offset
Definition: tttypes.h:605
FT_NEW_ARRAY
#define FT_NEW_ARRAY(ptr, count)
Definition: ftmemory.h:290
FT_STREAM_SEEK
#define FT_STREAM_SEEK(position)
Definition: ftstream.h:496
TT_SBit_LineMetricsRec_::min_advance_SB
FT_Char min_advance_SB
Definition: tttypes.h:544
TT_SBit_MetricsRec_
Definition: tttypes.h:435
FT_STREAM_POS
#define FT_STREAM_POS()
Definition: ftstream.h:493
TT_SBit_StrikeRec_::sbit_ranges
TT_SBit_Range sbit_ranges
Definition: tttypes.h:656
TT_SBit_ComponentRec_::y_offset
FT_Char y_offset
Definition: tttypes.h:695
ft2build.h
FT_Fixed
signed long FT_Fixed
Definition: fttypes.h:284
TT_SBit_RangeRec_::glyph_codes
FT_UShort * glyph_codes
Definition: tttypes.h:603
FT_FRAME_ULONG
#define FT_FRAME_ULONG(f)
Definition: ftstream.h:121
flags
GLenum GLsizei GLsizei GLsizei GLsizei GLbitfield flags
Definition: glew.h:2767
FT_UInt
unsigned int FT_UInt
Definition: fttypes.h:227
FT_FRAME_SKIP_LONG
#define FT_FRAME_SKIP_LONG
Definition: ftstream.h:136
FT_FRAME_BYTE
#define FT_FRAME_BYTE(f)
Definition: ftstream.h:126
mask
GLint GLint GLint GLint GLint GLint GLint GLbitfield mask
Definition: gl2ext.h:961
FT_FRAME_CHAR
#define FT_FRAME_CHAR(f)
Definition: ftstream.h:127
TT_SBit_ComponentRec_::x_offset
FT_Char x_offset
Definition: tttypes.h:694
FT_Size_Metrics_
Definition: freetype.h:1360
FT_Bitmap_::pixel_mode
char pixel_mode
Definition: ftimage.h:317
tt_face_free_eblc
tt_face_free_eblc(TT_Face face)
Definition: ttsbit0.c:110
TT_SBit_RangeRec_::index_format
FT_UShort index_format
Definition: tttypes.h:594
FT_GET_ULONG
#define FT_GET_ULONG()
Definition: ftstream.h:300
components
GLenum GLenum GLuint components
Definition: glew.h:10653
FT_FRAME_ENTER
#define FT_FRAME_ENTER(size)
Definition: ftstream.h:517
TT_SBit_LineMetricsRec_::max_width
FT_Byte max_width
Definition: tttypes.h:539
TT_SBit_Small_Metrics_::bearingX
FT_Char bearingX
Definition: tttypes.h:477
map
const GLubyte GLuint GLuint GLuint GLuint alpha GLboolean GLboolean GLboolean GLboolean alpha GLint GLint GLsizei GLsizei GLenum type GLenum GLint GLenum GLint GLint GLsizei GLsizei GLint border GLenum GLint GLint GLint GLint GLint GLsizei GLsizei height GLsizei GLsizei GLenum GLenum const GLvoid *pixels GLenum GLint GLint GLint GLint j2 GLdouble GLdouble GLdouble GLdouble GLdouble GLdouble zFar GLenum GLenum GLint *params GLenum GLenum GLint *params GLenum GLenum GLint *params GLenum GLenum GLfloat *params GLenum GLint GLenum GLenum GLvoid *pixels GLenum GLint GLenum GLint *params GLenum GLenum GLint *params GLenum GLsizei const GLvoid *pointer GLenum GLenum const GLint *params GLenum GLfloat GLfloat GLint GLint const GLfloat *points GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat *points GLint GLfloat GLfloat GLint GLfloat GLfloat v2 GLenum GLenum const GLint *params GLdouble GLdouble GLdouble GLdouble GLdouble GLdouble zFar GLenum map
Definition: SDL_glfuncs.h:268
right
GLfloat right
Definition: glew.h:13816
TT_SBit_RangeRec_::image_offset
FT_ULong image_offset
Definition: tttypes.h:596
FT_GET_LONG
#define FT_GET_LONG()
Definition: ftstream.h:299
FT_UShort
unsigned short FT_UShort
Definition: fttypes.h:205
FT_StreamRec_
Definition: ftsystem.h:321
FT_MEM_MOVE
#define FT_MEM_MOVE(dest, source, count)
Definition: ftmemory.h:205
source
GLsizei GLsizei GLchar * source
Definition: gl2ext.h:994
TT_FaceRec_
Definition: tttypes.h:1258
FT_FRAME_START
#define FT_FRAME_START(size)
Definition: ftstream.h:117
TT_SBit_RangeRec_::image_size
FT_ULong image_size
Definition: tttypes.h:598
tt_face_load_strike_metrics
tt_face_load_strike_metrics(TT_Face face, FT_ULong strike_index, FT_Size_Metrics *metrics)
Definition: ttsbit0.c:131
size
GLsizei size
Definition: gl2ext.h:1467
FT_PIXEL_MODE_MONO
Definition: ftimage.h:175
TTAG_EBDT
#define TTAG_EBDT
Definition: tttags.h:49