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