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