source: trunk/poppler/freetype2/src/sfnt/ttload.c @ 262

Last change on this file since 262 was 262, checked in by Eugene Romanenko, 12 years ago

PDF plugin: freetype library updated to version 2.3.8

File size: 47.3 KB
Line 
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-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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 <ft2build.h>
21#include FT_INTERNAL_DEBUG_H
22#include FT_INTERNAL_STREAM_H
23#include FT_TRUETYPE_TAGS_H
24#include "ttload.h"
25
26#include "sferrors.h"
27
28
29  /*************************************************************************/
30  /*                                                                       */
31  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
32  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
33  /* messages during execution.                                            */
34  /*                                                                       */
35#undef  FT_COMPONENT
36#define FT_COMPONENT  trace_ttload
37
38
39  /*************************************************************************/
40  /*                                                                       */
41  /* <Function>                                                            */
42  /*    tt_face_lookup_table                                               */
43  /*                                                                       */
44  /* <Description>                                                         */
45  /*    Looks for a TrueType table by name.                                */
46  /*                                                                       */
47  /* <Input>                                                               */
48  /*    face :: A face object handle.                                      */
49  /*                                                                       */
50  /*    tag  :: The searched tag.                                          */
51  /*                                                                       */
52  /* <Return>                                                              */
53  /*    A pointer to the table directory entry.  0 if not found.           */
54  /*                                                                       */
55  FT_LOCAL_DEF( TT_Table  )
56  tt_face_lookup_table( TT_Face   face,
57                        FT_ULong  tag  )
58  {
59    TT_Table  entry;
60    TT_Table  limit;
61#ifdef FT_DEBUG_LEVEL_TRACE
62    FT_Bool   zero_length = FALSE;
63#endif
64
65
66    FT_TRACE4(( "tt_face_lookup_table: %08p, `%c%c%c%c' -- ",
67                face,
68                (FT_Char)( tag >> 24 ),
69                (FT_Char)( tag >> 16 ),
70                (FT_Char)( tag >> 8  ),
71                (FT_Char)( tag       ) ));
72
73    entry = face->dir_tables;
74    limit = entry + face->num_tables;
75
76    for ( ; entry < limit; entry++ )
77    {
78      /* For compatibility with Windows, we consider    */
79      /* zero-length tables the same as missing tables. */
80      if ( entry->Tag == tag ) {
81        if ( entry->Length != 0 )
82        {
83          FT_TRACE4(( "found table.\n" ));
84          return entry;
85        }
86#ifdef FT_DEBUG_LEVEL_TRACE
87        zero_length = TRUE;
88#endif
89      }
90    }
91
92#ifdef FT_DEBUG_LEVEL_TRACE
93    if ( zero_length )
94      FT_TRACE4(( "ignoring empty table!\n" ));
95    else
96      FT_TRACE4(( "could not find table!\n" ));
97#endif
98
99    return NULL;
100  }
101
102
103  /*************************************************************************/
104  /*                                                                       */
105  /* <Function>                                                            */
106  /*    tt_face_goto_table                                                 */
107  /*                                                                       */
108  /* <Description>                                                         */
109  /*    Looks for a TrueType table by name, then seek a stream to it.      */
110  /*                                                                       */
111  /* <Input>                                                               */
112  /*    face   :: A face object handle.                                    */
113  /*                                                                       */
114  /*    tag    :: The searched tag.                                        */
115  /*                                                                       */
116  /*    stream :: The stream to seek when the table is found.              */
117  /*                                                                       */
118  /* <Output>                                                              */
119  /*    length :: The length of the table if found, undefined otherwise.   */
120  /*                                                                       */
121  /* <Return>                                                              */
122  /*    FreeType error code.  0 means success.                             */
123  /*                                                                       */
124  FT_LOCAL_DEF( FT_Error )
125  tt_face_goto_table( TT_Face    face,
126                      FT_ULong   tag,
127                      FT_Stream  stream,
128                      FT_ULong*  length )
129  {
130    TT_Table  table;
131    FT_Error  error;
132
133
134    table = tt_face_lookup_table( face, tag );
135    if ( table )
136    {
137      if ( length )
138        *length = table->Length;
139
140      if ( FT_STREAM_SEEK( table->Offset ) )
141        goto Exit;
142    }
143    else
144      error = SFNT_Err_Table_Missing;
145
146  Exit:
147    return error;
148  }
149
150
151  /* Here, we                                                         */
152  /*                                                                  */
153  /* - check that `num_tables' is valid (and adjust it if necessary)  */
154  /*                                                                  */
155  /* - look for a `head' table, check its size, and parse it to check */
156  /*   whether its `magic' field is correctly set                     */
157  /*                                                                  */
158  /* - errors (except errors returned by stream handling)             */
159  /*                                                                  */
160  /*     SFNT_Err_Unknown_File_Format:                                */
161  /*       no table is defined in directory, it is not sfnt-wrapped   */
162  /*       data                                                       */
163  /*     SFNT_Err_Table_Missing:                                      */
164  /*       table directory is valid, but essential tables             */
165  /*       (head/bhed/SING) are missing                               */
166  /*                                                                  */
167  static FT_Error
168  check_table_dir( SFNT_Header  sfnt,
169                   FT_Stream    stream )
170  {
171    FT_Error  error;
172    FT_UInt   nn, valid_entries = 0;
173    FT_UInt   has_head = 0, has_sing = 0, has_meta = 0;
174    FT_ULong  offset = sfnt->offset + 12;
175
176    static const FT_Frame_Field  table_dir_entry_fields[] =
177    {
178#undef  FT_STRUCTURE
179#define FT_STRUCTURE  TT_TableRec
180
181      FT_FRAME_START( 16 ),
182        FT_FRAME_ULONG( Tag ),
183        FT_FRAME_ULONG( CheckSum ),
184        FT_FRAME_ULONG( Offset ),
185        FT_FRAME_ULONG( Length ),
186      FT_FRAME_END
187    };
188
189
190    if ( FT_STREAM_SEEK( offset ) )
191      goto Exit;
192
193    for ( nn = 0; nn < sfnt->num_tables; nn++ )
194    {
195      TT_TableRec  table;
196
197
198      if ( FT_STREAM_READ_FIELDS( table_dir_entry_fields, &table ) )
199      {
200        nn--;
201        FT_TRACE2(( "check_table_dir:"
202                    " can read only %d table%s in font (instead of %d)\n",
203                    nn, nn == 1 ? "" : "s", sfnt->num_tables ));
204        sfnt->num_tables = nn;
205        break;
206      }
207
208      /* we ignore invalid tables */
209      if ( table.Offset + table.Length > stream->size )
210      {
211        FT_TRACE2(( "check_table_dir: table entry %d invalid\n", nn ));
212        continue;
213      }
214      else
215        valid_entries++;
216
217      if ( table.Tag == TTAG_head || table.Tag == TTAG_bhed )
218      {
219        FT_UInt32  magic;
220
221
222#ifndef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
223        if ( table.Tag == TTAG_head )
224#endif
225          has_head = 1;
226
227        /*
228         * The table length should be 0x36, but certain font tools make it
229         * 0x38, so we will just check that it is greater.
230         *
231         * Note that according to the specification, the table must be
232         * padded to 32-bit lengths, but this doesn't apply to the value of
233         * its `Length' field!
234         *
235         */
236        if ( table.Length < 0x36 )
237        {
238          FT_TRACE2(( "check_table_dir: `head' table too small\n" ));
239          error = SFNT_Err_Table_Missing;
240          goto Exit;
241        }
242
243        if ( FT_STREAM_SEEK( table.Offset + 12 ) ||
244             FT_READ_ULONG( magic )              )
245          goto Exit;
246
247        if ( magic != 0x5F0F3CF5UL )
248        {
249          FT_TRACE2(( "check_table_dir:"
250                      " no magic number found in `head' table\n"));
251          error = SFNT_Err_Table_Missing;
252          goto Exit;
253        }
254
255        if ( FT_STREAM_SEEK( offset + ( nn + 1 ) * 16 ) )
256          goto Exit;
257      }
258      else if ( table.Tag == TTAG_SING )
259        has_sing = 1;
260      else if ( table.Tag == TTAG_META )
261        has_meta = 1;
262    }
263
264    sfnt->num_tables = valid_entries;
265
266    if ( sfnt->num_tables == 0 )
267    {
268      FT_TRACE2(( "check_table_dir: no tables found\n" ));
269      error = SFNT_Err_Unknown_File_Format;
270      goto Exit;
271    }
272
273    /* if `sing' and `meta' tables are present, there is no `head' table */
274    if ( has_head || ( has_sing && has_meta ) )
275    {
276      error = SFNT_Err_Ok;
277      goto Exit;
278    }
279    else
280    {
281      FT_TRACE2(( "check_table_dir:" ));
282#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
283      FT_TRACE2(( " neither `head', `bhed', nor `sing' table found\n" ));
284#else
285      FT_TRACE2(( " neither `head' nor `sing' table found\n" ));
286#endif
287      error = SFNT_Err_Table_Missing;
288    }
289
290  Exit:
291    return error;
292  }
293
294
295  /*************************************************************************/
296  /*                                                                       */
297  /* <Function>                                                            */
298  /*    tt_face_load_font_dir                                              */
299  /*                                                                       */
300  /* <Description>                                                         */
301  /*    Loads the header of a SFNT font file.                              */
302  /*                                                                       */
303  /* <Input>                                                               */
304  /*    face       :: A handle to the target face object.                  */
305  /*                                                                       */
306  /*    stream     :: The input stream.                                    */
307  /*                                                                       */
308  /* <Output>                                                              */
309  /*    sfnt       :: The SFNT header.                                     */
310  /*                                                                       */
311  /* <Return>                                                              */
312  /*    FreeType error code.  0 means success.                             */
313  /*                                                                       */
314  /* <Note>                                                                */
315  /*    The stream cursor must be at the beginning of the font directory.  */
316  /*                                                                       */
317  FT_LOCAL_DEF( FT_Error )
318  tt_face_load_font_dir( TT_Face    face,
319                         FT_Stream  stream )
320  {
321    SFNT_HeaderRec  sfnt;
322    FT_Error        error;
323    FT_Memory       memory = stream->memory;
324    TT_TableRec*    entry;
325    FT_Int          nn;
326
327    static const FT_Frame_Field  offset_table_fields[] =
328    {
329#undef  FT_STRUCTURE
330#define FT_STRUCTURE  SFNT_HeaderRec
331
332      FT_FRAME_START( 8 ),
333        FT_FRAME_USHORT( num_tables ),
334        FT_FRAME_USHORT( search_range ),
335        FT_FRAME_USHORT( entry_selector ),
336        FT_FRAME_USHORT( range_shift ),
337      FT_FRAME_END
338    };
339
340
341    FT_TRACE2(( "tt_face_load_font_dir: %08p\n", face ));
342
343    /* read the offset table */
344
345    sfnt.offset = FT_STREAM_POS();
346
347    if ( FT_READ_ULONG( sfnt.format_tag )                    ||
348         FT_STREAM_READ_FIELDS( offset_table_fields, &sfnt ) )
349      goto Exit;
350
351    /* many fonts don't have these fields set correctly */
352#if 0
353    if ( sfnt.search_range != 1 << ( sfnt.entry_selector + 4 )        ||
354         sfnt.search_range + sfnt.range_shift != sfnt.num_tables << 4 )
355      return SFNT_Err_Unknown_File_Format;
356#endif
357
358    /* load the table directory */
359
360    FT_TRACE2(( "-- Number of tables: %10u\n",    sfnt.num_tables ));
361    FT_TRACE2(( "-- Format version:   0x%08lx\n", sfnt.format_tag ));
362
363    /* check first */
364    error = check_table_dir( &sfnt, stream );
365    if ( error )
366    {
367      FT_TRACE2(( "tt_face_load_font_dir: invalid table directory for TrueType!\n" ));
368
369      goto Exit;
370    }
371
372    face->num_tables = sfnt.num_tables;
373    face->format_tag = sfnt.format_tag;
374
375    if ( FT_QNEW_ARRAY( face->dir_tables, face->num_tables ) )
376      goto Exit;
377
378    if ( FT_STREAM_SEEK( sfnt.offset + 12 )       ||
379         FT_FRAME_ENTER( face->num_tables * 16L ) )
380      goto Exit;
381
382    entry = face->dir_tables;
383
384    for ( nn = 0; nn < sfnt.num_tables; nn++ )
385    {
386      entry->Tag      = FT_GET_TAG4();
387      entry->CheckSum = FT_GET_ULONG();
388      entry->Offset   = FT_GET_LONG();
389      entry->Length   = FT_GET_LONG();
390
391      /* ignore invalid tables */
392      if ( entry->Offset + entry->Length > stream->size )
393        continue;
394      else
395      {
396        FT_TRACE2(( "  %c%c%c%c  -  %08lx  -  %08lx\n",
397                    (FT_Char)( entry->Tag >> 24 ),
398                    (FT_Char)( entry->Tag >> 16 ),
399                    (FT_Char)( entry->Tag >> 8  ),
400                    (FT_Char)( entry->Tag       ),
401                    entry->Offset,
402                    entry->Length ));
403        entry++;
404      }
405    }
406
407    FT_FRAME_EXIT();
408
409    FT_TRACE2(( "table directory loaded\n\n" ));
410
411  Exit:
412    return error;
413  }
414
415
416  /*************************************************************************/
417  /*                                                                       */
418  /* <Function>                                                            */
419  /*    tt_face_load_any                                                   */
420  /*                                                                       */
421  /* <Description>                                                         */
422  /*    Loads any font table into client memory.                           */
423  /*                                                                       */
424  /* <Input>                                                               */
425  /*    face   :: The face object to look for.                             */
426  /*                                                                       */
427  /*    tag    :: The tag of table to load.  Use the value 0 if you want   */
428  /*              to access the whole font file, else set this parameter   */
429  /*              to a valid TrueType table tag that you can forge with    */
430  /*              the MAKE_TT_TAG macro.                                   */
431  /*                                                                       */
432  /*    offset :: The starting offset in the table (or the file if         */
433  /*              tag == 0).                                               */
434  /*                                                                       */
435  /*    length :: The address of the decision variable:                    */
436  /*                                                                       */
437  /*                If length == NULL:                                     */
438  /*                  Loads the whole table.  Returns an error if          */
439  /*                  `offset' == 0!                                       */
440  /*                                                                       */
441  /*                If *length == 0:                                       */
442  /*                  Exits immediately; returning the length of the given */
443  /*                  table or of the font file, depending on the value of */
444  /*                  `tag'.                                               */
445  /*                                                                       */
446  /*                If *length != 0:                                       */
447  /*                  Loads the next `length' bytes of table or font,      */
448  /*                  starting at offset `offset' (in table or font too).  */
449  /*                                                                       */
450  /* <Output>                                                              */
451  /*    buffer :: The address of target buffer.                            */
452  /*                                                                       */
453  /* <Return>                                                              */
454  /*    FreeType error code.  0 means success.                             */
455  /*                                                                       */
456  FT_LOCAL_DEF( FT_Error )
457  tt_face_load_any( TT_Face    face,
458                    FT_ULong   tag,
459                    FT_Long    offset,
460                    FT_Byte*   buffer,
461                    FT_ULong*  length )
462  {
463    FT_Error   error;
464    FT_Stream  stream;
465    TT_Table   table;
466    FT_ULong   size;
467
468
469    if ( tag != 0 )
470    {
471      /* look for tag in font directory */
472      table = tt_face_lookup_table( face, tag );
473      if ( !table )
474      {
475        error = SFNT_Err_Table_Missing;
476        goto Exit;
477      }
478
479      offset += table->Offset;
480      size    = table->Length;
481    }
482    else
483      /* tag == 0 -- the user wants to access the font file directly */
484      size = face->root.stream->size;
485
486    if ( length && *length == 0 )
487    {
488      *length = size;
489
490      return SFNT_Err_Ok;
491    }
492
493    if ( length )
494      size = *length;
495
496    stream = face->root.stream;
497    /* the `if' is syntactic sugar for picky compilers */
498    if ( FT_STREAM_READ_AT( offset, buffer, size ) )
499      goto Exit;
500
501  Exit:
502    return error;
503  }
504
505
506  /*************************************************************************/
507  /*                                                                       */
508  /* <Function>                                                            */
509  /*    tt_face_load_generic_header                                        */
510  /*                                                                       */
511  /* <Description>                                                         */
512  /*    Loads the TrueType table `head' or `bhed'.                         */
513  /*                                                                       */
514  /* <Input>                                                               */
515  /*    face   :: A handle to the target face object.                      */
516  /*                                                                       */
517  /*    stream :: The input stream.                                        */
518  /*                                                                       */
519  /* <Return>                                                              */
520  /*    FreeType error code.  0 means success.                             */
521  /*                                                                       */
522  static FT_Error
523  tt_face_load_generic_header( TT_Face    face,
524                               FT_Stream  stream,
525                               FT_ULong   tag )
526  {
527    FT_Error    error;
528    TT_Header*  header;
529
530    static const FT_Frame_Field  header_fields[] =
531    {
532#undef  FT_STRUCTURE
533#define FT_STRUCTURE  TT_Header
534
535      FT_FRAME_START( 54 ),
536        FT_FRAME_ULONG ( Table_Version ),
537        FT_FRAME_ULONG ( Font_Revision ),
538        FT_FRAME_LONG  ( CheckSum_Adjust ),
539        FT_FRAME_LONG  ( Magic_Number ),
540        FT_FRAME_USHORT( Flags ),
541        FT_FRAME_USHORT( Units_Per_EM ),
542        FT_FRAME_LONG  ( Created[0] ),
543        FT_FRAME_LONG  ( Created[1] ),
544        FT_FRAME_LONG  ( Modified[0] ),
545        FT_FRAME_LONG  ( Modified[1] ),
546        FT_FRAME_SHORT ( xMin ),
547        FT_FRAME_SHORT ( yMin ),
548        FT_FRAME_SHORT ( xMax ),
549        FT_FRAME_SHORT ( yMax ),
550        FT_FRAME_USHORT( Mac_Style ),
551        FT_FRAME_USHORT( Lowest_Rec_PPEM ),
552        FT_FRAME_SHORT ( Font_Direction ),
553        FT_FRAME_SHORT ( Index_To_Loc_Format ),
554        FT_FRAME_SHORT ( Glyph_Data_Format ),
555      FT_FRAME_END
556    };
557
558
559    error = face->goto_table( face, tag, stream, 0 );
560    if ( error )
561      goto Exit;
562
563    header = &face->header;
564
565    if ( FT_STREAM_READ_FIELDS( header_fields, header ) )
566      goto Exit;
567
568    FT_TRACE3(( "Units per EM: %4u\n", header->Units_Per_EM ));
569    FT_TRACE3(( "IndexToLoc:   %4d\n", header->Index_To_Loc_Format ));
570
571  Exit:
572    return error;
573  }
574
575
576  FT_LOCAL_DEF( FT_Error )
577  tt_face_load_head( TT_Face    face,
578                     FT_Stream  stream )
579  {
580    return tt_face_load_generic_header( face, stream, TTAG_head );
581  }
582
583
584#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
585
586  FT_LOCAL_DEF( FT_Error )
587  tt_face_load_bhed( TT_Face    face,
588                     FT_Stream  stream )
589  {
590    return tt_face_load_generic_header( face, stream, TTAG_bhed );
591  }
592
593#endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
594
595
596  /*************************************************************************/
597  /*                                                                       */
598  /* <Function>                                                            */
599  /*    tt_face_load_max_profile                                           */
600  /*                                                                       */
601  /* <Description>                                                         */
602  /*    Loads the maximum profile into a face object.                      */
603  /*                                                                       */
604  /* <Input>                                                               */
605  /*    face   :: A handle to the target face object.                      */
606  /*                                                                       */
607  /*    stream :: The input stream.                                        */
608  /*                                                                       */
609  /* <Return>                                                              */
610  /*    FreeType error code.  0 means success.                             */
611  /*                                                                       */
612  FT_LOCAL_DEF( FT_Error )
613  tt_face_load_maxp( TT_Face    face,
614                     FT_Stream  stream )
615  {
616    FT_Error        error;
617    TT_MaxProfile*  maxProfile = &face->max_profile;
618
619    const FT_Frame_Field  maxp_fields[] =
620    {
621#undef  FT_STRUCTURE
622#define FT_STRUCTURE  TT_MaxProfile
623
624      FT_FRAME_START( 6 ),
625        FT_FRAME_LONG  ( version ),
626        FT_FRAME_USHORT( numGlyphs ),
627      FT_FRAME_END
628    };
629
630    const FT_Frame_Field  maxp_fields_extra[] =
631    {
632      FT_FRAME_START( 26 ),
633        FT_FRAME_USHORT( maxPoints ),
634        FT_FRAME_USHORT( maxContours ),
635        FT_FRAME_USHORT( maxCompositePoints ),
636        FT_FRAME_USHORT( maxCompositeContours ),
637        FT_FRAME_USHORT( maxZones ),
638        FT_FRAME_USHORT( maxTwilightPoints ),
639        FT_FRAME_USHORT( maxStorage ),
640        FT_FRAME_USHORT( maxFunctionDefs ),
641        FT_FRAME_USHORT( maxInstructionDefs ),
642        FT_FRAME_USHORT( maxStackElements ),
643        FT_FRAME_USHORT( maxSizeOfInstructions ),
644        FT_FRAME_USHORT( maxComponentElements ),
645        FT_FRAME_USHORT( maxComponentDepth ),
646      FT_FRAME_END
647    };
648
649
650    error = face->goto_table( face, TTAG_maxp, stream, 0 );
651    if ( error )
652      goto Exit;
653
654    if ( FT_STREAM_READ_FIELDS( maxp_fields, maxProfile ) )
655      goto Exit;
656
657    maxProfile->maxPoints             = 0;
658    maxProfile->maxContours           = 0;
659    maxProfile->maxCompositePoints    = 0;
660    maxProfile->maxCompositeContours  = 0;
661    maxProfile->maxZones              = 0;
662    maxProfile->maxTwilightPoints     = 0;
663    maxProfile->maxStorage            = 0;
664    maxProfile->maxFunctionDefs       = 0;
665    maxProfile->maxInstructionDefs    = 0;
666    maxProfile->maxStackElements      = 0;
667    maxProfile->maxSizeOfInstructions = 0;
668    maxProfile->maxComponentElements  = 0;
669    maxProfile->maxComponentDepth     = 0;
670
671    if ( maxProfile->version >= 0x10000L )
672    {
673      if ( FT_STREAM_READ_FIELDS( maxp_fields_extra, maxProfile ) )
674        goto Exit;
675
676      /* XXX: an adjustment that is necessary to load certain */
677      /*      broken fonts like `Keystrokes MT' :-(           */
678      /*                                                      */
679      /*   We allocate 64 function entries by default when    */
680      /*   the maxFunctionDefs field is null.                 */
681
682      if ( maxProfile->maxFunctionDefs == 0 )
683        maxProfile->maxFunctionDefs = 64;
684
685      /* we add 4 phantom points later */
686      if ( maxProfile->maxTwilightPoints > ( 0xFFFFU - 4 ) )
687      {
688        FT_ERROR(( "Too much twilight points in `maxp' table;\n" ));
689        FT_ERROR(( "  some glyphs might be rendered incorrectly.\n" ));
690
691        maxProfile->maxTwilightPoints = 0xFFFFU - 4;
692      }
693    }
694
695    FT_TRACE3(( "numGlyphs: %u\n", maxProfile->numGlyphs ));
696
697  Exit:
698    return error;
699  }
700
701
702  /*************************************************************************/
703  /*                                                                       */
704  /* <Function>                                                            */
705  /*    tt_face_load_names                                                 */
706  /*                                                                       */
707  /* <Description>                                                         */
708  /*    Loads the name records.                                            */
709  /*                                                                       */
710  /* <Input>                                                               */
711  /*    face   :: A handle to the target face object.                      */
712  /*                                                                       */
713  /*    stream :: The input stream.                                        */
714  /*                                                                       */
715  /* <Return>                                                              */
716  /*    FreeType error code.  0 means success.                             */
717  /*                                                                       */
718  FT_LOCAL_DEF( FT_Error )
719  tt_face_load_name( TT_Face    face,
720                     FT_Stream  stream )
721  {
722    FT_Error      error;
723    FT_Memory     memory = stream->memory;
724    FT_ULong      table_pos, table_len;
725    FT_ULong      storage_start, storage_limit;
726    FT_UInt       count;
727    TT_NameTable  table;
728
729    static const FT_Frame_Field  name_table_fields[] =
730    {
731#undef  FT_STRUCTURE
732#define FT_STRUCTURE  TT_NameTableRec
733
734      FT_FRAME_START( 6 ),
735        FT_FRAME_USHORT( format ),
736        FT_FRAME_USHORT( numNameRecords ),
737        FT_FRAME_USHORT( storageOffset ),
738      FT_FRAME_END
739    };
740
741    static const FT_Frame_Field  name_record_fields[] =
742    {
743#undef  FT_STRUCTURE
744#define FT_STRUCTURE  TT_NameEntryRec
745
746      /* no FT_FRAME_START */
747        FT_FRAME_USHORT( platformID ),
748        FT_FRAME_USHORT( encodingID ),
749        FT_FRAME_USHORT( languageID ),
750        FT_FRAME_USHORT( nameID ),
751        FT_FRAME_USHORT( stringLength ),
752        FT_FRAME_USHORT( stringOffset ),
753      FT_FRAME_END
754    };
755
756
757    table         = &face->name_table;
758    table->stream = stream;
759
760    error = face->goto_table( face, TTAG_name, stream, &table_len );
761    if ( error )
762      goto Exit;
763
764    table_pos = FT_STREAM_POS();
765
766
767    if ( FT_STREAM_READ_FIELDS( name_table_fields, table ) )
768      goto Exit;
769
770    /* Some popular Asian fonts have an invalid `storageOffset' value   */
771    /* (it should be at least "6 + 12*num_names").  However, the string */
772    /* offsets, computed as "storageOffset + entry->stringOffset", are  */
773    /* valid pointers within the name table...                          */
774    /*                                                                  */
775    /* We thus can't check `storageOffset' right now.                   */
776    /*                                                                  */
777    storage_start = table_pos + 6 + 12*table->numNameRecords;
778    storage_limit = table_pos + table_len;
779
780    if ( storage_start > storage_limit )
781    {
782      FT_ERROR(( "invalid `name' table\n" ));
783      error = SFNT_Err_Name_Table_Missing;
784      goto Exit;
785    }
786
787    /* Allocate the array of name records. */
788    count                 = table->numNameRecords;
789    table->numNameRecords = 0;
790
791    if ( FT_NEW_ARRAY( table->names, count ) ||
792         FT_FRAME_ENTER( count * 12 )        )
793      goto Exit;
794
795    /* Load the name records and determine how much storage is needed */
796    /* to hold the strings themselves.                                */
797    {
798      TT_NameEntryRec*  entry = table->names;
799
800
801      for ( ; count > 0; count-- )
802      {
803        if ( FT_STREAM_READ_FIELDS( name_record_fields, entry ) )
804          continue;
805
806        /* check that the name is not empty */
807        if ( entry->stringLength == 0 )
808          continue;
809
810        /* check that the name string is within the table */
811        entry->stringOffset += table_pos + table->storageOffset;
812        if ( entry->stringOffset                       < storage_start ||
813             entry->stringOffset + entry->stringLength > storage_limit )
814        {
815          /* invalid entry - ignore it */
816          entry->stringOffset = 0;
817          entry->stringLength = 0;
818          continue;
819        }
820
821        entry++;
822      }
823
824      table->numNameRecords = (FT_UInt)( entry - table->names );
825    }
826
827    FT_FRAME_EXIT();
828
829    /* everything went well, update face->num_names */
830    face->num_names = (FT_UShort) table->numNameRecords;
831
832  Exit:
833    return error;
834  }
835
836
837  /*************************************************************************/
838  /*                                                                       */
839  /* <Function>                                                            */
840  /*    tt_face_free_names                                                 */
841  /*                                                                       */
842  /* <Description>                                                         */
843  /*    Frees the name records.                                            */
844  /*                                                                       */
845  /* <Input>                                                               */
846  /*    face :: A handle to the target face object.                        */
847  /*                                                                       */
848  FT_LOCAL_DEF( void )
849  tt_face_free_name( TT_Face  face )
850  {
851    FT_Memory     memory = face->root.driver->root.memory;
852    TT_NameTable  table  = &face->name_table;
853    TT_NameEntry  entry  = table->names;
854    FT_UInt       count  = table->numNameRecords;
855
856
857    if ( table->names )
858    {
859      for ( ; count > 0; count--, entry++ )
860      {
861        FT_FREE( entry->string );
862        entry->stringLength = 0;
863      }
864
865      /* free strings table */
866      FT_FREE( table->names );
867    }
868
869    table->numNameRecords = 0;
870    table->format         = 0;
871    table->storageOffset  = 0;
872  }
873
874
875  /*************************************************************************/
876  /*                                                                       */
877  /* <Function>                                                            */
878  /*    tt_face_load_cmap                                                  */
879  /*                                                                       */
880  /* <Description>                                                         */
881  /*    Loads the cmap directory in a face object.  The cmaps themselves   */
882  /*    are loaded on demand in the `ttcmap.c' module.                     */
883  /*                                                                       */
884  /* <Input>                                                               */
885  /*    face   :: A handle to the target face object.                      */
886  /*                                                                       */
887  /*    stream :: A handle to the input stream.                            */
888  /*                                                                       */
889  /* <Return>                                                              */
890  /*    FreeType error code.  0 means success.                             */
891  /*                                                                       */
892
893  FT_LOCAL_DEF( FT_Error )
894  tt_face_load_cmap( TT_Face    face,
895                     FT_Stream  stream )
896  {
897    FT_Error  error;
898
899
900    error = face->goto_table( face, TTAG_cmap, stream, &face->cmap_size );
901    if ( error )
902      goto Exit;
903
904    if ( FT_FRAME_EXTRACT( face->cmap_size, face->cmap_table ) )
905      face->cmap_size = 0;
906
907  Exit:
908    return error;
909  }
910
911
912
913  /*************************************************************************/
914  /*                                                                       */
915  /* <Function>                                                            */
916  /*    tt_face_load_os2                                                   */
917  /*                                                                       */
918  /* <Description>                                                         */
919  /*    Loads the OS2 table.                                               */
920  /*                                                                       */
921  /* <Input>                                                               */
922  /*    face   :: A handle to the target face object.                      */
923  /*                                                                       */
924  /*    stream :: A handle to the input stream.                            */
925  /*                                                                       */
926  /* <Return>                                                              */
927  /*    FreeType error code.  0 means success.                             */
928  /*                                                                       */
929  FT_LOCAL_DEF( FT_Error )
930  tt_face_load_os2( TT_Face    face,
931                    FT_Stream  stream )
932  {
933    FT_Error  error;
934    TT_OS2*   os2;
935
936    const FT_Frame_Field  os2_fields[] =
937    {
938#undef  FT_STRUCTURE
939#define FT_STRUCTURE  TT_OS2
940
941      FT_FRAME_START( 78 ),
942        FT_FRAME_USHORT( version ),
943        FT_FRAME_SHORT ( xAvgCharWidth ),
944        FT_FRAME_USHORT( usWeightClass ),
945        FT_FRAME_USHORT( usWidthClass ),
946        FT_FRAME_SHORT ( fsType ),
947        FT_FRAME_SHORT ( ySubscriptXSize ),
948        FT_FRAME_SHORT ( ySubscriptYSize ),
949        FT_FRAME_SHORT ( ySubscriptXOffset ),
950        FT_FRAME_SHORT ( ySubscriptYOffset ),
951        FT_FRAME_SHORT ( ySuperscriptXSize ),
952        FT_FRAME_SHORT ( ySuperscriptYSize ),
953        FT_FRAME_SHORT ( ySuperscriptXOffset ),
954        FT_FRAME_SHORT ( ySuperscriptYOffset ),
955        FT_FRAME_SHORT ( yStrikeoutSize ),
956        FT_FRAME_SHORT ( yStrikeoutPosition ),
957        FT_FRAME_SHORT ( sFamilyClass ),
958        FT_FRAME_BYTE  ( panose[0] ),
959        FT_FRAME_BYTE  ( panose[1] ),
960        FT_FRAME_BYTE  ( panose[2] ),
961        FT_FRAME_BYTE  ( panose[3] ),
962        FT_FRAME_BYTE  ( panose[4] ),
963        FT_FRAME_BYTE  ( panose[5] ),
964        FT_FRAME_BYTE  ( panose[6] ),
965        FT_FRAME_BYTE  ( panose[7] ),
966        FT_FRAME_BYTE  ( panose[8] ),
967        FT_FRAME_BYTE  ( panose[9] ),
968        FT_FRAME_ULONG ( ulUnicodeRange1 ),
969        FT_FRAME_ULONG ( ulUnicodeRange2 ),
970        FT_FRAME_ULONG ( ulUnicodeRange3 ),
971        FT_FRAME_ULONG ( ulUnicodeRange4 ),
972        FT_FRAME_BYTE  ( achVendID[0] ),
973        FT_FRAME_BYTE  ( achVendID[1] ),
974        FT_FRAME_BYTE  ( achVendID[2] ),
975        FT_FRAME_BYTE  ( achVendID[3] ),
976
977        FT_FRAME_USHORT( fsSelection ),
978        FT_FRAME_USHORT( usFirstCharIndex ),
979        FT_FRAME_USHORT( usLastCharIndex ),
980        FT_FRAME_SHORT ( sTypoAscender ),
981        FT_FRAME_SHORT ( sTypoDescender ),
982        FT_FRAME_SHORT ( sTypoLineGap ),
983        FT_FRAME_USHORT( usWinAscent ),
984        FT_FRAME_USHORT( usWinDescent ),
985      FT_FRAME_END
986    };
987
988    const FT_Frame_Field  os2_fields_extra[] =
989    {
990      FT_FRAME_START( 8 ),
991        FT_FRAME_ULONG( ulCodePageRange1 ),
992        FT_FRAME_ULONG( ulCodePageRange2 ),
993      FT_FRAME_END
994    };
995
996    const FT_Frame_Field  os2_fields_extra2[] =
997    {
998      FT_FRAME_START( 10 ),
999        FT_FRAME_SHORT ( sxHeight ),
1000        FT_FRAME_SHORT ( sCapHeight ),
1001        FT_FRAME_USHORT( usDefaultChar ),
1002        FT_FRAME_USHORT( usBreakChar ),
1003        FT_FRAME_USHORT( usMaxContext ),
1004      FT_FRAME_END
1005    };
1006
1007
1008    /* We now support old Mac fonts where the OS/2 table doesn't  */
1009    /* exist.  Simply put, we set the `version' field to 0xFFFF   */
1010    /* and test this value each time we need to access the table. */
1011    error = face->goto_table( face, TTAG_OS2, stream, 0 );
1012    if ( error )
1013      goto Exit;
1014
1015    os2 = &face->os2;
1016
1017    if ( FT_STREAM_READ_FIELDS( os2_fields, os2 ) )
1018      goto Exit;
1019
1020    os2->ulCodePageRange1 = 0;
1021    os2->ulCodePageRange2 = 0;
1022    os2->sxHeight         = 0;
1023    os2->sCapHeight       = 0;
1024    os2->usDefaultChar    = 0;
1025    os2->usBreakChar      = 0;
1026    os2->usMaxContext     = 0;
1027
1028    if ( os2->version >= 0x0001 )
1029    {
1030      /* only version 1 tables */
1031      if ( FT_STREAM_READ_FIELDS( os2_fields_extra, os2 ) )
1032        goto Exit;
1033
1034      if ( os2->version >= 0x0002 )
1035      {
1036        /* only version 2 tables */
1037        if ( FT_STREAM_READ_FIELDS( os2_fields_extra2, os2 ) )
1038          goto Exit;
1039      }
1040    }
1041
1042    FT_TRACE3(( "sTypoAscender:  %4d\n",   os2->sTypoAscender ));
1043    FT_TRACE3(( "sTypoDescender: %4d\n",   os2->sTypoDescender ));
1044    FT_TRACE3(( "usWinAscent:    %4u\n",   os2->usWinAscent ));
1045    FT_TRACE3(( "usWinDescent:   %4u\n",   os2->usWinDescent ));
1046    FT_TRACE3(( "fsSelection:    0x%2x\n", os2->fsSelection ));
1047
1048  Exit:
1049    return error;
1050  }
1051
1052
1053  /*************************************************************************/
1054  /*                                                                       */
1055  /* <Function>                                                            */
1056  /*    tt_face_load_postscript                                            */
1057  /*                                                                       */
1058  /* <Description>                                                         */
1059  /*    Loads the Postscript table.                                        */
1060  /*                                                                       */
1061  /* <Input>                                                               */
1062  /*    face   :: A handle to the target face object.                      */
1063  /*                                                                       */
1064  /*    stream :: A handle to the input stream.                            */
1065  /*                                                                       */
1066  /* <Return>                                                              */
1067  /*    FreeType error code.  0 means success.                             */
1068  /*                                                                       */
1069  FT_LOCAL_DEF( FT_Error )
1070  tt_face_load_post( TT_Face    face,
1071                     FT_Stream  stream )
1072  {
1073    FT_Error        error;
1074    TT_Postscript*  post = &face->postscript;
1075
1076    static const FT_Frame_Field  post_fields[] =
1077    {
1078#undef  FT_STRUCTURE
1079#define FT_STRUCTURE  TT_Postscript
1080
1081      FT_FRAME_START( 32 ),
1082        FT_FRAME_ULONG( FormatType ),
1083        FT_FRAME_ULONG( italicAngle ),
1084        FT_FRAME_SHORT( underlinePosition ),
1085        FT_FRAME_SHORT( underlineThickness ),
1086        FT_FRAME_ULONG( isFixedPitch ),
1087        FT_FRAME_ULONG( minMemType42 ),
1088        FT_FRAME_ULONG( maxMemType42 ),
1089        FT_FRAME_ULONG( minMemType1 ),
1090        FT_FRAME_ULONG( maxMemType1 ),
1091      FT_FRAME_END
1092    };
1093
1094
1095    error = face->goto_table( face, TTAG_post, stream, 0 );
1096    if ( error )
1097      return error;
1098
1099    if ( FT_STREAM_READ_FIELDS( post_fields, post ) )
1100      return error;
1101
1102    /* we don't load the glyph names, we do that in another */
1103    /* module (ttpost).                                     */
1104
1105    FT_TRACE3(( "FormatType:   0x%x\n", post->FormatType ));
1106    FT_TRACE3(( "isFixedPitch:   %s\n", post->isFixedPitch
1107                                        ? "  yes" : "   no" ));
1108
1109    return SFNT_Err_Ok;
1110  }
1111
1112
1113  /*************************************************************************/
1114  /*                                                                       */
1115  /* <Function>                                                            */
1116  /*    tt_face_load_pclt                                                  */
1117  /*                                                                       */
1118  /* <Description>                                                         */
1119  /*    Loads the PCL 5 Table.                                             */
1120  /*                                                                       */
1121  /* <Input>                                                               */
1122  /*    face   :: A handle to the target face object.                      */
1123  /*                                                                       */
1124  /*    stream :: A handle to the input stream.                            */
1125  /*                                                                       */
1126  /* <Return>                                                              */
1127  /*    FreeType error code.  0 means success.                             */
1128  /*                                                                       */
1129  FT_LOCAL_DEF( FT_Error )
1130  tt_face_load_pclt( TT_Face    face,
1131                     FT_Stream  stream )
1132  {
1133    static const FT_Frame_Field  pclt_fields[] =
1134    {
1135#undef  FT_STRUCTURE
1136#define FT_STRUCTURE  TT_PCLT
1137
1138      FT_FRAME_START( 54 ),
1139        FT_FRAME_ULONG ( Version ),
1140        FT_FRAME_ULONG ( FontNumber ),
1141        FT_FRAME_USHORT( Pitch ),
1142        FT_FRAME_USHORT( xHeight ),
1143        FT_FRAME_USHORT( Style ),
1144        FT_FRAME_USHORT( TypeFamily ),
1145        FT_FRAME_USHORT( CapHeight ),
1146        FT_FRAME_BYTES ( TypeFace, 16 ),
1147        FT_FRAME_BYTES ( CharacterComplement, 8 ),
1148        FT_FRAME_BYTES ( FileName, 6 ),
1149        FT_FRAME_CHAR  ( StrokeWeight ),
1150        FT_FRAME_CHAR  ( WidthType ),
1151        FT_FRAME_BYTE  ( SerifStyle ),
1152        FT_FRAME_BYTE  ( Reserved ),
1153      FT_FRAME_END
1154    };
1155
1156    FT_Error  error;
1157    TT_PCLT*  pclt = &face->pclt;
1158
1159
1160    /* optional table */
1161    error = face->goto_table( face, TTAG_PCLT, stream, 0 );
1162    if ( error )
1163      goto Exit;
1164
1165    if ( FT_STREAM_READ_FIELDS( pclt_fields, pclt ) )
1166      goto Exit;
1167
1168  Exit:
1169    return error;
1170  }
1171
1172
1173  /*************************************************************************/
1174  /*                                                                       */
1175  /* <Function>                                                            */
1176  /*    tt_face_load_gasp                                                  */
1177  /*                                                                       */
1178  /* <Description>                                                         */
1179  /*    Loads the `gasp' table into a face object.                         */
1180  /*                                                                       */
1181  /* <Input>                                                               */
1182  /*    face   :: A handle to the target face object.                      */
1183  /*                                                                       */
1184  /*    stream :: The input stream.                                        */
1185  /*                                                                       */
1186  /* <Return>                                                              */
1187  /*    FreeType error code.  0 means success.                             */
1188  /*                                                                       */
1189  FT_LOCAL_DEF( FT_Error )
1190  tt_face_load_gasp( TT_Face    face,
1191                     FT_Stream  stream )
1192  {
1193    FT_Error   error;
1194    FT_Memory  memory = stream->memory;
1195
1196    FT_UInt        j,num_ranges;
1197    TT_GaspRange   gaspranges;
1198
1199
1200    /* the gasp table is optional */
1201    error = face->goto_table( face, TTAG_gasp, stream, 0 );
1202    if ( error )
1203      goto Exit;
1204
1205    if ( FT_FRAME_ENTER( 4L ) )
1206      goto Exit;
1207
1208    face->gasp.version   = FT_GET_USHORT();
1209    face->gasp.numRanges = FT_GET_USHORT();
1210
1211    FT_FRAME_EXIT();
1212
1213    /* only support versions 0 and 1 of the table */
1214    if ( face->gasp.version >= 2 )
1215    {
1216      face->gasp.numRanges = 0;
1217      error = SFNT_Err_Invalid_Table;
1218      goto Exit;
1219    }
1220
1221    num_ranges = face->gasp.numRanges;
1222    FT_TRACE3(( "numRanges: %u\n", num_ranges ));
1223
1224    if ( FT_QNEW_ARRAY( gaspranges, num_ranges ) ||
1225         FT_FRAME_ENTER( num_ranges * 4L )      )
1226      goto Exit;
1227
1228    face->gasp.gaspRanges = gaspranges;
1229
1230    for ( j = 0; j < num_ranges; j++ )
1231    {
1232      gaspranges[j].maxPPEM  = FT_GET_USHORT();
1233      gaspranges[j].gaspFlag = FT_GET_USHORT();
1234
1235      FT_TRACE3(( "gaspRange %d: rangeMaxPPEM %5d, rangeGaspBehavior 0x%x\n",
1236                  j,
1237                  gaspranges[j].maxPPEM,
1238                  gaspranges[j].gaspFlag ));
1239    }
1240
1241    FT_FRAME_EXIT();
1242
1243  Exit:
1244    return error;
1245  }
1246
1247
1248/* END */
Note: See TracBrowser for help on using the repository browser.