sfnt2fnt.c 28.7 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
/*
 * sfnttofnt.  Bitmap only ttf to Window fnt file converter
 *
 * Copyright 2004 Huw Davies
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
18
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 20 21
 */

#include "config.h"
22
#include "wine/port.h"
23 24 25

#include <assert.h>
#include <ctype.h>
26
#include <errno.h>
27
#include <signal.h>
28
#include <stdio.h>
29
#include <stdlib.h>
30 31 32
#ifdef HAVE_GETOPT_H
# include <getopt.h>
#endif
33 34 35 36 37 38 39 40 41

#ifdef HAVE_FREETYPE

#ifdef HAVE_FT2BUILD_H
#include <ft2build.h>
#endif
#include FT_FREETYPE_H
#include FT_SFNT_NAMES_H
#include FT_TRUETYPE_TABLES_H
42
#include FT_TRUETYPE_TAGS_H
43

44
#define WINE_UNICODE_API /* nothing */
45 46
#include "wine/unicode.h"
#include "wingdi.h"
47
#include "basetsd.h"
48

49
#include "pshpack1.h"
50

51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87
typedef struct
{
    INT16 dfType;
    INT16 dfPoints;
    INT16 dfVertRes;
    INT16 dfHorizRes;
    INT16 dfAscent;
    INT16 dfInternalLeading;
    INT16 dfExternalLeading;
    BYTE  dfItalic;
    BYTE  dfUnderline;
    BYTE  dfStrikeOut;
    INT16 dfWeight;
    BYTE  dfCharSet;
    INT16 dfPixWidth;
    INT16 dfPixHeight;
    BYTE  dfPitchAndFamily;
    INT16 dfAvgWidth;
    INT16 dfMaxWidth;
    BYTE  dfFirstChar;
    BYTE  dfLastChar;
    BYTE  dfDefaultChar;
    BYTE  dfBreakChar;
    INT16 dfWidthBytes;
    LONG  dfDevice;
    LONG  dfFace;
    LONG  dfBitsPointer;
    LONG  dfBitsOffset;
    BYTE  dfReserved;
    LONG  dfFlags;
    INT16 dfAspace;
    INT16 dfBspace;
    INT16 dfCspace;
    LONG  dfColorPointer;
    LONG  dfReserved1[4];
} FONTINFO16;

88 89 90 91 92
typedef struct
{
    WORD dfVersion;
    DWORD dfSize;
    char dfCopyright[60];
93
    FONTINFO16 fi;
94 95
} FNT_HEADER;

96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
typedef struct
{
    WORD  offset;
    WORD  length;
    WORD  flags;
    WORD  id;
    WORD  handle;
    WORD  usage;
} NE_NAMEINFO;

typedef struct
{
    WORD  type_id;
    WORD  count;
    DWORD resloader;
} NE_TYPEINFO;

#define NE_FFLAGS_SINGLEDATA    0x0001
#define NE_FFLAGS_MULTIPLEDATA  0x0002
#define NE_FFLAGS_WIN32         0x0010
#define NE_FFLAGS_FRAMEBUF      0x0100
#define NE_FFLAGS_CONSOLE       0x0200
#define NE_FFLAGS_GUI           0x0300
#define NE_FFLAGS_SELFLOAD      0x0800
#define NE_FFLAGS_LINKERROR     0x2000
#define NE_FFLAGS_CALLWEP       0x4000
#define NE_FFLAGS_LIBMODULE     0x8000

#define NE_OSFLAGS_WINDOWS      0x02

#define NE_RSCTYPE_FONTDIR            0x8007
#define NE_RSCTYPE_FONT               0x8008
#define NE_RSCTYPE_SCALABLE_FONTPATH  0x80cc

#define NE_SEGFLAGS_DATA        0x0001
#define NE_SEGFLAGS_ALLOCATED   0x0002
#define NE_SEGFLAGS_LOADED      0x0004
#define NE_SEGFLAGS_ITERATED    0x0008
#define NE_SEGFLAGS_MOVEABLE    0x0010
#define NE_SEGFLAGS_SHAREABLE   0x0020
#define NE_SEGFLAGS_PRELOAD     0x0040
#define NE_SEGFLAGS_EXECUTEONLY 0x0080
#define NE_SEGFLAGS_READONLY    0x0080
#define NE_SEGFLAGS_RELOC_DATA  0x0100
#define NE_SEGFLAGS_SELFLOAD    0x0800
#define NE_SEGFLAGS_DISCARDABLE 0x1000
#define NE_SEGFLAGS_32BIT       0x2000

144 145 146 147 148
typedef struct {
    WORD width;
    DWORD offset;
} CHAR_TABLE_ENTRY;

149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183
typedef struct {
    DWORD version;
    ULONG numSizes;
} eblcHeader_t;

typedef struct {
    CHAR ascender;
    CHAR descender;
    BYTE widthMax;
    CHAR caretSlopeNumerator;
    CHAR caretSlopeDenominator;
    CHAR caretOffset;
    CHAR minOriginSB;
    CHAR minAdvanceSB;
    CHAR maxBeforeBL;
    CHAR maxAfterBL;
    CHAR pad1;
    CHAR pad2;
} sbitLineMetrics_t;

