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