git.oblomov.eu Git - wine/blob - tools/fnt2bdf.c

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