typedef struct {
    ULONG indexSubTableArrayOffset;
    ULONG indexTableSize;
    ULONG numberOfIndexSubTables;
    ULONG colorRef;
    sbitLineMetrics_t hori;
    sbitLineMetrics_t vert;
    USHORT startGlyphIndex;
    USHORT endGlyphIndex;
    BYTE ppemX;
    BYTE ppemY;
    BYTE bitDepth;
    CHAR flags;
} bitmapSizeTable_t;

184 185 186 187 188 189 190 191
typedef struct
{
    FT_Int major;
    FT_Int minor;
    FT_Int patch;
} FT_Version_t;
static FT_Version_t FT_Version;

192 193
#include "poppack.h"

194 195 196
#define GET_BE_WORD(ptr)  MAKEWORD( ((BYTE *)(ptr))[1], ((BYTE *)(ptr))[0] )
#define GET_BE_DWORD(ptr) ((DWORD)MAKELONG( GET_BE_WORD(&((WORD *)(ptr))[1]), \
                                            GET_BE_WORD(&((WORD *)(ptr))[0]) ))
197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215
#ifdef WORDS_BIGENDIAN
static WORD byteswap_word(WORD x)
{
    return ( ( (x & 0xff) << 8) |
	     ( (x & 0xff00) >> 8) );
}
static DWORD byteswap_dword(DWORD x)
{
    return ( ( (x & 0xff) << 24) |
	     ( (x & 0xff00) << 8) |
	     ( (x & 0xff0000) >> 8) |
	     ( (x & 0xff000000) >> 24) );
}
# define PUT_LE_WORD(x) byteswap_word(x)
# define PUT_LE_DWORD(x) byteswap_dword(x)
#else
# define PUT_LE_WORD(x) (x)
# define PUT_LE_DWORD(x) (x)
#endif
216

217 218 219 220 221 222 223
struct fontinfo
{
    FNT_HEADER hdr;
    CHAR_TABLE_ENTRY dfCharTable[258];
    BYTE *data;
};

