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