lib/gfxfont.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, 2005 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 <assert.h>
  25 #include <stdio.h>
  26 #include <memory.h>
  27 #include "../config.h"
  28 #include "gfxdevice.h"
  29 #include "gfxtools.h"
  30 #include "gfxfont.h"
  31 #include "ttf.h"
  32 #include "mem.h"
  33 #include "log.h"
  34
  35 static int loadfont_scale = 64;
  36 static int full_unicode = 1;
  37
  38 #ifdef HAVE_FREETYPE
  39
  40 #ifdef HAVE_FT2BUILD_H
  41 #include <ft2build.h>
  42 #include FT_FREETYPE_H
  43 #include FT_GLYPH_H
  44 #include FT_SIZES_H
  45 #include FT_SFNT_NAMES_H
  46 #include FT_TRUETYPE_IDS_H
  47 #include FT_OUTLINE_H
  48 #else
  49 #include <freetype/freetype.h>
  50 #include <freetype/ftglyph.h>
  51 #include <freetype/ftsizes.h>
  52 #include <freetype/ftsnames.h>
  53 #include <freetype/ttnameid.h>
  54 #include <freetype/ftoutln.h>
  55 #endif
  56
  57 /* Setting subpixels to 64 also means that the "point size" of the
  58    font outlines will be 64. So the font, when rendered at original
  59    size (i.e., the swf fontsize is 1024) will have the same size as
  60    if it was rendered at 64pt */
  61
  62 #define FT_SCALE 1
  63 #define FT_SUBPIXELS 64
  64
  65 typedef struct _gfxdrawinfo_t {
  66     gfxdrawer_t* draw;
  67     double quality;
  68 } gfxdrawinfo_t;
  69
  70 static int ft_move_to(const FT_Vector* _to, void* user)
  71 {
  72     gfxdrawinfo_t* info = (gfxdrawinfo_t*)user;
  73     gfxdrawer_t* draw = info->draw;
  74     double x = _to->x*FT_SCALE/(float)FT_SUBPIXELS;
  75     double y = -_to->y*FT_SCALE/(float)FT_SUBPIXELS;
  76     draw->moveTo(draw, x,y);
  77     return 0;
  78 }
  79 static int ft_line_to(const FT_Vector* _to, void* user)
  80 {
  81     gfxdrawinfo_t* info = (gfxdrawinfo_t*)user;
  82     gfxdrawer_t* draw = info->draw;
  83     double x = _to->x*FT_SCALE/(float)FT_SUBPIXELS;
  84     double y = -_to->y*FT_SCALE/(float)FT_SUBPIXELS;
  85     draw->lineTo(draw, x,y);
  86     return 0;
  87 }
  88 static int ft_cubic_to(const FT_Vector* _c1, const FT_Vector* _c2, const FT_Vector* _to, void* user)
  89 {
  90     gfxdrawinfo_t* info = (gfxdrawinfo_t*)user;
  91     gfxdrawer_t* draw = info->draw;
  92     double tox = _to->x*FT_SCALE/(float)FT_SUBPIXELS;
  93     double toy = -_to->y*FT_SCALE/(float)FT_SUBPIXELS;
  94     double c1x = _c1->x*FT_SCALE/(float)FT_SUBPIXELS;
  95     double c1y = -_c1->y*FT_SCALE/(float)FT_SUBPIXELS;
  96     double c2x = _c2->x*FT_SCALE/(float)FT_SUBPIXELS;
  97     double c2y = -_c2->y*FT_SCALE/(float)FT_SUBPIXELS;
  98     gfxdraw_cubicTo(draw, c1x, c1y, c2x, c2y, tox, toy, info->quality);
  99     return 0;
 100 }
 101 static int ft_conic_to(const FT_Vector* _c, const FT_Vector* _to, void* user)
 102 {
 103     gfxdrawinfo_t* info = (gfxdrawinfo_t*)user;
 104     gfxdrawer_t* draw = info->draw;
 105     double tox = _to->x*FT_SCALE/(float)FT_SUBPIXELS;
 106     double toy = -_to->y*FT_SCALE/(float)FT_SUBPIXELS;
 107     double cx = _c->x*FT_SCALE/(float)FT_SUBPIXELS;
 108     double cy = -_c->y*FT_SCALE/(float)FT_SUBPIXELS;
 109     gfxdraw_conicTo(draw, cx,cy, tox,toy, info->quality);
 110     return 0;
 111 }
 112 static FT_Outline_Funcs outline_functions =
 113 {
 114   ft_move_to,
 115   ft_line_to,
 116   ft_conic_to,
 117   ft_cubic_to,
 118   0,0
 119 };
 120
 121 static FT_Library ftlibrary = 0;
 122
 123 static gfxglyph_t cloneGlyph(gfxglyph_t*src)
 124 {
 125     gfxglyph_t dest;
 126     memset(&dest, 0, sizeof(dest));
 127     if(src->name)
 128         dest.name = strdup(src->name);
 129     dest.advance = src->advance;
 130     dest.unicode = src->unicode;
 131     dest.line = gfxline_clone(src->line);
 132     return dest;
 133 }
 134
 135 static void glyph_clear(gfxglyph_t*g)
 136 {
 137     gfxline_t*line;
 138     if(g->name) {
 139         free((void*)g->name); g->name = 0;
 140     }
 141     gfxline_free(g->line);g->line = 0;
 142 }
 143
 144 static int errorno = 0;
 145
 146 //#define DEBUG 1
 147
 148 gfxfont_t* gfxfont_load(const char*id, const char*filename, unsigned int flags, double quality)
 149 {
 150     FT_Face face;
 151     FT_Error error;
 152     const char* fontname = 0;
 153     FT_ULong charcode;
 154     FT_UInt gindex;
 155     gfxfont_t* font;
 156     int t;
 157     int*glyph2glyph = 0;
 158     int*glyph2unicode = 0;
 159     int max_unicode = 0;
 160     int charmap = -1;
 161     int isunicode = 1;
 162     int has_had_errors = 0;
 163     int num_names = 0;
 164
 165     if(ftlibrary == 0) {
 166         if(FT_Init_FreeType(&ftlibrary)) {
 167             fprintf(stderr, "Couldn't init freetype library!\n");
 168             exit(1);
 169         }
 170     }
 171     error = FT_New_Face(ftlibrary, filename, 0, &face);
 172     FT_Set_Pixel_Sizes (face, 16*loadfont_scale, 16*loadfont_scale);
 173 #ifdef DEBUG
 174     printf("gfxfont_load(%s, %s, %f)\n", id, filename, quality);
 175 #endif
 176
 177     if(error) {
 178         fprintf(stderr, "Couldn't load file %s- not a TTF file? (error=%02x)\n", filename, error);
 179         return 0;
 180     }
 181     if(face->num_glyphs <= 0) {
 182         fprintf(stderr, "File %s contains %d glyphs\n", filename, (int)face->num_glyphs);
 183         return 0;
 184     }
 185
 186     font = (gfxfont_t*)rfx_calloc(sizeof(gfxfont_t));
 187     //font->style =  ((face->style_flags&FT_STYLE_FLAG_ITALIC)?FONT_STYLE_ITALIC:0) |((face->style_flags&FT_STYLE_FLAG_BOLD)?FONT_STYLE_BOLD:0);
 188     //font->ascent = abs(face->ascender)*FT_SCALE*loadfont_scale*20/FT_SUBPIXELS/2; //face->bbox.xMin;
 189     //font->descent = abs(face->descender)*FT_SCALE*loadfont_scale*20/FT_SUBPIXELS/2; //face->bbox.xMax;
 190     //font->leading = font->layout->ascent + font->layout->descent;
 191     //font->encoding = FONT_ENCODING_UNICODE;
 192     font->max_unicode = 0;
 193     font->id = strdup(id);
 194
 195     font->glyphs = (gfxglyph_t*)rfx_calloc(face->num_glyphs*sizeof(gfxglyph_t));
 196     glyph2unicode = (int*)rfx_calloc(face->num_glyphs*sizeof(int));
 197     glyph2glyph = (int*)rfx_calloc(face->num_glyphs*sizeof(int));
 198
 199     if(FT_HAS_GLYPH_NAMES(face)) {
 200         //font->glyphnames = rfx_calloc(face->num_glyphs*sizeof(char*));
 201     }
 202
 203     fontname = FT_Get_Postscript_Name(face);
 204
 205 #ifdef DEBUG
 206     for(t=0;t<face->num_charmaps;t++) {
 207         printf("possible encoding: %c%c%c%c (%d of %d)\n",
 208                 (face->charmaps[t]->encoding >> 24)&255,
 209                 (face->charmaps[t]->encoding >> 16)&255,
 210                 (face->charmaps[t]->encoding >> 8)&255,
 211                 (face->charmaps[t]->encoding >> 0)&255,
 212                 t+1, face->num_charmaps
 213                 );
 214     }
 215 #endif
 216
 217     while(1)
 218     {
 219         charcode = FT_Get_First_Char(face, &gindex);
 220
 221         while(gindex != 0)
 222         {
 223             if(gindex >= 0 && gindex<face->num_glyphs) {
 224                 if(!glyph2unicode[gindex]) {
 225                     glyph2unicode[gindex] = charcode;
 226                     if(charcode + 1 > font->max_unicode) {
 227                         font->max_unicode = charcode + 1;
 228                     }
 229                 }
 230             }
 231             charcode = FT_Get_Next_Char(face, charcode, &gindex);
 232         }
 233
 234 #ifdef DEBUG
 235         if(face->charmap) {
 236             printf("ENCODING: %c%c%c%c (%d of %d) max_unicode=%d\n",
 237                     (face->charmap->encoding >> 24)&255,
 238                     (face->charmap->encoding >> 16)&255,
 239                     (face->charmap->encoding >> 8)&255,
 240                     (face->charmap->encoding >> 0)&255,
 241                     charmap, face->num_charmaps, font->max_unicode
 242                     );
 243         } else {
 244             printf("ENCODING: NONE (%d of %d) max_unicode=%d\n",
 245                     charmap, face->num_charmaps, font->max_unicode
 246                     );
 247         }
 248 #endif
 249
 250         /* if we didn't find a single encoding character, try
 251            the font's charmaps instead. That usually means that
 252            the encoding is no longer unicode.
 253            TODO: find a way to convert the encoding to unicode
 254          */
 255         if(font->max_unicode == 0 && charmap < face->num_charmaps-1
 256                 && face->charmaps[charmap+1]->encoding != 0x41444243 /* adbc, custom */
 257                 && face->charmaps[charmap+1]->encoding != 0x61726d6e    /* armn */
 258                 )
 259                 {
 260             charmap++;
 261             FT_Set_Charmap(face, face->charmaps[charmap]);
 262             isunicode = 0;
 263         } else
 264             break;
 265     }
 266     /* TODO: if isunicode is 1, we now need to permutate the character
 267              order so that each character is at it's encoding position */
 268
 269     if(full_unicode)
 270         font->max_unicode = 65535;
 271
 272     font->unicode2glyph = (int*)rfx_calloc(font->max_unicode*sizeof(int));
 273
 274     for(t=0;t<font->max_unicode;t++) {
 275         int g = FT_Get_Char_Index(face, t);
 276         if(!g || g>=face->num_glyphs)
 277             g = -1;
 278         font->unicode2glyph[t] = g;
 279         if(g>=0) {
 280 #ifdef DEBUG
 281             printf("u%d ->%d\n", t, g);
 282 #endif
 283             max_unicode = t+1;
 284             if(!glyph2unicode[g]) {
 285                 glyph2unicode[g] = t;
 286             }
 287         }
 288     }
 289     font->max_unicode = max_unicode;
 290
 291     font->num_glyphs = 0;
 292
 293
 294     for(t=0; t < face->num_glyphs; t++) {
 295         if(FT_HAS_GLYPH_NAMES(face)) {
 296             char name[128];
 297             error = FT_Get_Glyph_Name(face, t, name, 127);
 298             if(!error && name[0] && !strstr(name, "notdef")) {
 299                 num_names++;
 300             }
 301         }
 302     }
 303
 304
 305     for(t=0; t < face->num_glyphs; t++) {
 306         FT_Glyph glyph;
 307         char name[128];
 308         gfxdrawer_t draw;
 309         gfxdrawinfo_t info;
 310         char hasname = 0;
 311         int omit = 0;
 312         name[0]=0;
 313
 314         font->glyphs[font->num_glyphs].advance = 0;
 315         font->glyphs[font->num_glyphs].line = 0;
 316         font->glyphs[font->num_glyphs].unicode = glyph2unicode[t];
 317         font->glyphs[font->num_glyphs].name = 0;
 318
 319         if(FT_HAS_GLYPH_NAMES(face) && (num_names >= face->num_glyphs/10 || num_names > 2)) {
 320             name[0] = 0;
 321             error = FT_Get_Glyph_Name(face, t, name, 127);
 322             if(!error && name[0] && !strstr(name, "notdef")) {
 323                 font->glyphs[font->num_glyphs].name = strdup(name);
 324                 hasname = 1;
 325             }
 326         }
 327
 328 #if 0 // some cantonese pdfs fail to work if this is activated
 329
 330         if(has_had_errors && (isunicode && !glyph2unicode[t]) && !hasname && t>=256) {
 331             /* some freetype versions crash or corrupt memory if we try to load
 332                characters (without unicode index or name) above 256 for some fonts.
 333                So skip those characters once the first error occured */
 334             omit = 1;
 335         }
 336 #endif
 337
 338         if(!omit) {
 339             error = FT_Load_Glyph(face, t, FT_LOAD_NO_BITMAP);
 340             if(error) {
 341                 if(hasname)
 342                     fprintf(stderr, "Warning: glyph %d/%d (unicode %d, name %s) has return code %d\n", t, (int)face->num_glyphs, glyph2unicode[t], name, error);
 343                 else
 344                     fprintf(stderr, "Warning: glyph %d/%d (unicode %d) has return code %d\n", t, (int)face->num_glyphs, glyph2unicode[t], error);
 345                 omit = 2;
 346
 347 #if 0
 348                 if(!has_had_errors) {
 349                     char buf[256];
 350                     if(fontname && *fontname) {
 351                         fprintf(stderr, "font has been copied to %s.ttf\n", fontname);
 352                         sprintf(buf, "cp %s %s.ttf", filename, fontname);
 353                     } else {
 354                         fprintf(stderr, "font has been copied to badfont%d.ttf\n", errorno);
 355                         sprintf(buf, "cp %s badfont%d.ttf", filename, errorno);
 356                         errorno++;
 357                     }
 358                     system(buf);
 359                 }
 360 #endif
 361                 has_had_errors = 1;
 362             }
 363         }
 364         if(!omit) {
 365             error = FT_Get_Glyph(face->glyph, &glyph);
 366             if(error) {
 367                 fprintf(stderr, "Couldn't get glyph %d/%d, error:%d\n", t, (int)face->num_glyphs, error);
 368                 omit = 3;
 369             }
 370         }
 371
 372         if(!omit) {
 373             gfxline_t*l;
 374             int ok=0;
 375             gfxdrawer_target_gfxline(&draw);
 376             info.draw = &draw;
 377             info.quality = quality;
 378
 379             //error = FT_Outline_Decompose(&face->glyph->outline, &outline_functions, &info);
 380             error = FT_Outline_Decompose(&face->glyph->outline, &outline_functions, &info);
 381
 382             if(error) {
 383                 fprintf(stderr, "Couldn't decompose glyph %d\n", t);
 384                 gfxline_free((gfxline_t*)draw.result(&draw));
 385                 FT_Done_Glyph(glyph);
 386                 omit = 4;
 387             } else {
 388                 font->glyphs[font->num_glyphs].advance = glyph->advance.x/65536;
 389                 font->glyphs[font->num_glyphs].line = (gfxline_t*)draw.result(&draw);
 390             }
 391             l = font->glyphs[font->num_glyphs].line;
 392             while(l) {
 393                 if(l->type != gfx_moveTo) {
 394                     ok = 1;
 395                 }
 396                 l = l->next;
 397             }
 398             if(!ok && !name) {
 399                 gfxline_free(font->glyphs[font->num_glyphs].line);
 400                 font->glyphs[font->num_glyphs].line = 0;
 401                 font->glyphs[font->num_glyphs].advance = 0;
 402
 403                 /* Some PDFs created e.g. by InDesign tend to create
 404                    fonts with reduced (empty) characters, which still
 405                    have unicode indices attached to them.
 406                    Remove that information, in order to not confuse
 407                    any converter applications.
 408                     */
 409                 font->glyphs[font->num_glyphs].unicode = 0;
 410                 if(font->glyphs[font->num_glyphs].name) {
 411                     free((void*)font->glyphs[font->num_glyphs].name);
 412                     font->glyphs[font->num_glyphs].name = 0;
 413                 }
 414                 FT_Done_Glyph(glyph);
 415                 omit = 5;
 416             }
 417         }
 418
 419         if(!omit) {
 420             FT_Done_Glyph(glyph);
 421             font->glyphs[font->num_glyphs].unicode = glyph2unicode[t];
 422         }
 423
 424         glyph2glyph[t] = font->num_glyphs;
 425         font->num_glyphs++;
 426     }
 427
 428     /* notice: if skip_unused is true, font->glyph2unicode, font->glyphnames and font->layout->bounds will
 429                have more memory allocated than just font->num_glyphs, but only the first font->numchars
 430                are used/valid */
 431
 432     for(t=0;t<font->max_unicode;t++) {
 433         if(font->unicode2glyph[t]>=0) {
 434             font->unicode2glyph[t] = glyph2glyph[font->unicode2glyph[t]];
 435         }
 436     }
 437     rfx_free(glyph2glyph);
 438     rfx_free(glyph2unicode);
 439
 440     FT_Done_Face(face);
 441     FT_Done_FreeType(ftlibrary);ftlibrary=0;
 442
 443     if(!isunicode && font->num_glyphs>0 && font->max_unicode) {
 444         /* if the encoding isn't unicode, remap the font
 445            so that the encoding equals the char position, and
 446            remove the unicode table */
 447         int t;
 448         gfxglyph_t*newglyphs = (gfxglyph_t*)rfx_calloc(font->max_unicode*sizeof(gfxglyph_t));
 449
 450         for(t=0;t<max_unicode;t++) {
 451             int c = font->unicode2glyph[t];
 452             if(c>=font->num_glyphs || c<0)
 453                 c = 0;
 454             newglyphs[t] = cloneGlyph(&font->glyphs[c]);
 455             newglyphs[t].unicode = -1;
 456         }
 457         for(t=0;t<font->num_glyphs;t++) {
 458             glyph_clear(&font->glyphs[t]);
 459         }
 460         free(font->glyphs);
 461         font->glyphs = newglyphs;
 462         font->num_glyphs = font->max_unicode;
 463
 464         free(font->unicode2glyph);font->unicode2glyph = 0;
 465         font->max_unicode = 0;
 466     }
 467
 468     if(font->unicode2glyph) {
 469         int t;
 470         int bad = 0;
 471         /* check whether the Unicode indices look o.k.
 472            If they don't, disable the unicode lookup by setting
 473            the unicode map to -1 everywhere */
 474         for(t=0;t<font->num_glyphs;t++) {
 475             int c = font->glyphs[t].unicode;
 476             gfxline_t* line = font->glyphs[t].line;
 477             if(c && c < 32 && (line && line->next && line->next->next)) {
 478                 // the character maps into the unicode control character range
 479                 // between 0001-001f. Yet it is not empty. Treat the one
 480                 // mapping as broken, and look how many of those we find.
 481                 bad ++;
 482             }
 483         }
 484         if(bad>5) {
 485             free(font->unicode2glyph);font->unicode2glyph = 0;
 486             font->max_unicode = 0;
 487             for(t=0;t<font->num_glyphs;t++) {
 488                 font->glyphs[t].unicode = -1;
 489             }
 490         }
 491     }
 492
 493     return font;
 494 }
 495 #else
 496
 497 gfxfont_t* gfxfont_load(const char*id, const char*filename, unsigned int flags, double quality)
 498 {
 499     fprintf(stderr, "No freetype support compiled in! Not able to load %s\n", filename);
 500     return 0;
 501 }
 502
 503 #endif
 504
 505 void gfxfont_free(gfxfont_t*font)
 506 {
 507     int t;
 508     for(t=0;t<font->num_glyphs;t++) {
 509         glyph_clear(&font->glyphs[t]);
 510     }
 511     if(font->glyphs) {
 512         free(font->glyphs);font->glyphs = 0;
 513     }
 514     font->num_glyphs = 0;
 515     if(font->unicode2glyph) {
 516         free(font->unicode2glyph);font->unicode2glyph = 0;
 517     }
 518     if(font->id) {
 519         free((void*)font->id);font->id=0;
 520     }
 521     if(font->kerning) {
 522         free(font->kerning);font->kerning=0;
 523     }
 524
 525     free(font);
 526 }
 527
 528 static inline int invalid_unicode(int u)
 529 {
 530     return (u<32 || (u>=0xe000 && u<0xf900));
 531 }
 532 void gfxfont_fix_unicode(gfxfont_t*font)
 533 {
 534     int t;
 535
 536     /* find the current maximum unicode2glyph */
 537     int max = 0;
 538     for(t=0;t<font->num_glyphs;t++) {
 539         int u = font->glyphs[t].unicode;
 540         if(u > max)
 541             max = u;
 542     }
 543     char*used = rfx_calloc(max+1);
 544
 545     /* now, remap all duplicates (and invalid characters) and
 546        calculate the new maximum */
 547     int remap_pos=0;
 548     max = 0;
 549     for(t=0;t<font->num_glyphs;t++) {
 550         int u = font->glyphs[t].unicode;
 551         if(u>=0) {
 552             if(used[u] || invalid_unicode(u)) {
 553                 u = font->glyphs[t].unicode = 0xe000 + remap_pos++;
 554             } else {
 555                 used[u] = 1;
 556             }
 557         }
 558         if(u > max)
 559             max = u;
 560     }
 561     free(used);
 562     if(font->unicode2glyph) {
 563         free(font->unicode2glyph);
 564     }
 565     font->unicode2glyph = 0;
 566     font->max_unicode = 0;
 567 }
 568
 569 void gfxfont_add_unicode2glyph(gfxfont_t*font)
 570 {
 571     int t;
 572     int max = 0;
 573     for(t=0;t<font->num_glyphs;t++) {
 574         int u = font->glyphs[t].unicode;
 575         if(u > max)
 576             max = u;
 577     }
 578     if(!font->unicode2glyph) {
 579         /* (re)generate unicode2glyph-to-glyph mapping table by reverse mapping
 580            the glyph unicode2glyph's indexes into the mapping table. For collisions,
 581            we prefer the smaller unicode2glyph value.*/
 582         font->max_unicode = max+1;
 583         font->unicode2glyph = malloc(sizeof(font->unicode2glyph[0])*(font->max_unicode));
 584         memset(font->unicode2glyph, -1, sizeof(font->unicode2glyph[0])*(font->max_unicode));
 585
 586         for(t=0;t<font->num_glyphs;t++) {
 587             int u = font->glyphs[t].unicode;
 588             if(u>=0) {
 589                 assert(font->unicode2glyph[u]<0); // we took care of duplicates, right?
 590                 assert(u<font->max_unicode);
 591                 font->unicode2glyph[u] = t;
 592             }
 593         }
 594     } else {
 595         /* add the new glyph indexes (most probably, that's only the remapped values
 596            at 0xe000) to the unicode2glyph table. Notice: Unlike glyph2unicode, we don't
 597            care about collisions in the unicode2glyph table */
 598         int new_max_unicode = max+1;
 599         if(font->max_unicode < new_max_unicode) {
 600             font->unicode2glyph = rfx_realloc(font->unicode2glyph, sizeof(font->unicode2glyph[0])*(font->max_unicode));
 601             memset(font->unicode2glyph+font->max_unicode, -1, sizeof(font->unicode2glyph[0])*(new_max_unicode - font->max_unicode));
 602         }
 603         for(t=0;t<font->num_glyphs;t++) {
 604             int u = font->glyphs[t].unicode;
 605             if(u>=0 && font->unicode2glyph[u]<0) {
 606                 font->unicode2glyph[u] = t;
 607             }
 608         }
 609         font->max_unicode = new_max_unicode;
 610     }
 611 }
 612
 613 ttf_t* gfxfont_to_ttf(gfxfont_t*font, char eot)
 614 {
 615     ttf_t*ttf = ttf_new();
 616     int num_glyphs = font->num_glyphs;
 617     int offset = 0;
 618     int t;
 619     char has_nondef_glyph =
 620         font->num_glyphs && font->glyphs[0].unicode==-1 &&
 621         (!font->glyphs[0].line || !font->glyphs[0].line->next);
 622
 623     if(!has_nondef_glyph) {
 624         /* insert a new .nondef glyph at the start of the font */
 625         offset++;
 626         num_glyphs++;
 627     }
 628     ttf->num_glyphs = num_glyphs;
 629     ttf->glyphs = rfx_calloc(num_glyphs*sizeof(ttfglyph_t));
 630     double scale = 1.0;
 631     int max_unicode = font->max_unicode;
 632     int remap_pos=0;
 633     for(t=0;t<font->num_glyphs;t++) {
 634         gfxglyph_t*src = &font->glyphs[t];
 635         ttfglyph_t*dest = &ttf->glyphs[t+offset];
 636         gfxline_t*line = src->line;
 637         int count = 0;
 638         while(line) {
 639             count++;
 640             if(line->type == gfx_splineTo)
 641                 count++;
 642             line=line->next;
 643         }
 644         dest->num_points = count;
 645         dest->points = rfx_calloc(count*sizeof(ttfpoint_t));
 646         count = 0;
 647         line = src->line;
 648         while(line) {
 649             if(line->type == gfx_splineTo) {
 650                 dest->points[count].x = line->sx*scale;
 651                 dest->points[count].y = line->sy*scale;
 652                 count++;
 653             }
 654             dest->points[count].x = line->x*scale;
 655             dest->points[count].y = line->y*scale;
 656             dest->points[count].flags |= GLYPH_ON_CURVE;
 657             if(line->type == gfx_moveTo) {
 658                 dest->points[count].flags |= GLYPH_CONTOUR_START;
 659                 if(count)
 660                     dest->points[count-1].flags |= GLYPH_CONTOUR_END;
 661             }
 662             count++;
 663             line=line->next;
 664         }
 665         if(count)
 666             dest->points[count-1].flags |= GLYPH_CONTOUR_END;
 667
 668         /* compute bounding box */
 669         int s;
 670         if(count) {
 671             dest->xmin = dest->xmax = dest->points[0].x;
 672             dest->ymin = dest->ymax = dest->points[0].y;
 673             for(s=1;s<count;s++) {
 674                 if(dest->points[s].x < dest->xmin)
 675                     dest->xmin = dest->points[s].x;
 676                 if(dest->points[s].y < dest->ymin)
 677                     dest->ymin = dest->points[s].y;
 678                 if(dest->points[s].x > dest->xmax)
 679                     dest->xmax = dest->points[s].x;
 680                 if(dest->points[s].y > dest->ymax)
 681                     dest->ymax = dest->points[s].y;
 682             }
 683         }
 684
 685         if(eot) {
 686             dest->bearing = dest->xmin;
 687             /* for windows font rendering, make sure coordinates are always
 688                to the right of the origin (and use bearing to shift them "back".)
 689                Don't do this for non-windows platforms though because e.g. OS X
 690                ignores bearing. */
 691             int xshift=0;
 692             if(dest->xmin < 0) {
 693                 xshift = -dest->xmin;
 694                 for(s=0;s<count;s++) {
 695                     dest->points[s].x += xshift;
 696                 }
 697                 dest->xmin += xshift;
 698                 dest->xmax += xshift;
 699             }
 700         }
 701         dest->advance = src->advance*scale;
 702
 703         //dest->xmin=0; //TODO: might be necessary for some font engines?
 704
 705         dest->advance = src->advance*scale;
 706
 707         int u = font->glyphs[t].unicode;
 708         if(u > max_unicode)
 709             max_unicode = u;
 710     }
 711     ttf->unicode_size = max_unicode+1;
 712     ttf->unicode = rfx_calloc(sizeof(unicode_t)*ttf->unicode_size);
 713
 714     if(!font->unicode2glyph) {
 715         for(t=0;t<font->num_glyphs;t++) {
 716             gfxglyph_t*src = &font->glyphs[t];
 717             int u = font->glyphs[t].unicode;
 718             if(u<=0)
 719                 continue;
 720             if(u<32) {
 721                 msg("<warning> gfxfont_to_ttf: glyph %d has an invalid unicode (%d)", t, u);
 722                 continue;
 723             } else if(ttf->unicode[u]) {
 724                 msg("<warning> gfxfont_to_ttf: glyph %d has a duplicate unicode (%d)", t, u);
 725                 continue;
 726             }
 727             if(u<ttf->unicode_size)
 728                 ttf->unicode[u] = t+offset;
 729         }
 730     } else {
 731         int u;
 732         for(u=1;u<font->max_unicode;u++) {
 733             int g = font->unicode2glyph[u];
 734             if(g>=0 && u<32) {
 735                 msg("<warning> gfxfont_to_ttf: Font contains an invalid unicode (%d)", u);
 736                 continue;
 737             }
 738             if(g>=0 && g<font->num_glyphs && !ttf->unicode[u]) {
 739                 ttf->unicode[u] = g+offset;
 740             }
 741         }
 742     }
 743
 744     ttf->ascent = font->ascent;
 745     ttf->descent = -font->descent;
 746     ttf->lineGap = 0;
 747
 748     ttf->full_name = strdup(font->id);
 749     ttf->family_name = strdup(font->id);
 750     ttf->subfamily_name = strdup(font->id);
 751     ttf->postscript_name = strdup(font->id);
 752     ttf->version_string = strdup("Version 1.0");
 753     ttf->font_uid = strdup(font->id);
 754
 755     ttf_create_truetype_tables(ttf);
 756     return ttf;
 757 }
 758
 759 void gfxfont_save(gfxfont_t*font, const char*filename)
 760 {
 761     ttf_t*ttf = gfxfont_to_ttf(font, 0);
 762     ttf_save(ttf, filename);
 763     ttf_destroy(ttf);
 764 }
 765
 766 void gfxfont_save_eot(gfxfont_t*font, const char*filename)
 767 {
 768     ttf_t*ttf = gfxfont_to_ttf(font, 1);
 769     ttf_save_eot(ttf, filename);
 770     ttf_destroy(ttf);
 771 }
 772