?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Added ability to turn on/off debug channels.
[wine.git] / tools / fnt2bdf.c
blobc0a855e0ffb5ae92fa998c30f9097459d4c31d74
1 /************************************************
2 *
3 * Extract fonts from .fnt or Windows DLL files
4 * and convert them to the .bdf format.
5 *
6 * Copyright 1994-1996 Kevin Carothers and Alex Korobka
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 */
22
23 #include "config.h"
24
25 #ifdef HAVE_SYS_PARAM_H
26 # include <sys/param.h>
27 #endif
28 #include <sys/types.h>
29 #include <sys/stat.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <unistd.h>
34 #include <fcntl.h>
35
36 #include "fnt2bdf.h"
37 #include "module.h"
38
39 #define FILE_ERROR 0
40 #define FILE_DLL 1
41 #define FILE_FNT 2
42
43 /* global options */
44
45 int dump_bdf( fnt_fontS* cpe_font_struct, unsigned char* file_buffer);
46 int dump_bdf_hdr(FILE* fs, fnt_fontS* cpe_font_struct, unsigned char* file_buffer);
47
48 char* g_lpstrFileName = NULL;
49 char* g_lpstrCharSet = NULL;
50 char* g_lpstrInputFile = NULL;
51 int g_outputPoints = 0;
52
53 static char* errorDLLRead = "Unable to read Windows DLL.\n";
54 static char* errorFNTRead = "Unable to read .FNT file.\n";
55 static char* errorOpenFile = "Unable to open file.\n";
56 static char* errorMemory = "Memory allocation error.\n";
57 static char* errorFile = "Corrupt or invalid file.\n";
58 static char* errorFontData = "Unable to parse font data: Error ";
59 static char* errorEmpty = "No fonts found.\n";
60
61 /* info */
62
63 void usage(void)
64 {
65 printf("Usage: fnt2bdf [-t] [-c charset] [-o basename] [input file]\n");
66 printf(" -c charset\tcharset name for OEM_CHARSET fonts\n");
67 printf(" -f basename\tbasic output filename\n");
68 printf(" -t \t\toutput files by point size instead of pixel height\n");
69 printf(" input file\tMSWindows .fon, .fnt, .dll, or .exe file.\n");
70 printf("\nExample:\n fnt2bdf -c winsys vgasys.fnt\n\n");
71 exit(-1);
72 }
73
74 /* convert little-endian value to the local format */
75
76 int return_data_value(enum data_types dtype, void * pChr)
77 {
78 int ret_val = 0;
79
80 switch(dtype) {
81 case (dfChar):
82 ret_val = (int) *(unsigned char *)pChr;
83 break;
84
85 case(dfShort):
86 ret_val = *(unsigned char *)pChr;
87 ret_val += (*((unsigned char *)pChr + 1) << 8);
88 break;
89
90 case(dfLong): {
91 int i;
92
93 for(i=3; i >= 0; i--) {
94 ret_val += *((unsigned char *)pChr + i) << (8*i);
95 }
96 break;
97 }
98 case(dfString):
99 break;
100 }
101 return ret_val;
102 }
103
104 int make_bdf_filename(char* name, fnt_fontS* cpe_font_struct, unsigned char* file_buffer)
105 {
106 long l_nameoffset = return_data_value(dfLong, &cpe_font_struct->hdr.fi.dfFace);
107 char* lpChar;
108
109 if( !g_lpstrFileName )
110 {
111 if( !l_nameoffset ||
112 l_nameoffset > return_data_value(dfLong, &cpe_font_struct->hdr.dfSize) + 1 )
113 return ERROR_DATA;
114 lpChar = (char*)(file_buffer + l_nameoffset);
115 }
116 else lpChar = g_lpstrFileName;
117
118 strcpy( name, lpChar );
119
120 while( (lpChar = strchr( name, ' ')) )
121 *lpChar = '-';
122
123 /* construct a filename from the font typeface, slant, weight, and size */
124
125 if( cpe_font_struct->hdr.fi.dfItalic ) strcat(name, "_i" );
126 else strcat(name, "_r" );
127
128 lpChar = name + strlen( name );
129 sprintf(lpChar, "%d-%d.bdf", return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfWeight),
130 (g_outputPoints) ? return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfPoints)
131 : return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfPixHeight) );
132 return 0;
133 }
134
135 /* parse FONT resource and write .bdf file */
136
137 int parse_fnt_data(unsigned char* file_buffer, int length)
138 {
139 fnt_fontS cpe_font_struct;
140 int ic=0, t;
141
142 memcpy((char *) &cpe_font_struct.hdr, file_buffer, sizeof(fnt_hdrS));
143
144 /* check font header */
145
146 t = return_data_value(dfShort, &cpe_font_struct.hdr.dfVersion);
147 if( t != 0x300 && t != 0x200) return ERROR_VERSION;
148
149 t = return_data_value(dfLong, &cpe_font_struct.hdr.dfSize);
150 if( t > length ) return ERROR_SIZE;
151 else
152 {
153 /* set up the charWidth/charOffset structure pairs (dfCharTable)... */
154
155 int l_fchar = return_data_value(dfChar, &cpe_font_struct.hdr.fi.dfFirstChar),
156 l_lchar = return_data_value(dfChar, &cpe_font_struct.hdr.fi.dfLastChar);
157 int l_len = l_lchar - l_fchar + 1;
158 int l_ptr = sizeof(fnt_hdrS);
159
160 /* some fields were introduced for Windows 3.x fonts */
161 if( return_data_value(dfShort, &cpe_font_struct.hdr.dfVersion) == 0x200 )
162 l_ptr -= 30;
163
164 /* malloc size = (# chars) * sizeof(WinCharS) */
165
166 if((cpe_font_struct.dfCharTable = (WinCharS *) calloc(sizeof(WinCharS), l_len)) == NULL)
167 return ERROR_MEMORY;
168
169 /* NOW, convert them all to UNIX (lton) notation... */
170
171 for(ic=0; ic < l_len; ic++) {
172 cpe_font_struct.dfCharTable[ic].charWidth = return_data_value(dfShort, &file_buffer[l_ptr]);
173 l_ptr += 2; /* bump by sizeof(short) */
174
175
176 if( return_data_value(dfShort, &cpe_font_struct.hdr.dfVersion) == 0x200) {
177 cpe_font_struct.dfCharTable[ic].charOffset =
178 return_data_value(dfShort, &file_buffer[l_ptr]);
179 l_ptr += 2; /* bump by sizeof(long) */
180 }
181 else { /* Windows Version 3.0 type font */
182 cpe_font_struct.dfCharTable[ic].charOffset =
183 return_data_value(dfLong, &file_buffer[l_ptr]);
184 l_ptr += 4; /* bump by sizeof(long) */
185 }
186 }
187 t = dump_bdf(&cpe_font_struct, file_buffer);
188 free( cpe_font_struct.dfCharTable );
189 }
190 return t;
191 }
192
193 int dump_bdf( fnt_fontS* cpe_font_struct, unsigned char* file_buffer)
194 {
195 FILE* fp;
196 int ic;
197 int l_fchar = return_data_value(dfChar, &cpe_font_struct->hdr.fi.dfFirstChar),
198 l_lchar = return_data_value(dfChar, &cpe_font_struct->hdr.fi.dfLastChar);
199
200 int l_len = l_lchar-l_fchar + 1,
201 l_hgt = return_data_value(dfChar, &cpe_font_struct->hdr.fi.dfPixHeight);
202 int l_ascent = return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfAscent);
203 char l_filename[256];
204
205 if( (ic = make_bdf_filename(l_filename, cpe_font_struct, file_buffer)) )
206 return ic;
207
208 if((fp = fopen(l_filename, "w")) == (FILE *) 0)
209 {
210 fprintf(stderr, "Couldn't open \"%s\" for output.\n", l_filename);
211 return ERROR_FILE;
212 }
213
214 ic = dump_bdf_hdr(fp, cpe_font_struct, file_buffer);
215 if (ic) return (ic);
216
217 /* NOW, convert all chars to UNIX (lton) notation... */
218
219 for(ic=0; ic < l_len; ic++) {
220 int rowidx, l_span, /* how many char-cols wide is char? */
221 l_idx = cpe_font_struct->dfCharTable[ic].charOffset;
222
223 l_span = (int) (cpe_font_struct->dfCharTable[ic].charWidth-1)/8;
224
225 fprintf(fp, "STARTCHAR %d \n", ic);
226 fprintf(fp, "ENCODING %d\n", l_fchar);
227 fprintf(fp, "SWIDTH %d %d \n",
228 cpe_font_struct->dfCharTable[ic].charWidth*1000,
229 0);
230
231 fprintf(fp, "DWIDTH %d %d \n",
232 cpe_font_struct->dfCharTable[ic].charWidth, 0);
233
234 fprintf(fp, "BBX %d %d %d %d\n",
235 cpe_font_struct->dfCharTable[ic].charWidth, l_hgt, 0,
236 l_ascent - l_hgt);
237
238 fprintf(fp, "BITMAP\n");
239 for(rowidx=0; rowidx < l_hgt; rowidx++) {
240 switch(l_span) {
241 case(0): /* 1-7 pixels wide font */
242 {
243 fprintf(fp, "%02X\n", (int) file_buffer[l_idx+rowidx]);
244 break;
245 }
246
247 case(1): /* 8-15 pixels wide font */
248 {
249 fprintf(fp, "%02X%02X",
250 (int) file_buffer[l_idx+rowidx], file_buffer[l_idx+l_hgt+rowidx]);
251 fprintf(fp, "\n");
252 break;
253 }
254
255 case(2): /* 16-23 pixels wide font */
256 {
257 fprintf(fp, "%02X%02X%02X",
258 file_buffer[l_idx+rowidx],
259 file_buffer[l_idx+l_hgt+rowidx],
260 file_buffer[l_idx+(2*l_hgt)+rowidx]);
261 fprintf(fp, "\n");
262 break;
263 }
264
265 case(3): /* 24-31 pixels wide font */
266 {
267 fprintf(fp, "%02X%02X%02X%02X",
268 file_buffer[l_idx+rowidx],
269 file_buffer[l_idx+l_hgt+rowidx],
270 file_buffer[l_idx+(2*l_hgt)+rowidx],
271 file_buffer[l_idx+(3*l_hgt)+rowidx]);
272 fprintf(fp, "\n");
273 break;
274 }
275 case(4): /* 32-39 */
276 {
277 fprintf(fp, "%02X%02X%02X%02X%02X",
278 file_buffer[l_idx+rowidx],
279 file_buffer[l_idx+l_hgt+rowidx],
280 file_buffer[l_idx+(2*l_hgt)+rowidx],
281 file_buffer[l_idx+(3*l_hgt)+rowidx],
282 file_buffer[l_idx+(4*l_hgt)+rowidx]);
283 fprintf(fp, "\n");
284 break;
285 }
286 default:
287 fclose(fp);
288 unlink(l_filename);
289 return ERROR_DATA;
290 }
291 }
292 fprintf(fp, "ENDCHAR\n");
293
294 l_fchar++; /* Go to next one */
295 }
296 fprintf(fp, "ENDFONT\n");
297 fclose(fp);
298 return 0;
299 }
300
301
302 int dump_bdf_hdr(FILE* fs, fnt_fontS* cpe_font_struct, unsigned char* file_buffer)
303 {
304 int l_fchar = return_data_value(dfChar, &cpe_font_struct->hdr.fi.dfFirstChar),
305 l_lchar = return_data_value(dfChar, &cpe_font_struct->hdr.fi.dfLastChar);
306 int l_len = l_lchar - l_fchar + 1;
307 long l_nameoffset = return_data_value(dfLong, &cpe_font_struct->hdr.fi.dfFace);
308 int l_cellheight = return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfPixHeight);
309 int l_ascent = return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfAscent);
310
311 fprintf(fs, "STARTFONT 2.1\n");
312
313 /* Compose font name */
314
315 if( l_nameoffset &&
316 l_nameoffset < return_data_value(dfLong, &cpe_font_struct->hdr.dfSize) )
317 {
318 int dpi, point_size;
319 char* lpFace = (char*)(file_buffer + l_nameoffset), *lpChar;
320 short tmWeight = return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfWeight);
321
322 while((lpChar = strchr(lpFace, '-')) )
323 *lpChar = ' ';
324
325 fprintf(fs, "FONT -windows-%s-", lpFace );
326
327 if( tmWeight == 0 ) /* weight */
328 fputs("medium-", fs);
329 else if( tmWeight <= FW_LIGHT )
330 fputs("light-", fs);
331 else if( tmWeight <= FW_MEDIUM )
332 fputs("medium-", fs);
333 else if( tmWeight <= FW_DEMIBOLD )
334 fputs("demibold-", fs);
335 else if( tmWeight <= FW_BOLD )
336 fputs("bold-", fs);
337 else fputs("black-", fs);
338
339 if( cpe_font_struct->hdr.fi.dfItalic ) /* slant */
340 fputs("i-", fs);
341 else fputs("r-", fs);
342
343 /* style */
344
345 if( (cpe_font_struct->hdr.fi.dfPitchAndFamily & 0xF0) == FF_SWISS )
346 fputs("normal-sans-", fs);
347 else fputs("normal--", fs); /* still can be -sans */
348
349 /* y extents */
350
351 point_size = 10 * return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfPoints );
352 dpi = (l_cellheight * 720) / point_size;
353
354 fprintf(fs, "%d-%d-%d-%d-",l_cellheight, point_size,
355 return_data_value (dfShort, &cpe_font_struct->hdr.fi.dfHorizRes),
356 return_data_value (dfShort, &cpe_font_struct->hdr.fi.dfVertRes));
357
358 /* spacing */
359
360 if( return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfPixWidth) ) fputs("c-", fs);
361 else fputs("p-", fs);
362
363 /* average width */
364
365 fprintf( fs, "%d-", 10 * return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfAvgWidth) );
366
367 /* charset */
368
369 if( g_lpstrCharSet ) fprintf(fs, "%s\n", g_lpstrCharSet);
370 else
371 switch( cpe_font_struct->hdr.fi.dfCharSet )
372 {
373 /* Microsoft just had to invent its own charsets! */
374
375 case ANSI_CHARSET: fputs("microsoft-cp1252\n", fs); break;
376 case GREEK_CHARSET: fputs("microsoft-cp1253\n", fs); break;
377 case TURKISH_CHARSET: fputs("microsoft-cp1254\n", fs); break;
378 case HEBREW_CHARSET: fputs("microsoft-cp1255\n", fs); break;
379 case ARABIC_CHARSET: fputs("microsoft-cp1256\n", fs); break;
380 case BALTIC_CHARSET: fputs("microsoft-cp1257\n", fs); break;
381 case RUSSIAN_CHARSET: fputs("microsoft-cp1251\n", fs); break;
382 case EE_CHARSET: fputs("microsoft-cp1250\n", fs); break;
383 case SYMBOL_CHARSET: fputs("microsoft-symbol\n", fs); break;
384 case SHIFTJIS_CHARSET: fputs("jisx0208.1983-0\n", fs); break;
385 case DEFAULT_CHARSET: fputs("iso8859-1\n", fs); break;
386
387 default:
388 case OEM_CHARSET:
389 fputs("Undefined charset, use -c option.\n", stderr);
390 return ERROR_DATA;
391 }
392 }
393 else return ERROR_DATA;
394
395 fprintf(fs, "SIZE %d %d %d\n",
396 return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfPoints ),
397 return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfHorizRes),
398 return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfVertRes)); /* dfVertRes[2] */
399
400 fprintf(fs, "FONTBOUNDINGBOX %d %d %d %d\n",
401 return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfMaxWidth),
402 return_data_value(dfChar, &cpe_font_struct->hdr.fi.dfPixHeight),
403 0, l_ascent - l_cellheight );
404
405 fprintf(fs, "STARTPROPERTIES 4\n");
406
407 fprintf(fs, "FONT_ASCENT %d\n", l_ascent ); /* dfAscent[2] */
408 fprintf(fs, "FONT_DESCENT %d\n", l_cellheight - l_ascent );
409 fprintf(fs, "CAP_HEIGHT %d\n", l_ascent -
410 return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfInternalLeading));
411 fprintf(fs, "DEFAULT_CHAR %d\n", return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfDefaultChar));
412
413 fprintf(fs, "ENDPROPERTIES\n");
414
415 fprintf(fs, "CHARS %d\n", l_len);
416 return 0;
417 }
418
419
420
421 void parse_options(int argc, char **argv)
422 {
423 int i;
424
425 switch( argc )
426 {
427 case 2:
428 g_lpstrInputFile = argv[1];
429 break;
430
431 case 3:
432 case 4:
433 case 5:
434 case 6:
435 case 7:
436 case 8:
437 for( i = 1; i < argc - 1; i++ )
438 {
439 if( argv[i][0] != '-' ||
440 strlen(argv[i]) != 2 ) break;
441
442 if( argv[i][1] == 'c' )
443 g_lpstrCharSet = argv[i+1];
444 else
445 if( argv[i][1] == 'f' )
446 g_lpstrFileName = argv[i+1];
447 else
448 if( argv[i][1] == 't' )
449 {
450 g_outputPoints = 1;
451 continue;
452 }
453 else
454 usage();
455
456 i++;
457 }
458 if( i == argc - 1 )
459 {
460 g_lpstrInputFile = argv[i];
461 break;
462 }
463 default: usage();
464 }
465
466 }
467
468 /* read file data and return file type */
469
470 int get_resource_table(int fd, unsigned char** lpdata, int fsize)
471 {
472 IMAGE_DOS_HEADER mz_header;
473 IMAGE_OS2_HEADER ne_header;
474 long s, offset, size;
475 int retval;
476
477 lseek( fd, 0, SEEK_SET );
478
479 if( read(fd, &mz_header, sizeof(mz_header)) != sizeof(mz_header) )
480 return FILE_ERROR;
481
482 s = return_data_value(dfShort, &mz_header.e_magic);
483
484 if( s == IMAGE_DOS_SIGNATURE) /* looks like .dll file so far... */
485 {
486 s = return_data_value(dfShort, &mz_header.e_lfanew);
487 lseek( fd, s, SEEK_SET );
488
489 if( read(fd, &ne_header, sizeof(ne_header)) != sizeof(ne_header) )
490 return FILE_ERROR;
491
492 s = return_data_value(dfShort, &ne_header.ne_magic);
493
494 if( s == IMAGE_NT_SIGNATURE)
495 {
496 fprintf( stderr, "Do not know how to handle 32-bit Windows DLLs.\n");
497 return FILE_ERROR;
498 }
499 else if ( s != IMAGE_OS2_SIGNATURE) return FILE_ERROR;
500
501 s = return_data_value(dfShort, &ne_header.ne_rsrctab);
502 size = return_data_value(dfShort, &ne_header.ne_restab);
503
504 if( size > fsize ) return FILE_ERROR;
505
506 size -= s;
507 offset = s + return_data_value(dfShort, &mz_header.e_lfanew);
508
509 if( size <= sizeof(NE_TYPEINFO) ) return FILE_ERROR;
510 retval = FILE_DLL;
511 }
512 else if( s == 0x300 || s == 0x200 ) /* maybe .fnt ? */
513 {
514 size = return_data_value(dfLong, &((fnt_hdrS *)&mz_header)->dfSize);
515
516 if( size != fsize ) return FILE_ERROR;
517 offset = 0;
518 retval = FILE_FNT;
519 }
520 else return FILE_ERROR;
521
522 *lpdata = (unsigned char*)malloc(size);
523
524 if( *lpdata )
525 {
526 lseek( fd, offset, SEEK_SET );
527 if( read(fd, *lpdata, size) != size )
528 { free( *lpdata ); *lpdata = NULL; }
529 }
530 return retval;
531 }
532
533
534 /* entry point */
535
536 int main(int argc, char **argv)
537 {
538 unsigned char* lpdata = NULL;
539 int fd;
540
541 parse_options( argc, argv);
542
543 if( (fd = open( g_lpstrInputFile, O_RDONLY)) )
544 {
545 int i;
546 struct stat file_stat;
547
548 fstat( fd, &file_stat);
549 i = get_resource_table( fd, &lpdata, file_stat.st_size );
550
551 switch(i)
552 {
553 case FILE_DLL:
554 if( lpdata )
555 {
556 int j, count = 0;
557 NE_TYPEINFO* pTInfo = (NE_TYPEINFO*)(lpdata + 2);
558 NE_NAMEINFO* pFontStorage = NULL;
559
560 while( (i = return_data_value(dfShort, &pTInfo->type_id)) )
561 {
562 j = return_data_value(dfShort, &pTInfo->count);
563 if( i == NE_RSCTYPE_FONT )
564 {
565 count = j;
566 pFontStorage = (NE_NAMEINFO*)(pTInfo + 1);
567 break; /* found one */
568 }
569
570 pTInfo = (NE_TYPEINFO *)((char*)(pTInfo+1) + j*sizeof(NE_NAMEINFO));
571 }
572 if( pFontStorage && count )
573 {
574 unsigned short size_shift = return_data_value(dfShort, lpdata);
575 unsigned char* lpfont = NULL;
576 unsigned offset;
577 unsigned length;
578
579 for( j = 0; j < count; j++, pFontStorage++ )
580 {
581 length = return_data_value(dfShort, &pFontStorage->length) << size_shift;
582 offset = return_data_value(dfShort, &pFontStorage->offset) << size_shift;
583
584 if( !(lpfont = (unsigned char*) realloc( lpfont, length )) )
585 {
586 fprintf(stderr, errorMemory );
587 exit(1);
588 }
589
590 lseek( fd, offset, SEEK_SET );
591 if( read(fd, lpfont, length) != length )
592 {
593 fprintf(stderr, errorDLLRead );
594 exit(1);
595 }
596
597 if( (i = parse_fnt_data( lpfont, length )) )
598 {
599 fprintf(stderr, "%s%d\n", errorFontData, i );
600 exit(1);
601 }
602 }
603 free(lpfont); free(lpdata);
604 exit(0);
605 }
606 else
607 {
608 fprintf(stderr, errorEmpty );
609 exit(1);
610 }
611 free( lpdata );
612 }
613 else
614 {
615 fprintf(stderr, errorDLLRead);
616 exit(1);
617 }
618 break;
619
620 case FILE_FNT:
621 if( lpdata )
622 {
623 if( (i = parse_fnt_data( lpdata, file_stat.st_size )) )
624 {
625 fprintf(stderr, "%s%d\n", errorFontData, i );
626 exit(1);
627 }
628 free( lpdata );
629 }
630 else
631 {
632 fprintf(stderr, errorFNTRead);
633 exit(1);
634 }
635 break;
636
637 case FILE_ERROR:
638 fprintf(stderr, errorFile );
639 exit(1);
640 }
641 close(fd);
642 exit(0);
643 }
644 else
645 {
646 fprintf(stderr, errorOpenFile );
647 exit(1);
648 }
649 }
Windows API implementation