source: trunk/poppler/freetype2/src/cff/cffload.c @ 165

Last change on this file since 165 was 165, checked in by Eugene Romanenko, 15 years ago

update to latest freetype cvs, (closes #76)

File size: 46.0 KB
Line 
1/***************************************************************************/
2/*                                                                         */
3/*  cffload.c                                                              */
4/*                                                                         */
5/*    OpenType and CFF data/program tables loader (body).                  */
6/*                                                                         */
7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006 by                   */
8/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
9/*                                                                         */
10/*  This file is part of the FreeType project, and may only be used,       */
11/*  modified, and distributed under the terms of the FreeType project      */
12/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
13/*  this file you indicate that you have read the license and              */
14/*  understand and accept it fully.                                        */
15/*                                                                         */
16/***************************************************************************/
17
18
19#include <ft2build.h>
20#include FT_INTERNAL_DEBUG_H
21#include FT_INTERNAL_OBJECTS_H
22#include FT_INTERNAL_STREAM_H
23#include FT_SERVICE_POSTSCRIPT_CMAPS_H
24#include FT_TRUETYPE_TAGS_H
25
26#include "cffload.h"
27#include "cffparse.h"
28
29#include "cfferrs.h"
30
31
32#if 1
33  static const FT_UShort  cff_isoadobe_charset[229] =
34  {
35    0,
36    1,
37    2,
38    3,
39    4,
40    5,
41    6,
42    7,
43    8,
44    9,
45    10,
46    11,
47    12,
48    13,
49    14,
50    15,
51    16,
52    17,
53    18,
54    19,
55    20,
56    21,
57    22,
58    23,
59    24,
60    25,
61    26,
62    27,
63    28,
64    29,
65    30,
66    31,
67    32,
68    33,
69    34,
70    35,
71    36,
72    37,
73    38,
74    39,
75    40,
76    41,
77    42,
78    43,
79    44,
80    45,
81    46,
82    47,
83    48,
84    49,
85    50,
86    51,
87    52,
88    53,
89    54,
90    55,
91    56,
92    57,
93    58,
94    59,
95    60,
96    61,
97    62,
98    63,
99    64,
100    65,
101    66,
102    67,
103    68,
104    69,
105    70,
106    71,
107    72,
108    73,
109    74,
110    75,
111    76,
112    77,
113    78,
114    79,
115    80,
116    81,
117    82,
118    83,
119    84,
120    85,
121    86,
122    87,
123    88,
124    89,
125    90,
126    91,
127    92,
128    93,
129    94,
130    95,
131    96,
132    97,
133    98,
134    99,
135    100,
136    101,
137    102,
138    103,
139    104,
140    105,
141    106,
142    107,
143    108,
144    109,
145    110,
146    111,
147    112,
148    113,
149    114,
150    115,
151    116,
152    117,
153    118,
154    119,
155    120,
156    121,
157    122,
158    123,
159    124,
160    125,
161    126,
162    127,
163    128,
164    129,
165    130,
166    131,
167    132,
168    133,
169    134,
170    135,
171    136,
172    137,
173    138,
174    139,
175    140,
176    141,
177    142,
178    143,
179    144,
180    145,
181    146,
182    147,
183    148,
184    149,
185    150,
186    151,
187    152,
188    153,
189    154,
190    155,
191    156,
192    157,
193    158,
194    159,
195    160,
196    161,
197    162,
198    163,
199    164,
200    165,
201    166,
202    167,
203    168,
204    169,
205    170,
206    171,
207    172,
208    173,
209    174,
210    175,
211    176,
212    177,
213    178,
214    179,
215    180,
216    181,
217    182,
218    183,
219    184,
220    185,
221    186,
222    187,
223    188,
224    189,
225    190,
226    191,
227    192,
228    193,
229    194,
230    195,
231    196,
232    197,
233    198,
234    199,
235    200,
236    201,
237    202,
238    203,
239    204,
240    205,
241    206,
242    207,
243    208,
244    209,
245    210,
246    211,
247    212,
248    213,
249    214,
250    215,
251    216,
252    217,
253    218,
254    219,
255    220,
256    221,
257    222,
258    223,
259    224,
260    225,
261    226,
262    227,
263    228
264  };
265
266  static const FT_UShort  cff_expert_charset[166] =
267  {
268    0,
269    1,
270    229,
271    230,
272    231,
273    232,
274    233,
275    234,
276    235,
277    236,
278    237,
279    238,
280    13,
281    14,
282    15,
283    99,
284    239,
285    240,
286    241,
287    242,
288    243,
289    244,
290    245,
291    246,
292    247,
293    248,
294    27,
295    28,
296    249,
297    250,
298    251,
299    252,
300    253,
301    254,
302    255,
303    256,
304    257,
305    258,
306    259,
307    260,
308    261,
309    262,
310    263,
311    264,
312    265,
313    266,
314    109,
315    110,
316    267,
317    268,
318    269,
319    270,
320    271,
321    272,
322    273,
323    274,
324    275,
325    276,
326    277,
327    278,
328    279,
329    280,
330    281,
331    282,
332    283,
333    284,
334    285,
335    286,
336    287,
337    288,
338    289,
339    290,
340    291,
341    292,
342    293,
343    294,
344    295,
345    296,
346    297,
347    298,
348    299,
349    300,
350    301,
351    302,
352    303,
353    304,
354    305,
355    306,
356    307,
357    308,
358    309,
359    310,
360    311,
361    312,
362    313,
363    314,
364    315,
365    316,
366    317,
367    318,
368    158,
369    155,
370    163,
371    319,
372    320,
373    321,
374    322,
375    323,
376    324,
377    325,
378    326,
379    150,
380    164,
381    169,
382    327,
383    328,
384    329,
385    330,
386    331,
387    332,
388    333,
389    334,
390    335,
391    336,
392    337,
393    338,
394    339,
395    340,
396    341,
397    342,
398    343,
399    344,
400    345,
401    346,
402    347,
403    348,
404    349,
405    350,
406    351,
407    352,
408    353,
409    354,
410    355,
411    356,
412    357,
413    358,
414    359,
415    360,
416    361,
417    362,
418    363,
419    364,
420    365,
421    366,
422    367,
423    368,
424    369,
425    370,
426    371,
427    372,
428    373,
429    374,
430    375,
431    376,
432    377,
433    378
434  };
435
436  static const FT_UShort  cff_expertsubset_charset[87] =
437  {
438    0,
439    1,
440    231,
441    232,
442    235,
443    236,
444    237,
445    238,
446    13,
447    14,
448    15,
449    99,
450    239,
451    240,
452    241,
453    242,
454    243,
455    244,
456    245,
457    246,
458    247,
459    248,
460    27,
461    28,
462    249,
463    250,
464    251,
465    253,
466    254,
467    255,
468    256,
469    257,
470    258,
471    259,
472    260,
473    261,
474    262,
475    263,
476    264,
477    265,
478    266,
479    109,
480    110,
481    267,
482    268,
483    269,
484    270,
485    272,
486    300,
487    301,
488    302,
489    305,
490    314,
491    315,
492    158,
493    155,
494    163,
495    320,
496    321,
497    322,
498    323,
499    324,
500    325,
501    326,
502    150,
503    164,
504    169,
505    327,
506    328,
507    329,
508    330,
509    331,
510    332,
511    333,
512    334,
513    335,
514    336,
515    337,
516    338,
517    339,
518    340,
519    341,
520    342,
521    343,
522    344,
523    345,
524    346
525  };
526
527  static const FT_UShort  cff_standard_encoding[256] =
528  {
529    0,
530    0,
531    0,
532    0,
533    0,
534    0,
535    0,
536    0,
537    0,
538    0,
539    0,
540    0,
541    0,
542    0,
543    0,
544    0,
545    0,
546    0,
547    0,
548    0,
549    0,
550    0,
551    0,
552    0,
553    0,
554    0,
555    0,
556    0,
557    0,
558    0,
559    0,
560    0,
561    1,
562    2,
563    3,
564    4,
565    5,
566    6,
567    7,
568    8,
569    9,
570    10,
571    11,
572    12,
573    13,
574    14,
575    15,
576    16,
577    17,
578    18,
579    19,
580    20,
581    21,
582    22,
583    23,
584    24,
585    25,
586    26,
587    27,
588    28,
589    29,
590    30,
591    31,
592    32,
593    33,
594    34,
595    35,
596    36,
597    37,
598    38,
599    39,
600    40,
601    41,
602    42,
603    43,
604    44,
605    45,
606    46,
607    47,
608    48,
609    49,
610    50,
611    51,
612    52,
613    53,
614    54,
615    55,
616    56,
617    57,
618    58,
619    59,
620    60,
621    61,
622    62,
623    63,
624    64,
625    65,
626    66,
627    67,
628    68,
629    69,
630    70,
631    71,
632    72,
633    73,
634    74,
635    75,
636    76,
637    77,
638    78,
639    79,
640    80,
641    81,
642    82,
643    83,
644    84,
645    85,
646    86,
647    87,
648    88,
649    89,
650    90,
651    91,
652    92,
653    93,
654    94,
655    95,
656    0,
657    0,
658    0,
659    0,
660    0,
661    0,
662    0,
663    0,
664    0,
665    0,
666    0,
667    0,
668    0,
669    0,
670    0,
671    0,
672    0,
673    0,
674    0,
675    0,
676    0,
677    0,
678    0,
679    0,
680    0,
681    0,
682    0,
683    0,
684    0,
685    0,
686    0,
687    0,
688    0,
689    0,
690    96,
691    97,
692    98,
693    99,
694    100,
695    101,
696    102,
697    103,
698    104,
699    105,
700    106,
701    107,
702    108,
703    109,
704    110,
705    0,
706    111,
707    112,
708    113,
709    114,
710    0,
711    115,
712    116,
713    117,
714    118,
715    119,
716    120,
717    121,
718    122,
719    0,
720    123,
721    0,
722    124,
723    125,
724    126,
725    127,
726    128,
727    129,
728    130,
729    131,
730    0,
731    132,
732    133,
733    0,
734    134,
735    135,
736    136,
737    137,
738    0,
739    0,
740    0,
741    0,
742    0,
743    0,
744    0,
745    0,
746    0,
747    0,
748    0,
749    0,
750    0,
751    0,
752    0,
753    0,
754    138,
755    0,
756    139,
757    0,
758    0,
759    0,
760    0,
761    140,
762    141,
763    142,
764    143,
765    0,
766    0,
767    0,
768    0,
769    0,
770    144,
771    0,
772    0,
773    0,
774    145,
775    0,
776    0,
777    146,
778    147,
779    148,
780    149,
781    0,
782    0,
783    0,
784    0
785  };
786
787  static const FT_UShort  cff_expert_encoding[256] =
788  {
789    0,
790    0,
791    0,
792    0,
793    0,
794    0,
795    0,
796    0,
797    0,
798    0,
799    0,
800    0,
801    0,
802    0,
803    0,
804    0,
805    0,
806    0,
807    0,
808    0,
809    0,
810    0,
811    0,
812    0,
813    0,
814    0,
815    0,
816    0,
817    0,
818    0,
819    0,
820    0,
821    1,
822    229,
823    230,
824    0,
825    231,
826    232,
827    233,
828    234,
829    235,
830    236,
831    237,
832    238,
833    13,
834    14,
835    15,
836    99,
837    239,
838    240,
839    241,
840    242,
841    243,
842    244,
843    245,
844    246,
845    247,
846    248,
847    27,
848    28,
849    249,
850    250,
851    251,
852    252,
853    0,
854    253,
855    254,
856    255,
857    256,
858    257,
859    0,
860    0,
861    0,
862    258,
863    0,
864    0,
865    259,
866    260,
867    261,
868    262,
869    0,
870    0,
871    263,
872    264,
873    265,
874    0,
875    266,
876    109,
877    110,
878    267,
879    268,
880    269,
881    0,
882    270,
883    271,
884    272,
885    273,
886    274,
887    275,
888    276,
889    277,
890    278,
891    279,
892    280,
893    281,
894    282,
895    283,
896    284,
897    285,
898    286,
899    287,
900    288,
901    289,
902    290,
903    291,
904    292,
905    293,
906    294,
907    295,
908    296,
909    297,
910    298,
911    299,
912    300,
913    301,
914    302,
915    303,
916    0,
917    0,
918    0,
919    0,
920    0,
921    0,
922    0,
923    0,
924    0,
925    0,
926    0,
927    0,
928    0,
929    0,
930    0,
931    0,
932    0,
933    0,
934    0,
935    0,
936    0,
937    0,
938    0,
939    0,
940    0,
941    0,
942    0,
943    0,
944    0,
945    0,
946    0,
947    0,
948    0,
949    0,
950    304,
951    305,
952    306,
953    0,
954    0,
955    307,
956    308,
957    309,
958    310,
959    311,
960    0,
961    312,
962    0,
963    0,
964    312,
965    0,
966    0,
967    314,
968    315,
969    0,
970    0,
971    316,
972    317,
973    318,
974    0,
975    0,
976    0,
977    158,
978    155,
979    163,
980    319,
981    320,
982    321,
983    322,
984    323,
985    324,
986    325,
987    0,
988    0,
989    326,
990    150,
991    164,
992    169,
993    327,
994    328,
995    329,
996    330,
997    331,
998    332,
999    333,
1000    334,
1001    335,
1002    336,
1003    337,
1004    338,
1005    339,
1006    340,
1007    341,
1008    342,
1009    343,
1010    344,
1011    345,
1012    346,
1013    347,
1014    348,
1015    349,
1016    350,
1017    351,
1018    352,
1019    353,
1020    354,
1021    355,
1022    356,
1023    357,
1024    358,
1025    359,
1026    360,
1027    361,
1028    362,
1029    363,
1030    364,
1031    365,
1032    366,
1033    367,
1034    368,
1035    369,
1036    370,
1037    371,
1038    372,
1039    373,
1040    374,
1041    375,
1042    376,
1043    377,
1044    378
1045  };
1046#endif
1047
1048
1049  FT_LOCAL_DEF( FT_UShort )
1050  cff_get_standard_encoding( FT_UInt  charcode )
1051  {
1052    return  (FT_UShort)(charcode < 256 ? cff_standard_encoding[charcode] : 0);
1053  }
1054
1055
1056  /*************************************************************************/
1057  /*                                                                       */
1058  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
1059  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
1060  /* messages during execution.                                            */
1061  /*                                                                       */
1062#undef  FT_COMPONENT
1063#define FT_COMPONENT  trace_cffload
1064
1065
1066  static FT_Error
1067  cff_new_index( CFF_Index  idx,
1068                 FT_Stream  stream,
1069                 FT_Bool    load )
1070  {
1071    FT_Error   error;
1072    FT_Memory  memory = stream->memory;
1073    FT_UShort  count;
1074
1075
1076    FT_MEM_ZERO( idx, sizeof ( *idx ) );
1077
1078    idx->stream = stream;
1079    if ( !FT_READ_USHORT( count ) &&
1080         count > 0                )
1081    {
1082      FT_Byte*   p;
1083      FT_Byte    offsize;
1084      FT_ULong   data_size;
1085      FT_ULong*  poff;
1086      FT_Byte*   p_end;
1087
1088
1089      /* there is at least one element; read the offset size,           */
1090      /* then access the offset table to compute the index's total size */
1091      if ( FT_READ_BYTE( offsize ) )
1092        goto Exit;
1093
1094      if ( offsize < 1 || offsize > 4 )
1095      {
1096        error = FT_Err_Invalid_Table;
1097        goto Exit;
1098      }
1099
1100      idx->stream   = stream;
1101      idx->count    = count;
1102      idx->off_size = offsize;
1103      data_size     = (FT_ULong)( count + 1 ) * offsize;
1104
1105      if ( FT_NEW_ARRAY( idx->offsets, count + 1 ) ||
1106           FT_FRAME_ENTER( data_size )             )
1107        goto Exit;
1108
1109      poff   = idx->offsets;
1110      p      = (FT_Byte*)stream->cursor;
1111      p_end  = p + data_size;
1112
1113      switch ( offsize )
1114      {
1115      case 1:
1116        for ( ; p < p_end; p++, poff++ )
1117          poff[0] = p[0];
1118        break;
1119
1120      case 2:
1121        for ( ; p < p_end; p += 2, poff++ )
1122          poff[0] = FT_PEEK_USHORT( p );
1123        break;
1124
1125      case 3:
1126        for ( ; p < p_end; p += 3, poff++ )
1127          poff[0] = FT_PEEK_OFF3( p );
1128        break;
1129
1130      default:
1131        for ( ; p < p_end; p += 4, poff++ )
1132          poff[0] = FT_PEEK_ULONG( p );
1133      }
1134
1135      FT_FRAME_EXIT();
1136
1137      idx->data_offset = FT_STREAM_POS();
1138      data_size        = poff[-1] - 1;
1139
1140      if ( load )
1141      {
1142        /* load the data */
1143        if ( FT_FRAME_EXTRACT( data_size, idx->bytes ) )
1144          goto Exit;
1145      }
1146      else
1147      {
1148        /* skip the data */
1149        if ( FT_STREAM_SKIP( data_size ) )
1150          goto Exit;
1151      }
1152    }
1153
1154  Exit:
1155    if ( error )
1156      FT_FREE( idx->offsets );
1157
1158    return error;
1159  }
1160
1161
1162  static void
1163  cff_done_index( CFF_Index  idx )
1164  {
1165    if ( idx->stream )
1166    {
1167      FT_Stream  stream = idx->stream;
1168      FT_Memory  memory = stream->memory;
1169
1170
1171      if ( idx->bytes )
1172        FT_FRAME_RELEASE( idx->bytes );
1173
1174      FT_FREE( idx->offsets );
1175      FT_MEM_ZERO( idx, sizeof ( *idx ) );
1176    }
1177  }
1178
1179
1180  /* allocate a table containing pointers to an index's elements */
1181  static FT_Error
1182  cff_index_get_pointers( CFF_Index   idx,
1183                          FT_Byte***  table )
1184  {
1185    FT_Error   error  = CFF_Err_Ok;
1186    FT_Memory  memory = idx->stream->memory;
1187    FT_ULong   n, offset, old_offset;
1188    FT_Byte**  t;
1189
1190
1191    *table = 0;
1192
1193    if ( idx->count > 0 && !FT_NEW_ARRAY( t, idx->count + 1 ) )
1194    {
1195      old_offset = 1;
1196      for ( n = 0; n <= idx->count; n++ )
1197      {
1198        offset = idx->offsets[n];
1199        if ( !offset )
1200          offset = old_offset;
1201
1202        t[n] = idx->bytes + offset - 1;
1203
1204        old_offset = offset;
1205      }
1206      *table = t;
1207    }
1208
1209    return error;
1210  }
1211
1212
1213  FT_LOCAL_DEF( FT_Error )
1214  cff_index_access_element( CFF_Index  idx,
1215                            FT_UInt    element,
1216                            FT_Byte**  pbytes,
1217                            FT_ULong*  pbyte_len )
1218  {
1219    FT_Error  error = CFF_Err_Ok;
1220
1221
1222    if ( idx && idx->count > element )
1223    {
1224      /* compute start and end offsets */
1225      FT_ULong  off1, off2 = 0;
1226
1227
1228      off1 = idx->offsets[element];
1229      if ( off1 )
1230      {
1231        do
1232        {
1233          element++;
1234          off2 = idx->offsets[element];
1235
1236        } while ( off2 == 0 && element < idx->count );
1237
1238        if ( !off2 )
1239          off1 = 0;
1240      }
1241
1242      /* access element */
1243      if ( off1 && off2 > off1 )
1244      {
1245        *pbyte_len = off2 - off1;
1246
1247        if ( idx->bytes )
1248        {
1249          /* this index was completely loaded in memory, that's easy */
1250          *pbytes = idx->bytes + off1 - 1;
1251        }
1252        else
1253        {
1254          /* this index is still on disk/file, access it through a frame */
1255          FT_Stream  stream = idx->stream;
1256
1257
1258          if ( FT_STREAM_SEEK( idx->data_offset + off1 - 1 ) ||
1259               FT_FRAME_EXTRACT( off2 - off1, *pbytes )      )
1260            goto Exit;
1261        }
1262      }
1263      else
1264      {
1265        /* empty index element */
1266        *pbytes    = 0;
1267        *pbyte_len = 0;
1268      }
1269    }
1270    else
1271      error = CFF_Err_Invalid_Argument;
1272
1273  Exit:
1274    return error;
1275  }
1276
1277
1278  FT_LOCAL_DEF( void )
1279  cff_index_forget_element( CFF_Index  idx,
1280                            FT_Byte**  pbytes )
1281  {
1282    if ( idx->bytes == 0 )
1283    {
1284      FT_Stream  stream = idx->stream;
1285
1286
1287      FT_FRAME_RELEASE( *pbytes );
1288    }
1289  }
1290
1291
1292  FT_LOCAL_DEF( FT_String* )
1293  cff_index_get_name( CFF_Index  idx,
1294                      FT_UInt    element )
1295  {
1296    FT_Memory   memory = idx->stream->memory;
1297    FT_Byte*    bytes;
1298    FT_ULong    byte_len;
1299    FT_Error    error;
1300    FT_String*  name = 0;
1301
1302
1303    error = cff_index_access_element( idx, element, &bytes, &byte_len );
1304    if ( error )
1305      goto Exit;
1306
1307    if ( !FT_ALLOC( name, byte_len + 1 ) )
1308    {
1309      FT_MEM_COPY( name, bytes, byte_len );
1310      name[byte_len] = 0;
1311    }
1312    cff_index_forget_element( idx, &bytes );
1313
1314  Exit:
1315    return name;
1316  }
1317
1318
1319  FT_LOCAL_DEF( FT_String* )
1320  cff_index_get_sid_string( CFF_Index           idx,
1321                            FT_UInt             sid,
1322                            FT_Service_PsCMaps  psnames )
1323  {
1324    /* value 0xFFFFU indicates a missing dictionary entry */
1325    if ( sid == 0xFFFFU )
1326      return 0;
1327
1328    /* if it is not a standard string, return it */
1329    if ( sid > 390 )
1330      return cff_index_get_name( idx, sid - 391 );
1331
1332    /* CID-keyed CFF fonts don't have glyph names */
1333    if ( !psnames )
1334      return 0;
1335
1336    /* that's a standard string, fetch a copy from the PSName module */
1337    {
1338      FT_String*   name       = 0;
1339      const char*  adobe_name = psnames->adobe_std_strings( sid );
1340      FT_UInt      len;
1341
1342
1343      if ( adobe_name )
1344      {
1345        FT_Memory  memory = idx->stream->memory;
1346        FT_Error   error;
1347
1348
1349        len = (FT_UInt)ft_strlen( adobe_name );
1350        if ( !FT_ALLOC( name, len + 1 ) )
1351        {
1352          FT_MEM_COPY( name, adobe_name, len );
1353          name[len] = 0;
1354        }
1355
1356        FT_UNUSED( error );
1357      }
1358
1359      return name;
1360    }
1361  }
1362
1363
1364  /*************************************************************************/
1365  /*************************************************************************/
1366  /***                                                                   ***/
1367  /***   FD Select table support                                         ***/
1368  /***                                                                   ***/
1369  /*************************************************************************/
1370  /*************************************************************************/
1371
1372
1373  static void
1374  CFF_Done_FD_Select( CFF_FDSelect  fdselect,
1375                      FT_Stream     stream )
1376  {
1377    if ( fdselect->data )
1378      FT_FRAME_RELEASE( fdselect->data );
1379
1380    fdselect->data_size   = 0;
1381    fdselect->format      = 0;
1382    fdselect->range_count = 0;
1383  }
1384
1385
1386  static FT_Error
1387  CFF_Load_FD_Select( CFF_FDSelect  fdselect,
1388                      FT_UInt       num_glyphs,
1389                      FT_Stream     stream,
1390                      FT_ULong      offset )
1391  {
1392    FT_Error  error;
1393    FT_Byte   format;
1394    FT_UInt   num_ranges;
1395
1396
1397    /* read format */
1398    if ( FT_STREAM_SEEK( offset ) || FT_READ_BYTE( format ) )
1399      goto Exit;
1400
1401    fdselect->format      = format;
1402    fdselect->cache_count = 0;   /* clear cache */
1403
1404    switch ( format )
1405    {
1406    case 0:     /* format 0, that's simple */
1407      fdselect->data_size = num_glyphs;
1408      goto Load_Data;
1409
1410    case 3:     /* format 3, a tad more complex */
1411      if ( FT_READ_USHORT( num_ranges ) )
1412        goto Exit;
1413
1414      fdselect->data_size = num_ranges * 3 + 2;
1415
1416    Load_Data:
1417      if ( FT_FRAME_EXTRACT( fdselect->data_size, fdselect->data ) )
1418        goto Exit;
1419      break;
1420
1421    default:    /* hmm... that's wrong */
1422      error = CFF_Err_Invalid_File_Format;
1423    }
1424
1425  Exit:
1426    return error;
1427  }
1428
1429
1430  FT_LOCAL_DEF( FT_Byte )
1431  cff_fd_select_get( CFF_FDSelect  fdselect,
1432                     FT_UInt       glyph_index )
1433  {
1434    FT_Byte  fd = 0;
1435
1436
1437    switch ( fdselect->format )
1438    {
1439    case 0:
1440      fd = fdselect->data[glyph_index];
1441      break;
1442
1443    case 3:
1444      /* first, compare to cache */
1445      if ( (FT_UInt)( glyph_index - fdselect->cache_first ) <
1446                        fdselect->cache_count )
1447      {
1448        fd = fdselect->cache_fd;
1449        break;
1450      }
1451
1452      /* then, lookup the ranges array */
1453      {
1454        FT_Byte*  p       = fdselect->data;
1455        FT_Byte*  p_limit = p + fdselect->data_size;
1456        FT_Byte   fd2;
1457        FT_UInt   first, limit;
1458
1459
1460        first = FT_NEXT_USHORT( p );
1461        do
1462        {
1463          if ( glyph_index < first )
1464            break;
1465
1466          fd2   = *p++;
1467          limit = FT_NEXT_USHORT( p );
1468
1469          if ( glyph_index < limit )
1470          {
1471            fd = fd2;
1472
1473            /* update cache */
1474            fdselect->cache_first = first;
1475            fdselect->cache_count = limit-first;
1476            fdselect->cache_fd    = fd2;
1477            break;
1478          }
1479          first = limit;
1480
1481        } while ( p < p_limit );
1482      }
1483      break;
1484
1485    default:
1486      ;
1487    }
1488
1489    return fd;
1490  }
1491
1492
1493  /*************************************************************************/
1494  /*************************************************************************/
1495  /***                                                                   ***/
1496  /***   CFF font support                                                ***/
1497  /***                                                                   ***/
1498  /*************************************************************************/
1499  /*************************************************************************/
1500
1501  static FT_Error
1502  cff_charset_compute_cids( CFF_Charset  charset,
1503                            FT_UInt      num_glyphs,
1504                            FT_Memory    memory )
1505  {
1506    FT_Error   error   = FT_Err_Ok;
1507    FT_UInt    i;
1508    FT_UShort  max_cid = 0;
1509
1510
1511    if ( charset->max_cid > 0 )
1512      goto Exit;
1513
1514    for ( i = 0; i < num_glyphs; i++ )
1515      if ( charset->sids[i] > max_cid )
1516        max_cid = charset->sids[i];
1517    max_cid++;
1518
1519    if ( FT_NEW_ARRAY( charset->cids, max_cid ) )
1520      goto Exit;
1521
1522    for ( i = 0; i < num_glyphs; i++ )
1523      charset->cids[charset->sids[i]] = (FT_UShort)i;
1524
1525    charset->max_cid = max_cid;
1526
1527  Exit:
1528    return error;
1529  }
1530
1531
1532  static void
1533  cff_charset_free_cids( CFF_Charset  charset,
1534                         FT_Memory    memory )
1535  {
1536    FT_FREE( charset->cids );
1537    charset->max_cid = 0;
1538  }
1539
1540
1541  static void
1542  cff_charset_done( CFF_Charset  charset,
1543                    FT_Stream    stream )
1544  {
1545    FT_Memory  memory = stream->memory;
1546
1547
1548    cff_charset_free_cids( charset, memory );
1549
1550    FT_FREE( charset->sids );
1551    charset->format = 0;
1552    charset->offset = 0;
1553  }
1554
1555
1556  static FT_Error
1557  cff_charset_load( CFF_Charset  charset,
1558                    FT_UInt      num_glyphs,
1559                    FT_Stream    stream,
1560                    FT_ULong     base_offset,
1561                    FT_ULong     offset,
1562                    FT_Bool      invert )
1563  {
1564    FT_Memory  memory = stream->memory;
1565    FT_Error   error  = CFF_Err_Ok;
1566    FT_UShort  glyph_sid;
1567
1568
1569    /* If the the offset is greater than 2, we have to parse the */
1570    /* charset table.                                            */
1571    if ( offset > 2 )
1572    {
1573      FT_UInt  j;
1574
1575
1576      charset->offset = base_offset + offset;
1577
1578      /* Get the format of the table. */
1579      if ( FT_STREAM_SEEK( charset->offset ) ||
1580           FT_READ_BYTE( charset->format )   )
1581        goto Exit;
1582
1583      /* Allocate memory for sids. */
1584      if ( FT_NEW_ARRAY( charset->sids, num_glyphs ) )
1585        goto Exit;
1586
1587      /* assign the .notdef glyph */
1588      charset->sids[0] = 0;
1589
1590      switch ( charset->format )
1591      {
1592      case 0:
1593        if ( num_glyphs > 0 )
1594        {
1595          if ( FT_FRAME_ENTER( ( num_glyphs - 1 ) * 2 ) )
1596            goto Exit;
1597
1598          for ( j = 1; j < num_glyphs; j++ )
1599            charset->sids[j] = FT_GET_USHORT();
1600
1601          FT_FRAME_EXIT();
1602        }
1603        break;
1604
1605      case 1:
1606      case 2:
1607        {
1608          FT_UInt  nleft;
1609          FT_UInt  i;
1610
1611
1612          j = 1;
1613
1614          while ( j < num_glyphs )
1615          {
1616            /* Read the first glyph sid of the range. */
1617            if ( FT_READ_USHORT( glyph_sid ) )
1618              goto Exit;
1619
1620            /* Read the number of glyphs in the range.  */
1621            if ( charset->format == 2 )
1622            {
1623              if ( FT_READ_USHORT( nleft ) )
1624                goto Exit;
1625            }
1626            else
1627            {
1628              if ( FT_READ_BYTE( nleft ) )
1629                goto Exit;
1630            }
1631
1632            /* Fill in the range of sids -- `nleft + 1' glyphs. */
1633            for ( i = 0; j < num_glyphs && i <= nleft; i++, j++, glyph_sid++ )
1634              charset->sids[j] = glyph_sid;
1635          }
1636        }
1637        break;
1638
1639      default:
1640        FT_ERROR(( "cff_charset_load: invalid table format!\n" ));
1641        error = CFF_Err_Invalid_File_Format;
1642        goto Exit;
1643      }
1644    }
1645    else
1646    {
1647      /* Parse default tables corresponding to offset == 0, 1, or 2.  */
1648      /* CFF specification intimates the following:                   */
1649      /*                                                              */
1650      /* In order to use a predefined charset, the following must be  */
1651      /* true: The charset constructed for the glyphs in the font's   */
1652      /* charstrings dictionary must match the predefined charset in  */
1653      /* the first num_glyphs.                                        */
1654
1655      charset->offset = offset;  /* record charset type */
1656
1657      switch ( (FT_UInt)offset )
1658      {
1659      case 0:
1660        if ( num_glyphs > 229 )
1661        {
1662          FT_ERROR(( "cff_charset_load: implicit charset larger than\n"
1663                     "predefined charset (Adobe ISO-Latin)!\n" ));
1664          error = CFF_Err_Invalid_File_Format;
1665          goto Exit;
1666        }
1667
1668        /* Allocate memory for sids. */
1669        if ( FT_NEW_ARRAY( charset->sids, num_glyphs ) )
1670          goto Exit;
1671
1672        /* Copy the predefined charset into the allocated memory. */
1673        FT_ARRAY_COPY( charset->sids, cff_isoadobe_charset, num_glyphs );
1674
1675        break;
1676
1677      case 1:
1678        if ( num_glyphs > 166 )
1679        {
1680          FT_ERROR(( "cff_charset_load: implicit charset larger than\n"
1681                     "predefined charset (Adobe Expert)!\n" ));
1682          error = CFF_Err_Invalid_File_Format;
1683          goto Exit;
1684        }
1685
1686        /* Allocate memory for sids. */
1687        if ( FT_NEW_ARRAY( charset->sids, num_glyphs ) )
1688          goto Exit;
1689
1690        /* Copy the predefined charset into the allocated memory.     */
1691        FT_ARRAY_COPY( charset->sids, cff_expert_charset, num_glyphs );
1692
1693        break;
1694
1695      case 2:
1696        if ( num_glyphs > 87 )
1697        {
1698          FT_ERROR(( "cff_charset_load: implicit charset larger than\n"
1699                     "predefined charset (Adobe Expert Subset)!\n" ));
1700          error = CFF_Err_Invalid_File_Format;
1701          goto Exit;
1702        }
1703
1704        /* Allocate memory for sids. */
1705        if ( FT_NEW_ARRAY( charset->sids, num_glyphs ) )
1706          goto Exit;
1707
1708        /* Copy the predefined charset into the allocated memory.     */
1709        FT_ARRAY_COPY( charset->sids, cff_expertsubset_charset, num_glyphs );
1710
1711        break;
1712
1713      default:
1714        error = CFF_Err_Invalid_File_Format;
1715        goto Exit;
1716      }
1717    }
1718
1719    /* we have to invert the `sids' array for subsetted CID-keyed fonts */
1720    if ( invert )
1721      error = cff_charset_compute_cids( charset, num_glyphs, memory );
1722
1723  Exit:
1724    /* Clean up if there was an error. */
1725    if ( error )
1726    {
1727      FT_FREE( charset->sids );
1728      FT_FREE( charset->cids );
1729      charset->format = 0;
1730      charset->offset = 0;
1731      charset->sids   = 0;
1732    }
1733
1734    return error;
1735  }
1736
1737
1738  static void
1739  cff_encoding_done( CFF_Encoding  encoding )
1740  {
1741    encoding->format = 0;
1742    encoding->offset = 0;
1743    encoding->count  = 0;
1744  }
1745
1746
1747  static FT_Error
1748  cff_encoding_load( CFF_Encoding  encoding,
1749                     CFF_Charset   charset,
1750                     FT_UInt       num_glyphs,
1751                     FT_Stream     stream,
1752                     FT_ULong      base_offset,
1753                     FT_ULong      offset )
1754  {
1755    FT_Error   error = CFF_Err_Ok;
1756    FT_UInt    count;
1757    FT_UInt    j;
1758    FT_UShort  glyph_sid;
1759    FT_UInt    glyph_code;
1760
1761
1762    /* Check for charset->sids.  If we do not have this, we fail. */
1763    if ( !charset->sids )
1764    {
1765      error = CFF_Err_Invalid_File_Format;
1766      goto Exit;
1767    }
1768
1769    /* Zero out the code to gid/sid mappings. */
1770    for ( j = 0; j < 256; j++ )
1771    {
1772      encoding->sids [j] = 0;
1773      encoding->codes[j] = 0;
1774    }
1775
1776    /* Note: The encoding table in a CFF font is indexed by glyph index;  */
1777    /* the first encoded glyph index is 1.  Hence, we read the character  */
1778    /* code (`glyph_code') at index j and make the assignment:            */
1779    /*                                                                    */
1780    /*    encoding->codes[glyph_code] = j + 1                             */
1781    /*                                                                    */
1782    /* We also make the assignment:                                       */
1783    /*                                                                    */
1784    /*    encoding->sids[glyph_code] = charset->sids[j + 1]               */
1785    /*                                                                    */
1786    /* This gives us both a code to GID and a code to SID mapping.        */
1787
1788    if ( offset > 1 )
1789    {
1790      encoding->offset = base_offset + offset;
1791
1792      /* we need to parse the table to determine its size */
1793      if ( FT_STREAM_SEEK( encoding->offset ) ||
1794           FT_READ_BYTE( encoding->format )   ||
1795           FT_READ_BYTE( count )              )
1796        goto Exit;
1797
1798      switch ( encoding->format & 0x7F )
1799      {
1800      case 0:
1801        {
1802          FT_Byte*  p;
1803
1804
1805          /* By convention, GID 0 is always ".notdef" and is never */
1806          /* coded in the font.  Hence, the number of codes found  */
1807          /* in the table is `count+1'.                            */
1808          /*                                                       */
1809          encoding->count = count + 1;
1810
1811          if ( FT_FRAME_ENTER( count ) )
1812            goto Exit;
1813
1814          p = (FT_Byte*)stream->cursor;
1815
1816          for ( j = 1; j <= count; j++ )
1817          {
1818            glyph_code = *p++;
1819
1820            /* Make sure j is not too big. */
1821            if ( j < num_glyphs )
1822            {
1823              /* Assign code to GID mapping. */
1824              encoding->codes[glyph_code] = (FT_UShort)j;
1825
1826              /* Assign code to SID mapping. */
1827              encoding->sids[glyph_code] = charset->sids[j];
1828            }
1829          }
1830
1831          FT_FRAME_EXIT();
1832        }
1833        break;
1834
1835      case 1:
1836        {
1837          FT_UInt  nleft;
1838          FT_UInt  i = 1;
1839          FT_UInt  k;
1840
1841
1842          encoding->count = 0;
1843
1844          /* Parse the Format1 ranges. */
1845          for ( j = 0;  j < count; j++, i += nleft )
1846          {
1847            /* Read the first glyph code of the range. */
1848            if ( FT_READ_BYTE( glyph_code ) )
1849              goto Exit;
1850
1851            /* Read the number of codes in the range. */
1852            if ( FT_READ_BYTE( nleft ) )
1853              goto Exit;
1854
1855            /* Increment nleft, so we read `nleft + 1' codes/sids. */
1856            nleft++;
1857
1858            /* compute max number of character codes */
1859            if ( (FT_UInt)nleft > encoding->count )
1860              encoding->count = nleft;
1861
1862            /* Fill in the range of codes/sids. */
1863            for ( k = i; k < nleft + i; k++, glyph_code++ )
1864            {
1865              /* Make sure k is not too big. */
1866              if ( k < num_glyphs && glyph_code < 256 )
1867              {
1868                /* Assign code to GID mapping. */
1869                encoding->codes[glyph_code] = (FT_UShort)k;
1870
1871                /* Assign code to SID mapping. */
1872                encoding->sids[glyph_code] = charset->sids[k];
1873              }
1874            }
1875          }
1876
1877          /* simple check; one never knows what can be found in a font */
1878          if ( encoding->count > 256 )
1879            encoding->count = 256;
1880        }
1881        break;
1882
1883      default:
1884        FT_ERROR(( "cff_encoding_load: invalid table format!\n" ));
1885        error = CFF_Err_Invalid_File_Format;
1886        goto Exit;
1887      }
1888
1889      /* Parse supplemental encodings, if any. */
1890      if ( encoding->format & 0x80 )
1891      {
1892        FT_UInt  gindex;
1893
1894
1895        /* count supplements */
1896        if ( FT_READ_BYTE( count ) )
1897          goto Exit;
1898
1899        for ( j = 0; j < count; j++ )
1900        {
1901          /* Read supplemental glyph code. */
1902          if ( FT_READ_BYTE( glyph_code ) )
1903            goto Exit;
1904
1905          /* Read the SID associated with this glyph code. */
1906          if ( FT_READ_USHORT( glyph_sid ) )
1907            goto Exit;
1908
1909          /* Assign code to SID mapping. */
1910          encoding->sids[glyph_code] = glyph_sid;
1911
1912          /* First, look up GID which has been assigned to */
1913          /* SID glyph_sid.                                */
1914          for ( gindex = 0; gindex < num_glyphs; gindex++ )
1915          {
1916            if ( charset->sids[gindex] == glyph_sid )
1917            {
1918              encoding->codes[glyph_code] = (FT_UShort)gindex;
1919              break;
1920            }
1921          }
1922        }
1923      }
1924    }
1925    else
1926    {
1927      /* We take into account the fact a CFF font can use a predefined */
1928      /* encoding without containing all of the glyphs encoded by this */
1929      /* encoding (see the note at the end of section 12 in the CFF    */
1930      /* specification).                                               */
1931
1932      switch ( (FT_UInt)offset )
1933      {
1934      case 0:
1935        /* First, copy the code to SID mapping. */
1936        FT_ARRAY_COPY( encoding->sids, cff_standard_encoding, 256 );
1937        goto Populate;
1938
1939      case 1:
1940        /* First, copy the code to SID mapping. */
1941        FT_ARRAY_COPY( encoding->sids, cff_expert_encoding, 256 );
1942
1943      Populate:
1944        /* Construct code to GID mapping from code to SID mapping */
1945        /* and charset.                                           */
1946
1947        encoding->count = 0;
1948
1949        error = cff_charset_compute_cids( charset, num_glyphs,
1950                                          stream->memory );
1951        if ( error )
1952          goto Exit;
1953
1954        for ( j = 0; j < 256; j++ )
1955        {
1956          FT_UInt  sid = encoding->sids[j];
1957          FT_UInt  gid = 0;
1958
1959
1960          if ( sid )
1961            gid = charset->cids[sid];
1962
1963          if ( gid != 0 )
1964          {
1965            encoding->codes[j] = (FT_UShort)gid;
1966
1967            if ( encoding->count < j + 1 )
1968              encoding->count = j + 1;
1969          }
1970          else
1971          {
1972            encoding->codes[j] = 0;
1973            encoding->sids [j] = 0;
1974          }
1975        }
1976        break;
1977
1978      default:
1979        FT_ERROR(( "cff_encoding_load: invalid table format!\n" ));
1980        error = CFF_Err_Invalid_File_Format;
1981        goto Exit;
1982      }
1983    }
1984
1985  Exit:
1986
1987    /* Clean up if there was an error. */
1988    return error;
1989  }
1990
1991
1992  static FT_Error
1993  cff_subfont_load( CFF_SubFont  font,
1994                    CFF_Index    idx,
1995                    FT_UInt      font_index,
1996                    FT_Stream    stream,
1997                    FT_ULong     base_offset )
1998  {
1999    FT_Error         error;
2000    CFF_ParserRec    parser;
2001    FT_Byte*         dict = NULL;
2002    FT_ULong         dict_len;
2003    CFF_FontRecDict  top  = &font->font_dict;
2004    CFF_Private      priv = &font->private_dict;
2005
2006
2007    cff_parser_init( &parser, CFF_CODE_TOPDICT, &font->font_dict );
2008
2009    /* set defaults */
2010    FT_MEM_ZERO( top, sizeof ( *top ) );
2011
2012    top->underline_position  = -100L << 16;
2013    top->underline_thickness = 50L << 16;
2014    top->charstring_type     = 2;
2015    top->font_matrix.xx      = 0x10000L;
2016    top->font_matrix.yy      = 0x10000L;
2017    top->cid_count           = 8720;
2018
2019    /* we use the implementation specific SID value 0xFFFF to indicate */
2020    /* missing entries                                                 */
2021    top->version             = 0xFFFFU;
2022    top->notice              = 0xFFFFU;
2023    top->copyright           = 0xFFFFU;
2024    top->full_name           = 0xFFFFU;
2025    top->family_name         = 0xFFFFU;
2026    top->weight              = 0xFFFFU;
2027    top->embedded_postscript = 0xFFFFU;
2028
2029    top->cid_registry        = 0xFFFFU;
2030    top->cid_ordering        = 0xFFFFU;
2031    top->cid_font_name       = 0xFFFFU;
2032
2033    error = cff_index_access_element( idx, font_index, &dict, &dict_len ) ||
2034            cff_parser_run( &parser, dict, dict + dict_len );
2035
2036    cff_index_forget_element( idx, &dict );
2037
2038    if ( error )
2039      goto Exit;
2040
2041    /* if it is a CID font, we stop there */
2042    if ( top->cid_registry != 0xFFFFU )
2043      goto Exit;
2044
2045    /* parse the private dictionary, if any */
2046    if ( top->private_offset && top->private_size )
2047    {
2048      /* set defaults */
2049      FT_MEM_ZERO( priv, sizeof ( *priv ) );
2050
2051      priv->blue_shift       = 7;
2052      priv->blue_fuzz        = 1;
2053      priv->lenIV            = -1;
2054      priv->expansion_factor = (FT_Fixed)( 0.06 * 0x10000L );
2055      priv->blue_scale       = (FT_Fixed)( 0.039625 * 0x10000L * 1000 );
2056
2057      cff_parser_init( &parser, CFF_CODE_PRIVATE, priv );
2058
2059      if ( FT_STREAM_SEEK( base_offset + font->font_dict.private_offset ) ||
2060           FT_FRAME_ENTER( font->font_dict.private_size )                 )
2061        goto Exit;
2062
2063      error = cff_parser_run( &parser,
2064                              (FT_Byte*)stream->cursor,
2065                              (FT_Byte*)stream->limit );
2066      FT_FRAME_EXIT();
2067      if ( error )
2068        goto Exit;
2069
2070      /* ensure that `num_blue_values' is even */
2071      priv->num_blue_values &= ~1;
2072    }
2073
2074    /* read the local subrs, if any */
2075    if ( priv->local_subrs_offset )
2076    {
2077      if ( FT_STREAM_SEEK( base_offset + top->private_offset +
2078                           priv->local_subrs_offset ) )
2079        goto Exit;
2080
2081      error = cff_new_index( &font->local_subrs_index, stream, 1 );
2082      if ( error )
2083        goto Exit;
2084
2085      font->num_local_subrs = font->local_subrs_index.count;
2086      error = cff_index_get_pointers( &font->local_subrs_index,
2087                                      &font->local_subrs );
2088      if ( error )
2089        goto Exit;
2090    }
2091
2092  Exit:
2093    return error;
2094  }
2095
2096
2097  static void
2098  cff_subfont_done( FT_Memory    memory,
2099                    CFF_SubFont  subfont )
2100  {
2101    if ( subfont )
2102    {
2103      cff_done_index( &subfont->local_subrs_index );
2104      FT_FREE( subfont->local_subrs );
2105    }
2106  }
2107
2108
2109  FT_LOCAL_DEF( FT_Error )
2110  cff_font_load( FT_Stream  stream,
2111                 FT_Int     face_index,
2112                 CFF_Font   font )
2113  {
2114    static const FT_Frame_Field  cff_header_fields[] =
2115    {
2116#undef  FT_STRUCTURE
2117#define FT_STRUCTURE  CFF_FontRec
2118
2119      FT_FRAME_START( 4 ),
2120        FT_FRAME_BYTE( version_major ),
2121        FT_FRAME_BYTE( version_minor ),
2122        FT_FRAME_BYTE( header_size ),
2123        FT_FRAME_BYTE( absolute_offsize ),
2124      FT_FRAME_END
2125    };
2126
2127    FT_Error         error;
2128    FT_Memory        memory = stream->memory;
2129    FT_ULong         base_offset;
2130    CFF_FontRecDict  dict;
2131
2132
2133    FT_ZERO( font );
2134
2135    font->stream = stream;
2136    font->memory = memory;
2137    dict         = &font->top_font.font_dict;
2138    base_offset  = FT_STREAM_POS();
2139
2140    /* read CFF font header */
2141    if ( FT_STREAM_READ_FIELDS( cff_header_fields, font ) )
2142      goto Exit;
2143
2144    /* check format */
2145    if ( font->version_major   != 1 ||
2146         font->header_size      < 4 ||
2147         font->absolute_offsize > 4 )
2148    {
2149      FT_TRACE2(( "[not a CFF font header!]\n" ));
2150      error = CFF_Err_Unknown_File_Format;
2151      goto Exit;
2152    }
2153
2154    /* skip the rest of the header */
2155    if ( FT_STREAM_SKIP( font->header_size - 4 ) )
2156      goto Exit;
2157
2158    /* read the name, top dict, string and global subrs index */
2159    if ( FT_SET_ERROR( cff_new_index( &font->name_index,         stream, 0 )) ||
2160         FT_SET_ERROR( cff_new_index( &font->font_dict_index,    stream, 0 )) ||
2161         FT_SET_ERROR( cff_new_index( &font->string_index,       stream, 0 )) ||
2162         FT_SET_ERROR( cff_new_index( &font->global_subrs_index, stream, 1 )) )
2163      goto Exit;
2164
2165    /* well, we don't really forget the `disabled' fonts... */
2166    font->num_faces = font->name_index.count;
2167    if ( face_index >= (FT_Int)font->num_faces )
2168    {
2169      FT_ERROR(( "cff_font_load: incorrect face index = %d\n",
2170                 face_index ));
2171      error = CFF_Err_Invalid_Argument;
2172    }
2173
2174    /* in case of a font format check, simply exit now */
2175    if ( face_index < 0 )
2176      goto Exit;
2177
2178    /* now, parse the top-level font dictionary */
2179    error = cff_subfont_load( &font->top_font,
2180                              &font->font_dict_index,
2181                              face_index,
2182                              stream,
2183                              base_offset );
2184    if ( error )
2185      goto Exit;
2186
2187    if ( FT_STREAM_SEEK( base_offset + dict->charstrings_offset ) )
2188      goto Exit;
2189
2190    error = cff_new_index( &font->charstrings_index, stream, 0 );
2191    if ( error )
2192      goto Exit;
2193
2194    /* now, check for a CID font */
2195    if ( dict->cid_registry != 0xFFFFU )
2196    {
2197      CFF_IndexRec  fd_index;
2198      CFF_SubFont   sub;
2199      FT_UInt       idx;
2200
2201
2202      /* this is a CID-keyed font, we must now allocate a table of */
2203      /* sub-fonts, then load each of them separately              */
2204      if ( FT_STREAM_SEEK( base_offset + dict->cid_fd_array_offset ) )
2205        goto Exit;
2206
2207      error = cff_new_index( &fd_index, stream, 0 );
2208      if ( error )
2209        goto Exit;
2210
2211      if ( fd_index.count > CFF_MAX_CID_FONTS )
2212      {
2213        FT_ERROR(( "cff_font_load: FD array too large in CID font\n" ));
2214        goto Fail_CID;
2215      }
2216
2217      /* allocate & read each font dict independently */
2218      font->num_subfonts = fd_index.count;
2219      if ( FT_NEW_ARRAY( sub, fd_index.count ) )
2220        goto Fail_CID;
2221
2222      /* set up pointer table */
2223      for ( idx = 0; idx < fd_index.count; idx++ )
2224        font->subfonts[idx] = sub + idx;
2225
2226      /* now load each subfont independently */
2227      for ( idx = 0; idx < fd_index.count; idx++ )
2228      {
2229        sub = font->subfonts[idx];
2230        error = cff_subfont_load( sub, &fd_index, idx,
2231                                  stream, base_offset );
2232        if ( error )
2233          goto Fail_CID;
2234      }
2235
2236      /* now load the FD Select array */
2237      error = CFF_Load_FD_Select( &font->fd_select,
2238                                  font->charstrings_index.count,
2239                                  stream,
2240                                  base_offset + dict->cid_fd_select_offset );
2241
2242    Fail_CID:
2243      cff_done_index( &fd_index );
2244
2245      if ( error )
2246        goto Exit;
2247    }
2248    else
2249      font->num_subfonts = 0;
2250
2251    /* read the charstrings index now */
2252    if ( dict->charstrings_offset == 0 )
2253    {
2254      FT_ERROR(( "cff_font_load: no charstrings offset!\n" ));
2255      error = CFF_Err_Unknown_File_Format;
2256      goto Exit;
2257    }
2258
2259    /* explicit the global subrs */
2260    font->num_global_subrs = font->global_subrs_index.count;
2261    font->num_glyphs       = font->charstrings_index.count;
2262
2263    error = cff_index_get_pointers( &font->global_subrs_index,
2264                                    &font->global_subrs ) ;
2265
2266    if ( error )
2267      goto Exit;
2268
2269    /* read the Charset and Encoding tables if available */
2270    if ( font->num_glyphs > 0 )
2271    {
2272      FT_Bool  invert = FT_BOOL( dict->cid_registry != 0xFFFFU );
2273
2274
2275      error = cff_charset_load( &font->charset, font->num_glyphs, stream,
2276                                base_offset, dict->charset_offset, invert );
2277      if ( error )
2278        goto Exit;
2279
2280      /* CID-keyed CFFs don't have an encoding */
2281      if ( dict->cid_registry == 0xFFFFU )
2282      {
2283        error = cff_encoding_load( &font->encoding,
2284                                   &font->charset,
2285                                   font->num_glyphs,
2286                                   stream,
2287                                   base_offset,
2288                                   dict->encoding_offset );
2289        if ( error )
2290          goto Exit;
2291      }
2292      else
2293        /* CID-keyed fonts only need CIDs */
2294        FT_FREE( font->charset.sids );
2295    }
2296
2297    /* get the font name (/CIDFontName for CID-keyed fonts, */
2298    /* /FontName otherwise)                                 */
2299    font->font_name = cff_index_get_name( &font->name_index, face_index );
2300
2301  Exit:
2302    return error;
2303  }
2304
2305
2306  FT_LOCAL_DEF( void )
2307  cff_font_done( CFF_Font  font )
2308  {
2309    FT_Memory  memory = font->memory;
2310    FT_UInt    idx;
2311
2312
2313    cff_done_index( &font->global_subrs_index );
2314    cff_done_index( &font->string_index );
2315    cff_done_index( &font->font_dict_index );
2316    cff_done_index( &font->name_index );
2317    cff_done_index( &font->charstrings_index );
2318
2319    /* release font dictionaries, but only if working with */
2320    /* a CID keyed CFF font                                */
2321    if ( font->num_subfonts > 0 )
2322    {
2323      for ( idx = 0; idx < font->num_subfonts; idx++ )
2324        cff_subfont_done( memory, font->subfonts[idx] );
2325
2326      /* the subfonts array has been allocated as a single block */
2327      FT_FREE( font->subfonts[0] );
2328    }
2329
2330    cff_encoding_done( &font->encoding );
2331    cff_charset_done( &font->charset, font->stream );
2332
2333    cff_subfont_done( memory, &font->top_font );
2334
2335    CFF_Done_FD_Select( &font->fd_select, font->stream );
2336
2337    FT_FREE( font->global_subrs );
2338    FT_FREE( font->font_name );
2339  }
2340
2341
2342/* END */
Note: See TracBrowser for help on using the repository browser.