abfc0c1a7706953aa44c9d6d9d26f6f78fbec158
[swftools.git] / lib / modules / swffont.c
1 /* swffont.c
2
3    Functions for loading external fonts.
4
5    Extension module for the rfxswf library.
6    Part of the swftools package.
7
8    Copyright (c) 2003, 2004 Matthias Kramm
9  
10    This program is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 2 of the License, or
13    (at your option) any later version.
14
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License for more details.
19
20    You should have received a copy of the GNU General Public License
21    along with this program; if not, write to the Free Software
22    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
23
24 static int loadfont_scale = 1;
25 static int skip_unused = 1;
26
27 // TODO: should be named "setLoadFontParameters"
28 void swf_SetLoadFontParameters(int _scale, int _skip_unused)
29 {
30     loadfont_scale = _scale;
31     skip_unused = _skip_unused;
32 }
33
34 #ifdef HAVE_FREETYPE
35
36 #include <freetype/freetype.h>
37 #include <freetype/ftglyph.h>
38 #include <freetype/ftsnames.h>
39 #include <freetype/ttnameid.h>
40 #include <freetype/ftoutln.h>
41
42 #define FT_SCALE loadfont_scale
43 #define FT_SUBPIXELS 64
44
45 static int ft_move_to(FT_Vector* _to, void* user) 
46 {
47     drawer_t* draw = (drawer_t*)user;
48     FPOINT to;
49     to.x = _to->x*FT_SCALE/(float)FT_SUBPIXELS;
50     to.y = -_to->y*FT_SCALE/(float)FT_SUBPIXELS;
51     draw->moveTo(draw, &to);
52     return 0;
53 }
54 static int ft_line_to(FT_Vector* _to, void* user) 
55 {
56     drawer_t* draw = (drawer_t*)user;
57     FPOINT to;
58     to.x = _to->x*FT_SCALE/(float)FT_SUBPIXELS;
59     to.y = -_to->y*FT_SCALE/(float)FT_SUBPIXELS;
60     draw->lineTo(draw, &to);
61     return 0;
62 }
63 static int ft_cubic_to(FT_Vector* _c1, FT_Vector* _c2, FT_Vector* _to, void* user)
64 {
65     drawer_t* draw = (drawer_t*)user;
66     FPOINT c1,c2,to;
67     to.x = _to->x*FT_SCALE/(float)FT_SUBPIXELS;
68     to.y = -_to->y*FT_SCALE/(float)FT_SUBPIXELS;
69     c1.x = _c1->x*FT_SCALE/(float)FT_SUBPIXELS;
70     c1.y = -_c1->y*FT_SCALE/(float)FT_SUBPIXELS;
71     c2.x = _c2->x*FT_SCALE/(float)FT_SUBPIXELS;
72     c2.y = -_c2->y*FT_SCALE/(float)FT_SUBPIXELS;
73     draw_cubicTo(draw, &c1, &c2, &to);
74     return 0;
75 }
76 static int ft_conic_to(FT_Vector* _c, FT_Vector* _to, void* user) 
77 {
78     drawer_t* draw = (drawer_t*)user;
79     FPOINT c,to;
80     to.x = _to->x*FT_SCALE/(float)FT_SUBPIXELS;
81     to.y = -_to->y*FT_SCALE/(float)FT_SUBPIXELS;
82     c.x = _c->x*FT_SCALE/(float)FT_SUBPIXELS;
83     c.y = -_c->y*FT_SCALE/(float)FT_SUBPIXELS;
84     draw_conicTo(draw, &c, &to);
85     return 0;
86 }
87 static FT_Outline_Funcs outline_functions =
88 {
89   ft_move_to,
90   ft_line_to,
91   ft_conic_to,
92   ft_cubic_to,
93   0,0
94 };
95
96 static FT_Library ftlibrary = 0;
97
98 SWFFONT* swf_LoadTrueTypeFont(char*filename)
99 {
100     FT_Face face;
101     FT_Error error;
102     const char* name = 0;
103     FT_ULong charcode;
104     FT_UInt gindex;
105     SWFFONT* font;
106     int t;
107     int*glyph2glyph;
108    
109     if(ftlibrary == 0) {
110         if(FT_Init_FreeType(&ftlibrary)) {
111             fprintf(stderr, "Couldn't init freetype library!\n");
112             exit(1);
113         }
114     }
115     error = FT_New_Face(ftlibrary, filename, 0, &face);
116     if(error) {
117         fprintf(stderr, "Couldn't load file %s- not a TTF file?\n", filename);
118         return 0;
119     }
120     if(face->num_glyphs <= 0) {
121         fprintf(stderr, "File %s contains %d glyphs\n", face->num_glyphs);
122         return 0;
123     }
124
125     font = malloc(sizeof(SWFFONT));
126     memset(font, 0, sizeof(SWFFONT));
127     font->id = -1;
128     font->version = 2;
129     font->layout = malloc(sizeof(SWFLAYOUT));
130     memset(font->layout, 0, sizeof(SWFLAYOUT));
131     font->layout->bounds = malloc(face->num_glyphs*sizeof(SRECT));
132     font->style =  ((face->style_flags&FT_STYLE_FLAG_ITALIC)?FONT_STYLE_ITALIC:0)
133                   |((face->style_flags&FT_STYLE_FLAG_BOLD)?FONT_STYLE_BOLD:0);
134     font->encoding = FONT_ENCODING_UNICODE;
135     font->glyph2ascii = malloc(face->num_glyphs*sizeof(U16));
136     memset(font->glyph2ascii, 0, face->num_glyphs*sizeof(U16));
137     font->maxascii = 0;
138     font->glyph = malloc(face->num_glyphs*sizeof(SWFGLYPH));
139     memset(font->glyph, 0, face->num_glyphs*sizeof(SWFGLYPH));
140     if(FT_HAS_GLYPH_NAMES(face)) {
141         font->glyphnames = malloc(face->num_glyphs*sizeof(char*));
142         memset(font->glyphnames,0,face->num_glyphs*sizeof(char*));
143     }
144
145     font->layout->ascent = face->ascender*20/FT_SUBPIXELS; //face->bbox.xMin;
146     font->layout->descent = abs(face->descender)*20/FT_SUBPIXELS; //face->bbox.xMax;
147     font->layout->leading = abs(face->bbox.yMin - face->bbox.yMax); //-face->bbox.xMin*20/FT_SUBPIXELS;
148     font->layout->kerningcount = 0;
149     
150     name = FT_Get_Postscript_Name(face);
151     if(name && *name)
152         font->name = (U8*)strdup(name);
153
154 /*    // Map Glyphs to Unicode, version 1 (quick and dirty):
155     int t;
156     for(t=0;t<65536;t++) {
157         int index = FT_Get_Char_Index(face, t);
158         if(index>=0 && index<face->num_glyphs) {
159             if(font->glyph2ascii[index]<0)
160                 font->glyph2ascii[index] = t;
161         }
162     }*/
163     
164     // Map Glyphs to Unicode, version 2 (much nicer):
165     // (The third way would be the AGL algorithm, as proposed
166     //  by Werner Lemberg on freetype@freetype.org)
167
168     charcode = FT_Get_First_Char(face, &gindex);
169     while(gindex != 0)
170     {
171         if(gindex >= 0 && gindex<face->num_glyphs) {
172             if(!font->glyph2ascii[gindex]) {
173                 font->glyph2ascii[gindex] = charcode;
174                 if(charcode + 1 > font->maxascii) {
175                     font->maxascii = charcode + 1;
176                 }
177             }
178         }
179         charcode = FT_Get_Next_Char(face, charcode, &gindex);
180     }
181     
182     font->ascii2glyph = malloc(font->maxascii*sizeof(int));
183     
184     for(t=0;t<font->maxascii;t++) {
185         int g = FT_Get_Char_Index(face, t);
186         if(!g || g>=face->num_glyphs)
187             g = -1;
188         font->ascii2glyph[t] = g;
189         if(g>=0) {
190             if(!font->glyph2ascii[g]) {
191                 font->glyph2ascii[g] = t;
192             }
193         }
194     }
195
196     font->numchars = 0;
197
198     glyph2glyph = (int*)malloc(face->num_glyphs*sizeof(int));
199
200     for(t=0; t < face->num_glyphs; t++) {
201         FT_Glyph glyph;
202         FT_BBox bbox;
203         FT_Matrix matrix;
204         char name[128];
205         drawer_t draw;
206         int ret;
207         char hasname = 0;
208         name[0]=0;
209         if(FT_HAS_GLYPH_NAMES(face)) {
210             error = FT_Get_Glyph_Name(face, t, name, 127);
211             if(!error && name[0] && !strstr(name, "notdef")) {
212                 font->glyphnames[font->numchars] = strdup(name);
213                 hasname = 1;
214             }
215         }
216         if(!font->glyph2ascii[t] && !hasname && skip_unused) {
217             continue;
218         }
219         error = FT_Load_Glyph(face, t, FT_LOAD_NO_BITMAP|FT_LOAD_NO_SCALE);
220         if(error) {
221             fprintf(stderr, "Couldn't load glyph %d\n", t);
222             continue;
223         }
224         error = FT_Get_Glyph(face->glyph, &glyph);
225         if(error) {
226             fprintf(stderr, "Couldn't get glyph %d\n", t);
227             continue;
228         }
229
230         FT_Glyph_Get_CBox(glyph, ft_glyph_bbox_unscaled, &bbox);
231         bbox.yMin = -bbox.yMin;
232         bbox.yMax = -bbox.yMax;
233         if(bbox.xMax < bbox.xMin) {
234             // swap
235             bbox.xMax ^= bbox.xMin;
236             bbox.xMin ^= bbox.xMax;
237             bbox.xMax ^= bbox.xMin;
238         }
239         if(bbox.yMax < bbox.yMin) {
240             // swap
241             bbox.yMax ^= bbox.yMin;
242             bbox.yMin ^= bbox.yMax;
243             bbox.yMax ^= bbox.yMin;
244         }
245
246         swf_Shape01DrawerInit(&draw, 0);
247
248         //error = FT_Outline_Decompose(&face->glyph->outline, &outline_functions, &draw);
249         error = FT_Outline_Decompose(&face->glyph->outline, &outline_functions, &draw);
250         draw.finish(&draw);
251         
252         if(error) {
253             fprintf(stderr, "Couldn't decompose glyph %d\n", t);
254             draw.dealloc(&draw);
255             continue;
256         }
257
258         draw.finish(&draw);
259
260 #if 0
261         if(bbox.xMin > 0) {
262             font->glyph[font->numchars].advance = (bbox.xMax*FT_SCALE)/FT_SUBPIXELS;
263         } else {
264             font->glyph[font->numchars].advance = ((bbox.xMax - bbox.xMin)*FT_SCALE)/FT_SUBPIXELS;
265         }
266 #else
267         font->glyph[font->numchars].advance = glyph->advance.x*20/65536;
268 #endif
269         
270         font->glyph[font->numchars].shape = swf_ShapeDrawerToShape(&draw);
271         
272         font->layout->bounds[font->numchars].xmin = (bbox.xMin*FT_SCALE*20)/FT_SUBPIXELS;
273         font->layout->bounds[font->numchars].ymin = (bbox.yMin*FT_SCALE*20)/FT_SUBPIXELS;
274         font->layout->bounds[font->numchars].xmax = (bbox.xMax*FT_SCALE*20)/FT_SUBPIXELS;
275         font->layout->bounds[font->numchars].ymax = (bbox.yMax*FT_SCALE*20)/FT_SUBPIXELS;
276
277         draw.dealloc(&draw);
278
279         FT_Done_Glyph(glyph);
280         font->glyph2ascii[font->numchars] = font->glyph2ascii[t];
281         glyph2glyph[t] = font->numchars;
282         font->numchars++;
283     }
284     /* notice: if skip_unused is true, font->glyph2ascii, font->glyphnames and font->layout->bounds will 
285                have more memory allocated than just font->numchars, but only the first font->numchars 
286                are used/valid */
287
288     for(t=0;t<font->maxascii;t++) {
289         if(font->ascii2glyph[t]>=0) {
290             font->ascii2glyph[t] = glyph2glyph[font->ascii2glyph[t]];
291         }
292     }
293     free(glyph2glyph);
294
295     FT_Done_Face(face);
296     FT_Done_FreeType(ftlibrary);ftlibrary=0;
297
298     return font;
299 }
300 #else  //HAVE_FREETYPE
301
302 SWFFONT* swf_LoadTrueTypeFont(char*filename)
303 {
304     fprintf(stderr, "Warning: no freetype library- not able to load %s\n", filename);
305     return 0;
306 }
307
308 #endif
309
310 #ifdef HAVE_T1LIB
311
312 #include <t1lib.h>
313
314 static int t1lib_initialized = 0;
315
316 static int counter = 0;
317
318 SWFFONT* swf_LoadT1Font(char*filename)
319 {
320     SWFFONT * font;
321     int nr;
322     float angle,underline;
323     char*fontname,*fullname,*familyname;
324     BBox bbox;
325     int s,num;
326     char**charnames;
327     char**charname;
328     int c;
329
330     if(!t1lib_initialized) {
331         T1_SetBitmapPad(16);
332         if ((T1_InitLib(NO_LOGFILE)==NULL)){
333             fprintf(stderr, "Initialization of t1lib failed\n");
334             return 0;
335         }
336         t1lib_initialized = 1;
337     }
338     nr = T1_AddFont(filename);
339     T1_LoadFont(nr);
340
341     charnames = T1_GetAllCharNames(nr);
342
343     angle = T1_GetItalicAngle(nr);
344     fontname = T1_GetFontName(nr);
345     fullname = T1_GetFullName(nr);
346     familyname = T1_GetFamilyName(nr);
347     underline = T1_GetUnderlinePosition(nr);
348     bbox = T1_GetFontBBox(nr);
349
350     font = (SWFFONT*)malloc(sizeof(SWFFONT));
351     memset(font, 0, sizeof(SWFFONT));
352
353     font->version = 2;
354     if(fontname) 
355         font->name = (U8*)strdup(fontname);
356     else 
357         font->name = 0;
358     font->layout = (SWFLAYOUT*)malloc(sizeof(SWFLAYOUT));
359     memset(font->layout, 0, sizeof(SWFLAYOUT));
360
361     num = 0;
362     charname = charnames;
363     while(*charname) {
364         charname++;
365         num++;
366     }
367
368     font->maxascii = num;
369     font->numchars = num;
370     
371     font->style = (/*bold*/0?FONT_STYLE_BOLD:0) + (angle>0.05?FONT_STYLE_ITALIC:0);
372
373     font->glyph = (SWFGLYPH*)malloc(num*sizeof(SWFGLYPH));
374     memset(font->glyph, 0, num*sizeof(SWFGLYPH));
375     font->glyph2ascii = (U16*)malloc(num*sizeof(U16));
376     memset(font->glyph2ascii, 0, num*sizeof(U16));
377     font->ascii2glyph = (int*)malloc(font->maxascii*sizeof(int));
378     memset(font->ascii2glyph, -1, font->maxascii*sizeof(int));
379     font->layout->ascent = (U16)(underline - bbox.lly);
380     font->layout->descent = (U16)(bbox.ury - underline);
381     font->layout->leading = (U16)(font->layout->ascent - 
382                              font->layout->descent -
383                              (bbox.lly - bbox.ury));
384     font->layout->bounds = (SRECT*)malloc(sizeof(SRECT)*num);
385     memset(font->layout->bounds, 0, sizeof(SRECT)*num);
386     font->layout->kerningcount = 0;
387     font->layout->kerning = 0;
388     font->glyphnames = malloc(num*sizeof(char*));
389     memset(font->glyphnames, 0, num*sizeof(char*));
390   
391     num = 0;
392
393     charname = charnames;
394     for(c=0;c<font->numchars;c++) {
395         drawer_t draw;
396         SRECT bbox;
397         T1_OUTLINE * outline;
398         FPOINT pos,last;
399         int firstx;
400         
401         outline = T1_GetCharOutline(nr, c, 100.0, 0);
402         firstx = outline->dest.x/0xffff;
403
404         pos.x = 0;
405         pos.y = 0;
406         last = pos;
407         
408         font->glyphnames[c] = strdup(*charname);
409
410         if(c<font->maxascii)
411             font->ascii2glyph[c] = c;
412         font->glyph2ascii[c] = c;
413         
414         swf_Shape01DrawerInit(&draw, 0);
415
416         while(outline) {
417             pos.x += (outline->dest.x/(float)0xffff);
418             pos.y += (outline->dest.y/(float)0xffff);
419
420             if(outline->type == T1_PATHTYPE_MOVE) {
421                 draw.moveTo(&draw,&pos);
422             } else if(outline->type == T1_PATHTYPE_LINE) {
423                 draw.lineTo(&draw,&pos);
424             } else if(outline->type == T1_PATHTYPE_BEZIER) {
425                 T1_BEZIERSEGMENT*o2 = (T1_BEZIERSEGMENT*)outline;
426                 FPOINT b,c;
427                 b.x = o2->B.x/(float)0xffff+last.x;
428                 b.y = o2->B.y/(float)0xffff+last.y;
429                 c.x = o2->C.x/(float)0xffff+last.x;
430                 c.y = o2->C.y/(float)0xffff+last.y;
431                 draw_cubicTo(&draw,&b,&c,&pos);
432             } else {
433                 fprintf(stderr, "loadT1Font: unknown outline type:%d\n", outline->type);
434             }
435             last = pos;
436             outline = outline->link;
437         }
438         
439         draw.finish(&draw);
440
441         font->glyph[c].shape = swf_ShapeDrawerToShape(&draw);
442         bbox = swf_ShapeDrawerGetBBox(&draw);
443         draw.dealloc(&draw);
444             
445         font->layout->bounds[c] = bbox;
446         font->glyph[c].advance = bbox.xmax;
447         if(!font->glyph[c].advance) {
448             font->glyph[c].advance = firstx;
449         }
450         charname++;
451     }
452     return font;
453 }
454
455 #else
456
457 SWFFONT* swf_LoadT1Font(char*filename)
458 {
459     fprintf(stderr, "Warning: no t1lib- not able to load %s\n", filename);
460     return 0;
461 }
462
463 #endif
464
465 SWFFONT* swf_DummyFont()
466 {
467     SWFFONT*font = (SWFFONT*)malloc(sizeof(SWFFONT));
468     memset(font, 0, sizeof(SWFFONT));
469     return font;
470 }
471
472 static int isSWF(const char*filename)
473 {
474     FILE*fi = fopen(filename, "rb");
475     char a[8];
476     if(!fi) {
477         perror(filename);
478         return -1;
479     }
480     memset(a, 0, sizeof(a));
481     fread(a, 4, 1, fi);
482     fclose(fi);
483
484     if(!strncmp(a, "FWS", 3) || !strncmp(a, "CWS", 3)) {
485         return 1;
486     }
487     return 0;
488 }
489
490 SWFFONT* swf_LoadFont(char*filename)
491 {
492     int is_swf;
493     if(filename == 0)
494         return swf_DummyFont();
495     is_swf = isSWF(filename);
496     if(is_swf<0)
497         return 0;
498     if(is_swf) {
499         return swf_ReadFont(filename);
500     }
501 #if defined(HAVE_FREETYPE)
502     return swf_LoadTrueTypeFont(filename);
503 #elif defined(HAVE_T1LIB)
504     return swf_LoadT1Font(filename);
505 #else
506     fprintf(stderr, "Error: Neither T1lib nor FreeType support compiled in. Could not load %s\n", filename);
507     return 0;
508 #endif
509 }
510