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