added checking for freetype.
[swftools.git] / pdf2swf / ttf2pt1 / ft.c
1 /*
2  * The font parser using the FreeType library version 2.
3  *
4  * see COPYRIGHT
5  *
6  */
7
8 #ifdef USE_FREETYPE
9
10 #include <stdio.h>
11 #include <string.h>
12 #include <stdlib.h>
13 #include <ctype.h>
14 #include <sys/types.h>
15 #include <freetype/freetype.h>
16 #include <freetype/ftglyph.h>
17 #include <freetype/ftsnames.h>
18 #include <freetype/ttnameid.h>
19 #include <freetype/ftoutln.h>
20 #include "pt1.h"
21 #include "global.h"
22
23 /* prototypes of call entries */
24 static void openfont(char *fname, char *arg);
25 static void closefont( void);
26 static int getnglyphs ( void);
27 static int glnames( GLYPH *glyph_list);
28 static void glmetrics( GLYPH *glyph_list);
29 static int glenc( GLYPH *glyph_list, int *encoding, int *unimap);
30 static void fnmetrics( struct font_metrics *fm);
31 static void glpath( int glyphno, GLYPH *glyph_list);
32 static void kerning( GLYPH *glyph_list);
33
34 /* globals */
35
36 /* front-end descriptor */
37 struct frontsw freetype_sw = {
38         /*name*/       "ft",
39         /*descr*/      "based on the FreeType library",
40         /*suffix*/     { "ttf", "otf", "pfa", "pfb" },
41         /*open*/       openfont,
42         /*close*/      closefont,
43         /*nglyphs*/    getnglyphs,
44         /*glnames*/    glnames,
45         /*glmetrics*/  glmetrics,
46         /*glenc*/      glenc,
47         /*fnmetrics*/  fnmetrics,
48         /*glpath*/     glpath,
49         /*kerning*/    kerning,
50 };
51
52 /* statics */
53
54 static char * dupcnstring( unsigned char *s, int len);
55
56 static FT_Library library;
57 static FT_Face face;
58
59 static int enc_type, enc_found;
60
61 /* SFNT functions do not seem to be included by default in FT2beta8 */
62 #define ENABLE_SFNT
63
64 /*
65  * Open font and prepare to return information to the main driver.
66  * May print error and warning messages.
67  * Exit on error.
68  */
69
70 static void
71 openfont(
72         char *fname,
73         char *arg /* unused now */
74 )
75 {
76         FT_Error error;
77
78         if( FT_Init_FreeType( &library ) ) {
79                 fprintf(stderr, "** FreeType initialization failed\n");
80                 exit(1);
81         }
82
83         if( error = FT_New_Face( library, fname, 0, &face ) ) {
84                 if ( error == FT_Err_Unknown_File_Format )
85                         fprintf(stderr, "**** %s has format unknown to FreeType\n", fname);
86                 else
87                         fprintf(stderr, "**** Cannot access %s ****\n", fname);
88                 exit(1);
89         }
90
91         if(FT_HAS_FIXED_SIZES(face)) {
92                 WARNING_1 fprintf(stderr, "Font contains bitmaps\n");
93         }
94         if(FT_HAS_MULTIPLE_MASTERS(face)) {
95                 WARNING_1 fprintf(stderr, "Font contains multiple masters, using default\n");
96         }
97
98         if(ISDBG(FT)) fprintf(stderr," %d units per EM\n", face->units_per_EM);
99
100         enc_found = 0;
101 }
102
103 /*
104  * Close font.
105  * Exit on error.
106  */
107
108 static void
109 closefont(
110         void
111 )
112 {
113         if( FT_Done_Face(face) ) {
114                 WARNING_1 fprintf(stderr, "Errors when closing the font file, ignored\n");
115         }
116         if( FT_Done_FreeType(library) ) {
117                 WARNING_1 fprintf(stderr, "Errors when stopping FreeType, ignored\n");
118         }
119 }
120
121 /*
122  * Get the number of glyphs in font.
123  */
124
125 static int
126 getnglyphs (
127         void
128 )
129 {
130         if(ISDBG(FT)) fprintf(stderr, "%d glyphs in font\n", face->num_glyphs);
131         return (int)face->num_glyphs;
132 }
133
134 /*
135  * Get the names of the glyphs.
136  * Returns 0 if the names were assigned, non-zero if the font
137  * provides no glyph names.
138  */
139
140 static int
141 glnames(
142         GLYPH *glyph_list
143 )
144 {
145 #define MAX_NAMELEN     1024
146         unsigned char bf[1024];
147         int i;
148
149         if( ! FT_HAS_GLYPH_NAMES(face) ) {
150                 WARNING_1 fprintf(stderr, "Font has no glyph names\n");
151                 return 1;
152         }
153
154         for(i=0; i < face->num_glyphs; i++) {
155                 if( FT_Get_Glyph_Name(face, i, bf, MAX_NAMELEN) || bf[0]==0 ) {
156                         sprintf(bf, "_g_%d", i);
157                         WARNING_2 fprintf(stderr,
158                                 "Glyph No. %d has no postscript name, becomes %s\n", i, bf);
159                 }
160                 glyph_list[i].name = strdup(bf);
161                 if(ISDBG(FT)) fprintf(stderr, "%d has name %s\n", i, bf);
162                 if (glyph_list[i].name == NULL) {
163                         fprintf (stderr, "****malloc failed %s line %d\n", __FILE__, __LINE__);
164                         exit(255);
165                 }
166         }
167         return 0;
168 }
169
170 /*
171  * Get the metrics of the glyphs.
172  */
173
174 static void
175 glmetrics(
176         GLYPH *glyph_list
177 )
178 {
179         GLYPH          *g;
180         int i;
181         FT_Glyph_Metrics *met;
182         FT_BBox bbox;
183         FT_Glyph gly;
184
185         for(i=0; i < face->num_glyphs; i++) {
186                 g = &(glyph_list[i]);
187
188                 if( FT_Load_Glyph(face, i, FT_LOAD_NO_BITMAP|FT_LOAD_NO_SCALE) ) {
189                         fprintf(stderr, "Can't load glyph %s, skipped\n", g->name);
190                         continue;
191                 }
192
193                 met = &face->glyph->metrics;
194
195                 if(FT_HAS_HORIZONTAL(face)) {
196                         g->width = met->horiAdvance;
197                         g->lsb = met->horiBearingX;
198                 } else {
199                         WARNING_2 fprintf(stderr, "Glyph %s has no horizontal metrics, guessed them\n", g->name);
200                         g->width = met->width;
201                         g->lsb = 0;
202                 }
203
204                 if( FT_Get_Glyph(face->glyph, &gly) ) {
205                         fprintf(stderr, "Can't access glyph %s bbox, skipped\n", g->name);
206                         continue;
207                 }
208
209                 FT_Glyph_Get_CBox(gly, ft_glyph_bbox_unscaled, &bbox);
210                 g->xMin = bbox.xMin;
211                 g->yMin = bbox.yMin;
212                 g->xMax = bbox.xMax;
213                 g->yMax = bbox.yMax;
214
215                 g->ttf_pathlen = face->glyph->outline.n_points;
216         }
217 }
218
219 /*
220  * Get the original encoding of the font. 
221  * Returns 1 for if the original encoding is Unicode, 2 if the
222  * original encoding is other 16-bit, 0 if 8-bit.
223  */
224
225 static int
226 glenc(
227         GLYPH *glyph_list,
228         int *encoding,
229         int *unimap
230 )
231 {
232         int i, e;
233         unsigned code;
234
235         if(ISDBG(FT)) 
236                 for(e=0; e < face->num_charmaps; e++) {
237                         fprintf(stderr, "found encoding pid=%d eid=%d\n", 
238                                 face->charmaps[e]->platform_id,
239                                 face->charmaps[e]->encoding_id);
240                 }
241
242         if(enc_found)
243                 goto populate_map;
244
245         enc_type = 0;
246
247         /* first check for an explicit PID/EID */
248
249         if(force_pid != -1) {
250                 for(e=0; e < face->num_charmaps; e++) {
251                         if(face->charmaps[e]->platform_id == force_pid
252                         && face->charmaps[e]->encoding_id == force_eid) {
253                                 WARNING_1 fprintf(stderr, "Found Encoding PID=%d/EID=%d\n", 
254                                         force_pid, force_eid);
255                                 if( FT_Set_Charmap(face, face->charmaps[e]) ) {
256                                         fprintf(stderr, "**** Cannot set charmap in FreeType ****\n");
257                                         exit(1);
258                                 }
259                                 enc_type = 1;
260                                 goto populate_map;
261                         }
262                 }
263                 fprintf(stderr, "*** TTF encoding table PID=%d/EID=%d not found\n", 
264                         force_pid, force_eid);
265                 exit(1);
266         }
267
268         /* next check for a direct Adobe mapping */
269
270         if(!forcemap) {
271                 for(e=0; e < face->num_charmaps; e++) {
272                         if(face->charmaps[e]->encoding == ft_encoding_adobe_custom) {
273                                 WARNING_1 fputs("Found Adobe Custom Encoding\n", stderr);
274                                 if( FT_Set_Charmap(face, face->charmaps[e]) ) {
275                                         fprintf(stderr, "**** Cannot set charmap in FreeType ****\n");
276                                         exit(1);
277                                 }
278                                 goto populate_map;
279                         }
280                 }
281         }
282
283         for(e=0; e < face->num_charmaps; e++) {
284                 if(face->charmaps[e]->platform_id == 3) {
285                         switch(face->charmaps[e]->encoding_id) {
286                         case 0:
287                                 WARNING_1 fputs("Found Symbol Encoding\n", stderr);
288                                 break;
289                         case 1:
290                                 WARNING_1 fputs("Found Unicode Encoding\n", stderr);
291                                 enc_type = 1;
292                                 break;
293                         default:
294                                 WARNING_1 {
295                                         fprintf(stderr,
296                                         "****MS Encoding ID %d not supported****\n",
297                                                 face->charmaps[e]->encoding_id);
298                                         fputs("Treating it like Symbol encoding\n", stderr);
299                                 }
300                                 break;
301                         }
302                         break;
303                 }
304         }
305         if(e >= face->num_charmaps) {
306                 WARNING_1 fputs("No Microsoft encoding, using first encoding available\n", stderr);
307                 e = 0;
308         }
309         
310         if( FT_Set_Charmap(face, face->charmaps[e]) ) {
311                 fprintf(stderr, "**** Cannot set charmap in FreeType ****\n");
312                 exit(1);
313         }
314
315 populate_map:
316         enc_found = 1;
317         for(i=0; i<ENCTABSZ; i++) {
318                 if(encoding[i] != -1)
319                         continue;
320                 if(enc_type == 1 || forcemap) {
321                         code = unimap[i];
322                         if(code == (unsigned) -1)
323                                 continue;
324                 } else
325                         code = i;
326
327                 code = FT_Get_Char_Index(face, code);
328                 if(0 && ISDBG(FT)) fprintf(stderr, "code of %3d is %3d\n", i, code);
329                 if(code == 0)
330                         continue; /* .notdef */
331                 encoding[i] = code;
332         }
333
334         return enc_type;
335 }
336
337 /* duplicate a string with counter to a 0-terminated string */
338 static char *
339 dupcnstring(
340         unsigned char *s,
341         int len
342 )
343 {
344         char *res, *out;
345         int i, c;
346         static int warned=0;
347
348         if(( res = malloc(len+1) )==NULL) {
349                 fprintf (stderr, "****malloc failed %s line %d\n", __FILE__, __LINE__);
350                 exit(255);
351         }
352
353         out = res;
354         for(i=0; i<len; i++) {
355                 if(( c=s[i] )>=' ' && c!=127)
356                         *out++ = c;
357                 else if(!warned) {
358                         warned=1;
359                         WARNING_1 fprintf(stderr, "Some font name strings are in Unicode, may not show properly\n");
360                 }
361         }
362         *out = 0;
363         return res;
364 }
365
366 /*
367  * Get the font metrics
368  */
369 static void 
370 fnmetrics(
371         struct font_metrics *fm
372 )
373 {
374         char *str;
375         static char *fieldstocheck[3];
376 #ifdef ENABLE_SFNT
377         FT_SfntName sn;
378 #endif /* ENABLE_SFNT */
379         int i;
380
381         fm->italic_angle = 0.0; /* FreeType hides the angle */
382         fm->underline_position = face->underline_position;
383         fm->underline_thickness = face->underline_thickness;
384         fm->is_fixed_pitch = FT_IS_FIXED_WIDTH(face);
385
386         fm->ascender = face->ascender;
387         fm->descender = face->descender;
388
389         fm->units_per_em =  face->units_per_EM;
390
391         fm->bbox[0] = face->bbox.xMin;
392         fm->bbox[1] = face->bbox.yMin;
393         fm->bbox[2] = face->bbox.xMax;
394         fm->bbox[3] = face->bbox.yMax;
395
396 #ifdef ENABLE_SFNT
397         if( FT_Get_Sfnt_Name(face, TT_NAME_ID_COPYRIGHT, &sn) )
398 #endif /* ENABLE_SFNT */
399                 fm->name_copyright = "";
400 #ifdef ENABLE_SFNT
401         else
402                 fm->name_copyright = dupcnstring(sn.string, sn.string_len);
403 #endif /* ENABLE_SFNT */
404
405         fm->name_family = face->family_name;
406
407         fm->name_style = face->style_name;
408         if(fm->name_style == NULL)
409                 fm->name_style = "";
410
411 #ifdef ENABLE_SFNT
412         if( FT_Get_Sfnt_Name(face, TT_NAME_ID_FULL_NAME, &sn) ) 
413 #endif /* ENABLE_SFNT */
414         {
415                 int len;
416
417                 len = strlen(fm->name_family) + strlen(fm->name_style) + 2;
418                 if(( fm->name_full = malloc(len) )==NULL) {
419                         fprintf (stderr, "****malloc failed %s line %d\n", __FILE__, __LINE__);
420                         exit(255);
421                 }
422                 strcpy(fm->name_full, fm->name_family);
423                 if(strlen(fm->name_style) != 0) {
424                         strcat(fm->name_full, " ");
425                         strcat(fm->name_full, fm->name_style);
426                 }
427         } 
428 #ifdef ENABLE_SFNT
429         else
430                 fm->name_full = dupcnstring(sn.string, sn.string_len);
431 #endif /* ENABLE_SFNT */
432
433 #ifdef ENABLE_SFNT
434         if( FT_Get_Sfnt_Name(face, TT_NAME_ID_VERSION_STRING, &sn) )
435 #endif /* ENABLE_SFNT */
436                 fm->name_version = "1.0";
437 #ifdef ENABLE_SFNT
438         else
439                 fm->name_version = dupcnstring(sn.string, sn.string_len);
440 #endif /* ENABLE_SFNT */
441
442 #ifdef ENABLE_SFNT
443         if( FT_Get_Sfnt_Name(face, TT_NAME_ID_PS_NAME , &sn) ) {
444 #endif /* ENABLE_SFNT */
445                 if(( fm->name_ps = strdup(fm->name_full) )==NULL) {
446                         fprintf (stderr, "****malloc failed %s line %d\n", __FILE__, __LINE__);
447                         exit(255);
448                 }
449 #ifdef ENABLE_SFNT
450         } else
451                 fm->name_ps = dupcnstring(sn.string, sn.string_len);
452 #endif /* ENABLE_SFNT */
453         for(i=0; fm->name_ps[i]!=0; i++)
454                 if(fm->name_ps[i] == ' ')
455                         fm->name_ps[i] = '_'; /* no spaces in the Postscript name *m
456
457         /* guess the boldness from the font names */
458         fm->force_bold=0;
459
460         fieldstocheck[0] = fm->name_style;
461         fieldstocheck[1] = fm->name_full;
462         fieldstocheck[2] = fm->name_ps;
463
464         for(i=0; !fm->force_bold && i<sizeof fieldstocheck /sizeof(fieldstocheck[0]); i++) {
465                 str=fieldstocheck[i];
466                 for(i=0; str[i]!=0; i++) {
467                         if( (str[i]=='B'
468                                 || str[i]=='b' 
469                                         && ( i==0 || !isalpha(str[i-1]) )
470                                 )
471                         && !strncmp("old",&str[i+1],3)
472                         && !islower(str[i+4])
473                         ) {
474                                 fm->force_bold=1;
475                                 break;
476                         }
477                 }
478         }
479 }
480
481 /*
482  * Functions to decompose the outlines
483  */
484
485 static GLYPH *curg;
486 static double lastx, lasty;
487
488 static int
489 outl_moveto(
490         FT_Vector *to,
491         void *unused
492 )
493 {
494         double tox, toy;
495
496         tox = fscale((double)to->x); toy = fscale((double)to->y);
497
498         /* FreeType does not do explicit closepath() */
499         if(curg->lastentry) {
500                 g_closepath(curg);
501         }
502         fg_rmoveto(curg, tox, toy);
503         lastx = tox; lasty = toy;
504
505         return 0;
506 }
507
508 static int
509 outl_lineto(
510         FT_Vector *to,
511         void *unused
512 )
513 {
514         double tox, toy;
515
516         tox = fscale((double)to->x); toy = fscale((double)to->y);
517
518         fg_rlineto(curg, tox, toy);
519         lastx = tox; lasty = toy;
520
521         return 0;
522 }
523
524 static int
525 outl_conicto(
526         FT_Vector *control1,
527         FT_Vector *to,
528         void *unused
529 )
530 {
531         double c1x, c1y, tox, toy;
532
533         c1x = fscale((double)control1->x); c1y = fscale((double)control1->y);
534         tox = fscale((double)to->x); toy = fscale((double)to->y);
535
536         fg_rrcurveto(curg,
537                 (lastx + 2.0 * c1x) / 3.0, (lasty + 2.0 * c1y) / 3.0,
538                 (2.0 * c1x + tox) / 3.0, (2.0 * c1y + toy) / 3.0,
539                 tox, toy );
540         lastx = tox; lasty = toy;
541
542         return 0;
543 }
544
545 static int
546 outl_cubicto(
547         FT_Vector *control1,
548         FT_Vector *control2,
549         FT_Vector *to,
550         void *unused
551 )
552 {
553         double c1x, c1y, c2x, c2y, tox, toy;
554
555         c1x = fscale((double)control1->x); c1y = fscale((double)control1->y);
556         c2x = fscale((double)control2->x); c2y = fscale((double)control2->y);
557         tox = fscale((double)to->x); toy = fscale((double)to->y);
558
559         fg_rrcurveto(curg, c1x, c1y, c2x, c2y, tox, toy);
560         lastx = tox; lasty = toy;
561
562         return 0;
563 }
564
565 static FT_Outline_Funcs ft_outl_funcs = {
566         outl_moveto,
567         outl_lineto,
568         outl_conicto,
569         outl_cubicto,
570         0,
571         0
572 };
573
574 /*
575  * Get the path of contrours for a glyph.
576  */
577
578 static void
579 glpath(
580         int glyphno,
581         GLYPH *glyf_list
582 )
583 {
584         FT_Outline *ol;
585
586         curg = &glyf_list[glyphno];
587
588         if( FT_Load_Glyph(face, glyphno, FT_LOAD_NO_BITMAP|FT_LOAD_NO_SCALE|FT_LOAD_NO_HINTING) 
589         || face->glyph->format != ft_glyph_format_outline ) {
590                 fprintf(stderr, "Can't load glyph %s, skipped\n", curg->name);
591                 return;
592         }
593
594         ol = &face->glyph->outline;
595         lastx = 0.0; lasty = 0.0;
596
597         if( FT_Outline_Decompose(ol, &ft_outl_funcs, NULL) ) {
598                 fprintf(stderr, "Can't decompose outline of glyph %s, skipped\n", curg->name);
599                 return;
600         }
601
602         /* FreeType does not do explicit closepath() */
603         if(curg->lastentry) {
604                 g_closepath(curg);
605         }
606
607         if(ol->flags & ft_outline_reverse_fill) {
608                 assertpath(curg->entries, __FILE__, __LINE__, curg->name);
609                 reversepaths(curg);
610         }
611 }
612
613 /*
614  * Get the kerning data.
615  */
616
617 static void
618 kerning(
619         GLYPH *glyph_list
620 )
621 {
622         int     i, j, n;
623         int     nglyphs = face->num_glyphs;
624         FT_Vector k;
625         GLYPH *gl;
626
627         if( nglyphs == 0 || !FT_HAS_KERNING(face) ) {
628         WARNING_1 fputs("No Kerning data\n", stderr);
629                 return;
630         }
631
632         for(i=0; i<nglyphs; i++)  {
633                 if( (glyph_list[i].flags & GF_USED) ==0)
634                         continue;
635                 for(j=0; j<nglyphs; j++) {
636                         if( (glyph_list[j].flags & GF_USED) ==0)
637                                 continue;
638                         if( FT_Get_Kerning(face, i, j, ft_kerning_unscaled, &k) )
639                                 continue;
640                         if( k.x == 0 )
641                                 continue;
642
643                         addkernpair(i, j, k.x);
644                 }
645         }
646 }
647
648 #endif