]> git.saurik.com Git - wxWidgets.git/blob - src/freetype/sfnt/ttload.c
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
better learn the operators...
[wxWidgets.git] / src / freetype / sfnt / ttload.c
1 /***************************************************************************/
2 /* */
3 /* ttload.c */
4 /* */
5 /* Load the basic TrueType tables, i.e., tables that can be either in */
6 /* TTF or OTF fonts (body). */
7 /* */
8 /* Copyright 1996-2000 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 #include <freetype/internal/ftdebug.h>
21 #include <freetype/internal/tterrors.h>
22 #include <freetype/tttags.h>
23
24
25 #ifdef FT_FLAT_COMPILE
26
27 #include "ttload.h"
28 #include "ttcmap.h"
29
30 #else
31
32 #include <sfnt/ttload.h>
33 #include <sfnt/ttcmap.h>
34
35 #endif
36
37
38 /*************************************************************************/
39 /* */
40 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
41 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
42 /* messages during execution. */
43 /* */
44 #undef FT_COMPONENT
45 #define FT_COMPONENT trace_ttload
46
47
48 /*************************************************************************/
49 /* */
50 /* <Function> */
51 /* TT_LookUp_Table */
52 /* */
53 /* <Description> */
54 /* Looks for a TrueType table by name. */
55 /* */
56 /* <Input> */
57 /* face :: A face object handle. */
58 /* tag :: The searched tag. */
59 /* */
60 /* <Return> */
61 /* A pointer to the table directory entry. 0 if not found. */
62 /* */
63 LOCAL_FUNC
64 TT_Table* TT_LookUp_Table( TT_Face face,
65 FT_ULong tag )
66 {
67 TT_Table* entry;
68 TT_Table* limit;
69
70
71 FT_TRACE3(( "TT_LookUp_Table: %08p, `%c%c%c%c'\n",
72 face,
73 (FT_Char)( tag >> 24 ),
74 (FT_Char)( tag >> 16 ),
75 (FT_Char)( tag >> 8 ),
76 (FT_Char)( tag ) ));
77
78 entry = face->dir_tables;
79 limit = entry + face->num_tables;
80
81 for ( ; entry < limit; entry++ )
82 {
83 if ( entry->Tag == tag )
84 return entry;
85 }
86
87 FT_TRACE3(( " Could not find table!\n" ));
88 return 0;
89 }
90
91
92 /*************************************************************************/
93 /* */
94 /* <Function> */
95 /* TT_Goto_Table */
96 /* */
97 /* <Description> */
98 /* Looks for a TrueType table by name, then seek a stream to it. */
99 /* */
100 /* <Input> */
101 /* face :: A face object handle. */
102 /* tag :: The searched tag. */
103 /* stream :: The stream to seek when the table is found. */
104 /* */
105 /* <Output> */
106 /* length :: The length of the table if found, undefined otherwise. */
107 /* */
108 /* <Return> */
109 /* FreeType error code. 0 means success. */
110 /* */
111 LOCAL_FUNC
112 FT_Error TT_Goto_Table( TT_Face face,
113 FT_ULong tag,
114 FT_Stream stream,
115 FT_ULong* length )
116 {
117 TT_Table* table;
118 FT_Error error;
119
120
121 table = TT_LookUp_Table( face, tag );
122 if ( table )
123 {
124 if ( length )
125 *length = table->Length;
126
127 (void)FILE_Seek( table->Offset );
128 }
129 else
130 error = TT_Err_Table_Missing;
131
132 return error;
133 }
134
135
136 /*************************************************************************/
137 /* */
138 /* <Function> */
139 /* TT_Load_SFNT_Header */
140 /* */
141 /* <Description> */
142 /* Loads the header of a SFNT font file. Supports collections. */
143 /* */
144 /* <Input> */
145 /* face :: A handle to the target face object. */
146 /* stream :: The input stream. */
147 /* face_index :: If the font is a collection, the number of the font */
148 /* in the collection, ignored otherwise. */
149 /* */
150 /* <Output> */
151 /* sfnt :: The SFNT header. */
152 /* */
153 /* <Return> */
154 /* FreeType error code. 0 means success. */
155 /* */
156 /* <Note> */
157 /* The stream cursor must be at the font file's origin. */
158 /* */
159 /* This function recognizes fonts embedded in a `TrueType collection' */
160 /* */
161 /* The header will be checked whether it is valid by looking at the */
162 /* values of `search_range', `entry_selector', and `range_shift'. */
163 /* */
164 LOCAL_FUNC
165 FT_Error TT_Load_SFNT_Header( TT_Face face,
166 FT_Stream stream,
167 FT_Long face_index,
168 SFNT_Header* sfnt )
169 {
170 FT_Error error;
171 FT_ULong format_tag;
172 FT_Memory memory = stream->memory;
173
174 const FT_Frame_Field sfnt_header_fields[] =
175 {
176 FT_FRAME_START( 8 ),
177 FT_FRAME_USHORT( SFNT_Header, num_tables ),
178 FT_FRAME_USHORT( SFNT_Header, search_range ),
179 FT_FRAME_USHORT( SFNT_Header, entry_selector ),
180 FT_FRAME_USHORT( SFNT_Header, range_shift ),
181 FT_FRAME_END
182 };
183
184 const FT_Frame_Field ttc_header_fields[] =
185 {
186 FT_FRAME_START( 8 ),
187 FT_FRAME_LONG( TTC_Header, version ),
188 FT_FRAME_LONG( TTC_Header, count ),
189 FT_FRAME_END };
190
191
192 FT_TRACE2(( "TT_Load_SFNT_Header: %08p, %ld\n",
193 face, face_index ));
194
195 face->ttc_header.tag = 0;
196 face->ttc_header.version = 0;
197 face->ttc_header.count = 0;
198
199 face->num_tables = 0;
200
201 /* first of all, read the first 4 bytes. If it is `ttcf', then the */
202 /* file is a TrueType collection, otherwise it can be any other */
203 /* kind of font. */
204 if ( READ_ULong( format_tag ) )
205 goto Exit;
206
207 if ( format_tag == TTAG_ttcf )
208 {
209 FT_Int n;
210
211
212 FT_TRACE3(( "TT_Load_SFNT_Header: file is a collection\n" ));
213
214 /* it's a TrueType collection, i.e. a file containing several */
215 /* font files. Read the font directory now */
216 if ( READ_Fields( ttc_header_fields, &face->ttc_header ) )
217 goto Exit;
218
219 /* now read the offsets of each font in the file */
220 if ( ALLOC_ARRAY( face->ttc_header.offsets,
221 face->ttc_header.count,
222 FT_ULong ) ||
223 ACCESS_Frame( face->ttc_header.count * 4L ) )
224 goto Exit;
225
226 for ( n = 0; n < face->ttc_header.count; n++ )
227 face->ttc_header.offsets[n] = GET_ULong();
228
229 FORGET_Frame();
230
231 /* check face index */
232 if ( face_index >= face->ttc_header.count )
233 {
234 error = TT_Err_Bad_Argument;
235 goto Exit;
236 }
237
238 /* seek to the appropriate TrueType file, then read tag */
239 if ( FILE_Seek( face->ttc_header.offsets[face_index] ) ||
240 READ_Long( format_tag ) )
241 goto Exit;
242 }
243
244 /* the format tag was read, now check the rest of the header */
245 sfnt->format_tag = format_tag;
246 if ( READ_Fields( sfnt_header_fields, sfnt ) )
247 goto Exit;
248
249 /* now, check the values of `num_tables', `seach_range', etc. */
250 {
251 FT_UInt num_tables = sfnt->num_tables;
252 FT_ULong entry_selector = 1L << sfnt->entry_selector;
253
254
255 /* IMPORTANT: Many fonts have an incorrect `search_range' value, so */
256 /* we only check the `entry_selector' correctness here. */
257 /* */
258 if ( num_tables == 0 ||
259 entry_selector > num_tables ||
260 entry_selector * 2 <= num_tables )
261 {
262 FT_TRACE2(( "TT_Load_SFNT_Header: file is not SFNT!\n" ));
263 error = FT_Err_Unknown_File_Format;
264 }
265 }
266
267 Exit:
268 return error;
269 }
270
271
272 /*************************************************************************/
273 /* */
274 /* <Function> */
275 /* TT_Load_Directory */
276 /* */
277 /* <Description> */
278 /* Loads the table directory into a face object. */
279 /* */
280 /* <InOut> */
281 /* face :: A handle to the target face object. */
282 /* */
283 /* <Input> */
284 /* stream :: The input stream. */
285 /* sfnt :: The SFNT directory header. */
286 /* */
287 /* <Return> */
288 /* FreeType error code. 0 means success. */
289 /* */
290 /* <Note> */
291 /* The stream cursor must be at the font file's origin. */
292 /* */
293 LOCAL_FUNC
294 FT_Error TT_Load_Directory( TT_Face face,
295 FT_Stream stream,
296 SFNT_Header* sfnt )
297 {
298 FT_Error error;
299 FT_Memory memory = stream->memory;
300
301 TT_Table *entry, *limit;
302
303
304 FT_TRACE2(( "TT_Load_Directory: %08p\n", face ));
305
306 FT_TRACE2(( "-- Tables count: %12u\n", sfnt->num_tables ));
307 FT_TRACE2(( "-- Format version: %08lx\n", sfnt->format_tag ));
308
309 face->num_tables = sfnt->num_tables;
310
311 if ( ALLOC_ARRAY( face->dir_tables,
312 face->num_tables,
313 TT_Table ) )
314 goto Exit;
315
316 if ( ACCESS_Frame( face->num_tables * 16L ) )
317 goto Exit;
318
319 entry = face->dir_tables;
320 limit = entry + face->num_tables;
321
322 for ( ; entry < limit; entry++ )
323 { /* loop through the tables and get all entries */
324 entry->Tag = GET_Tag4();
325 entry->CheckSum = GET_ULong();
326 entry->Offset = GET_Long();
327 entry->Length = GET_Long();
328
329 FT_TRACE2(( " %c%c%c%c - %08lx - %08lx\n",
330 (FT_Char)( entry->Tag >> 24 ),
331 (FT_Char)( entry->Tag >> 16 ),
332 (FT_Char)( entry->Tag >> 8 ),
333 (FT_Char)( entry->Tag ),
334 entry->Offset,
335 entry->Length ));
336 }
337
338 FORGET_Frame();
339
340 FT_TRACE2(( "Directory loaded\n\n" ));
341
342 Exit:
343 return error;
344 }
345
346
347 /*************************************************************************/
348 /* */
349 /* <Function> */
350 /* TT_Load_Any */
351 /* */
352 /* <Description> */
353 /* Loads any font table into client memory. */
354 /* */
355 /* <Input> */
356 /* face :: The face object to look for. */
357 /* */
358 /* tag :: The tag of table to load. Use the value 0 if you want */
359 /* to access the whole font file, else set this parameter */
360 /* to a valid TrueType table tag that you can forge with */
361 /* the MAKE_TT_TAG macro. */
362 /* */
363 /* offset :: The starting offset in the table (or the file if */
364 /* tag == 0). */
365 /* */
366 /* length :: The address of the decision variable: */
367 /* */
368 /* If length == NULL: */
369 /* Loads the whole table. Returns an error if */
370 /* `offset' == 0! */
371 /* */
372 /* If *length == 0: */
373 /* Exits immediately; returning the length of the given */
374 /* table or of the font file, depending on the value of */
375 /* `tag'. */
376 /* */
377 /* If *length != 0: */
378 /* Loads the next `length' bytes of table or font, */
379 /* starting at offset `offset' (in table or font too). */
380 /* */
381 /* <Output> */
382 /* buffer :: The address of target buffer. */
383 /* */
384 /* <Return> */
385 /* FreeType error code. 0 means success. */
386 /* */
387 LOCAL_FUNC
388 FT_Error TT_Load_Any( TT_Face face,
389 FT_ULong tag,
390 FT_Long offset,
391 FT_Byte* buffer,
392 FT_ULong* length )
393 {
394 FT_Error error;
395 FT_Stream stream;
396 TT_Table* table;
397 FT_ULong size;
398
399
400 if ( tag != 0 )
401 {
402 /* look for tag in font directory */
403 table = TT_LookUp_Table( face, tag );
404 if ( !table )
405 {
406 error = TT_Err_Table_Missing;
407 goto Exit;
408 }
409
410 offset += table->Offset;
411 size = table->Length;
412 }
413 else
414 /* tag == 0 -- the user wants to access the font file directly */
415 size = face->root.stream->size;
416
417 if ( length && *length == 0 )
418 {
419 *length = size;
420
421 return TT_Err_Ok;
422 }
423
424 if ( length )
425 size = *length;
426
427 stream = face->root.stream;
428 (void)FILE_Read_At( offset, buffer, size );
429
430 Exit:
431 return error;
432 }
433
434
435 /*************************************************************************/
436 /* */
437 /* <Function> */
438 /* TT_Load_Header */
439 /* */
440 /* <Description> */
441 /* Loads the TrueType font header. */
442 /* */
443 /* <Input> */
444 /* face :: A handle to the target face object. */
445 /* stream :: The input stream. */
446 /* */
447 /* <Return> */
448 /* FreeType error code. 0 means success. */
449 /* */
450 LOCAL_FUNC
451 FT_Error TT_Load_Header( TT_Face face,
452 FT_Stream stream )
453 {
454 FT_Error error;
455 TT_Header* header;
456
457 static const FT_Frame_Field header_fields[] =
458 {
459 FT_FRAME_START( 54 ),
460 FT_FRAME_ULONG( TT_Header, Table_Version ),
461 FT_FRAME_ULONG( TT_Header, Font_Revision ),
462 FT_FRAME_LONG( TT_Header, CheckSum_Adjust ),
463 FT_FRAME_LONG( TT_Header, Magic_Number ),
464 FT_FRAME_USHORT( TT_Header, Flags ),
465 FT_FRAME_USHORT( TT_Header, Units_Per_EM ),
466 FT_FRAME_LONG( TT_Header, Created[0] ),
467 FT_FRAME_LONG( TT_Header, Created[1] ),
468 FT_FRAME_LONG( TT_Header, Modified[0] ),
469 FT_FRAME_LONG( TT_Header, Modified[1] ),
470 FT_FRAME_SHORT( TT_Header, xMin ),
471 FT_FRAME_SHORT( TT_Header, yMin ),
472 FT_FRAME_SHORT( TT_Header, xMax ),
473 FT_FRAME_SHORT( TT_Header, yMax ),
474 FT_FRAME_USHORT( TT_Header, Mac_Style ),
475 FT_FRAME_USHORT( TT_Header, Lowest_Rec_PPEM ),
476 FT_FRAME_SHORT( TT_Header, Font_Direction ),
477 FT_FRAME_SHORT( TT_Header, Index_To_Loc_Format ),
478 FT_FRAME_SHORT( TT_Header, Glyph_Data_Format ),
479 FT_FRAME_END
480 };
481
482
483 FT_TRACE2(( "Load_TT_Header: %08p\n", face ));
484
485 error = face->goto_table( face, TTAG_head, stream, 0 );
486 if ( error )
487 {
488 FT_TRACE0(( "Font Header is missing!\n" ));
489 goto Exit;
490 }
491
492 header = &face->header;
493
494 if ( READ_Fields( header_fields, header ) )
495 goto Exit;
496
497 FT_TRACE2(( " Units per EM: %8u\n", header->Units_Per_EM ));
498 FT_TRACE2(( " IndexToLoc: %8d\n", header->Index_To_Loc_Format ));
499 FT_TRACE2(( "Font Header Loaded.\n" ));
500
501 Exit:
502 return error;
503 }
504
505
506 /*************************************************************************/
507 /* */
508 /* <Function> */
509 /* TT_Load_MaxProfile */
510 /* */
511 /* <Description> */
512 /* Loads the maximum profile into a face object. */
513 /* */
514 /* <Input> */
515 /* face :: A handle to the target face object. */
516 /* stream :: The input stream. */
517 /* */
518 /* <Return> */
519 /* FreeType error code. 0 means success. */
520 /* */
521 LOCAL_FUNC
522 FT_Error TT_Load_MaxProfile( TT_Face face,
523 FT_Stream stream )
524 {
525 FT_Error error;
526 TT_MaxProfile* maxProfile = &face->max_profile;
527
528 const FT_Frame_Field maxp_fields[] =
529 {
530 FT_FRAME_START( 32 ),
531 FT_FRAME_ULONG( TT_MaxProfile, version ),
532 FT_FRAME_USHORT( TT_MaxProfile, numGlyphs ),
533 FT_FRAME_USHORT( TT_MaxProfile, maxPoints ),
534 FT_FRAME_USHORT( TT_MaxProfile, maxContours ),
535 FT_FRAME_USHORT( TT_MaxProfile, maxCompositePoints ),
536 FT_FRAME_USHORT( TT_MaxProfile, maxCompositeContours ),
537 FT_FRAME_USHORT( TT_MaxProfile, maxZones ),
538 FT_FRAME_USHORT( TT_MaxProfile, maxTwilightPoints ),
539 FT_FRAME_USHORT( TT_MaxProfile, maxStorage ),
540 FT_FRAME_USHORT( TT_MaxProfile, maxFunctionDefs ),
541 FT_FRAME_USHORT( TT_MaxProfile, maxInstructionDefs ),
542 FT_FRAME_USHORT( TT_MaxProfile, maxStackElements ),
543 FT_FRAME_USHORT( TT_MaxProfile, maxSizeOfInstructions ),
544 FT_FRAME_USHORT( TT_MaxProfile, maxComponentElements ),
545 FT_FRAME_USHORT( TT_MaxProfile, maxComponentDepth ),
546 FT_FRAME_END };
547
548
549 FT_TRACE2(( "Load_TT_MaxProfile: %08p\n", face ));
550
551 error = face->goto_table( face, TTAG_maxp, stream, 0 );
552 if ( error )
553 goto Exit;
554
555 if ( READ_Fields( maxp_fields, maxProfile ) )
556 goto Exit;
557
558 /* XXX: an adjustment that is necessary to load certain */
559 /* broken fonts like `Keystrokes MT' :-( */
560 /* */
561 /* We allocate 64 function entries by default when */
562 /* the maxFunctionDefs field is null. */
563
564 if ( maxProfile->maxFunctionDefs == 0 )
565 maxProfile->maxFunctionDefs = 64;
566
567 face->root.num_glyphs = maxProfile->numGlyphs;
568
569 face->root.max_points = MAX( maxProfile->maxCompositePoints,
570 maxProfile->maxPoints );
571
572 face->root.max_contours = MAX( maxProfile->maxCompositeContours,
573 maxProfile->maxContours );
574
575 face->max_components = (FT_ULong)maxProfile->maxComponentElements +
576 maxProfile->maxComponentDepth;
577
578 /* XXX: some fonts have maxComponents set to 0; we will */
579 /* then use 16 of them by default. */
580 if ( face->max_components == 0 )
581 face->max_components = 16;
582
583 /* We also increase maxPoints and maxContours in order to support */
584 /* some broken fonts. */
585 face->root.max_points += 8;
586 face->root.max_contours += 4;
587
588 FT_TRACE2(( "MAXP loaded.\n" ));
589
590 Exit:
591 return error;
592 }
593
594
595 /*************************************************************************/
596 /* */
597 /* <Function> */
598 /* TT_Load_Metrics */
599 /* */
600 /* <Description> */
601 /* Loads the horizontal or vertical metrics table into a face object. */
602 /* */
603 /* <Input> */
604 /* face :: A handle to the target face object. */
605 /* stream :: The input stream. */
606 /* vertical :: A boolean flag. If set, load vertical metrics. */
607 /* */
608 /* <Return> */
609 /* FreeType error code. 0 means success. */
610 /* */
611 static
612 FT_Error TT_Load_Metrics( TT_Face face,
613 FT_Stream stream,
614 FT_Bool vertical )
615 {
616 FT_Error error;
617 FT_Memory memory = stream->memory;
618
619 FT_ULong table_len;
620 FT_Long num_shorts, num_longs, num_shorts_checked;
621
622 TT_LongMetrics** longs;
623 TT_ShortMetrics** shorts;
624
625
626 FT_TRACE2(( "TT_Load_%s_Metrics: %08p\n", vertical ? "Vertical"
627 : "Horizontal",
628 face ));
629
630 if ( vertical )
631 {
632 /* The table is optional, quit silently if it wasn't found */
633 /* XXX: Some fonts have a valid vertical header with a non-null */
634 /* `number_of_VMetrics' fields, but no corresponding `vmtx' */
635 /* table to get the metrics from (e.g. mingliu). */
636 /* */
637 /* For safety, we set the field to 0! */
638 /* */
639 error = face->goto_table( face, TTAG_vmtx, stream, &table_len );
640 if ( error )
641 {
642 /* Set number_Of_VMetrics to 0! */
643 FT_TRACE2(( " no vertical header in file.\n" ));
644 face->vertical.number_Of_VMetrics = 0;
645 error = TT_Err_Ok;
646 goto Exit;
647 }
648
649 num_longs = face->vertical.number_Of_VMetrics;
650 longs = (TT_LongMetrics**)&face->vertical.long_metrics;
651 shorts = (TT_ShortMetrics**)&face->vertical.short_metrics;
652 }
653 else
654 {
655 error = face->goto_table( face, TTAG_hmtx, stream, &table_len );
656 if ( error )
657 {
658 FT_ERROR(( " no horizontal metrics in file!\n" ));
659 error = TT_Err_Hmtx_Table_Missing;
660 goto Exit;
661 }
662
663 num_longs = face->horizontal.number_Of_HMetrics;
664 longs = (TT_LongMetrics**)&face->horizontal.long_metrics;
665 shorts = (TT_ShortMetrics**)&face->horizontal.short_metrics;
666 }
667
668 /* never trust derived values */
669
670 num_shorts = face->max_profile.numGlyphs - num_longs;
671 num_shorts_checked = ( table_len - num_longs * 4L ) / 2;
672
673 if ( num_shorts < 0 )
674 {
675 FT_ERROR(( "TT_Load_%s_Metrics: more metrics than glyphs!\n",
676 vertical ? "Vertical"
677 : "Horizontal" ));
678
679 error = vertical ? TT_Err_Invalid_Vert_Metrics
680 : TT_Err_Invalid_Horiz_Metrics;
681 goto Exit;
682 }
683
684 if ( ALLOC_ARRAY( *longs, num_longs, TT_LongMetrics ) ||
685 ALLOC_ARRAY( *shorts, num_shorts, TT_ShortMetrics ) )
686 goto Exit;
687
688 if ( ACCESS_Frame( table_len ) )
689 goto Exit;
690
691 {
692 TT_LongMetrics* cur = *longs;
693 TT_LongMetrics* limit = cur + num_longs;
694
695
696 for ( ; cur < limit; cur++ )
697 {
698 cur->advance = GET_UShort();
699 cur->bearing = GET_Short();
700 }
701 }
702
703 /* do we have an inconsistent number of metric values? */
704 {
705 TT_ShortMetrics* cur = *shorts;
706 TT_ShortMetrics* limit = cur + MIN( num_shorts, num_shorts_checked );
707
708
709 for ( ; cur < limit; cur++ )
710 *cur = GET_Short();
711
712 /* we fill up the missing left side bearings with the */
713 /* last valid value. Since this will occur for buggy CJK */
714 /* fonts usually only, nothing serious will happen */
715 if ( num_shorts > num_shorts_checked && num_shorts_checked > 0 )
716 {
717 FT_Short val = *(shorts)[num_shorts_checked - 1];
718
719
720 limit = *shorts + num_shorts;
721 for ( ; cur < limit; cur++ )
722 *cur = val;
723 }
724 }
725
726 FORGET_Frame();
727
728 FT_TRACE2(( "loaded\n" ));
729
730 Exit:
731 return error;
732 }
733
734
735 /*************************************************************************/
736 /* */
737 /* <Function> */
738 /* TT_Load_Metrics_Header */
739 /* */
740 /* <Description> */
741 /* Loads the horizontal or vertical header in a face object. */
742 /* */
743 /* <Input> */
744 /* face :: A handle to the target face object. */
745 /* stream :: The input stream. */
746 /* vertical :: A boolean flag. If set, load vertical metrics. */
747 /* */
748 /* <Return> */
749 /* FreeType error code. 0 means success. */
750 /* */
751 LOCAL_FUNC
752 FT_Error TT_Load_Metrics_Header( TT_Face face,
753 FT_Stream stream,
754 FT_Bool vertical )
755 {
756 FT_Error error;
757 TT_HoriHeader* header;
758
759 const FT_Frame_Field metrics_header_fields[] =
760 {
761 FT_FRAME_START( 36 ),
762 FT_FRAME_ULONG( TT_HoriHeader, Version ),
763 FT_FRAME_SHORT( TT_HoriHeader, Ascender ),
764 FT_FRAME_SHORT( TT_HoriHeader, Descender ),
765 FT_FRAME_SHORT( TT_HoriHeader, Line_Gap ),
766 FT_FRAME_USHORT( TT_HoriHeader, advance_Width_Max ),
767 FT_FRAME_SHORT( TT_HoriHeader, min_Left_Side_Bearing ),
768 FT_FRAME_SHORT( TT_HoriHeader, min_Right_Side_Bearing ),
769 FT_FRAME_SHORT( TT_HoriHeader, xMax_Extent ),
770 FT_FRAME_SHORT( TT_HoriHeader, caret_Slope_Rise ),
771 FT_FRAME_SHORT( TT_HoriHeader, caret_Slope_Run ),
772 FT_FRAME_SHORT( TT_HoriHeader, Reserved[0] ),
773 FT_FRAME_SHORT( TT_HoriHeader, Reserved[1] ),
774 FT_FRAME_SHORT( TT_HoriHeader, Reserved[2] ),
775 FT_FRAME_SHORT( TT_HoriHeader, Reserved[3] ),
776 FT_FRAME_SHORT( TT_HoriHeader, Reserved[4] ),
777 FT_FRAME_SHORT( TT_HoriHeader, metric_Data_Format ),
778 FT_FRAME_USHORT( TT_HoriHeader, number_Of_HMetrics ),
779 FT_FRAME_END
780 };
781
782
783 FT_TRACE2(( vertical ? "Vertical header " : "Horizontal header " ));
784
785 if ( vertical )
786 {
787 face->vertical_info = 0;
788
789 /* The vertical header table is optional, so return quietly if */
790 /* we don't find it. */
791 error = face->goto_table( face, TTAG_vhea, stream, 0 );
792 if ( error )
793 {
794 error = TT_Err_Ok;
795 goto Exit;
796 }
797
798 face->vertical_info = 1;
799 header = (TT_HoriHeader*)&face->vertical;
800 }
801 else
802 {
803 /* The horizontal header is mandatory; return an error if we */
804 /* don't find it. */
805 error = face->goto_table( face, TTAG_hhea, stream, 0 );
806 if ( error )
807 {
808 error = TT_Err_Horiz_Header_Missing;
809 goto Exit;
810 }
811
812 header = &face->horizontal;
813 }
814
815 if ( READ_Fields( metrics_header_fields, header ) )
816 goto Exit;
817
818 header->long_metrics = NULL;
819 header->short_metrics = NULL;
820
821 FT_TRACE2(( "loaded\n" ));
822
823 /* Now try to load the corresponding metrics */
824
825 error = TT_Load_Metrics( face, stream, vertical );
826
827 Exit:
828 return error;
829 }
830
831
832 /*************************************************************************/
833 /* */
834 /* <Function> */
835 /* TT_Load_Names */
836 /* */
837 /* <Description> */
838 /* Loads the name records. */
839 /* */
840 /* <Input> */
841 /* face :: A handle to the target face object. */
842 /* stream :: The input stream. */
843 /* */
844 /* <Return> */
845 /* FreeType error code. 0 means success. */
846 /* */
847 LOCAL_FUNC
848 FT_Error TT_Load_Names( TT_Face face,
849 FT_Stream stream )
850 {
851 FT_Error error;
852 FT_Memory memory = stream->memory;
853
854 FT_ULong table_pos, table_len;
855 FT_ULong storageSize;
856
857 TT_NameTable* names;
858
859 const FT_Frame_Field name_table_fields[] =
860 {
861 FT_FRAME_START( 6 ),
862 FT_FRAME_USHORT( TT_NameTable, format ),
863 FT_FRAME_USHORT( TT_NameTable, numNameRecords ),
864 FT_FRAME_USHORT( TT_NameTable, storageOffset ),
865 FT_FRAME_END
866 };
867
868 const FT_Frame_Field name_record_fields[] =
869 {
870 /* no FT_FRAME_START */
871 FT_FRAME_USHORT( TT_NameRec, platformID ),
872 FT_FRAME_USHORT( TT_NameRec, encodingID ),
873 FT_FRAME_USHORT( TT_NameRec, languageID ),
874 FT_FRAME_USHORT( TT_NameRec, nameID ),
875 FT_FRAME_USHORT( TT_NameRec, stringLength ),
876 FT_FRAME_USHORT( TT_NameRec, stringOffset ),
877 FT_FRAME_END
878 };
879
880
881 FT_TRACE2(( "Names " ));
882
883 error = face->goto_table( face, TTAG_name, stream, &table_len );
884 if ( error )
885 {
886 /* The name table is required so indicate failure. */
887 FT_TRACE2(( "is missing!\n" ));
888 error = TT_Err_Name_Table_Missing;
889 goto Exit;
890 }
891
892 table_pos = FILE_Pos();
893
894 names = &face->name_table;
895
896 if ( READ_Fields( name_table_fields, names ) )
897 goto Exit;
898
899 /* Allocate the array of name records. */
900 if ( ALLOC_ARRAY( names->names,
901 names->numNameRecords,
902 TT_NameRec ) ||
903 ACCESS_Frame( names->numNameRecords * 12L ) )
904 goto Exit;
905
906 /* Load the name records and determine how much storage is needed */
907 /* to hold the strings themselves. */
908 {
909 TT_NameRec* cur = names->names;
910 TT_NameRec* limit = cur + names->numNameRecords;
911
912
913 storageSize = 0;
914
915 for ( ; cur < limit; cur ++ )
916 {
917 FT_ULong upper;
918
919
920 (void)READ_Fields( name_record_fields, cur );
921
922 upper = (FT_ULong)( cur->stringOffset + cur->stringLength );
923 if ( upper > storageSize )
924 storageSize = upper;
925 }
926 }
927
928 FORGET_Frame();
929
930 if ( storageSize > 0 )
931 {
932 /* allocate the name storage area in memory, then read it */
933 if ( ALLOC( names->storage, storageSize ) ||
934 FILE_Read_At( table_pos + names->storageOffset,
935 names->storage, storageSize ) )
936 goto Exit;
937
938 /* Go through and assign the string pointers to the name records. */
939 {
940 TT_NameRec* cur = names->names;
941 TT_NameRec* limit = cur + names->numNameRecords;
942
943
944 for ( ; cur < limit; cur++ )
945 cur->string = names->storage + cur->stringOffset;
946 }
947
948 #ifdef FT_DEBUG_LEVEL_TRACE
949
950 /* Print Name Record Table in case of debugging */
951 {
952 TT_NameRec* cur = names->names;
953 TT_NameRec* limit = cur + names->numNameRecords;
954
955
956 for ( ; cur < limit; cur++ )
957 {
958 FT_UInt j;
959
960
961 FT_TRACE3(( "%d %d %x %d\n ",
962 cur->platformID,
963 cur->encodingID,
964 cur->languageID,
965 cur->nameID ));
966
967 /* I know that M$ encoded strings are Unicode, */
968 /* but this works reasonable well for debugging purposes. */
969 if ( cur->string )
970 for ( j = 0; j < cur->stringLength; j++ )
971 {
972 FT_Char c = *( cur->string + j );
973
974
975 if ( (FT_Byte)c < 128 )
976 FT_TRACE3(( "%c", c ));
977 }
978 }
979 }
980 FT_TRACE3(( "\n" ));
981
982 #endif /* FT_DEBUG_LEVEL_TRACE */
983
984 }
985 FT_TRACE2(( "loaded\n" ));
986
987 /* everything went well, update face->num_names */
988 face->num_names = names->numNameRecords;
989
990 Exit:
991 return error;
992 }
993
994
995 /*************************************************************************/
996 /* */
997 /* <Function> */
998 /* TT_Free_Names */
999 /* */
1000 /* <Description> */
1001 /* Frees the name records. */
1002 /* */
1003 /* <Input> */
1004 /* face :: A handle to the target face object. */
1005 /* */
1006 LOCAL_FUNC
1007 void TT_Free_Names( TT_Face face )
1008 {
1009 FT_Memory memory = face->root.driver->root.memory;
1010 TT_NameTable* names = &face->name_table;
1011
1012
1013 /* free strings table */
1014 FREE( names->names );
1015
1016 /* free strings storage */
1017 FREE( names->storage );
1018
1019 names->numNameRecords = 0;
1020 names->format = 0;
1021 names->storageOffset = 0;
1022 }
1023
1024
1025 /*************************************************************************/
1026 /* */
1027 /* <Function> */
1028 /* TT_Load_CMap */
1029 /* */
1030 /* <Description> */
1031 /* Loads the cmap directory in a face object. The cmaps itselves are */
1032 /* loaded on demand in the `ttcmap.c' module. */
1033 /* */
1034 /* <Input> */
1035 /* face :: A handle to the target face object. */
1036 /* stream :: A handle to the input stream. */
1037 /* */
1038 /* <Return> */
1039 /* FreeType error code. 0 means success. */
1040 /* */
1041 LOCAL_FUNC
1042 FT_Error TT_Load_CMap( TT_Face face,
1043 FT_Stream stream )
1044 {
1045 FT_Error error;
1046 FT_Memory memory = stream->memory;
1047 FT_Long table_start;
1048 TT_CMapDir cmap_dir;
1049
1050 const FT_Frame_Field cmap_fields[] =
1051 {
1052 FT_FRAME_START( 4 ),
1053 FT_FRAME_USHORT( TT_CMapDir, tableVersionNumber ),
1054 FT_FRAME_USHORT( TT_CMapDir, numCMaps ),
1055 FT_FRAME_END
1056 };
1057
1058 const FT_Frame_Field cmap_rec_fields[] =
1059 {
1060 FT_FRAME_START( 6 ),
1061 FT_FRAME_USHORT( TT_CMapTable, format ),
1062 FT_FRAME_USHORT( TT_CMapTable, length ),
1063 FT_FRAME_USHORT( TT_CMapTable, version ),
1064 FT_FRAME_END
1065 };
1066
1067
1068 FT_TRACE2(( "CMaps " ));
1069
1070 error = face->goto_table( face, TTAG_cmap, stream, 0 );
1071 if ( error )
1072 {
1073 error = TT_Err_CMap_Table_Missing;
1074 goto Exit;
1075 }
1076
1077 table_start = FILE_Pos();
1078
1079 if ( READ_Fields( cmap_fields, &cmap_dir ) )
1080 goto Exit;
1081
1082 /* reserve space in face table for cmap tables */
1083 if ( ALLOC_ARRAY( face->charmaps,
1084 cmap_dir.numCMaps,
1085 TT_CharMapRec ) )
1086 goto Exit;
1087
1088 face->num_charmaps = cmap_dir.numCMaps;
1089 {
1090 TT_CharMap charmap = face->charmaps;
1091 TT_CharMap limit = charmap + face->num_charmaps;
1092
1093
1094 /* read the header of each charmap first */
1095 if ( ACCESS_Frame( face->num_charmaps * 8L ) )
1096 goto Exit;
1097
1098 for ( ; charmap < limit; charmap++ )
1099 {
1100 TT_CMapTable* cmap;
1101
1102
1103 charmap->root.face = (FT_Face)face;
1104 cmap = &charmap->cmap;
1105
1106 cmap->loaded = FALSE;
1107 cmap->platformID = GET_UShort();
1108 cmap->platformEncodingID = GET_UShort();
1109 cmap->offset = (FT_ULong)GET_Long();
1110 }
1111
1112 FORGET_Frame();
1113
1114 /* now read the rest of each table */
1115 for ( charmap = face->charmaps; charmap < limit; charmap++ )
1116 {
1117 TT_CMapTable* cmap = &charmap->cmap;
1118
1119
1120 if ( FILE_Seek( table_start + (FT_Long)cmap->offset ) ||
1121 READ_Fields( cmap_rec_fields, cmap ) )
1122 goto Exit;
1123
1124 cmap->offset = FILE_Pos();
1125 }
1126 }
1127
1128 FT_TRACE2(( "loaded\n" ));
1129
1130 Exit:
1131 return error;
1132 }
1133
1134
1135 /*************************************************************************/
1136 /* */
1137 /* <Function> */
1138 /* TT_Load_OS2 */
1139 /* */
1140 /* <Description> */
1141 /* Loads the OS2 table. */
1142 /* */
1143 /* <Input> */
1144 /* face :: A handle to the target face object. */
1145 /* stream :: A handle to the input stream. */
1146 /* */
1147 /* <Return> */
1148 /* FreeType error code. 0 means success. */
1149 /* */
1150 LOCAL_FUNC
1151 FT_Error TT_Load_OS2( TT_Face face,
1152 FT_Stream stream )
1153 {
1154 FT_Error error;
1155 TT_OS2* os2;
1156
1157 const FT_Frame_Field os2_fields[] =
1158 {
1159 FT_FRAME_START( 78 ),
1160 FT_FRAME_USHORT( TT_OS2, version ),
1161 FT_FRAME_SHORT( TT_OS2, xAvgCharWidth ),
1162 FT_FRAME_USHORT( TT_OS2, usWeightClass ),
1163 FT_FRAME_USHORT( TT_OS2, usWidthClass ),
1164 FT_FRAME_SHORT( TT_OS2, fsType ),
1165 FT_FRAME_SHORT( TT_OS2, ySubscriptXSize ),
1166 FT_FRAME_SHORT( TT_OS2, ySubscriptYSize ),
1167 FT_FRAME_SHORT( TT_OS2, ySubscriptXOffset ),
1168 FT_FRAME_SHORT( TT_OS2, ySubscriptYOffset ),
1169 FT_FRAME_SHORT( TT_OS2, ySuperscriptXSize ),
1170 FT_FRAME_SHORT( TT_OS2, ySuperscriptYSize ),
1171 FT_FRAME_SHORT( TT_OS2, ySuperscriptXOffset ),
1172 FT_FRAME_SHORT( TT_OS2, ySuperscriptYOffset ),
1173 FT_FRAME_SHORT( TT_OS2, yStrikeoutSize ),
1174 FT_FRAME_SHORT( TT_OS2, yStrikeoutPosition ),
1175 FT_FRAME_SHORT( TT_OS2, sFamilyClass ),
1176 FT_FRAME_BYTE( TT_OS2, panose[0] ),
1177 FT_FRAME_BYTE( TT_OS2, panose[1] ),
1178 FT_FRAME_BYTE( TT_OS2, panose[2] ),
1179 FT_FRAME_BYTE( TT_OS2, panose[3] ),
1180 FT_FRAME_BYTE( TT_OS2, panose[4] ),
1181 FT_FRAME_BYTE( TT_OS2, panose[5] ),
1182 FT_FRAME_BYTE( TT_OS2, panose[6] ),
1183 FT_FRAME_BYTE( TT_OS2, panose[7] ),
1184 FT_FRAME_BYTE( TT_OS2, panose[8] ),
1185 FT_FRAME_BYTE( TT_OS2, panose[9] ),
1186 FT_FRAME_ULONG( TT_OS2, ulUnicodeRange1 ),
1187 FT_FRAME_ULONG( TT_OS2, ulUnicodeRange2 ),
1188 FT_FRAME_ULONG( TT_OS2, ulUnicodeRange3 ),
1189 FT_FRAME_ULONG( TT_OS2, ulUnicodeRange4 ),
1190 FT_FRAME_BYTE( TT_OS2, achVendID[0] ),
1191 FT_FRAME_BYTE( TT_OS2, achVendID[1] ),
1192 FT_FRAME_BYTE( TT_OS2, achVendID[2] ),
1193 FT_FRAME_BYTE( TT_OS2, achVendID[3] ),
1194
1195 FT_FRAME_USHORT( TT_OS2, fsSelection ),
1196 FT_FRAME_USHORT( TT_OS2, usFirstCharIndex ),
1197 FT_FRAME_USHORT( TT_OS2, usLastCharIndex ),
1198 FT_FRAME_SHORT( TT_OS2, sTypoAscender ),
1199 FT_FRAME_SHORT( TT_OS2, sTypoDescender ),
1200 FT_FRAME_SHORT( TT_OS2, sTypoLineGap ),
1201 FT_FRAME_USHORT( TT_OS2, usWinAscent ),
1202 FT_FRAME_USHORT( TT_OS2, usWinDescent ),
1203 FT_FRAME_END
1204 };
1205
1206 const FT_Frame_Field os2_fields_extra[] =
1207 {
1208 FT_FRAME_START( 8 ),
1209 FT_FRAME_ULONG( TT_OS2, ulCodePageRange1 ),
1210 FT_FRAME_ULONG( TT_OS2, ulCodePageRange2 ),
1211 FT_FRAME_END
1212 };
1213
1214 const FT_Frame_Field os2_fields_extra2[] =
1215 {
1216 FT_FRAME_START( 10 ),
1217 FT_FRAME_SHORT( TT_OS2, sxHeight ),
1218 FT_FRAME_SHORT( TT_OS2, sCapHeight ),
1219 FT_FRAME_USHORT( TT_OS2, usDefaultChar ),
1220 FT_FRAME_USHORT( TT_OS2, usBreakChar ),
1221 FT_FRAME_USHORT( TT_OS2, usMaxContext ),
1222 FT_FRAME_END
1223 };
1224
1225
1226 FT_TRACE2(( "OS/2 Table " ));
1227
1228 /* We now support old Mac fonts where the OS/2 table doesn't */
1229 /* exist. Simply put, we set the `version' field to 0xFFFF */
1230 /* and test this value each time we need to access the table. */
1231 error = face->goto_table( face, TTAG_OS2, stream, 0 );
1232 if ( error )
1233 {
1234 FT_TRACE2(( "is missing!\n" ));
1235 face->os2.version = 0xFFFF;
1236 error = TT_Err_Ok;
1237 goto Exit;
1238 }
1239
1240 os2 = &face->os2;
1241
1242 if ( READ_Fields( os2_fields, os2 ) )
1243 goto Exit;
1244
1245 os2->ulCodePageRange1 = 0;
1246 os2->ulCodePageRange2 = 0;
1247
1248 if ( os2->version >= 0x0001 )
1249 {
1250 /* only version 1 tables */
1251 if ( READ_Fields( os2_fields_extra, os2 ) )
1252 goto Exit;
1253
1254 if ( os2->version >= 0x0002 )
1255 {
1256 /* only version 2 tables */
1257 if ( READ_Fields( os2_fields_extra2, os2 ) )
1258 goto Exit;
1259 }
1260 }
1261
1262 FT_TRACE2(( "loaded\n" ));
1263
1264 Exit:
1265 return error;
1266 }
1267
1268
1269 /*************************************************************************/
1270 /* */
1271 /* <Function> */
1272 /* TT_Load_Postscript */
1273 /* */
1274 /* <Description> */
1275 /* Loads the Postscript table. */
1276 /* */
1277 /* <Input> */
1278 /* face :: A handle to the target face object. */
1279 /* stream :: A handle to the input stream. */
1280 /* */
1281 /* <Return> */
1282 /* FreeType error code. 0 means success. */
1283 /* */
1284 LOCAL_FUNC
1285 FT_Error TT_Load_PostScript( TT_Face face,
1286 FT_Stream stream )
1287 {
1288 FT_Error error;
1289 TT_Postscript* post = &face->postscript;
1290
1291 static const FT_Frame_Field post_fields[] =
1292 {
1293 FT_FRAME_START( 32 ),
1294 FT_FRAME_ULONG( TT_Postscript, FormatType ),
1295 FT_FRAME_ULONG( TT_Postscript, italicAngle ),
1296 FT_FRAME_SHORT( TT_Postscript, underlinePosition ),
1297 FT_FRAME_SHORT( TT_Postscript, underlineThickness ),
1298 FT_FRAME_ULONG( TT_Postscript, isFixedPitch ),
1299 FT_FRAME_ULONG( TT_Postscript, minMemType42 ),
1300 FT_FRAME_ULONG( TT_Postscript, maxMemType42 ),
1301 FT_FRAME_ULONG( TT_Postscript, minMemType1 ),
1302 FT_FRAME_ULONG( TT_Postscript, maxMemType1 ),
1303 FT_FRAME_END
1304 };
1305
1306
1307 FT_TRACE2(( "PostScript " ));
1308
1309 error = face->goto_table( face, TTAG_post, stream, 0 );
1310 if ( error )
1311 return TT_Err_Post_Table_Missing;
1312
1313 if ( READ_Fields( post_fields, post ) )
1314 return error;
1315
1316 /* we don't load the glyph names, we do that in another */
1317 /* module (ttpost). */
1318 FT_TRACE2(( "loaded\n" ));
1319
1320 return TT_Err_Ok;
1321 }
1322
1323
1324 /*************************************************************************/
1325 /* */
1326 /* <Function> */
1327 /* TT_Load_PCLT */
1328 /* */
1329 /* <Description> */
1330 /* Loads the PCL 5 Table. */
1331 /* */
1332 /* <Input> */
1333 /* face :: A handle to the target face object. */
1334 /* stream :: A handle to the input stream. */
1335 /* */
1336 /* <Return> */
1337 /* FreeType error code. 0 means success. */
1338 /* */
1339 LOCAL_FUNC
1340 FT_Error TT_Load_PCLT( TT_Face face,
1341 FT_Stream stream )
1342 {
1343 static const FT_Frame_Field pclt_fields[] =
1344 {
1345 FT_FRAME_START( 54 ),
1346 FT_FRAME_ULONG ( TT_PCLT, Version ),
1347 FT_FRAME_ULONG ( TT_PCLT, FontNumber ),
1348 FT_FRAME_USHORT( TT_PCLT, Pitch ),
1349 FT_FRAME_USHORT( TT_PCLT, xHeight ),
1350 FT_FRAME_USHORT( TT_PCLT, Style ),
1351 FT_FRAME_USHORT( TT_PCLT, TypeFamily ),
1352 FT_FRAME_USHORT( TT_PCLT, CapHeight ),
1353 FT_FRAME_BYTES ( TT_PCLT, TypeFace, 16 ),
1354 FT_FRAME_BYTES ( TT_PCLT, CharacterComplement, 8 ),
1355 FT_FRAME_BYTES ( TT_PCLT, FileName, 6 ),
1356 FT_FRAME_CHAR ( TT_PCLT, StrokeWeight ),
1357 FT_FRAME_CHAR ( TT_PCLT, WidthType ),
1358 FT_FRAME_BYTE ( TT_PCLT, SerifStyle ),
1359 FT_FRAME_BYTE ( TT_PCLT, Reserved ),
1360 FT_FRAME_END
1361 };
1362
1363 FT_Error error;
1364 TT_PCLT* pclt = &face->pclt;
1365
1366
1367 FT_TRACE2(( "PCLT " ));
1368
1369 /* optional table */
1370 error = face->goto_table( face, TTAG_PCLT, stream, 0 );
1371 if ( error )
1372 {
1373 FT_TRACE2(( "missing (optional)\n" ));
1374 pclt->Version = 0;
1375 return TT_Err_Ok;
1376 }
1377
1378 if ( READ_Fields( pclt_fields, pclt ) )
1379 goto Exit;
1380
1381 FT_TRACE2(( "loaded\n" ));
1382
1383 Exit:
1384 return error;
1385 }
1386
1387
1388 /*************************************************************************/
1389 /* */
1390 /* <Function> */
1391 /* TT_Load_Gasp */
1392 /* */
1393 /* <Description> */
1394 /* Loads the `gasp' table into a face object. */
1395 /* */
1396 /* <Input> */
1397 /* face :: A handle to the target face object. */
1398 /* stream :: The input stream. */
1399 /* */
1400 /* <Return> */
1401 /* FreeType error code. 0 means success. */
1402 /* */
1403 LOCAL_FUNC
1404 FT_Error TT_Load_Gasp( TT_Face face,
1405 FT_Stream stream )
1406 {
1407 FT_Error error;
1408 FT_Memory memory = stream->memory;
1409
1410 FT_UInt j,num_ranges;
1411 TT_GaspRange* gaspranges;
1412
1413
1414 FT_TRACE2(( "TT_Load_Gasp: %08p\n", face ));
1415
1416 /* the gasp table is optional */
1417 error = face->goto_table( face, TTAG_gasp, stream, 0 );
1418 if ( error )
1419 return TT_Err_Ok;
1420
1421 if ( ACCESS_Frame( 4L ) )
1422 goto Exit;
1423
1424 face->gasp.version = GET_UShort();
1425 face->gasp.numRanges = GET_UShort();
1426
1427 FORGET_Frame();
1428
1429 num_ranges = face->gasp.numRanges;
1430 FT_TRACE3(( "number of ranges = %d\n", num_ranges ));
1431
1432 if ( ALLOC_ARRAY( gaspranges, num_ranges, TT_GaspRange ) ||
1433 ACCESS_Frame( num_ranges * 4L ) )
1434 goto Exit;
1435
1436 face->gasp.gaspRanges = gaspranges;
1437
1438 for ( j = 0; j < num_ranges; j++ )
1439 {
1440 gaspranges[j].maxPPEM = GET_UShort();
1441 gaspranges[j].gaspFlag = GET_UShort();
1442
1443 FT_TRACE3(( " [max:%d flag:%d]",
1444 gaspranges[j].maxPPEM,
1445 gaspranges[j].gaspFlag ));
1446 }
1447 FT_TRACE3(( "\n" ));
1448
1449 FORGET_Frame();
1450 FT_TRACE2(( "GASP loaded\n" ));
1451
1452 Exit:
1453 return error;
1454 }
1455
1456
1457 /*************************************************************************/
1458 /* */
1459 /* <Function> */
1460 /* TT_Load_Kern */
1461 /* */
1462 /* <Description> */
1463 /* Loads the first kerning table with format 0 in the font. Only */
1464 /* accepts the first horizontal kerning table. Developers should use */
1465 /* the `ftxkern' extension to access other kerning tables in the font */
1466 /* file, if they really want to. */
1467 /* */
1468 /* <Input> */
1469 /* face :: A handle to the target face object. */
1470 /* stream :: The input stream. */
1471 /* */
1472 /* <Return> */
1473 /* FreeType error code. 0 means success. */
1474 /* */
1475 LOCAL_FUNC
1476 FT_Error TT_Load_Kern( TT_Face face,
1477 FT_Stream stream )
1478 {
1479 FT_Error error;
1480 FT_Memory memory = stream->memory;
1481
1482 FT_UInt n, num_tables, version;
1483
1484
1485 /* the kern table is optional; exit silently if it is missing */
1486 error = face->goto_table( face, TTAG_kern, stream, 0 );
1487 if ( error )
1488 return TT_Err_Ok;
1489
1490 if ( ACCESS_Frame( 4L ) )
1491 goto Exit;
1492
1493 version = GET_UShort();
1494 num_tables = GET_UShort();
1495
1496 FORGET_Frame();
1497
1498 for ( n = 0; n < num_tables; n++ )
1499 {
1500 FT_UInt coverage;
1501 FT_UInt length;
1502
1503
1504 if ( ACCESS_Frame( 6L ) )
1505 goto Exit;
1506
1507 version = GET_UShort(); /* version */
1508 length = GET_UShort() - 6; /* substract header length */
1509 coverage = GET_UShort();
1510
1511 FORGET_Frame();
1512
1513 if ( coverage == 0x0001 )
1514 {
1515 FT_UInt num_pairs;
1516 TT_Kern_0_Pair* pair;
1517 TT_Kern_0_Pair* limit;
1518
1519
1520 /* found a horizontal format 0 kerning table! */
1521 if ( ACCESS_Frame( 8L ) )
1522 goto Exit;
1523
1524 num_pairs = GET_UShort();
1525
1526 /* skip the rest */
1527
1528 FORGET_Frame();
1529
1530 /* allocate array of kerning pairs */
1531 if ( ALLOC_ARRAY( face->kern_pairs, num_pairs, TT_Kern_0_Pair ) ||
1532 ACCESS_Frame( 6L * num_pairs ) )
1533 goto Exit;
1534
1535 pair = face->kern_pairs;
1536 limit = pair + num_pairs;
1537 for ( ; pair < limit; pair++ )
1538 {
1539 pair->left = GET_UShort();
1540 pair->right = GET_UShort();
1541 pair->value = GET_UShort();
1542 }
1543
1544 FORGET_Frame();
1545
1546 face->num_kern_pairs = num_pairs;
1547 face->kern_table_index = n;
1548 goto Exit;
1549 }
1550
1551 if ( FILE_Skip( length ) )
1552 goto Exit;
1553 }
1554
1555 /* no kern table found -- doesn't matter */
1556 face->kern_table_index = -1;
1557 face->num_kern_pairs = 0;
1558 face->kern_pairs = NULL;
1559
1560 Exit:
1561 return error;
1562 }
1563
1564
1565 /*************************************************************************/
1566 /* */
1567 /* <Function> */
1568 /* TT_Load_Hdmx */
1569 /* */
1570 /* <Description> */
1571 /* Loads the horizontal device metrics table. */
1572 /* */
1573 /* <Input> */
1574 /* face :: A handle to the target face object. */
1575 /* stream :: A handle to the input stream. */
1576 /* */
1577 /* <Return> */
1578 /* FreeType error code. 0 means success. */
1579 /* */
1580 LOCAL_FUNC
1581 FT_Error TT_Load_Hdmx( TT_Face face,
1582 FT_Stream stream )
1583 {
1584 FT_Error error;
1585 FT_Memory memory = stream->memory;
1586
1587 TT_Hdmx* hdmx = &face->hdmx;
1588 FT_Long num_glyphs;
1589 FT_Long record_size;
1590
1591
1592 hdmx->version = 0;
1593 hdmx->num_records = 0;
1594 hdmx->records = 0;
1595
1596 /* this table is optional */
1597 error = face->goto_table( face, TTAG_hdmx, stream, 0 );
1598 if ( error )
1599 return TT_Err_Ok;
1600
1601 if ( ACCESS_Frame( 8L ) )
1602 goto Exit;
1603
1604 hdmx->version = GET_UShort();
1605 hdmx->num_records = GET_Short();
1606 record_size = GET_Long();
1607
1608 FORGET_Frame();
1609
1610 /* Only recognize format 0 */
1611 if ( hdmx->version != 0 )
1612 goto Exit;
1613
1614 if ( ALLOC_ARRAY( hdmx->records, hdmx->num_records, TT_HdmxRec ) )
1615 goto Exit;
1616
1617 num_glyphs = face->root.num_glyphs;
1618 record_size -= num_glyphs + 2;
1619
1620 {
1621 TT_HdmxRec* cur = hdmx->records;
1622 TT_HdmxRec* limit = cur + hdmx->num_records;
1623
1624
1625 for ( ; cur < limit; cur++ )
1626 {
1627 /* read record */
1628 if ( READ_Byte( cur->ppem ) ||
1629 READ_Byte( cur->max_width ) )
1630 goto Exit;
1631
1632 if ( ALLOC( cur->widths, num_glyphs ) ||
1633 FILE_Read( cur->widths, num_glyphs ) )
1634 goto Exit;
1635
1636 /* skip padding bytes */
1637 if ( record_size > 0 && FILE_Skip( record_size ) )
1638 goto Exit;
1639 }
1640 }
1641
1642 Exit:
1643 return error;
1644 }
1645
1646
1647 /*************************************************************************/
1648 /* */
1649 /* <Function> */
1650 /* TT_Free_Hdmx */
1651 /* */
1652 /* <Description> */
1653 /* Frees the horizontal device metrics table. */
1654 /* */
1655 /* <Input> */
1656 /* face :: A handle to the target face object. */
1657 /* */
1658 LOCAL_FUNC
1659 void TT_Free_Hdmx( TT_Face face )
1660 {
1661 if ( face )
1662 {
1663 FT_Int n;
1664 FT_Memory memory = face->root.driver->root.memory;
1665
1666
1667 for ( n = 0; n < face->hdmx.num_records; n++ )
1668 FREE( face->hdmx.records[n].widths );
1669
1670 FREE( face->hdmx.records );
1671 face->hdmx.num_records = 0;
1672 }
1673 }
1674
1675
1676 /* END */
wxWidgets (Impactor)