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