tools/convttf.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2007 Jonas Hurrelmann
  11  *
  12  * A command-line tool to convert ttf file to bitmap fonts
  13  *
  14  * All files in this archive are subject to the GNU General Public License.
  15  * See the file COPYING in the source tree root for full license agreement.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21 #include <ft2build.h>
  22 #include FT_FREETYPE_H
  23 #include FT_GLYPH_H
  24
  25 #include <stdbool.h>
  26 #include <stdio.h>
  27 #ifdef WIN32
  28 #include <windows.h>
  29 #else
  30 #include <stdlib.h>
  31 #include <unistd.h>
  32 #endif
  33 #include FT_SFNT_NAMES_H
  34 #include FT_TRUETYPE_TABLES_H
  35
  36 #include <string.h>
  37 /*
  38  * Set the default values used to generate a BDF font.
  39  */
  40 #ifndef DEFAULT_PLATFORM_ID
  41 #define DEFAULT_PLATFORM_ID 3
  42 #endif
  43
  44 #ifndef DEFAULT_ENCODING_ID
  45 #define DEFAULT_ENCODING_ID 1
  46 #endif
  47
  48 #define ABS(x)           (((x) < 0) ? -(x) : (x))
  49
  50 #define VERSION     "RB12"
  51 /*
  52  * nameID macros for getting strings from the OT font.
  53  */
  54 enum {
  55     BDFOTF_COPYRIGHT_STRING = 0,
  56     BDFOTF_FAMILY_STRING,
  57     BDFOTF_SUBFAMILY_STRING,
  58     BDFOTF_UNIQUEID_STRING,
  59     BDFOTF_FULLNAME_STRING,
  60     BDFOTF_VENDOR_STRING,
  61     BDFOTF_POSTSCRIPT_STRING,
  62     BDFOTF_TRADEMARK_STRING,
  63 };
  64 /*
  65  * String names for the string indexes. Used for error messages.
  66  */
  67 static char *string_names[] = {
  68     "\"Copyright\"",
  69     "\"Family\"",
  70     "\"SubFamily\"",
  71     "\"Unique ID\"",
  72     "\"Full Name\"",
  73     "\"Vendor\"",
  74     "\"Postscript Name\"",
  75     "\"Trademark\""
  76 };
  77
  78
  79 /*
  80  * The default platform and encoding ID's.
  81  */
  82 static int pid = DEFAULT_PLATFORM_ID;
  83 static int eid = DEFAULT_ENCODING_ID;
  84
  85
  86 /*
  87  * A flag indicating if a CMap was found or not.
  88  */
  89 static FT_UShort nocmap;
  90
  91 int pct                     = 0; /* display ttc table if it is not zero. */
  92 FT_Long         max_char    = 65535;
  93 int             pixel_size  = 15;
  94 FT_Long         start_char  = 0;
  95 FT_Long         limit_char;
  96 FT_Long         firstchar   = 0;
  97 FT_Long         lastchar;
  98 FT_Long         ttc_index   = -1;
  99 int             flg_all_ttc = 0;
 100 short           antialias   = 1; /* smooth fonts with gray levels  */
 101 int             oflag       = 0;
 102 char            outfile[1024];
 103 float           between_chr = 0.0f;
 104 float           between_row = 0.0f;
 105 int             hv_resolution = 60;
 106 int             dump_glyphs = 0;
 107 int             digits_equally_wide = 1; /* Try to make digits equally wide */
 108 int             trimming    = 0;
 109 int             trim_dp     = 0; /* trim descent percent */
 110 int             trim_da     = 0; /* trim descnet actual  */
 111 int             trim_ap     = 0; /* trim ascent  precent */
 112 int             trim_aa     = 0; /* trim ascent  actual  */
 113
 114 struct font_header_struct {
 115     char header[4];                 /* magic number and version bytes */
 116     unsigned short maxwidth;        /* max width in pixels */
 117     unsigned short height;          /* height in pixels */
 118     unsigned short ascent;          /* ascent (baseline) height */
 119     unsigned short depth;           /* depth 0=1-bit, 1=4-bit */
 120     unsigned long firstchar;        /* first character in font */
 121     unsigned long defaultchar;      /* default character in font */
 122     unsigned long size;             /* # characters in font */
 123     unsigned long nbits;            /* # bytes imagebits data in file */ /* = bits_size */
 124
 125     FT_Long noffset;          /* # longs offset data in file */
 126     FT_Long nwidth;           /* # bytes width data in file */
 127 };
 128
 129 struct font_struct {
 130     struct font_header_struct header;
 131     unsigned char *chars_data;
 132     unsigned short *offset;
 133     FT_Long *offset_long;
 134     unsigned char *width;
 135 };
 136
 137 struct ttc_table{
 138     FT_Long     ttc_count;
 139     char        **ttf_name;
 140 };
 141
 142 /* exit the program with given message */
 143 static void
 144 panic( const char*  message)
 145 {
 146     fprintf( stderr, "%s\n", message );
 147     exit( 1 );
 148 }
 149
 150 static void
 151 arg_panic( const char* message, const char* arg )
 152 {
 153     fprintf( stderr, "%s: %s\n", message, arg );
 154     exit( 1 );
 155 }
 156
 157 static int writebyte(FILE *fp, unsigned char c)
 158 {
 159     return putc(c, fp) != EOF;
 160 }
 161
 162 static int writeshort(FILE *fp, unsigned short s)
 163 {
 164     putc(s, fp);
 165     return putc(s>>8, fp) != EOF;
 166 }
 167
 168 static int writeint(FILE *fp, unsigned int l)
 169 {
 170     putc(l, fp);
 171     putc(l>>8, fp);
 172     putc(l>>16, fp);
 173     return putc(l>>24, fp) != EOF;
 174 }
 175
 176 static int writestr(FILE *fp, char *str, int count)
 177 {
 178     return (int)fwrite(str, 1, count, fp) == count;
 179 }
 180
 181 /* print usage information */
 182 void usage(void)
 183 {
 184     char help[] = {
 185         "Usage: convttf [options] [input-files]\n"
 186         "       convttf [options] [-o output-file] [single-input-file]\n\n"
 187         "       Default output-file : <font-size>-<basename>.fnt.\n"
 188         "                              When '-ta' or '-tc' is specified in command line,\n "
 189         "                               default output-file is: \n"
 190         "                             <font-size>-<internal postscript-name of input-file>.fnt.\n"
 191         "Options:\n"
 192         "    -s N   Start output at character encodings >= N\n"
 193         "    -l N   Limit output to character encodings <= N\n"
 194         "    -p N   Font size N in pixel (default N=15)\n"
 195         "    -c N   Character separation in pixel.Insert space between lines.\n"
 196         "    -x     Trim glyphs horizontally of nearly empty space\n"
 197         "              (to improve spacing on V's W's, etc.)\n"
 198         "    -X     Set the horizontal and vertical resolution (default: 60)\n"
 199         "    -TA N  Trim vertical ascent  (N percent)\n"
 200         "    -TD N  Trim vertical descent (N percent)\n"
 201         "    -Ta N  Trim vertical ascent  (N pixels)\n"
 202         "    -Td N  Trim vertical descent (N pixels)\n"
 203         "    -r N   Row separation in pixel.Insert space between characters\n"
 204         "    -d     Debug: print converted glyph images\n"
 205         "    -tt    Display the True Type Collection tables available in the font\n"
 206         "    -t N   Index of true type collection. It must be start from 0.(default N=0).\n"
 207         "    -ta    Convert all fonts in ttc (ignores outfile option)\n"
 208         "    -w     Don't try to make digits (0-9) equally wide\n"
 209     };
 210     fprintf(stderr, "%s", help);
 211     exit( 1 );
 212 }
 213
 214 /* remove directory prefix and file suffix from full path*/
 215 char *basename(char *path)
 216 {
 217     char *p, *b;
 218     static char base[256];
 219
 220     /* remove prepended path and extension*/
 221     b = path;
 222     for (p=path; *p; ++p) {
 223         if (*p == '/')
 224             b = p + 1;
 225     }
 226     strcpy(base, b);
 227     for (p=base; *p; ++p) {
 228         if (*p == '.') {
 229             *p = 0;
 230             break;
 231         }
 232     }
 233     return base;
 234 }
 235
 236
 237 void setcharmap(FT_Face face)
 238 {
 239     FT_Long i;
 240
 241     /*
 242      * Get the requested cmap.
 243      */
 244     for (i = 0; i < face->num_charmaps; i++) {
 245         if (face->charmaps[i]->platform_id == pid &&
 246             face->charmaps[i]->encoding_id == eid)
 247           break;
 248     }
 249
 250     if (i == face->num_charmaps && pid == 3 && eid == 1) {
 251         /*
 252          * Make a special case when this fails with pid == 3 and eid == 1.
 253          * Change to eid == 0 and try again.  This captures the two possible
 254          * cases for MS fonts.  Some other method should be used to cycle
 255          * through all the alternatives later.
 256          */
 257         for (i = 0; i < face->num_charmaps; i++) {
 258         if (face->charmaps[i]->platform_id == pid &&
 259             face->charmaps[i]->encoding_id == 0)
 260               break;
 261         }
 262         if (i < face->num_charmaps) {
 263             pid = 3;
 264             eid = 1;
 265             FT_Set_Charmap(face, face->charmaps[i]);
 266         } else {
 267             /*
 268              * No CMAP was found.
 269              */
 270             nocmap = 1;
 271             pid = eid = -1;
 272         }
 273     } else {
 274         FT_Set_Charmap(face, face->charmaps[i]);
 275         nocmap = 0;
 276     }
 277
 278 }
 279
 280 /*
 281  * quote in otf2bdf.
 282  * A generic routine to get a name from the OT name table.  This routine
 283  * always looks for English language names and checks three possibilities:
 284  * 1. English names with the MS Unicode encoding ID.
 285  * 2. English names with the MS unknown encoding ID.
 286  * 3. English names with the Apple Unicode encoding ID.
 287  *
 288  * The particular name ID mut be provided (e.g. nameID = 0 for copyright
 289  * string, nameID = 6 for Postscript name, nameID = 1 for typeface name.
 290  *
 291  * If the `dash_to_space' flag is non-zero, all dashes (-) in the name will be
 292  * replaced with the character passed.
 293  *
 294  * Returns the number of bytes added.
 295  */
 296 static int
 297 otf_get_english_string(FT_Face face, int nameID, int dash_to_space,
 298                        char *name, int name_size)
 299 {
 300
 301     int j, encid;
 302     FT_UInt i, nrec;
 303     FT_SfntName sfntName;
 304     unsigned char *s;
 305     unsigned short slen;
 306
 307     nrec = FT_Get_Sfnt_Name_Count(face);
 308
 309     for (encid = 1, j = 0; j < 2; j++, encid--) {
 310         /*
 311          * Locate one of the MS English font names.
 312          */
 313         for (i = 0; i < nrec; i++) {
 314            FT_Get_Sfnt_Name(face, i, &sfntName);
 315            if (sfntName.platform_id == 3 &&
 316                sfntName.encoding_id == encid &&
 317                sfntName.name_id == nameID &&
 318                (sfntName.language_id == 0x0409 ||
 319                 sfntName.language_id == 0x0809 ||
 320                 sfntName.language_id == 0x0c09 ||
 321                 sfntName.language_id == 0x1009 ||
 322                 sfntName.language_id == 0x1409 ||
 323                 sfntName.language_id == 0x1809)) {
 324                s = sfntName.string;
 325                slen = sfntName.string_len;
 326                break;
 327            }
 328         }
 329
 330         if (i < nrec) {
 331             if (slen >> 1 >= name_size) {
 332                 fprintf(stderr, "warning: %s string longer than buffer."
 333                 "Truncating to %d bytes.\n", string_names[nameID], name_size);
 334                 slen = name_size << 1;
 335             }
 336
 337             /*
 338              * Found one of the MS English font names.  The name is by
 339              * definition encoded in Unicode, so copy every second byte into
 340              * the `name' parameter, assuming there is enough space.
 341              */
 342             for (i = 1; i < slen; i += 2) {
 343                 if (dash_to_space)
 344                   *name++ = (s[i] != '-') ? s[i] : ' ';
 345                 else if (s[i] == '\r' || s[i] == '\n') {
 346                     if (s[i] == '\r' && i + 2 < slen && s[i + 2] == '\n')
 347                       i += 2;
 348                     *name++ = ' ';
 349                     *name++ = ' ';
 350                 } else
 351                   *name++ = s[i];
 352             }
 353             *name = 0;
 354             return (slen >> 1);
 355         }
 356     }
 357
 358     /*
 359      * No MS English name found, attempt to find an Apple Unicode English
 360      * name.
 361      */
 362     for (i = 0; i < nrec; i++) {
 363         FT_Get_Sfnt_Name(face, i, &sfntName);
 364         if (sfntName.platform_id == 0 && sfntName.language_id == 0 &&
 365             sfntName.name_id == nameID) {
 366             s = sfntName.string;
 367             slen = sfntName.string_len;
 368             break;
 369         }
 370     }
 371
 372     if (i < nrec) {
 373         if (slen >> 1 >= name_size) {
 374             fprintf(stderr, "warning: %s string longer than buffer."
 375             "Truncating to %d bytes.\n", string_names[nameID], name_size);
 376             slen = name_size << 1;
 377         }
 378
 379         /*
 380          * Found the Apple Unicode English name.  The name is by definition
 381          * encoded in Unicode, so copy every second byte into the `name'
 382          * parameter, assuming there is enough space.
 383          */
 384         for (i = 1; i < slen; i += 2) {
 385             if (dash_to_space)
 386               *name++ = (s[i] != '-') ? s[i] : ' ';
 387             else if (s[i] == '\r' || s[i] == '\n') {
 388                 if (s[i] == '\r' && i + 2 < slen && s[i + 2] == '\n')
 389                   i += 2;
 390                 *name++ = ' ';
 391                 *name++ = ' ';
 392             } else
 393               *name++ = s[i];
 394         }
 395         *name = 0;
 396         return (slen >> 1);
 397     }
 398
 399     return 0;
 400 }
 401
 402
 403 int get_ttc_table(char *path, struct ttc_table *ttcname )
 404 {
 405
 406
 407     FT_Error    error;
 408     FT_Library  library;
 409     FT_Face     face;
 410     FT_Long     i;
 411     char        xlfd[BUFSIZ];
 412
 413     /* init number of ttf in ttc */
 414     ttcname->ttc_count = 0;
 415
 416     /* Initialize engine */
 417     if ( ( error = FT_Init_FreeType( &library ) ) != 0 )
 418     {
 419         panic( "Error while initializing engine" );
 420         return error;
 421     }
 422
 423
 424     /* Load face */
 425     error = FT_New_Face( library, path, (FT_Long) 0, &face );
 426     if ( error )
 427     {
 428         arg_panic( "Could not find/open font", path );
 429         return error;
 430     }
 431
 432     ttcname->ttc_count = face->num_faces;
 433     ttcname->ttf_name = malloc( sizeof(char*) * ttcname->ttc_count);
 434
 435     for(i = 0; i < ttcname->ttc_count; i++)
 436     {
 437         error = FT_New_Face( library, path, i, &face );
 438         if ( error == FT_Err_Cannot_Open_Stream )
 439             arg_panic( "Could not find/open font", path );
 440         otf_get_english_string(face, BDFOTF_POSTSCRIPT_STRING, 0, xlfd,
 441                                   sizeof(xlfd));
 442         ttcname->ttf_name[i] = malloc(sizeof(char) * (strlen(xlfd) + 1 ));
 443         strcpy(ttcname->ttf_name[i], xlfd);
 444     }
 445     return 0;
 446 }
 447
 448 void print_ttc_table(char* path)
 449 {
 450     struct ttc_table ttcname;
 451     FT_Long     i;
 452
 453     get_ttc_table(path, &ttcname);
 454     printf("ttc header count = %ld \n\n", ttcname.ttc_count);
 455     printf("Encoding tables available in the true type collection\n\n");
 456     printf("INDEX\tPOSTSCRIPT NAME\n");
 457     printf("-----------------------------------------------------\n");
 458     for(i = 0; i < ttcname.ttc_count; i++)
 459     {
 460         printf("%ld\t%s\n", i, ttcname.ttf_name[i]);
 461     }
 462     for(i = 0; i < ttcname.ttc_count; i++)
 463     {
 464         free(ttcname.ttf_name[i]);
 465     }
 466     printf("\n\n");
 467     free(ttcname.ttf_name);
 468
 469     return;
 470 }
 471
 472 FT_Long getcharindex(FT_Face face, FT_Long code)
 473 {
 474     FT_Long idx;
 475     if (nocmap) {
 476         if (code >= face->num_glyphs)
 477             idx = 0;
 478         else
 479             idx = code;
 480     } else
 481         idx = FT_Get_Char_Index( face, code);
 482
 483     if ( idx <= 0 || idx > face->num_glyphs)
 484         return 0;
 485     else
 486         return idx;
 487 }
 488
 489 void print_raw_glyph( FT_Face face)
 490 {
 491     int pixel,row,col,width;
 492     width = face->glyph->metrics.width >> 6;
 493
 494     printf("\n---Raw-Glyph---\n");
 495     for(row=0; row < face->glyph->metrics.height >> 6; row++)
 496     {
 497         printf("_");
 498         for(col=0; col < width; col++)
 499         {
 500             pixel = *(face->glyph->bitmap.buffer+width*row+col)/26;
 501             if ( pixel ) printf("%d",pixel); else printf(" ");
 502         }
 503         printf("_\n");
 504     }
 505     printf("----End-----\n");
 506 }
 507
 508 int glyph_width( FT_Face face, FT_Long code, FT_Long digit_width )
 509 {
 510     int width;
 511
 512     if (code >= '0' && code <= '9' && digit_width)
 513     {
 514         width = digit_width;
 515     }
 516     else
 517     {
 518         int pitch, h_adv;
 519         unsigned spacing = (unsigned)(between_chr * (1<<6));/* convert to fixed point */
 520
 521         pitch = ABS(face->glyph->bitmap.pitch);
 522         h_adv = face->glyph->metrics.horiAdvance >> 6;
 523         width = (face->glyph->metrics.width + spacing) >> 6;
 524
 525         if(pitch == 0)    pitch = h_adv;
 526         if(width < pitch) width = pitch;
 527     }
 528
 529     return width;
 530 }
 531
 532 FT_Long check_digit_width( FT_Face face )
 533 {
 534     FT_Long code;
 535     FT_Long last_advance = -1;
 536
 537     for (code='0'; code <= '9'; ++code)
 538     {
 539         FT_Glyph_Metrics* metrics;
 540
 541         FT_Load_Char(face, code, FT_LOAD_RENDER | FT_LOAD_NO_BITMAP);
 542         metrics = &face->glyph->metrics;
 543
 544         if ((last_advance != -1 && last_advance != metrics->horiAdvance) ||
 545             metrics->horiBearingX < 0)
 546         {
 547             last_advance = 0;
 548             break;
 549         }
 550
 551         last_advance = metrics->horiAdvance;
 552     }
 553
 554     return last_advance >> 6;
 555 }
 556
 557 void trim_glyph( FT_GlyphSlot glyph, int *empty_first_col,
 558                 int *empty_last_col, int *width )
 559 {
 560     int row;
 561     int stride = glyph->bitmap.pitch;
 562     int end = stride-1;
 563     int trim_left = 2, trim_right = 2;
 564
 565     const unsigned char limit = 64u;
 566     const unsigned char *image = glyph->bitmap.buffer;
 567
 568     if (*width < 2)
 569         return; /* nothing to do? */
 570
 571     for(row=0; row< glyph->metrics.height >> 6; row++)
 572     {
 573         const unsigned char *column = image+row*stride;
 574         if (*column++ < limit && trim_left)
 575         {
 576             if (*column >= limit/2)
 577                 trim_left = 1;
 578         }
 579         else
 580             trim_left = 0;
 581
 582         column = image+row*stride+end;
 583         if (*column-- < limit && trim_right)
 584         {
 585             if (*column >= limit/2)
 586                 trim_right = 1;
 587         }
 588         else
 589             trim_right = 0;
 590     }
 591
 592
 593     (*width) -= trim_left + trim_right;
 594     if (*width < 0) *width = 0;
 595
 596     *empty_first_col = trim_left;
 597     *empty_last_col = trim_right;
 598 }
 599
 600 void convttf(char* path, char* destfile, FT_Long face_index)
 601 {
 602     FT_Error    error;
 603     FT_Library  library;
 604     FT_Face     face;
 605     int         w,h;
 606     int         row,col;
 607     int         empty_first_col, empty_last_col;
 608     FT_Long     charindex;
 609     FT_Long     index = 0;
 610     FT_Long     code;
 611     FT_Long     digit_width = 0;
 612
 613     int depth = 2;
 614     unsigned char bit_shift = 1 << depth;
 615     unsigned char pixel_per_byte = CHAR_BIT / bit_shift;
 616
 617     /* Initialize engine */
 618     if ( ( error = FT_Init_FreeType( &library ) ) != 0 )
 619         panic( "Error while initializing engine" );
 620
 621     /* Load face */
 622     error = FT_New_Face( library, path, (FT_Long) face_index, &face );
 623     if ( error == FT_Err_Cannot_Open_Stream )
 624         arg_panic( "Could not find/open font\n", path );
 625     else if ( error )
 626         arg_panic( "Error while opening font\n", path );
 627
 628
 629     setcharmap( face );
 630     /* Set font header data */
 631     struct font_struct export_font;
 632     export_font.header.header[0] = 'R';
 633     export_font.header.header[1] = 'B';
 634     export_font.header.header[2] = '1';
 635     export_font.header.header[3] = '2';
 636     //export_font.header.height = 0;
 637     //export_font.header.ascent = 0;
 638
 639     float extra_space = (float)(between_row-trim_aa-trim_da);
 640     FT_Set_Char_Size( face, 0, pixel_size << 6, hv_resolution, hv_resolution );
 641     export_font.header.ascent =
 642             ((face->size->metrics.ascender*(100-trim_ap)/100) >> 6) - trim_aa;
 643
 644     export_font.header.height =
 645         (((face->size->metrics.ascender*(100-trim_ap)/100) -
 646         (face->size->metrics.descender*(100-trim_dp)/100)) >> 6) + extra_space;
 647
 648     printf("\n");
 649     printf("Please wait, converting %s:\n", path);
 650
 651     /* "face->num_glyphs" is NG.; */
 652     if ( limit_char == 0 ) limit_char = max_char;
 653     if ( limit_char > max_char ) limit_char = max_char;
 654
 655     FT_Long char_count = 0;
 656
 657
 658
 659     export_font.header.maxwidth = 1;
 660     export_font.header.depth = 1;
 661     firstchar = limit_char;
 662     lastchar  = start_char;
 663
 664     if (digits_equally_wide)
 665         digit_width = check_digit_width(face);
 666
 667     /* calculate memory usage */
 668     for(code = start_char; code <= limit_char ; code++ )
 669     {
 670         charindex = getcharindex( face, code);
 671         if ( !(charindex) ) continue;
 672         error = FT_Load_Glyph( face, charindex,
 673                                (FT_LOAD_RENDER | FT_LOAD_NO_BITMAP) );
 674         if ( error ) continue;
 675
 676         w = glyph_width( face, code, digit_width );
 677         if (w == 0) continue;
 678         empty_first_col = empty_last_col = 0;
 679         if(trimming)
 680             trim_glyph( face->glyph, &empty_first_col, &empty_last_col, &w);
 681
 682         if (export_font.header.maxwidth < w)
 683             export_font.header.maxwidth = w;
 684
 685
 686         char_count++;
 687         index += (w*export_font.header.height + pixel_per_byte - 1)/pixel_per_byte;
 688
 689         if (code >= lastchar)
 690             lastchar = code;
 691
 692         if (code <= firstchar)
 693             firstchar = code;
 694     }
 695     export_font.header.defaultchar = firstchar;
 696     export_font.header.firstchar = firstchar;
 697     export_font.header.size = lastchar - firstchar + 1;
 698     export_font.header.nbits = index;
 699     export_font.header.noffset = export_font.header.size;
 700     export_font.header.nwidth  = export_font.header.size;
 701
 702     /* check if we need to use long offsets */
 703     char use_long_offset = (export_font.header.nbits >= 0xFFDB );
 704
 705     /* allocate memory */
 706     export_font.offset = NULL;
 707     export_font.offset_long = NULL;
 708     if (use_long_offset)
 709         export_font.offset_long =
 710             malloc( sizeof(FT_Long)* export_font.header.noffset );
 711     else
 712         export_font.offset =
 713             malloc( sizeof(unsigned short)* export_font.header.noffset );
 714
 715     export_font.width =
 716             malloc( sizeof(unsigned char) * export_font.header.nwidth );
 717     export_font.chars_data =
 718             malloc( sizeof(unsigned char) * export_font.header.nbits );
 719
 720     /* for now we use the full height for each character */
 721     h = export_font.header.height;
 722
 723     index = 0;
 724     int done = 0;
 725     char char_name[1024];
 726     int converted_char_count = 0;
 727     int failed_char_count = 0;
 728
 729     for( code = firstchar; code <= lastchar; code++ )
 730     {
 731         /* Get gylph index from the char and render it */
 732         charindex = getcharindex( face, code);
 733         if ( !charindex )
 734         {
 735             if ( use_long_offset )
 736                 export_font.offset_long[code - firstchar] = export_font.offset_long[0];
 737             else
 738                 export_font.offset[code - firstchar] = export_font.offset[0];
 739             export_font.width[code - firstchar] = export_font.width[0];
 740             continue;
 741         }
 742
 743         error = FT_Load_Glyph( face, charindex ,
 744                                (FT_LOAD_RENDER | FT_LOAD_NO_BITMAP) );
 745         if ( error ) {
 746             continue;
 747         }
 748         if FT_HAS_GLYPH_NAMES( face )
 749             FT_Get_Glyph_Name( face, charindex, char_name, 16);
 750         else
 751             char_name[0] = '\0';
 752
 753         FT_GlyphSlot slot = face->glyph;
 754         FT_Bitmap* source = &slot->bitmap;
 755         //print_raw_glyph( face );
 756         w = glyph_width( face, code, digit_width );
 757         if (w == 0) continue;
 758         empty_first_col = empty_last_col = 0;
 759
 760         if(trimming)
 761             trim_glyph( face->glyph, &empty_first_col, &empty_last_col, &w );
 762
 763         if ( use_long_offset )
 764             export_font.offset_long[code - firstchar] = index;
 765         else
 766             export_font.offset[code - firstchar] = index;
 767
 768         export_font.width[code - firstchar] = w;
 769
 770         /* copy the glyph bitmap to a full sized glyph bitmap */
 771         unsigned char* src = source->buffer;
 772         unsigned char* tmpbuf = malloc(sizeof(unsigned char) * w * h);
 773         memset(tmpbuf, 0xff, w*h);
 774         int start_y =  export_font.header.ascent - slot->bitmap_top;
 775
 776         int glyph_height = source->rows;
 777         int stride = source->pitch;
 778         unsigned char* buf = tmpbuf;
 779         unsigned char* endbuf = tmpbuf + w*h;
 780
 781         int error = 0;
 782         /* insert empty pixels on the left */
 783         int col_off = w - stride;
 784         if (col_off > 1) col_off /= 2;
 785         if (col_off < 0) col_off = 0;
 786
 787         for(row=0; row < glyph_height; row++)
 788         {
 789             if(row+start_y < 0 || row+start_y >= h)
 790                 continue;
 791             for(col = empty_first_col; col < stride; col++)
 792             {
 793                 unsigned char *tsrc, *dst;
 794                 dst = buf + (w*(start_y+row)) + col + col_off;
 795                 tsrc = src + stride*row + col;
 796                 if (dst < endbuf && dst >= tmpbuf)
 797                     *dst = 0xff - *tsrc;
 798                 else {
 799                     error = 1;
 800                     printf("Error! row: %3d col: %3d\n", row, col);
 801                 }
 802             }
 803         }
 804         if(error) print_raw_glyph(face);
 805
 806         buf = tmpbuf;
 807         int numbits;
 808         unsigned int field;
 809         field = 0;
 810         numbits = pixel_per_byte;
 811
 812         for(row=0; row < h; row++)
 813         {
 814             for(col=0; col < w; col++)
 815             {
 816                 unsigned int src = *buf++;
 817                 unsigned int cur_col = (src + 8) / 17;
 818                 field |= (cur_col << (bit_shift*(pixel_per_byte-numbits)));
 819
 820                 if (--numbits == 0)
 821                 {
 822                     export_font.chars_data[index++] = (unsigned char)field;
 823                     numbits = pixel_per_byte;
 824                     field = 0;
 825                 }
 826             }
 827         }
 828
 829         /* Pad last byte */
 830         if (numbits != pixel_per_byte)
 831         {
 832             export_font.chars_data[index++] = (unsigned char)field;
 833         }
 834
 835         if( dump_glyphs )
 836         {
 837             /* debug: dump char */
 838             printf("\n---Converted Glyph Dump---\n");
 839             unsigned char bit_max = (1 << bit_shift) - 1;
 840             if ( code > 32 && code < 255 ) {
 841                 row = h;
 842                 if(use_long_offset)
 843                     buf =  &(export_font.chars_data[export_font.offset_long[
 844                              code - firstchar]]);
 845                 else
 846                     buf =  &(export_font.chars_data[export_font.offset[
 847                              code - firstchar]]);
 848                 unsigned char current_data;
 849                 unsigned char font_bits;
 850                 numbits = pixel_per_byte;
 851                 current_data = *buf;
 852                 do
 853                 {
 854                     col =  w;
 855                     printf("-");
 856                     do
 857                     {
 858                         font_bits = current_data & bit_max;
 859                         if (font_bits==bit_max)
 860                             printf(" ");
 861                         else
 862                         {
 863                             if(font_bits > bit_max/2)
 864                                 printf(".");
 865                             else
 866                                 printf("@");
 867                         }
 868                         if (--numbits == 0)
 869                         {
 870                             current_data = *(++buf);
 871                             numbits = pixel_per_byte;
 872                         }
 873                         else
 874                         {
 875                             current_data >>= bit_shift;
 876                         }
 877                     } while (--col);
 878                     printf("-\n");
 879                 } while (--row);
 880             }
 881             buf = NULL;
 882             printf("---End Glyph Dump---\n");
 883         }
 884
 885         free(tmpbuf);
 886         converted_char_count++;
 887         done = (100*(converted_char_count))/char_count;
 888         printf("Converted %s %d (%d%%)\e[K\r",
 889                char_name,converted_char_count,done); fflush(stdout);
 890     }
 891
 892     FILE *file = fopen(destfile, "w");
 893     printf("Writing %s\n", destfile);
 894
 895     /* font info */
 896     writestr(file, VERSION, 4);
 897     writeshort(file, export_font.header.maxwidth);
 898     writeshort(file, export_font.header.height);
 899     writeshort(file, export_font.header.ascent);
 900     writeshort(file, export_font.header.depth);
 901     writeint(file, export_font.header.firstchar);
 902     writeint(file, export_font.header.defaultchar);
 903     writeint(file, export_font.header.size);
 904     writeint(file, export_font.header.nbits);
 905     writeint(file, export_font.header.noffset);
 906     writeint(file, export_font.header.nwidth);
 907
 908     fwrite( (char*)export_font.chars_data, 1,
 909                export_font.header.nbits, file);
 910     free(export_font.chars_data);
 911
 912     int skip,i;
 913     char pad[] = {0,0,0,0};
 914     if ( use_long_offset )
 915     {
 916         skip = ((export_font.header.nbits + 3) & ~3) -
 917             export_font.header.nbits;
 918         fwrite(pad, 1, skip, file); /* pad */
 919         for(i = 0; i < export_font.header.noffset; i++)
 920             writeint(file, export_font.offset_long[i]);
 921     }
 922     else
 923     {
 924         skip = ((export_font.header.nbits + 1) & ~1) -
 925             export_font.header.nbits;
 926         fwrite(pad, 1, skip, file); /* pad */
 927         for(i = 0; i < export_font.header.noffset; i++)
 928             writeshort(file, export_font.offset[i]);
 929     }
 930
 931     for(i = 0; i < export_font.header.nwidth; i++)
 932         writebyte(file, export_font.width[i]);
 933     free(export_font.width);
 934
 935     if ( use_long_offset )
 936         free(export_font.offset_long);
 937     else
 938         free(export_font.offset);
 939
 940     fclose(file);
 941     FT_Done_Face( face );
 942     FT_Done_FreeType( library );
 943     printf("done (converted %d glyphs, %d errors).\e[K\n\n",
 944            converted_char_count, failed_char_count);
 945
 946 }
 947
 948 void convttc(char* path)
 949 {
 950     struct ttc_table ttcname;
 951     FT_Long          i;
 952
 953     get_ttc_table(path, &ttcname);
 954
 955     if (ttcname.ttc_count == 0)
 956     {
 957         printf("This file is a not true type font.\n");
 958         return;
 959     }
 960
 961     /* default */
 962     if (!flg_all_ttc && ttc_index    == -1)
 963     {
 964         if (!oflag)
 965         {   /* generate filename */
 966             snprintf(outfile, sizeof(outfile),
 967                      "%d-%s.fnt", pixel_size, basename(path));
 968         }
 969         convttf(path, outfile, (FT_Long) 0);
 970     }
 971
 972     /* set face_index of ttc */
 973     else if (!flg_all_ttc)
 974     {
 975         print_ttc_table(path);
 976         if ( !oflag )
 977         {
 978             if (ttc_index >= 0 &&
 979                 ttc_index < ttcname.ttc_count)
 980             {
 981                 if (strcmp(ttcname.ttf_name[ttc_index], "") != 0)
 982                 {
 983                     snprintf(outfile, sizeof(outfile), "%d-%s.fnt",
 984                              pixel_size, ttcname.ttf_name[ttc_index]);
 985                 }
 986                 else
 987                 {
 988                     snprintf(outfile, sizeof(outfile), "%d-%s-%ld.fnt",
 989                              pixel_size, basename(path), ttc_index);
 990                 }
 991             }
 992             else
 993             {
 994                 printf("illegal face index of ttc.\n");
 995             }
 996         }
 997         convttf(path, outfile, ttc_index);
 998     }
 999     else { /* convert all fonts */
1000         print_ttc_table(path);
1001         for(i = 0; i < ttcname.ttc_count; i++)
1002         {
1003             snprintf(outfile, sizeof(outfile), "%d-%s.fnt",
1004                      pixel_size, ttcname.ttf_name[i]);
1005             convttf(path, outfile, i);
1006         }
1007     }
1008
1009     for(i = 0; i < ttcname.ttc_count; i++)
1010     {
1011         free(ttcname.ttf_name[i]);
1012     }
1013     free(ttcname.ttf_name);
1014 }
1015
1016
1017
1018 /* parse command line options*/
1019 void getopts(int *pac, char ***pav)
1020 {
1021     char *p;
1022     char **av;
1023     int ac;
1024     ac = *pac;
1025     av = *pav;
1026
1027     limit_char  = max_char;
1028     start_char  = 0;
1029
1030     while (ac > 0 && av[0][0] == '-') {
1031         p = &av[0][1];
1032         while( *p)
1033             switch(*p++) {
1034             case 'h':case 'H':
1035                 usage();
1036                 break;
1037             case ' ':           /* multiple -args on av[]*/
1038                 while( *p && *p == ' ')
1039                     p++;
1040                 if( *p++ != '-')    /* next option must have dash*/
1041                     p = "";
1042                 break;          /* proceed to next option*/
1043             case 'o':       /* set output file*/
1044                 oflag = 1;
1045                 if (*p) {
1046                     strcpy(outfile, p);
1047                     while (*p && *p != ' ')
1048                         p++;
1049                 }
1050                 else {
1051                     av++; ac--;
1052                     if (ac > 0)
1053                         strcpy(outfile, av[0]);
1054                 }
1055                 break;
1056             case 'l':       /* set encoding limit*/
1057                 if (*p) {
1058                     limit_char = atoi(p);
1059                     while (*p && *p != ' ')
1060                         p++;
1061                 }
1062                 else {
1063                     av++; ac--;
1064                     if (ac > 0)
1065                         limit_char = atoi(av[0]);
1066                 }
1067                 break;
1068             case 's':       /* set encoding start*/
1069                 if (*p) {
1070                     start_char = atol(p);
1071                     while (*p && *p != ' ')
1072                         p++;
1073                 }
1074                 else {
1075                     av++; ac--;
1076                     if (ac > 0)
1077                         start_char = atol(av[0]);
1078                 }
1079                 break;
1080             case 'p':       /* set pixel size*/
1081                 if (*p) {
1082                     pixel_size = atoi(p);
1083                     while (*p && *p != ' ')
1084                         p++;
1085                 }
1086                 else {
1087                     av++; ac--;
1088                     if (ac > 0)
1089                         pixel_size = atoi(av[0]);
1090                 }
1091                 break;
1092             case 'c':       /* set spaece between characters */
1093                 {
1094                     if (*p) {
1095                         between_chr = atof(p);
1096                         while (*p && *p != ' ')
1097                             p++;
1098                     }
1099                     else {
1100                         av++; ac--;
1101                         if (ac > 0)
1102                             between_chr = atof(av[0]);
1103                     }
1104                     break;
1105                 }
1106             case 'd':
1107                 dump_glyphs = 1;
1108                 while (*p && *p != ' ')
1109                     p++;
1110                 break;
1111             case 'x':
1112                 trimming = 1;
1113                 while (*p && *p != ' ')
1114                     p++;
1115                 break;
1116             case 'X':
1117                 if (*p) {
1118                     hv_resolution = atoi(p);
1119                     while (*p && *p != ' ')
1120                         p++;
1121                 }
1122                 else {
1123                     av++; ac--;
1124                     if (ac > 0)
1125                         hv_resolution = atoi(av[0]);
1126                 }
1127                 break;
1128             case 'r':
1129                 if (*p) {
1130                     between_row = atof(p);
1131                     while (*p && *p != ' ')
1132                         p++;
1133                 }
1134                 else {
1135                     av++; ac--;
1136                     if (ac > 0)
1137                         between_row = atof(av[0]);
1138                 }
1139                 break;
1140             case 'T':
1141                   if(*p == 'A') {
1142                       if(*(++p)) {
1143                           trim_ap = atoi(p);
1144                           while (*p && *p != ' ')
1145                               p++;
1146                       }
1147                       else {
1148                           av++; ac--;
1149                           if (ac > 0)
1150                               trim_ap = atoi(av[0]);
1151                       }
1152                       break;
1153                   }
1154                   if(*p == 'D') {
1155                       if(*(++p)) {
1156                           trim_dp = atoi(p);
1157                           while (*p && *p != ' ')
1158                               p++;
1159                       }
1160                       else {
1161                           av++; ac--;
1162                           if (ac > 0)
1163                               trim_dp = atoi(av[0]);
1164                       }
1165                       break;
1166                   }
1167                   if(*p == 'a') {
1168                       if(*(++p)) {
1169                           trim_aa = atoi(p);
1170                           while (*p && *p != ' ')
1171                               p++;
1172                       }
1173                       else {
1174                           av++; ac--;
1175                           if (ac > 0)
1176                               trim_aa = atoi(av[0]);
1177                       }
1178                       break;
1179                   }
1180                   if(*p == 'd') {
1181                       if(*(++p)) {
1182                           trim_da = atoi(p);
1183
1184                       }
1185                       else {
1186                           av++; ac--;
1187                           if (ac > 0)
1188                               trim_da = atoi(av[0]);
1189                       }
1190                       break;
1191                   }
1192                   fprintf(stderr, "Unknown option ignored: %s\n", p-1);
1193                   while (*p && *p != ' ')
1194                       p++;
1195                   break;
1196             case 't':     /* display ttc table */
1197                 if (*p == 't') {
1198                     pct = 1;
1199                     while (*p && *p != ' ')
1200                         p++;
1201                 }
1202
1203                 else if (*p == 'a') {
1204                     flg_all_ttc = 1;
1205                     while (*p && *p != ' ')
1206                         p++;
1207                 }
1208
1209                 else if (*p) {
1210                     ttc_index = atoi(p);
1211                     while (*p && *p != ' ')
1212                         p++;
1213                 }
1214                 else {
1215                     av++; ac--;
1216                     if (ac > 0)
1217                         ttc_index = atoi(av[0]);
1218                 }
1219                 break;
1220             case 'w':     /* Don't try to make digits equally wide */
1221                 digits_equally_wide = 0;
1222                 while (*p && *p != ' ')
1223                     p++;
1224                 break;
1225
1226             default:
1227                 fprintf(stderr, "Unknown option ignored: %s\n", p-1);
1228                 while (*p && *p != ' ')
1229                     p++;
1230             }
1231         ++av; --ac;
1232     }
1233     *pac = ac;
1234     *pav = av;
1235 }
1236
1237
1238 int main(int ac, char **av)
1239 {
1240     int ret = 0;
1241
1242     ++av; --ac;     /* skip av[0]*/
1243
1244     getopts(&ac, &av);  /* read command line options*/
1245
1246     if (ac < 1)
1247     {
1248         usage();
1249     }
1250     if (oflag)
1251     {
1252         if (ac > 1)
1253         {
1254             usage();
1255         }
1256     }
1257
1258     if (limit_char < start_char)
1259     {
1260         usage();
1261         exit(0);
1262     }
1263
1264     while (pct && ac > 0)
1265     {
1266         print_ttc_table(av[0]);
1267         ++av; --ac;
1268         exit(0);
1269     }
1270
1271     while (ac > 0)
1272     {
1273         convttc(av[0]);
1274         ++av; --ac;
1275     }
1276
1277     exit(ret);
1278 }
1279
1280
1281
1282 /*
1283  * Trie node structure.
1284  */
1285 typedef struct {
1286     unsigned short key; /* Key value.                   */
1287     unsigned short val; /* Data for the key.                */
1288     unsigned long sibs; /* Offset of siblings from trie beginning.  */
1289     unsigned long kids; /* Offset of children from trie beginning.  */
1290 } node_t;
1291
1292 /*
1293  * The trie used for remapping codes.
1294  */
1295 static node_t *nodes;
1296 static unsigned long nodes_used = 0;
1297
1298 int
1299 otf2bdf_remap(unsigned short *code)
1300 {
1301     unsigned long i, n, t;
1302     unsigned short c, codes[2];
1303
1304     /*
1305      * If no mapping table was loaded, then simply return the code.
1306      */
1307     if (nodes_used == 0)
1308       return 1;
1309
1310     c = *code;
1311     codes[0] = (c >> 8) & 0xff;
1312     codes[1] = c & 0xff;
1313
1314     for (i = n = 0; i < 2; i++) {
1315         t = nodes[n].kids;
1316         if (t == 0)
1317           return 0;
1318         for (; nodes[t].sibs && nodes[t].key != codes[i]; t = nodes[t].sibs);
1319         if (nodes[t].key != codes[i])
1320           return 0;
1321         n = t;
1322     }
1323
1324     *code = nodes[n].val;
1325     return 1;
1326 }