224 225 226 227 228 229 230 231 232 233 234 235
static const BYTE MZ_hdr[] =
{
    'M',  'Z',  0x0d, 0x01, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
    0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00,
    0x0e, 0x1f, 0xba, 0x0e, 0x00, 0xb4, 0x09, 0xcd, 0x21, 0xb8, 0x01, 0x4c, 0xcd, 0x21, 'T',  'h',
    'i',  's',  ' ',  'P',  'r',  'o',  'g',  'r',  'a',  'm',  ' ',  'c',  'a',  'n',  'n',  'o',
    't',  ' ',  'b',  'e',  ' ',  'r',  'u',  'n',  ' ',  'i',  'n',  ' ',  'D',  'O',  'S',  ' ',
    'm',  'o',  'd',  'e',  0x0d, 0x0a, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

236 237 238 239 240 241
static char *option_output;
static int option_defchar = ' ';
static int option_dpi = 96;
static int option_fnt_mode = 0;
static int option_quiet = 0;

242 243
static const char *output_name;

244 245
static FT_Library ft_library;

246
static void usage(char **argv)
247
{
248 249 250 251 252 253 254 255
    fprintf(stderr, "%s [options] input.ttf ppem,enc,avg_width ...\n", argv[0]);
    fprintf(stderr, "Options:\n");
    fprintf(stderr, "  -h       Display help\n" );
    fprintf(stderr, "  -d char  Set the font default char\n" );
    fprintf(stderr, "  -o file  Set output file name\n" );
    fprintf(stderr, "  -q       Quiet mode\n" );
    fprintf(stderr, "  -r dpi   Set resolution in DPI (default: 96)\n" );
    fprintf(stderr, "  -s       Single .fnt file mode\n" );
256 257
}

258 259 260 261
#ifndef __GNUC__
#define __attribute__(X)
#endif

262 263 264 265 266 267
/* atexit handler to cleanup files */
static void cleanup(void)
{
    if (output_name) unlink( output_name );
}

268 269 270 271 272
static void exit_on_signal( int sig )
{
    exit(1);  /* this will call the atexit functions */
}

273 274 275 276 277 278 279 280 281 282 283 284
static void error(const char *s, ...) __attribute__((format (printf, 1, 2)));

static void error(const char *s, ...)
{
    va_list ap;
    va_start(ap, s);
    fprintf(stderr, "Error: ");
    vfprintf(stderr, s, ap);
    va_end(ap);
    exit(1);
}

285 286 287 288 289
static const char *get_face_name( const struct fontinfo *info )
{
    return (const char *)info->data + info->hdr.fi.dfFace - info->hdr.fi.dfBitsOffset;
}

290
static int lookup_charset(int enc)
291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343
{
    /* FIXME: make winelib app and use TranslateCharsetInfo */
    switch(enc) {
    case 1250:
        return EE_CHARSET;
    case 1251:
        return RUSSIAN_CHARSET;
    case 1252:
        return ANSI_CHARSET;
    case 1253:
        return GREEK_CHARSET;
    case 1254:
        return TURKISH_CHARSET;
    case 1255:
        return HEBREW_CHARSET;
    case 1256:
        return ARABIC_CHARSET;
    case 1257:
        return BALTIC_CHARSET;
    case 1258:
        return VIETNAMESE_CHARSET;
    case 437:
    case 737:
    case 775:
    case 850:
    case 852:
    case 855:
    case 857:
    case 860:
    case 861:
    case 862:
    case 863:
    case 864:
    case 865:
    case 866:
    case 869:
        return OEM_CHARSET;
    case 874:
        return THAI_CHARSET;
    case 932:
        return SHIFTJIS_CHARSET;
    case 936:
        return GB2312_CHARSET;
    case 949:
        return HANGUL_CHARSET;
    case 950:
        return CHINESEBIG5_CHARSET;
    }
    fprintf(stderr, "Unknown encoding %d - using OEM_CHARSET\n", enc);

    return OEM_CHARSET;
}

344 345 346 347 348 349 350 351 352
static int get_char(const union cptable *cptable, int enc, int index)
{
    /* Korean has the Won sign in place of '\\' */
    if(enc == 949 && index == '\\')
        return 0x20a9;

    return cptable->sbcs.cp2uni[index];
}

353 354
static struct fontinfo *fill_fontinfo( const char *face_name, int ppem, int enc, int dpi,
                                       unsigned char def_char, int avg_width )
355
{
356
    FT_Face face;
357
    int ascent = 0, il, el, width_bytes = 0, space_size, max_width = 0;
358 359 360
    BYTE left_byte, right_byte, byte;
    DWORD start;
    int i, x, y, x_off, x_end, first_char;
361
    FT_UInt gi;
362 363 364 365
    int num_names;
    const union cptable *cptable;
    FT_SfntName sfntname;
    TT_OS2 *os2;
366 367 368 369
    FT_ULong needed;
    eblcHeader_t *eblc;
    bitmapSizeTable_t *size_table;
    int num_sizes;
370 371 372 373 374
    struct fontinfo *info;
    size_t data_pos;

    if (FT_New_Face(ft_library, face_name, 0, &face)) error( "Cannot open face %s\n", face_name );
    if (FT_Set_Pixel_Sizes(face, ppem, ppem)) error( "cannot set face size to %u\n", ppem );
375

376
    cptable = wine_cp_get_table(enc);
377 378
    if(!cptable)
        error("Can't find codepage %d\n", enc);
379

380
    if(cptable->info.char_size != 1) {
381 382
        /* for double byte charsets we actually want to use cp1252 */
        cptable = wine_cp_get_table(1252);
383 384
        if(!cptable)
            error("Can't find codepage 1252\n");
385 386
    }

387
    assert( face->size->metrics.y_ppem == ppem );
388 389

    needed = 0;
390
    if (FT_Load_Sfnt_Table(face, TTAG_EBLC, 0, NULL, &needed))
391 392 393 394
        fprintf(stderr,"Can't find EBLC table\n");
    else
    {
        eblc = malloc(needed);
395
        FT_Load_Sfnt_Table(face, TTAG_EBLC, 0, (FT_Byte *)eblc, &needed);
396

397
        num_sizes = GET_BE_DWORD(&eblc->numSizes);
398

399 400
        size_table = (bitmapSizeTable_t *)(eblc + 1);
        for(i = 0; i < num_sizes; i++)
401
        {
402
            if( (signed char)size_table->hori.ascender - (signed char)size_table->hori.descender == ppem)
403 404 405 406 407
            {
                ascent = size_table->hori.ascender;
                break;
            }
            size_table++;
408 409
        }

410 411
        free(eblc);
    }
412

413 414 415 416 417 418 419 420 421 422 423
    /* Versions of fontforge prior to early 2006 have incorrect
       ascender values in the eblc table, so we won't find the 
       correct bitmapSizeTable.  In this case use the height of
       the Aring glyph instead. */
    if(ascent == 0) 
    {
        if(FT_Load_Char(face, 0xc5, FT_LOAD_DEFAULT))
            error("Can't find Aring\n");
        ascent = face->glyph->metrics.horiBearingY >> 6;
    }

424
    start = sizeof(FNT_HEADER);
425

426 427
    if(FT_Load_Char(face, 'M', FT_LOAD_DEFAULT))
        error("Can't find M\n");
428 429
    il = ascent - (face->glyph->metrics.height >> 6);

430 431
    /* Hack: Courier has no internal leading, nor do any Chinese or Japanese fonts */
    if(!strcmp(face->family_name, "Courier") || enc == 936 || enc == 950 || enc == 932)
432
        il = 0;
433 434 435
    else if (!strcmp(face->family_name, "Fixedsys"))
        il = 3;

436 437
    /* Japanese System font has an external leading */
    if (!strcmp(face->family_name, "System") && enc == 932)
438 439 440
        el = 2;
    else
        el = 0;
441 442 443

    first_char = FT_Get_First_Char(face, &gi);
    if(first_char == 0xd) /* fontforge's first glyph is 0xd, we'll catch this and skip it */
444 445
        first_char = 32; /* FT_Get_Next_Char for some reason returns too high
                            number in this case */
446

447
    info = calloc( 1, sizeof(*info) );
448

449 450 451
    info->hdr.fi.dfFirstChar = first_char;
    info->hdr.fi.dfLastChar = 0xff;
    start += ((unsigned char)info->hdr.fi.dfLastChar - (unsigned char)info->hdr.fi.dfFirstChar + 3 ) * sizeof(*info->dfCharTable);
452 453 454 455

    num_names = FT_Get_Sfnt_Name_Count(face);
    for(i = 0; i <num_names; i++) {
        FT_Get_Sfnt_Name(face, i, &sfntname);
456 457
        if(sfntname.platform_id == 1 && sfntname.encoding_id == 0 &&
           sfntname.language_id == 0 && sfntname.name_id == 0) {
458 459 460
            size_t len = min( sfntname.string_len, sizeof(info->hdr.dfCopyright)-1 );
            memcpy(info->hdr.dfCopyright, sfntname.string, len);
            info->hdr.dfCopyright[len] = 0;
461
        }
462 463 464 465
    }

    os2 = FT_Get_Sfnt_Table(face, ft_sfnt_os2);
    for(i = first_char; i < 0x100; i++) {
466 467
        int c = get_char(cptable, enc, i);
        gi = FT_Get_Char_Index(face, c);
468
        if(gi == 0 && !option_quiet)
469 470
            fprintf(stderr, "warning: %s %u: missing glyph for char %04x\n",
                    face->family_name, ppem, cptable->sbcs.cp2uni[i]);
471
        if(FT_Load_Char(face, c, FT_LOAD_DEFAULT)) {
472 473 474
            fprintf(stderr, "error loading char %d - bad news!\n", i);
            continue;
        }
475 476
        info->dfCharTable[i].width = face->glyph->metrics.horiAdvance >> 6;
        info->dfCharTable[i].offset = start + (width_bytes * ppem);
477 478 479 480 481 482
        width_bytes += ((face->glyph->metrics.horiAdvance >> 6) + 7) >> 3;
        if(max_width < (face->glyph->metrics.horiAdvance >> 6))
            max_width = face->glyph->metrics.horiAdvance >> 6;
    }
    /* space */
    space_size = (ppem + 3) / 4;
483 484
    info->dfCharTable[i].width = space_size;
    info->dfCharTable[i].offset = start + (width_bytes * ppem);
485 486
    width_bytes += (space_size + 7) >> 3;
    /* sentinel */
487 488 489 490
    info->dfCharTable[++i].width = 0;
    info->dfCharTable[i].offset = start + (width_bytes * ppem);

    info->hdr.fi.dfType = 0;
491
    info->hdr.fi.dfPoints = ((ppem - il - el) * 72 + dpi/2) / dpi;
492 493 494 495 496 497 498 499 500 501 502 503 504
    info->hdr.fi.dfVertRes = dpi;
    info->hdr.fi.dfHorizRes = dpi;
    info->hdr.fi.dfAscent = ascent;
    info->hdr.fi.dfInternalLeading = il;
    info->hdr.fi.dfExternalLeading = el;
    info->hdr.fi.dfItalic = (face->style_flags & FT_STYLE_FLAG_ITALIC) ? 1 : 0;
    info->hdr.fi.dfUnderline = 0;
    info->hdr.fi.dfStrikeOut = 0;
    info->hdr.fi.dfWeight = os2->usWeightClass;
    info->hdr.fi.dfCharSet = lookup_charset(enc);
    info->hdr.fi.dfPixWidth = (face->face_flags & FT_FACE_FLAG_FIXED_WIDTH) ? avg_width : 0;
    info->hdr.fi.dfPixHeight = ppem;
    info->hdr.fi.dfPitchAndFamily = FT_IS_FIXED_WIDTH(face) ? 0 : TMPF_FIXED_PITCH;
505 506
    switch(os2->panose[PAN_FAMILYTYPE_INDEX]) {
    case PAN_FAMILY_SCRIPT:
507
        info->hdr.fi.dfPitchAndFamily |= FF_SCRIPT;
508 509 510
	break;
    case PAN_FAMILY_DECORATIVE:
    case PAN_FAMILY_PICTORIAL:
511
        info->hdr.fi.dfPitchAndFamily |= FF_DECORATIVE;
512 513
	break;
    case PAN_FAMILY_TEXT_DISPLAY:
514 515
        if(info->hdr.fi.dfPitchAndFamily == 0) /* fixed */
	    info->hdr.fi.dfPitchAndFamily = FF_MODERN;
516 517 518 519 520
	else {
	    switch(os2->panose[PAN_SERIFSTYLE_INDEX]) {
	    case PAN_SERIF_NORMAL_SANS:
	    case PAN_SERIF_OBTUSE_SANS:
	    case PAN_SERIF_PERP_SANS:
521
	        info->hdr.fi.dfPitchAndFamily |= FF_SWISS;
522 523
		break;
	    default:
524
	        info->hdr.fi.dfPitchAndFamily |= FF_ROMAN;
525 526 527 528
	    }
	}
	break;
    default:
529
        info->hdr.fi.dfPitchAndFamily |= FF_DONTCARE;
530 531
    }

532
    info->hdr.fi.dfAvgWidth = avg_width;
533
    info->hdr.fi.dfMaxWidth = (enc == 932) ? avg_width * 2 : max_width;
534 535 536
    info->hdr.fi.dfDefaultChar = def_char - info->hdr.fi.dfFirstChar;
    info->hdr.fi.dfBreakChar = ' ' - info->hdr.fi.dfFirstChar;
    info->hdr.fi.dfWidthBytes = (width_bytes + 1) & ~1;
537

538 539 540 541
    info->hdr.fi.dfFace = start + info->hdr.fi.dfWidthBytes * ppem;
    info->hdr.fi.dfBitsOffset = start;
    info->hdr.fi.dfFlags = 0x10; /* DFF_1COLOR */
    info->hdr.fi.dfFlags |= FT_IS_FIXED_WIDTH(face) ? 1 : 2; /* DFF_FIXED : DFF_PROPORTIONAL */
542

543 544 545 546 547
    info->hdr.dfVersion = 0x300;
    info->hdr.dfSize = start + info->hdr.fi.dfWidthBytes * ppem + strlen(face->family_name) + 1;

    info->data = calloc( info->hdr.dfSize - start, 1 );
    data_pos = 0;
548 549

    for(i = first_char; i < 0x100; i++) {
550 551
        int c = get_char(cptable, enc, i);
        if(FT_Load_Char(face, c, FT_LOAD_DEFAULT)) {
552 553
            continue;
        }
554
        assert(info->dfCharTable[i].width == face->glyph->metrics.horiAdvance >> 6);
555

556
        for(x = 0; x < ((info->dfCharTable[i].width + 7) / 8); x++) {
557 558 559
            for(y = 0; y < ppem; y++) {
                if(y < ascent - face->glyph->bitmap_top ||
                   y >=  face->glyph->bitmap.rows + ascent - face->glyph->bitmap_top) {
560
                    info->data[data_pos++] = 0;
561 562 563 564 565
                    continue;
                }
                x_off = face->glyph->bitmap_left / 8;
                x_end = (face->glyph->bitmap_left + face->glyph->bitmap.width - 1) / 8;
                if(x < x_off || x > x_end) {
566
                    info->data[data_pos++] = 0;
567 568 569 570 571 572 573
                    continue;
                }
                if(x == x_off)
                    left_byte = 0;
                else
                    left_byte = face->glyph->bitmap.buffer[(y - (ascent - face->glyph->bitmap_top)) * face->glyph->bitmap.pitch + x - x_off - 1];

574
                /* On the last non-trivial output byte (x == x_end) have we got one or two input bytes */
575 576 577 578 579 580 581
                if(x == x_end && (face->glyph->bitmap_left % 8 != 0) && ((face->glyph->bitmap.width % 8 == 0) || (x != (((face->glyph->bitmap.width) & ~0x7) + face->glyph->bitmap_left) / 8)))
                    right_byte = 0;
                else
                    right_byte = face->glyph->bitmap.buffer[(y - (ascent - face->glyph->bitmap_top)) * face->glyph->bitmap.pitch + x - x_off];

                byte = (left_byte << (8 - (face->glyph->bitmap_left & 7))) & 0xff;
                byte |= ((right_byte >> (face->glyph->bitmap_left & 7)) & 0xff);
582
                info->data[data_pos++] = byte;
583 584 585
            }
        }
    }
586 587
    data_pos += ((space_size + 7) / 8) * ppem;
    if (width_bytes & 1) data_pos += ppem;
588

589 590 591
    memcpy( info->data + data_pos, face->family_name, strlen( face->family_name ));
    data_pos += strlen( face->family_name ) + 1;
    assert( start + data_pos == info->hdr.dfSize );
592

593 594
    FT_Done_Face( face );
    return info;
595 596
}

597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622
static void adjust_fontinfo( FONTINFO16 * fi )
{
    fi->dfType = PUT_LE_WORD(fi->dfType);
    fi->dfPoints = PUT_LE_WORD(fi->dfPoints);
    fi->dfVertRes = PUT_LE_WORD(fi->dfVertRes);
    fi->dfHorizRes = PUT_LE_WORD(fi->dfHorizRes);
    fi->dfAscent = PUT_LE_WORD(fi->dfAscent);
    fi->dfInternalLeading = PUT_LE_WORD(fi->dfInternalLeading);
    fi->dfExternalLeading = PUT_LE_WORD(fi->dfExternalLeading);
    fi->dfWeight = PUT_LE_WORD(fi->dfWeight);
    fi->dfPixWidth = PUT_LE_WORD(fi->dfPixWidth);
    fi->dfPixHeight = PUT_LE_WORD(fi->dfPixHeight);
    fi->dfAvgWidth = PUT_LE_WORD(fi->dfAvgWidth);
    fi->dfMaxWidth = PUT_LE_WORD(fi->dfMaxWidth);
    fi->dfWidthBytes = PUT_LE_WORD(fi->dfWidthBytes);
    fi->dfAspace = PUT_LE_WORD(fi->dfAspace);
    fi->dfBspace = PUT_LE_WORD(fi->dfBspace);
    fi->dfCspace = PUT_LE_WORD(fi->dfCspace);
    fi->dfDevice = PUT_LE_DWORD(fi->dfDevice);
    fi->dfFace = PUT_LE_DWORD(fi->dfFace);
    fi->dfBitsPointer = PUT_LE_DWORD(fi->dfBitsPointer);
    fi->dfBitsOffset = PUT_LE_DWORD(fi->dfBitsOffset);
    fi->dfFlags = PUT_LE_DWORD(fi->dfFlags);
    fi->dfColorPointer = PUT_LE_DWORD(fi->dfColorPointer);
}

623 624
static void write_fontinfo( const struct fontinfo *info, FILE *fp )
{
625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640
    FNT_HEADER tmp_hdr;
    int num_chars, i;
    CHAR_TABLE_ENTRY tmp_chartable[258];
    memcpy(&tmp_hdr, &info->hdr, sizeof(info->hdr));
    tmp_hdr.dfVersion = PUT_LE_WORD(tmp_hdr.dfVersion);
    tmp_hdr.dfSize = PUT_LE_DWORD(tmp_hdr.dfSize);
    adjust_fontinfo(&(tmp_hdr.fi));
    fwrite( &tmp_hdr, sizeof(info->hdr), 1, fp );
    num_chars = ((unsigned char)info->hdr.fi.dfLastChar - (unsigned char)info->hdr.fi.dfFirstChar) + 3;

    memcpy(&tmp_chartable, info->dfCharTable + info->hdr.fi.dfFirstChar, num_chars * sizeof(CHAR_TABLE_ENTRY));
    for (i=0; i < num_chars; ++i) {
        tmp_chartable[i].width = PUT_LE_WORD(tmp_chartable[i].width);
        tmp_chartable[i].offset = PUT_LE_DWORD(tmp_chartable[i].offset);
    }
    fwrite( tmp_chartable, sizeof(CHAR_TABLE_ENTRY), num_chars, fp );
641 642
    fwrite( info->data, info->hdr.dfSize - info->hdr.fi.dfBitsOffset, 1, fp );
}
643

644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678
/* parse options from the argv array and remove all the recognized ones */
static char **parse_options( int argc, char **argv )
{
    int optc;

    while ((optc = getopt( argc, argv, "d:ho:qr:s" )) != -1)
    {
        switch(optc)
        {
        case 'd':
            option_defchar = atoi( optarg );
            break;
        case 'o':
            option_output = strdup( optarg );
            break;
        case 'q':
            option_quiet = 1;
            break;
        case 'r':
            option_dpi = atoi( optarg );
            break;
        case 's':
            option_fnt_mode = 1;
            break;
        case 'h':
            usage(argv);
            exit(0);
        case '?':
            usage(argv);
            exit(1);
        }
    }
    return &argv[optind];
}

679 680
int main(int argc, char **argv)
{
681 682 683 684 685 686 687 688 689 690 691 692 693
    int i, j;
    FILE *ofp;
    short align, num_files;
    int resource_table_len, non_resident_name_len, resident_name_len;
    unsigned short resource_table_off, resident_name_off, module_ref_off, non_resident_name_off, fontdir_off, font_off;
    char resident_name[200];
    int fontdir_len = 2;
    char non_resident_name[200];
    unsigned short first_res = 0x0050, pad, res;
    IMAGE_OS2_HEADER NE_hdr;
    NE_TYPEINFO rc_type;
    NE_NAMEINFO rc_name;
    struct fontinfo **info;
694 695
    char *input_file;
    char **args;
696
    short tmp16;
697

698 699 700 701 702
    args = parse_options( argc, argv );

    input_file = *args++;
    if (!input_file || !*args)
    {
703
        usage(argv);
704
        exit(1);
705 706
    }

707
    if(FT_Init_FreeType(&ft_library))
708
        error("ft init failure\n");
709

710
    FT_Version.major=FT_Version.minor=FT_Version.patch=-1;
711
    FT_Library_Version(ft_library,&FT_Version.major,&FT_Version.minor,&FT_Version.patch);
712

713 714 715 716 717 718
    num_files = 0;
    while (args[num_files]) num_files++;

    if (option_fnt_mode && num_files > 1)
        error( "can only specify one font in .fnt mode\n" );

719 720
    info = malloc( num_files * sizeof(*info) );
    for (i = 0; i < num_files; i++)
721
    {
722
        int ppem, enc, avg_width;
723 724
        const char *name;

725
        if (sscanf( args[i], "%d,%d,%d", &ppem, &enc, &avg_width ) != 3)
726 727 728 729
        {
            usage(argv);
            exit(1);
        }
730 731
        if (!(info[i] = fill_fontinfo( input_file, ppem, enc, option_dpi, option_defchar, avg_width )))
            exit(1);
732 733 734 735 736 737 738 739 740 741 742

        name = get_face_name( info[i] );
        fontdir_len += 0x74 + strlen(name) + 1;
        if(i == 0) {
            sprintf(non_resident_name, "FONTRES 100,%d,%d : %s %d",
                    info[i]->hdr.fi.dfVertRes, info[i]->hdr.fi.dfHorizRes,
                    name, info[i]->hdr.fi.dfPoints );
            strcpy(resident_name, name);
        } else {
            sprintf(non_resident_name + strlen(non_resident_name), ",%d", info[i]->hdr.fi.dfPoints );
        }
743 744
    }

745
    if (option_dpi <= 108)
746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762
        strcat(non_resident_name, " (VGA res)");
    else
        strcat(non_resident_name, " (8514 res)");
    non_resident_name_len = strlen(non_resident_name) + 4;

    /* shift count + fontdir entry + num_files of font + nul type + \007FONTDIR */
    resource_table_len = sizeof(align) + sizeof("FONTDIR") +
                         sizeof(NE_TYPEINFO) + sizeof(NE_NAMEINFO) +
                         sizeof(NE_TYPEINFO) + sizeof(NE_NAMEINFO) * num_files +
                         sizeof(NE_TYPEINFO);
    resource_table_off = sizeof(NE_hdr);
    resident_name_off = resource_table_off + resource_table_len;
    resident_name_len = strlen(resident_name) + 4;
    module_ref_off = resident_name_off + resident_name_len;
    non_resident_name_off = sizeof(MZ_hdr) + module_ref_off + sizeof(align);

    memset(&NE_hdr, 0, sizeof(NE_hdr));
763
    NE_hdr.ne_magic = PUT_LE_WORD(0x454e);
764 765
    NE_hdr.ne_ver = 5;
    NE_hdr.ne_rev = 1;
766 767 768 769 770 771 772
    NE_hdr.ne_flags = PUT_LE_WORD(NE_FFLAGS_LIBMODULE | NE_FFLAGS_GUI);
    NE_hdr.ne_cbnrestab = PUT_LE_WORD(non_resident_name_len);
    NE_hdr.ne_segtab = PUT_LE_WORD(sizeof(NE_hdr));
    NE_hdr.ne_rsrctab = PUT_LE_WORD(sizeof(NE_hdr));
    NE_hdr.ne_restab = PUT_LE_WORD(resident_name_off);
    NE_hdr.ne_modtab = PUT_LE_WORD(module_ref_off);
    NE_hdr.ne_imptab = PUT_LE_WORD(module_ref_off);
773
    NE_hdr.ne_enttab = NE_hdr.ne_modtab;
774 775
    NE_hdr.ne_nrestab = PUT_LE_DWORD(non_resident_name_off);
    NE_hdr.ne_align = PUT_LE_WORD(4);
776
    NE_hdr.ne_exetyp = NE_OSFLAGS_WINDOWS;
777
    NE_hdr.ne_expver = PUT_LE_WORD(0x400);
778 779 780

    fontdir_off = (non_resident_name_off + non_resident_name_len + 15) & ~0xf;
    font_off = (fontdir_off + fontdir_len + 15) & ~0x0f;
781

782
    atexit( cleanup );
783 784 785 786 787 788
    signal( SIGTERM, exit_on_signal );
    signal( SIGINT, exit_on_signal );
#ifdef SIGHUP
    signal( SIGHUP, exit_on_signal );
#endif

789
    if (!option_output)  /* build a default output name */
790
    {
791 792 793 794 795 796 797 798
        char *p = strrchr( input_file, '/' );
        if (p) p++;
        else p = input_file;
        option_output = malloc( strlen(p) + sizeof(".fon") );
        strcpy( option_output, p );
        p = strrchr( option_output, '.' );
        if (!p) p = option_output + strlen(option_output);
        strcpy( p, option_fnt_mode ? ".fnt" : ".fon" );
799 800
    }

801
    if (!(ofp = fopen(option_output, "wb")))
802
    {
803
        perror( option_output );
804 805
        exit(1);
    }
806 807 808 809 810 811
    output_name = option_output;
    if (option_fnt_mode)
    {
        write_fontinfo( info[0], ofp );
        goto done;
    }
812 813 814 815

    fwrite(MZ_hdr, sizeof(MZ_hdr), 1, ofp);
    fwrite(&NE_hdr, sizeof(NE_hdr), 1, ofp);

816
    align = PUT_LE_WORD(4);
817 818
    fwrite(&align, sizeof(align), 1, ofp);

819 820
    rc_type.type_id = PUT_LE_WORD(NE_RSCTYPE_FONTDIR);
    rc_type.count = PUT_LE_WORD(1);
821 822 823
    rc_type.resloader = 0;
    fwrite(&rc_type, sizeof(rc_type), 1, ofp);

824 825 826 827
    rc_name.offset = PUT_LE_WORD(fontdir_off >> 4);
    rc_name.length = PUT_LE_WORD((fontdir_len + 15) >> 4);
    rc_name.flags = PUT_LE_WORD(NE_SEGFLAGS_MOVEABLE | NE_SEGFLAGS_PRELOAD);
    rc_name.id = PUT_LE_WORD(resident_name_off - sizeof("FONTDIR") - sizeof(NE_hdr));
828 829 830 831
    rc_name.handle = 0;
    rc_name.usage = 0;
    fwrite(&rc_name, sizeof(rc_name), 1, ofp);

832 833
    rc_type.type_id = PUT_LE_WORD(NE_RSCTYPE_FONT);
    rc_type.count = PUT_LE_WORD(num_files);
834 835 836 837 838 839
    rc_type.resloader = 0;
    fwrite(&rc_type, sizeof(rc_type), 1, ofp);

    for(res = first_res | 0x8000, i = 0; i < num_files; i++, res++) {
        int len = (info[i]->hdr.dfSize + 15) & ~0xf;

840 841 842 843
        rc_name.offset = PUT_LE_WORD(font_off >> 4);
        rc_name.length = PUT_LE_WORD(len >> 4);
        rc_name.flags = PUT_LE_WORD(NE_SEGFLAGS_MOVEABLE | NE_SEGFLAGS_SHAREABLE | NE_SEGFLAGS_DISCARDABLE);
        rc_name.id = PUT_LE_WORD(res);
844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878
        rc_name.handle = 0;
        rc_name.usage = 0;
        fwrite(&rc_name, sizeof(rc_name), 1, ofp);

        font_off += len;
    }

    /* empty type info */
    memset(&rc_type, 0, sizeof(rc_type));
    fwrite(&rc_type, sizeof(rc_type), 1, ofp);

    fputc(strlen("FONTDIR"), ofp);
    fwrite("FONTDIR", strlen("FONTDIR"), 1, ofp);
    fputc(strlen(resident_name), ofp);
    fwrite(resident_name, strlen(resident_name), 1, ofp);

    fputc(0x00, ofp);    fputc(0x00, ofp);
    fputc(0x00, ofp);
    fputc(0x00, ofp);    fputc(0x00, ofp);

    fputc(strlen(non_resident_name), ofp);
    fwrite(non_resident_name, strlen(non_resident_name), 1, ofp);
    fputc(0x00, ofp); /* terminator */

    /* empty ne_modtab and ne_imptab */
    fputc(0x00, ofp);
    fputc(0x00, ofp);

    pad = ftell(ofp) & 0xf;
    if(pad != 0)
        pad = 0x10 - pad;
    for(i = 0; i < pad; i++)
        fputc(0x00, ofp);

    /* FONTDIR resource */
879 880
    tmp16 = PUT_LE_WORD(num_files);
    fwrite(&tmp16, sizeof(tmp16), 1, ofp);
881 882

    for(res = first_res, i = 0; i < num_files; i++, res++) {
883 884
        FNT_HEADER tmp_hdr;
        int sz;
885
        const char *name = get_face_name( info[i] );
886 887 888 889 890 891 892 893
        tmp16 = PUT_LE_WORD(res);
        fwrite(&tmp16, sizeof(tmp16), 1, ofp);
        sz = FIELD_OFFSET(FNT_HEADER,fi.dfBitsOffset);
        memcpy(&tmp_hdr, &info[i]->hdr, sz);
        tmp_hdr.dfVersion = PUT_LE_WORD(tmp_hdr.dfVersion);
        tmp_hdr.dfSize = PUT_LE_DWORD(tmp_hdr.dfSize);
        adjust_fontinfo(&(tmp_hdr.fi));
        fwrite(&tmp_hdr, FIELD_OFFSET(FNT_HEADER,fi.dfBitsOffset), 1, ofp);
894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911
        fputc(0x00, ofp);
        fwrite(name, strlen(name) + 1, 1, ofp);
    }

    pad = ftell(ofp) & 0xf;
    if(pad != 0)
        pad = 0x10 - pad;
    for(i = 0; i < pad; i++)
        fputc(0x00, ofp);

    for(res = first_res, i = 0; i < num_files; i++, res++) {
        write_fontinfo( info[i], ofp );
        pad = info[i]->hdr.dfSize & 0xf;
        if(pad != 0)
            pad = 0x10 - pad;
        for(j = 0; j < pad; j++)
            fputc(0x00, ofp);
    }
912
done:
913
    fclose(ofp);
914
    output_name = NULL;
915 916 917 918 919 920 921
    exit(0);
}

#else /* HAVE_FREETYPE */

int main(int argc, char **argv)
{
922
    fprintf( stderr, "%s needs to be built with FreeType support\n", argv[0] );
923 924 925 926
    exit(1);
}

#endif /* HAVE_FREETYPE */