?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
rpcrt4/tests: Use standard wine_dbgstr_longlong.
[wine.git] / tools / sfnt2fon / sfnt2fon.c
blobea915dac4ccc90843bddcd5bf352b586f4e77080
1 /*
2 * sfnt2fon. Bitmap-only ttf to Windows font file converter
3 *
4 * Copyright 2004 Huw Davies
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * 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 #include <assert.h>
25 #include <ctype.h>
26 #include <errno.h>
27 #include <signal.h>
28 #include <stdio.h>
29 #include <stdlib.h>
30 #ifdef HAVE_GETOPT_H
31 # include <getopt.h>
32 #endif
33
34 #ifdef HAVE_FREETYPE
35
36 #ifdef HAVE_FT2BUILD_H
37 #include <ft2build.h>
38 #endif
39 #include FT_FREETYPE_H
40 #include FT_SFNT_NAMES_H
41 #include FT_TRUETYPE_TABLES_H
42 #include FT_TRUETYPE_TAGS_H
43
44 #include "wine/unicode.h"
45 #include "wingdi.h"
46 #include "basetsd.h"
47
48 #include "pshpack1.h"
49
50 typedef struct
51 {
52 INT16 dfType;
53 INT16 dfPoints;
54 INT16 dfVertRes;
55 INT16 dfHorizRes;
56 INT16 dfAscent;
57 INT16 dfInternalLeading;
58 INT16 dfExternalLeading;
59 BYTE dfItalic;
60 BYTE dfUnderline;
61 BYTE dfStrikeOut;
62 INT16 dfWeight;
63 BYTE dfCharSet;
64 INT16 dfPixWidth;
65 INT16 dfPixHeight;
66 BYTE dfPitchAndFamily;
67 INT16 dfAvgWidth;
68 INT16 dfMaxWidth;
69 BYTE dfFirstChar;
70 BYTE dfLastChar;
71 BYTE dfDefaultChar;
72 BYTE dfBreakChar;
73 INT16 dfWidthBytes;
74 LONG dfDevice;
75 LONG dfFace;
76 LONG dfBitsPointer;
77 LONG dfBitsOffset;
78 BYTE dfReserved;
79 LONG dfFlags;
80 INT16 dfAspace;
81 INT16 dfBspace;
82 INT16 dfCspace;
83 LONG dfColorPointer;
84 LONG dfReserved1[4];
85 } FONTINFO16;
86
87 typedef struct
88 {
89 WORD dfVersion;
90 DWORD dfSize;
91 char dfCopyright[60];
92 FONTINFO16 fi;
93 } FNT_HEADER;
94
95 typedef struct
96 {
97 WORD offset;
98 WORD length;
99 WORD flags;
100 WORD id;
101 WORD handle;
102 WORD usage;
103 } NE_NAMEINFO;
104
105 typedef struct
106 {
107 WORD type_id;
108 WORD count;
109 DWORD resloader;
110 } NE_TYPEINFO;
111
112 #define NE_FFLAGS_SINGLEDATA 0x0001
113 #define NE_FFLAGS_MULTIPLEDATA 0x0002
114 #define NE_FFLAGS_WIN32 0x0010
115 #define NE_FFLAGS_FRAMEBUF 0x0100
116 #define NE_FFLAGS_CONSOLE 0x0200
117 #define NE_FFLAGS_GUI 0x0300
118 #define NE_FFLAGS_SELFLOAD 0x0800
119 #define NE_FFLAGS_LINKERROR 0x2000
120 #define NE_FFLAGS_CALLWEP 0x4000
121 #define NE_FFLAGS_LIBMODULE 0x8000
122
123 #define NE_OSFLAGS_WINDOWS 0x02
124
125 #define NE_RSCTYPE_FONTDIR 0x8007
126 #define NE_RSCTYPE_FONT 0x8008
127 #define NE_RSCTYPE_SCALABLE_FONTPATH 0x80cc
128
129 #define NE_SEGFLAGS_DATA 0x0001
130 #define NE_SEGFLAGS_ALLOCATED 0x0002
131 #define NE_SEGFLAGS_LOADED 0x0004
132 #define NE_SEGFLAGS_ITERATED 0x0008
133 #define NE_SEGFLAGS_MOVEABLE 0x0010
134 #define NE_SEGFLAGS_SHAREABLE 0x0020
135 #define NE_SEGFLAGS_PRELOAD 0x0040
136 #define NE_SEGFLAGS_EXECUTEONLY 0x0080
137 #define NE_SEGFLAGS_READONLY 0x0080
138 #define NE_SEGFLAGS_RELOC_DATA 0x0100
139 #define NE_SEGFLAGS_SELFLOAD 0x0800
140 #define NE_SEGFLAGS_DISCARDABLE 0x1000
141 #define NE_SEGFLAGS_32BIT 0x2000
142
143 typedef struct {
144 WORD width;
145 DWORD offset;
146 } CHAR_TABLE_ENTRY;
147
148 typedef struct {
149 DWORD version;
150 ULONG numSizes;
151 } eblcHeader_t;
152
153 typedef struct {
154 CHAR ascender;
155 CHAR descender;
156 BYTE widthMax;
157 CHAR caretSlopeNumerator;
158 CHAR caretSlopeDenominator;
159 CHAR caretOffset;
160 CHAR minOriginSB;
161 CHAR minAdvanceSB;
162 CHAR maxBeforeBL;
163 CHAR maxAfterBL;
164 CHAR pad1;
165 CHAR pad2;
166 } sbitLineMetrics_t;
167
168 typedef struct {
169 ULONG indexSubTableArrayOffset;
170 ULONG indexTableSize;
171 ULONG numberOfIndexSubTables;
172 ULONG colorRef;
173 sbitLineMetrics_t hori;
174 sbitLineMetrics_t vert;
175 USHORT startGlyphIndex;
176 USHORT endGlyphIndex;
177 BYTE ppemX;
178 BYTE ppemY;
179 BYTE bitDepth;
180 CHAR flags;
181 } bitmapSizeTable_t;
182
183 typedef struct
184 {
185 FT_Int major;
186 FT_Int minor;
187 FT_Int patch;
188 } FT_Version_t;
189 static FT_Version_t FT_Version;
190
191 #include "poppack.h"
192
193 #define GET_BE_WORD(ptr) MAKEWORD( ((BYTE *)(ptr))[1], ((BYTE *)(ptr))[0] )
194 #define GET_BE_DWORD(ptr) ((DWORD)MAKELONG( GET_BE_WORD(&((WORD *)(ptr))[1]), \
195 GET_BE_WORD(&((WORD *)(ptr))[0]) ))
196 #ifdef WORDS_BIGENDIAN
197 static WORD byteswap_word(WORD x)
198 {
199 return ( ( (x & 0xff) << 8) |
200 ( (x & 0xff00) >> 8) );
201 }
202 static DWORD byteswap_dword(DWORD x)
203 {
204 return ( ( (x & 0xff) << 24) |
205 ( (x & 0xff00) << 8) |
206 ( (x & 0xff0000) >> 8) |
207 ( (x & 0xff000000) >> 24) );
208 }
209 # define PUT_LE_WORD(x) byteswap_word(x)
210 # define PUT_LE_DWORD(x) byteswap_dword(x)
211 #else
212 # define PUT_LE_WORD(x) (x)
213 # define PUT_LE_DWORD(x) (x)
214 #endif
215
216 struct fontinfo
217 {
218 FNT_HEADER hdr;
219 CHAR_TABLE_ENTRY dfCharTable[258];
220 BYTE *data;
221 };
222
223 static const BYTE MZ_hdr[] =
224 {
225 'M', 'Z', 0x0d, 0x01, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
226 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
227 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
228 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00,
229 0x0e, 0x1f, 0xba, 0x0e, 0x00, 0xb4, 0x09, 0xcd, 0x21, 0xb8, 0x01, 0x4c, 0xcd, 0x21, 'T', 'h',
230 'i', 's', ' ', 'P', 'r', 'o', 'g', 'r', 'a', 'm', ' ', 'c', 'a', 'n', 'n', 'o',
231 't', ' ', 'b', 'e', ' ', 'r', 'u', 'n', ' ', 'i', 'n', ' ', 'D', 'O', 'S', ' ',
232 'm', 'o', 'd', 'e', 0x0d, 0x0a, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
233 };
234
235 static char *option_output;
236 static int option_defchar = ' ';
237 static int option_dpi = 96;
238 static int option_fnt_mode = 0;
239 static int option_quiet = 0;
240
241 static const char *output_name;
242
243 static FT_Library ft_library;
244
245 static void usage(char **argv)
246 {
247 fprintf(stderr, "%s [options] input.ttf ppem,enc,avg_width ...\n", argv[0]);
248 fprintf(stderr, "Options:\n");
249 fprintf(stderr, " -h Display help\n" );
250 fprintf(stderr, " -d char Set the font default char\n" );
251 fprintf(stderr, " -o file Set output file name\n" );
252 fprintf(stderr, " -q Quiet mode\n" );
253 fprintf(stderr, " -r dpi Set resolution in DPI (default: 96)\n" );
254 fprintf(stderr, " -s Single .fnt file mode\n" );
255 }
256
257 #ifndef __GNUC__
258 #define __attribute__(X)
259 #endif
260
261 /* atexit handler to cleanup files */
262 static void cleanup(void)
263 {
264 if (output_name) unlink( output_name );
265 }
266
267 static void exit_on_signal( int sig )
268 {
269 exit(1); /* this will call the atexit functions */
270 }
271
272 static void error(const char *s, ...) __attribute__((format (printf, 1, 2)));
273
274 static void error(const char *s, ...)
275 {
276 va_list ap;
277 va_start(ap, s);
278 fprintf(stderr, "Error: ");
279 vfprintf(stderr, s, ap);
280 va_end(ap);
281 exit(1);
282 }
283
284 static const char *get_face_name( const struct fontinfo *info )
285 {
286 return (const char *)info->data + info->hdr.fi.dfFace - info->hdr.fi.dfBitsOffset;
287 }
288
289 static int lookup_charset(int enc)
290 {
291 /* FIXME: make winelib app and use TranslateCharsetInfo */
292 switch(enc) {
293 case 1250:
294 return EE_CHARSET;
295 case 1251:
296 return RUSSIAN_CHARSET;
297 case 1252:
298 return ANSI_CHARSET;
299 case 1253:
300 return GREEK_CHARSET;
301 case 1254:
302 return TURKISH_CHARSET;
303 case 1255:
304 return HEBREW_CHARSET;
305 case 1256:
306 return ARABIC_CHARSET;
307 case 1257:
308 return BALTIC_CHARSET;
309 case 1258:
310 return VIETNAMESE_CHARSET;
311 case 437:
312 case 737:
313 case 775:
314 case 850:
315 case 852:
316 case 855:
317 case 857:
318 case 860:
319 case 861:
320 case 862:
321 case 863:
322 case 864:
323 case 865:
324 case 866:
325 case 869:
326 return OEM_CHARSET;
327 case 874:
328 return THAI_CHARSET;
329 case 932:
330 return SHIFTJIS_CHARSET;
331 case 936:
332 return GB2312_CHARSET;
333 case 949:
334 return HANGUL_CHARSET;
335 case 950:
336 return CHINESEBIG5_CHARSET;
337 }
338 fprintf(stderr, "Unknown encoding %d - using OEM_CHARSET\n", enc);
339
340 return OEM_CHARSET;
341 }
342
343 static int get_char(const union cptable *cptable, int enc, int index)
344 {
345 /* Korean has the Won sign in place of '\\' */
346 if(enc == 949 && index == '\\')
347 return 0x20a9;
348
349 return cptable->sbcs.cp2uni[index];
350 }
351
352 static struct fontinfo *fill_fontinfo( const char *face_name, int ppem, int enc, int dpi,
353 unsigned char def_char, int avg_width )
354 {
355 FT_Face face;
356 int ascent = 0, il, el, width_bytes = 0, space_size, max_width = 0;
357 BYTE left_byte, right_byte, byte;
358 DWORD start;
359 int i, x, y, x_off, x_end, first_char;
360 FT_UInt gi;
361 int num_names;
362 const union cptable *cptable;
363 FT_SfntName sfntname;
364 TT_OS2 *os2;
365 FT_ULong needed;
366 eblcHeader_t *eblc;
367 bitmapSizeTable_t *size_table;
368 int num_sizes;
369 struct fontinfo *info;
370 size_t data_pos;
371
372 if (FT_New_Face(ft_library, face_name, 0, &face)) error( "Cannot open face %s\n", face_name );
373 if (FT_Set_Pixel_Sizes(face, ppem, ppem)) error( "cannot set face size to %u\n", ppem );
374
375 cptable = wine_cp_get_table(enc);
376 if(!cptable)
377 error("Can't find codepage %d\n", enc);
378
379 if(cptable->info.char_size != 1) {
380 /* for double byte charsets we actually want to use cp1252 */
381 cptable = wine_cp_get_table(1252);
382 if(!cptable)
383 error("Can't find codepage 1252\n");
384 }
385
386 assert( face->size->metrics.y_ppem == ppem );
387
388 needed = 0;
389 if (FT_Load_Sfnt_Table(face, TTAG_EBLC, 0, NULL, &needed))
390 fprintf(stderr,"Can't find EBLC table\n");
391 else
392 {
393 eblc = malloc(needed);
394 FT_Load_Sfnt_Table(face, TTAG_EBLC, 0, (FT_Byte *)eblc, &needed);
395
396 num_sizes = GET_BE_DWORD(&eblc->numSizes);
397
398 size_table = (bitmapSizeTable_t *)(eblc + 1);
399 for(i = 0; i < num_sizes; i++)
400 {
401 if( (signed char)size_table->hori.ascender - (signed char)size_table->hori.descender == ppem)
402 {
403 ascent = size_table->hori.ascender;
404 break;
405 }
406 size_table++;
407 }
408
409 free(eblc);
410 }
411
412 /* Versions of fontforge prior to early 2006 have incorrect
413 ascender values in the eblc table, so we won't find the
414 correct bitmapSizeTable. In this case use the height of
415 the Aring glyph instead. */
416 if(ascent == 0)
417 {
418 if(FT_Load_Char(face, 0xc5, FT_LOAD_DEFAULT))
419 error("Can't find Aring\n");
420 ascent = face->glyph->metrics.horiBearingY >> 6;
421 }
422
423 start = sizeof(FNT_HEADER);
424
425 if(FT_Load_Char(face, 'M', FT_LOAD_DEFAULT))
426 error("Can't find M\n");
427 il = ascent - (face->glyph->metrics.height >> 6);
428
429 /* Hack: Courier has no internal leading, nor do any Chinese or Japanese fonts */
430 if(!strcmp(face->family_name, "Courier") || enc == 936 || enc == 950 || enc == 932)
431 il = 0;
432 else if (!strcmp(face->family_name, "Fixedsys"))
433 il = 3;
434
435 /* Japanese System font has an external leading */
436 if (!strcmp(face->family_name, "System") && enc == 932)
437 el = 2;
438 else
439 el = 0;
440
441 first_char = FT_Get_First_Char(face, &gi);
442 if(first_char == 0xd) /* fontforge's first glyph is 0xd, we'll catch this and skip it */
443 first_char = 32; /* FT_Get_Next_Char for some reason returns too high
444 number in this case */
445
446 info = calloc( 1, sizeof(*info) );
447
448 info->hdr.fi.dfFirstChar = first_char;
449 info->hdr.fi.dfLastChar = 0xff;
450 start += ((unsigned char)info->hdr.fi.dfLastChar - (unsigned char)info->hdr.fi.dfFirstChar + 3 ) * sizeof(*info->dfCharTable);
451
452 num_names = FT_Get_Sfnt_Name_Count(face);
453 for(i = 0; i <num_names; i++) {
454 FT_Get_Sfnt_Name(face, i, &sfntname);
455 if(sfntname.platform_id == 1 && sfntname.encoding_id == 0 &&
456 sfntname.language_id == 0 && sfntname.name_id == 0) {
457 size_t len = min( sfntname.string_len, sizeof(info->hdr.dfCopyright)-1 );
458 memcpy(info->hdr.dfCopyright, sfntname.string, len);
459 info->hdr.dfCopyright[len] = 0;
460 }
461 }
462
463 os2 = FT_Get_Sfnt_Table(face, ft_sfnt_os2);
464 for(i = first_char; i < 0x100; i++) {
465 int c = get_char(cptable, enc, i);
466 gi = FT_Get_Char_Index(face, c);
467 if(gi == 0 && !option_quiet)
468 fprintf(stderr, "warning: %s %u: missing glyph for char %04x\n",
469 face->family_name, ppem, cptable->sbcs.cp2uni[i]);
470 if(FT_Load_Char(face, c, FT_LOAD_DEFAULT)) {
471 fprintf(stderr, "error loading char %d - bad news!\n", i);
472 continue;
473 }
474 info->dfCharTable[i].width = face->glyph->metrics.horiAdvance >> 6;
475 info->dfCharTable[i].offset = start + (width_bytes * ppem);
476 width_bytes += ((face->glyph->metrics.horiAdvance >> 6) + 7) >> 3;
477 if(max_width < (face->glyph->metrics.horiAdvance >> 6))
478 max_width = face->glyph->metrics.horiAdvance >> 6;
479 }
480 /* space */
481 space_size = (ppem + 3) / 4;
482 info->dfCharTable[i].width = space_size;
483 info->dfCharTable[i].offset = start + (width_bytes * ppem);
484 width_bytes += (space_size + 7) >> 3;
485 /* sentinel */
486 info->dfCharTable[++i].width = 0;
487 info->dfCharTable[i].offset = start + (width_bytes * ppem);
488
489 info->hdr.fi.dfType = 0;
490 info->hdr.fi.dfPoints = ((ppem - il - el) * 72 + dpi/2) / dpi;
491 info->hdr.fi.dfVertRes = dpi;
492 info->hdr.fi.dfHorizRes = dpi;
493 info->hdr.fi.dfAscent = ascent;
494 info->hdr.fi.dfInternalLeading = il;
495 info->hdr.fi.dfExternalLeading = el;
496 info->hdr.fi.dfItalic = (face->style_flags & FT_STYLE_FLAG_ITALIC) ? 1 : 0;
497 info->hdr.fi.dfUnderline = 0;
498 info->hdr.fi.dfStrikeOut = 0;
499 info->hdr.fi.dfWeight = os2->usWeightClass;
500 info->hdr.fi.dfCharSet = lookup_charset(enc);
501 info->hdr.fi.dfPixWidth = (face->face_flags & FT_FACE_FLAG_FIXED_WIDTH) ? avg_width : 0;
502 info->hdr.fi.dfPixHeight = ppem;
503 info->hdr.fi.dfPitchAndFamily = FT_IS_FIXED_WIDTH(face) ? 0 : TMPF_FIXED_PITCH;
504 switch(os2->panose[PAN_FAMILYTYPE_INDEX]) {
505 case PAN_FAMILY_SCRIPT:
506 info->hdr.fi.dfPitchAndFamily |= FF_SCRIPT;
507 break;
508 case PAN_FAMILY_DECORATIVE:
509 case PAN_FAMILY_PICTORIAL:
510 info->hdr.fi.dfPitchAndFamily |= FF_DECORATIVE;
511 break;
512 case PAN_FAMILY_TEXT_DISPLAY:
513 if(info->hdr.fi.dfPitchAndFamily == 0) /* fixed */
514 info->hdr.fi.dfPitchAndFamily = FF_MODERN;
515 else {
516 switch(os2->panose[PAN_SERIFSTYLE_INDEX]) {
517 case PAN_SERIF_NORMAL_SANS:
518 case PAN_SERIF_OBTUSE_SANS:
519 case PAN_SERIF_PERP_SANS:
520 info->hdr.fi.dfPitchAndFamily |= FF_SWISS;
521 break;
522 default:
523 info->hdr.fi.dfPitchAndFamily |= FF_ROMAN;
524 }
525 }
526 break;
527 default:
528 info->hdr.fi.dfPitchAndFamily |= FF_DONTCARE;
529 }
530
531 info->hdr.fi.dfAvgWidth = avg_width;
532 info->hdr.fi.dfMaxWidth = (enc == 932) ? avg_width * 2 : max_width;
533 info->hdr.fi.dfDefaultChar = def_char - info->hdr.fi.dfFirstChar;
534 info->hdr.fi.dfBreakChar = ' ' - info->hdr.fi.dfFirstChar;
535 info->hdr.fi.dfWidthBytes = (width_bytes + 1) & ~1;
536
537 info->hdr.fi.dfFace = start + info->hdr.fi.dfWidthBytes * ppem;
538 info->hdr.fi.dfBitsOffset = start;
539 info->hdr.fi.dfFlags = 0x10; /* DFF_1COLOR */
540 info->hdr.fi.dfFlags |= FT_IS_FIXED_WIDTH(face) ? 1 : 2; /* DFF_FIXED : DFF_PROPORTIONAL */
541
542 info->hdr.dfVersion = 0x300;
543 info->hdr.dfSize = start + info->hdr.fi.dfWidthBytes * ppem + strlen(face->family_name) + 1;
544
545 info->data = calloc( info->hdr.dfSize - start, 1 );
546 data_pos = 0;
547
548 for(i = first_char; i < 0x100; i++) {
549 int c = get_char(cptable, enc, i);
550 if(FT_Load_Char(face, c, FT_LOAD_DEFAULT)) {
551 continue;
552 }
553 assert(info->dfCharTable[i].width == face->glyph->metrics.horiAdvance >> 6);
554
555 for(x = 0; x < ((info->dfCharTable[i].width + 7) / 8); x++) {
556 for(y = 0; y < ppem; y++) {
557 if(y < ascent - face->glyph->bitmap_top ||
558 y >= face->glyph->bitmap.rows + ascent - face->glyph->bitmap_top) {
559 info->data[data_pos++] = 0;
560 continue;
561 }
562 x_off = face->glyph->bitmap_left / 8;
563 x_end = (face->glyph->bitmap_left + face->glyph->bitmap.width - 1) / 8;
564 if(x < x_off || x > x_end) {
565 info->data[data_pos++] = 0;
566 continue;
567 }
568 if(x == x_off)
569 left_byte = 0;
570 else
571 left_byte = face->glyph->bitmap.buffer[(y - (ascent - face->glyph->bitmap_top)) * face->glyph->bitmap.pitch + x - x_off - 1];
572
573 /* On the last non-trivial output byte (x == x_end) have we got one or two input bytes */
574 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)))
575 right_byte = 0;
576 else
577 right_byte = face->glyph->bitmap.buffer[(y - (ascent - face->glyph->bitmap_top)) * face->glyph->bitmap.pitch + x - x_off];
578
579 byte = (left_byte << (8 - (face->glyph->bitmap_left & 7))) & 0xff;
580 byte |= ((right_byte >> (face->glyph->bitmap_left & 7)) & 0xff);
581 info->data[data_pos++] = byte;
582 }
583 }
584 }
585 data_pos += ((space_size + 7) / 8) * ppem;
586 if (width_bytes & 1) data_pos += ppem;
587
588 memcpy( info->data + data_pos, face->family_name, strlen( face->family_name ));
589 data_pos += strlen( face->family_name ) + 1;
590 assert( start + data_pos == info->hdr.dfSize );
591
592 FT_Done_Face( face );
593 return info;
594 }
595
596 static void adjust_fontinfo( FONTINFO16 * fi )
597 {
598 fi->dfType = PUT_LE_WORD(fi->dfType);
599 fi->dfPoints = PUT_LE_WORD(fi->dfPoints);
600 fi->dfVertRes = PUT_LE_WORD(fi->dfVertRes);
601 fi->dfHorizRes = PUT_LE_WORD(fi->dfHorizRes);
602 fi->dfAscent = PUT_LE_WORD(fi->dfAscent);
603 fi->dfInternalLeading = PUT_LE_WORD(fi->dfInternalLeading);
604 fi->dfExternalLeading = PUT_LE_WORD(fi->dfExternalLeading);
605 fi->dfWeight = PUT_LE_WORD(fi->dfWeight);
606 fi->dfPixWidth = PUT_LE_WORD(fi->dfPixWidth);
607 fi->dfPixHeight = PUT_LE_WORD(fi->dfPixHeight);
608 fi->dfAvgWidth = PUT_LE_WORD(fi->dfAvgWidth);
609 fi->dfMaxWidth = PUT_LE_WORD(fi->dfMaxWidth);
610 fi->dfWidthBytes = PUT_LE_WORD(fi->dfWidthBytes);
611 fi->dfAspace = PUT_LE_WORD(fi->dfAspace);
612 fi->dfBspace = PUT_LE_WORD(fi->dfBspace);
613 fi->dfCspace = PUT_LE_WORD(fi->dfCspace);
614 fi->dfDevice = PUT_LE_DWORD(fi->dfDevice);
615 fi->dfFace = PUT_LE_DWORD(fi->dfFace);
616 fi->dfBitsPointer = PUT_LE_DWORD(fi->dfBitsPointer);
617 fi->dfBitsOffset = PUT_LE_DWORD(fi->dfBitsOffset);
618 fi->dfFlags = PUT_LE_DWORD(fi->dfFlags);
619 fi->dfColorPointer = PUT_LE_DWORD(fi->dfColorPointer);
620 }
621
622 static void write_fontinfo( const struct fontinfo *info, FILE *fp )
623 {
624 FNT_HEADER tmp_hdr;
625 int num_chars, i;
626 CHAR_TABLE_ENTRY tmp_chartable[258];
627 memcpy(&tmp_hdr, &info->hdr, sizeof(info->hdr));
628 tmp_hdr.dfVersion = PUT_LE_WORD(tmp_hdr.dfVersion);
629 tmp_hdr.dfSize = PUT_LE_DWORD(tmp_hdr.dfSize);
630 adjust_fontinfo(&(tmp_hdr.fi));
631 fwrite( &tmp_hdr, sizeof(info->hdr), 1, fp );
632 num_chars = ((unsigned char)info->hdr.fi.dfLastChar - (unsigned char)info->hdr.fi.dfFirstChar) + 3;
633
634 memcpy(&tmp_chartable, info->dfCharTable + info->hdr.fi.dfFirstChar, num_chars * sizeof(CHAR_TABLE_ENTRY));
635 for (i=0; i < num_chars; ++i) {
636 tmp_chartable[i].width = PUT_LE_WORD(tmp_chartable[i].width);
637 tmp_chartable[i].offset = PUT_LE_DWORD(tmp_chartable[i].offset);
638 }
639 fwrite( tmp_chartable, sizeof(CHAR_TABLE_ENTRY), num_chars, fp );
640 fwrite( info->data, info->hdr.dfSize - info->hdr.fi.dfBitsOffset, 1, fp );
641 }
642
643 /* parse options from the argv array and remove all the recognized ones */
644 static char **parse_options( int argc, char **argv )
645 {
646 int optc;
647
648 while ((optc = getopt_long( argc, argv, "d:ho:qr:s", NULL, NULL )) != -1)
649 {
650 switch(optc)
651 {
652 case 'd':
653 option_defchar = atoi( optarg );
654 break;
655 case 'o':
656 option_output = strdup( optarg );
657 break;
658 case 'q':
659 option_quiet = 1;
660 break;
661 case 'r':
662 option_dpi = atoi( optarg );
663 break;
664 case 's':
665 option_fnt_mode = 1;
666 break;
667 case 'h':
668 usage(argv);
669 exit(0);
670 case '?':
671 usage(argv);
672 exit(1);
673 }
674 }
675 return &argv[optind];
676 }
677
678 int main(int argc, char **argv)
679 {
680 int i, j;
681 FILE *ofp;
682 short align, num_files;
683 int resource_table_len, non_resident_name_len, resident_name_len;
684 unsigned short resource_table_off, resident_name_off, module_ref_off, non_resident_name_off, fontdir_off, font_off;
685 char resident_name[200];
686 int fontdir_len = 2;
687 char non_resident_name[200];
688 unsigned short first_res = 0x0050, pad, res;
689 IMAGE_OS2_HEADER NE_hdr;
690 NE_TYPEINFO rc_type;
691 NE_NAMEINFO rc_name;
692 struct fontinfo **info;
693 char *input_file;
694 char **args;
695 short tmp16;
696
697 args = parse_options( argc, argv );
698
699 input_file = *args++;
700 if (!input_file || !*args)
701 {
702 usage(argv);
703 exit(1);
704 }
705
706 if(FT_Init_FreeType(&ft_library))
707 error("ft init failure\n");
708
709 FT_Version.major=FT_Version.minor=FT_Version.patch=-1;
710 FT_Library_Version(ft_library,&FT_Version.major,&FT_Version.minor,&FT_Version.patch);
711
712 num_files = 0;
713 while (args[num_files]) num_files++;
714
715 if (option_fnt_mode && num_files > 1)
716 error( "can only specify one font in .fnt mode\n" );
717
718 info = malloc( num_files * sizeof(*info) );
719 for (i = 0; i < num_files; i++)
720 {
721 int ppem, enc, avg_width;
722 const char *name;
723
724 if (sscanf( args[i], "%d,%d,%d", &ppem, &enc, &avg_width ) != 3)
725 {
726 usage(argv);
727 exit(1);
728 }
729 if (!(info[i] = fill_fontinfo( input_file, ppem, enc, option_dpi, option_defchar, avg_width )))
730 exit(1);
731
732 name = get_face_name( info[i] );
733 fontdir_len += 0x74 + strlen(name) + 1;
734 if(i == 0) {
735 sprintf(non_resident_name, "FONTRES 100,%d,%d : %s %d",
736 info[i]->hdr.fi.dfVertRes, info[i]->hdr.fi.dfHorizRes,
737 name, info[i]->hdr.fi.dfPoints );
738 strcpy(resident_name, name);
739 } else {
740 sprintf(non_resident_name + strlen(non_resident_name), ",%d", info[i]->hdr.fi.dfPoints );
741 }
742 }
743
744 if (option_dpi <= 108)
745 strcat(non_resident_name, " (VGA res)");
746 else
747 strcat(non_resident_name, " (8514 res)");
748 non_resident_name_len = strlen(non_resident_name) + 4;
749
750 /* shift count + fontdir entry + num_files of font + nul type + \007FONTDIR */
751 resource_table_len = sizeof(align) + sizeof("FONTDIR") +
752 sizeof(NE_TYPEINFO) + sizeof(NE_NAMEINFO) +
753 sizeof(NE_TYPEINFO) + sizeof(NE_NAMEINFO) * num_files +
754 sizeof(NE_TYPEINFO);
755 resource_table_off = sizeof(NE_hdr);
756 resident_name_off = resource_table_off + resource_table_len;
757 resident_name_len = strlen(resident_name) + 4;
758 module_ref_off = resident_name_off + resident_name_len;
759 non_resident_name_off = sizeof(MZ_hdr) + module_ref_off + sizeof(align);
760
761 memset(&NE_hdr, 0, sizeof(NE_hdr));
762 NE_hdr.ne_magic = PUT_LE_WORD(0x454e);
763 NE_hdr.ne_ver = 5;
764 NE_hdr.ne_rev = 1;
765 NE_hdr.ne_flags = PUT_LE_WORD(NE_FFLAGS_LIBMODULE | NE_FFLAGS_GUI);
766 NE_hdr.ne_cbnrestab = PUT_LE_WORD(non_resident_name_len);
767 NE_hdr.ne_segtab = PUT_LE_WORD(sizeof(NE_hdr));
768 NE_hdr.ne_rsrctab = PUT_LE_WORD(sizeof(NE_hdr));
769 NE_hdr.ne_restab = PUT_LE_WORD(resident_name_off);
770 NE_hdr.ne_modtab = PUT_LE_WORD(module_ref_off);
771 NE_hdr.ne_imptab = PUT_LE_WORD(module_ref_off);
772 NE_hdr.ne_enttab = NE_hdr.ne_modtab;
773 NE_hdr.ne_nrestab = PUT_LE_DWORD(non_resident_name_off);
774 NE_hdr.ne_align = PUT_LE_WORD(4);
775 NE_hdr.ne_exetyp = NE_OSFLAGS_WINDOWS;
776 NE_hdr.ne_expver = PUT_LE_WORD(0x400);
777
778 fontdir_off = (non_resident_name_off + non_resident_name_len + 15) & ~0xf;
779 font_off = (fontdir_off + fontdir_len + 15) & ~0x0f;
780
781 atexit( cleanup );
782 signal( SIGTERM, exit_on_signal );
783 signal( SIGINT, exit_on_signal );
784 #ifdef SIGHUP
785 signal( SIGHUP, exit_on_signal );
786 #endif
787
788 if (!option_output) /* build a default output name */
789 {
790 char *p = strrchr( input_file, '/' );
791 if (p) p++;
792 else p = input_file;
793 option_output = malloc( strlen(p) + sizeof(".fon") );
794 strcpy( option_output, p );
795 p = strrchr( option_output, '.' );
796 if (!p) p = option_output + strlen(option_output);
797 strcpy( p, option_fnt_mode ? ".fnt" : ".fon" );
798 }
799
800 if (!(ofp = fopen(option_output, "wb")))
801 {
802 perror( option_output );
803 exit(1);
804 }
805 output_name = option_output;
806 if (option_fnt_mode)
807 {
808 write_fontinfo( info[0], ofp );
809 goto done;
810 }
811
812 fwrite(MZ_hdr, sizeof(MZ_hdr), 1, ofp);
813 fwrite(&NE_hdr, sizeof(NE_hdr), 1, ofp);
814
815 align = PUT_LE_WORD(4);
816 fwrite(&align, sizeof(align), 1, ofp);
817
818 rc_type.type_id = PUT_LE_WORD(NE_RSCTYPE_FONTDIR);
819 rc_type.count = PUT_LE_WORD(1);
820 rc_type.resloader = 0;
821 fwrite(&rc_type, sizeof(rc_type), 1, ofp);
822
823 rc_name.offset = PUT_LE_WORD(fontdir_off >> 4);
824 rc_name.length = PUT_LE_WORD((fontdir_len + 15) >> 4);
825 rc_name.flags = PUT_LE_WORD(NE_SEGFLAGS_MOVEABLE | NE_SEGFLAGS_PRELOAD);
826 rc_name.id = PUT_LE_WORD(resident_name_off - sizeof("FONTDIR") - sizeof(NE_hdr));
827 rc_name.handle = 0;
828 rc_name.usage = 0;
829 fwrite(&rc_name, sizeof(rc_name), 1, ofp);
830
831 rc_type.type_id = PUT_LE_WORD(NE_RSCTYPE_FONT);
832 rc_type.count = PUT_LE_WORD(num_files);
833 rc_type.resloader = 0;
834 fwrite(&rc_type, sizeof(rc_type), 1, ofp);
835
836 for(res = first_res | 0x8000, i = 0; i < num_files; i++, res++) {
837 int len = (info[i]->hdr.dfSize + 15) & ~0xf;
838
839 rc_name.offset = PUT_LE_WORD(font_off >> 4);
840 rc_name.length = PUT_LE_WORD(len >> 4);
841 rc_name.flags = PUT_LE_WORD(NE_SEGFLAGS_MOVEABLE | NE_SEGFLAGS_SHAREABLE | NE_SEGFLAGS_DISCARDABLE);
842 rc_name.id = PUT_LE_WORD(res);
843 rc_name.handle = 0;
844 rc_name.usage = 0;
845 fwrite(&rc_name, sizeof(rc_name), 1, ofp);
846
847 font_off += len;
848 }
849
850 /* empty type info */
851 memset(&rc_type, 0, sizeof(rc_type));
852 fwrite(&rc_type, sizeof(rc_type), 1, ofp);
853
854 fputc(strlen("FONTDIR"), ofp);
855 fwrite("FONTDIR", strlen("FONTDIR"), 1, ofp);
856 fputc(strlen(resident_name), ofp);
857 fwrite(resident_name, strlen(resident_name), 1, ofp);
858
859 fputc(0x00, ofp); fputc(0x00, ofp);
860 fputc(0x00, ofp);
861 fputc(0x00, ofp); fputc(0x00, ofp);
862
863 fputc(strlen(non_resident_name), ofp);
864 fwrite(non_resident_name, strlen(non_resident_name), 1, ofp);
865 fputc(0x00, ofp); /* terminator */
866
867 /* empty ne_modtab and ne_imptab */
868 fputc(0x00, ofp);
869 fputc(0x00, ofp);
870
871 pad = ftell(ofp) & 0xf;
872 if(pad != 0)
873 pad = 0x10 - pad;
874 for(i = 0; i < pad; i++)
875 fputc(0x00, ofp);
876
877 /* FONTDIR resource */
878 tmp16 = PUT_LE_WORD(num_files);
879 fwrite(&tmp16, sizeof(tmp16), 1, ofp);
880
881 for(res = first_res, i = 0; i < num_files; i++, res++) {
882 FNT_HEADER tmp_hdr;
883 int sz;
884 const char *name = get_face_name( info[i] );
885 tmp16 = PUT_LE_WORD(res);
886 fwrite(&tmp16, sizeof(tmp16), 1, ofp);
887 sz = FIELD_OFFSET(FNT_HEADER,fi.dfBitsOffset);
888 memcpy(&tmp_hdr, &info[i]->hdr, sz);
889 tmp_hdr.dfVersion = PUT_LE_WORD(tmp_hdr.dfVersion);
890 tmp_hdr.dfSize = PUT_LE_DWORD(tmp_hdr.dfSize);
891 adjust_fontinfo(&(tmp_hdr.fi));
892 fwrite(&tmp_hdr, FIELD_OFFSET(FNT_HEADER,fi.dfBitsOffset), 1, ofp);
893 fputc(0x00, ofp);
894 fwrite(name, strlen(name) + 1, 1, ofp);
895 }
896
897 pad = ftell(ofp) & 0xf;
898 if(pad != 0)
899 pad = 0x10 - pad;
900 for(i = 0; i < pad; i++)
901 fputc(0x00, ofp);
902
903 for(res = first_res, i = 0; i < num_files; i++, res++) {
904 write_fontinfo( info[i], ofp );
905 pad = info[i]->hdr.dfSize & 0xf;
906 if(pad != 0)
907 pad = 0x10 - pad;
908 for(j = 0; j < pad; j++)
909 fputc(0x00, ofp);
910 }
911 done:
912 fclose(ofp);
913 output_name = NULL;
914 exit(0);
915 }
916
917 #else /* HAVE_FREETYPE */
918
919 int main(int argc, char **argv)
920 {
921 fprintf( stderr, "%s needs to be built with FreeType support\n", argv[0] );
922 exit(1);
923 }
924
925 #endif /* HAVE_FREETYPE */
Windows API implementation