Gitiles
Code Review Sign In
gerrit.rockbox.org / rockbox / 22fd07578d7de9f2fc106f54e27a7a46e0f51949 / . / fonts / bdf2bmp.c
blob: 8ca73cd49f73c91c7c37d596a4afc93420dfeda6 [file] [log] [blame]
Daniel Stenberg22fd0752004-05-21 16:53:06 +0000[diff] [blame^]1/*
2 * bdf2bmp -- output all glyphs in a bdf-font to a bmp-image-file
3 * version: 0.6
4 * date: Wed Jan 10 23:59:03 2001
5 * author: ITOU Hiroki (itouh@lycos.ne.jp)
6 */
7
8/*
9 * Copyright (c) 2000,2001 ITOU Hiroki
10 * All rights reserved.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in the
19 * documentation and/or other materials provided with the distribution.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33
34/* modify if you want; color of spacing */
35#define COLOR_SPACING_RED 0x9a
36#define COLOR_SPACING_GREEN 0x9a
37#define COLOR_SPACING_BLUE 0xbd
38/* modify if you want; out-of-dwidth over baseline */
39#define COLOR_OVERBL_RED 0xca
40#define COLOR_OVERBL_GREEN 0xca
41#define COLOR_OVERBL_BLUE 0xd8
42/* modify if you want; out-of-dwidth under baseline */
43#define COLOR_UNDERBL_RED 0xde
44#define COLOR_UNDERBL_GREEN 0xde
45#define COLOR_UNDERBL_BLUE 0xe7
46
47#define VERBOSE
48
49#include <stdio.h> /* printf(), fopen(), fwrite() */
50#include <stdlib.h> /* malloc(), EXIT_SUCCESS, strtol(), exit() */
51#include <string.h> /* strcmp(), strcpy() */
52#include <limits.h> /* strtol() */
53#include <sys/stat.h> /* stat() */
54#include <sys/types.h> /* stat ? */
55#include <ctype.h> /* isdigit() */
56
57#define LINE_CHARMAX 1000 /* number of max characters in bdf-font-file; number is without reason */
58#define FILENAME_CHARMAX 256 /* number of max characters in filenames; number is without reason */
59#define ON 1 /* number is without reason; only needs the difference to OFF */
60#define OFF 0 /* number is without reason; only needs the difference to ON */
61#define PARAM_MAX 10 /* max number of parameters */
62
63#ifdef DEBUG
64#define d_printf(message,arg) printf(message,arg)
65#else /* not DEBUG */
66#define d_printf(message,arg)
67#endif /* DEBUG */
68
69#ifdef VERBOSE
70#define v_printf(message,arg) printf(message,arg)
71#else /* not VERBOSE */
72#define v_printf(message,arg)
73#endif /* VERBOSE */
74
75/* macro */
76#define STOREBITMAP() if(flagBitmap == ON){\
77 memcpy(nextP, sP, length);\
78 nextP += length;\
79 }
80
81struct boundingbox{
82 int w; /* width (pixel) */
83 int h; /* height */
84 int offx; /* offset y (pixel) */
85 int offy; /* offset y */
86};
87
88/* global var */
89struct boundingbox font; /* global boundingbox */
90static int chars; /* total number of glyphs in a bdf file */
91static int dwflag = ON; /* device width; only used for proportional-fonts */
92static int endian; /* 0 = MSB, 1 = LSB */
93
94/* func prototype */
95void checkEndian(void);
96void dwrite(const void *ptrP, int n, FILE *outP);
97void writeBmpFile(unsigned char *bitmapP, int spacing, int colchar, FILE *bmpP);
98void assignBitmap(unsigned char *bitmapP, char *glyphP, int sizeglyphP, struct boundingbox glyph, int dw);
99int getline(char* lineP, int max, FILE* inputP);
100unsigned char *readBdfFile(unsigned char *bitmapP, FILE *readP);
101void printhelp(void);
102int main(int argc, char *argv[]);
103
104
105
106/*
107 * Is your-CPU-byte-order MSB or LSB?
108 * MSB .. Most Significant Byte first (BigEndian) e.g. PowerPC, SPARC
109 * LSB .. Least Significant Byte first (LittleEndian) e.g. Intel Pentium
110 */
111void checkEndian(void){
112 unsigned long ulong = 0x12345678;
113 unsigned char *ucharP;
114
115 ucharP = (unsigned char *)(&ulong);
116 if(*ucharP == 0x78){
117 d_printf("LSB 0x%x\n", *ucharP);
118 endian = 1;
119 }else{
120 d_printf("MSB 0x%x\n", *ucharP);
121 endian = 0;
122 }
123}
124
125
126
127/*
128 * write to disk; with arranging LSBfirst(LittleEndian) byte order,
129 * because BMP-file is defined as LSB-first
130 */
131void dwrite(const void *varP, int n, FILE *outP){
132 const unsigned char *p = varP;
133 int i;
134 unsigned char tmp;
135
136 if(endian == 1){
137 /* LSB; write without arranging */
138 for(i=0; i<n; i++){
139 tmp = fwrite(p+i, 1, sizeof(unsigned char), outP);
140 if(tmp != sizeof(unsigned char)){
141 printf("error: cannot write an output-file\n");
142 exit(EXIT_FAILURE);
143 }
144 }
145 }else{
146 /* MSB; write with arranging */
147 for(i=n-1; i>=0; i--){
148 tmp = fwrite(p+i, 1, sizeof(unsigned char), outP);
149 if(tmp != sizeof(unsigned char)){
150 printf("error: cannot write an output-file\n");
151 exit(EXIT_FAILURE);
152 }
153 }
154 }
155}
156
157
158
159/*
160 * 3. read bitmapAREA(onMemory) and write bmpFile with adding spacing
161 * BMP-file: noCompression(BI_RGB), 8bitColor, Windows-Win32 type
162 */
163void writeBmpFile(unsigned char *bitmapP, int spacing, int colchar, FILE *bmpP){
164 long bmpw; /* bmp-image width (pixel) */
165 long bmph; /* bmp-image height (pixel) */
166 int bmppad; /* number of padding pixels */
167 unsigned long bmpTotalSize; /* bmp filesize (byte) */
168 /* bmp-lines needs to be long alined and padded with 0 */
169 unsigned long ulong;
170 unsigned short ushort;
171 signed long slong;
172 unsigned char uchar;
173 int i,x,y,g,tmp;
174 int rowchar; /* number of row glyphs */
175 int bx, by;
176
177 /* bmp-image width */
178 bmpw = (font.w+spacing)*colchar + spacing;
179
180 /* bmp-image height */
181 rowchar = (chars/colchar) + (chars%colchar!=0);
182 bmph = (font.h+spacing)*rowchar + spacing;
183
184 v_printf(" BMP width = %d pixels\n", (int)bmpw);
185 v_printf(" BMP height = %d pixels\n", (int)bmph);
186 d_printf(" number of glyphs column=%d ", colchar);
187 d_printf("row=%d\n", rowchar);
188
189 bmppad = ((bmpw + 3) / 4 * 4) - bmpw;
190 bmpTotalSize = (bmpw + bmppad) * bmph
191 + sizeof(long)*11 + sizeof(short)*5 + sizeof(char)*4*256;
192 v_printf(" BMP filesize = %d bytes\n", (int)bmpTotalSize);
193
194
195 /*
196 * BITMAPFILEHEADER struct
197 */
198 ushort = 0x4d42; /* 4d = 'M', 42 = 'B' */
199 dwrite(&ushort, sizeof(ushort), bmpP);
200 ulong = bmpTotalSize;
201 dwrite(&ulong, sizeof(ulong), bmpP);
202 ushort = 0x00;
203 dwrite(&ushort, sizeof(ushort), bmpP); /* reserved as 0 */
204 dwrite(&ushort, sizeof(ushort), bmpP); /* reserved as 0 */
205
206 /* bfOffBits: offset to image-data array */
207 ulong = sizeof(long)*11 + sizeof(short)*5 + sizeof(char)*4*256;
208 dwrite(&ulong, sizeof(ulong), bmpP);
209
210
211 /*
212 * BITMAPINFOHEADER struct
213 */
214 ulong = 40; /* when Windows-BMP, this is 40 */
215 dwrite(&ulong, sizeof(ulong), bmpP);
216 slong = bmpw; /* biWidth */
217 dwrite(&slong, sizeof(slong), bmpP);
218 slong = bmph; /* biHeight: down-top */
219 dwrite(&slong, sizeof(slong), bmpP);
220 ushort = 1; /* biPlanes: must be 1 */
221 dwrite(&ushort, sizeof(ushort), bmpP);
222 ushort = 8; /* biBitCount: 8bitColor */
223 dwrite(&ushort, sizeof(ushort), bmpP);
224 ulong = 0; /* biCompression: noCompression(BI_RGB) */
225 dwrite(&ulong, sizeof(ulong), bmpP);
226 ulong = 0; /* biSizeImage: when noComprsn, 0 is ok */
227 dwrite(&ulong, sizeof(ulong), bmpP);
228 slong = 0; /* biXPelsPerMeter: resolution x; 0 ok */
229 dwrite(&slong, sizeof(slong), bmpP);
230 slong = 0; /* biYPelsPerMeter: res y; 0 is ok */
231 dwrite(&slong, sizeof(slong), bmpP);
232 ulong = 0; /* biClrUsed: optimized color palette; not used */
233 dwrite(&ulong, sizeof(ulong), bmpP);
234 ulong = 0; /* biClrImportant: 0 is ok */
235 dwrite(&ulong, sizeof(ulong), bmpP);
236
237 /*
238 * RGBQUAD[256]: color palette
239 */
240 /* palette[0]: background of glyphs */
241 uchar = 0xff;
242 dwrite(&uchar, sizeof(uchar), bmpP); /* rgbBlue: B */
243 dwrite(&uchar, sizeof(uchar), bmpP); /* rgbGreen: G */
244 dwrite(&uchar, sizeof(uchar), bmpP); /* rgbRed: R */
245 uchar = 0;
246 dwrite(&uchar, sizeof(uchar), bmpP); /* rgbReserved: must be 0 */
247
248 /* palette[1]: foreground of glyphs */
249 uchar = 0;
250 for(i=0; i<4; i++)
251 dwrite(&uchar, sizeof(uchar), bmpP); /* palette[1]: #000000 */
252
253 /* palette[2]: spacing */
254 uchar = COLOR_SPACING_BLUE;
255 dwrite(&uchar, sizeof(uchar), bmpP); /* B */
256 uchar = COLOR_SPACING_GREEN;
257 dwrite(&uchar, sizeof(uchar), bmpP); /* G */
258 uchar = COLOR_SPACING_RED;
259 dwrite(&uchar, sizeof(uchar), bmpP); /* R */
260 uchar = 0;
261 dwrite(&uchar, sizeof(uchar), bmpP); /* must be 0 */
262
263 /* palette[3]: out of dwidth over baseline */
264 uchar = COLOR_OVERBL_BLUE;
265 dwrite(&uchar, sizeof(uchar), bmpP); /* B */
266 uchar = COLOR_OVERBL_GREEN;
267 dwrite(&uchar, sizeof(uchar), bmpP); /* G */
268 uchar = COLOR_OVERBL_RED;
269 dwrite(&uchar, sizeof(uchar), bmpP); /* R */
270 uchar = 0;
271 dwrite(&uchar, sizeof(uchar), bmpP); /* must be 0 */
272
273 /* palette[4]: out of dwidth; under baseline */
274 uchar = COLOR_UNDERBL_BLUE;
275 dwrite(&uchar, sizeof(uchar), bmpP); /* B */
276 uchar = COLOR_UNDERBL_GREEN;
277 dwrite(&uchar, sizeof(uchar), bmpP); /* G */
278 uchar = COLOR_UNDERBL_RED;
279 dwrite(&uchar, sizeof(uchar), bmpP); /* R */
280 uchar = 0;
281 dwrite(&uchar, sizeof(uchar), bmpP); /* must be 0 */
282
283 /* palette[5] to palette[255]: not used */
284 for(i=5; i<256; i++){
285 uchar = 0x00; /* palette[5to255]: #000000 */
286 dwrite(&uchar, sizeof(uchar), bmpP);
287 dwrite(&uchar, sizeof(uchar), bmpP);
288 dwrite(&uchar, sizeof(uchar), bmpP);
289 dwrite(&uchar, sizeof(uchar), bmpP);
290 }
291
292 /*
293 * IMAGE DATA array
294 */
295 for(y=bmph-1; y>=0; y--){
296 for(x=0; x<bmpw+bmppad; x++){
297 if(x>=bmpw){
298 /* padding: long(4bytes) aligned */
299 uchar = 0; /* must pad with 0 */
300 dwrite(&uchar, sizeof(uchar), bmpP);
301 }else{
302 if( (y%(font.h+spacing)<spacing) || (x%(font.w+spacing)<spacing) ){
303 /* spacing */
304 uchar = 2; /* fill palette[2] */
305 dwrite(&uchar, sizeof(uchar), bmpP);
306 }else{
307 /* read bitmapAREA & write bmpFile */
308 g = (x/(font.w+spacing)) + (y/(font.h+spacing)*colchar);
309 bx = x - (spacing*(g%colchar)) - spacing;
310 by = y - (spacing*(g/colchar)) - spacing;
311 tmp = g*(font.h*font.w) + (by%font.h)*font.w + (bx%font.w);
312 if(tmp >= chars*font.h*font.w){
313 /* spacing over the last glyph */
314 uchar = 2; /* fill palette[2] */
315 }else
316 uchar = *( bitmapP + tmp);
317 dwrite(&uchar, sizeof(uchar), bmpP);
318 }
319 }
320 }
321 }
322 return;
323}
324
325
326
327
328/*
329 * 2. transfer bdf-font-file to bitmapAREA(onMemory) one glyph by one
330 */
331void assignBitmap(unsigned char *bitmapP, char *glyphP, int sizeglyphP, struct boundingbox glyph, int dw){
332 static char *hex2binP[]= {
333 "0000","0001","0010","0011","0100","0101","0110","0111",
334 "1000","1001","1010","1011","1100","1101","1110","1111"
335 };
336 int d; /* decimal number translated from hexNumber */
337 int hexlen; /* a line length(without newline code) */
338 char binP[LINE_CHARMAX]; /* binary strings translated from decimal number */
339 static int nowchar = 0; /* number of glyphs handlled until now */
340 char *tmpP;
341 char tmpsP[LINE_CHARMAX];
342 int bitAh, bitAw; /* bitA width, height */
343 int offtop, offbottom, offleft; /* glyph offset */
344 unsigned char *bitAP;
345 unsigned char *bitBP;
346 int i,j,x,y;
347
348 /*
349 * 2.1) change hexadecimal strings to a bitmap of glyph( called bitA)
350 */
351 tmpP = strstr(glyphP, "\n");
352 if(tmpP == NULL){
353 /* if there is BITMAP\nENDCHAR in a given bdf-file */
354 *glyphP = '0';
355 *(glyphP+1) = '0';
356 *(glyphP+2) = '\n';
357 tmpP = glyphP + 2;
358 sizeglyphP = 3;
359 }
360 hexlen = tmpP - glyphP;
361 bitAw = hexlen * 4;
362 bitAh = sizeglyphP / (hexlen+1);
363 bitAP = malloc(bitAw * bitAh); /* address of bitA */
364 if(bitAP == NULL){
365 printf("error bitA malloc\n");
366 exit(EXIT_FAILURE);
367 }
368 for(i=0,x=0,y=0; i<sizeglyphP; i++){
369 if(glyphP[i] == '\n'){
370 x=0; y++;
371 }else{
372 sprintf(tmpsP, "0x%c", glyphP[i]); /* get one character from hexadecimal strings */
373 d = (int)strtol(tmpsP,(char **)NULL, 16);
374 strcpy(binP, hex2binP[d]); /* change hexa strings to bin strings */
375 for(j=0; j<4; j++,x++){
376 if( bitAP+y*bitAw+x > bitAP+bitAw*bitAh ){
377 printf("error: bitA pointer\n");
378 exit(EXIT_FAILURE);
379 }else{
380 *(bitAP + y*bitAw + x) = binP[j] - '0';
381 }
382 }
383 }
384 }
385
386 /*
387 * 2.2)make another bitmap area(called bitB)
388 * bitB is sized to FONTBOUNDINGBOX
389 */
390 bitBP = malloc(font.w * font.h); /* address of bitB */
391 if(bitBP == NULL){
392 printf("error bitB malloc\n");
393 exit(EXIT_FAILURE);
394 }
395 for(i=0; i<font.h; i++){
396 for(j=0; j<font.w; j++){
397 if(dwflag == OFF){
398 /* all in boundingbox: palette[0] */
399 *(bitBP + i*font.w + j) = 0;
400 }else{
401 /* show the baselines and widths of glyphs */
402 if( (j < (-1)*font.offx) || (j >= (-1)*font.offx+dw)){
403 if(i < font.h - (-1)*font.offy){
404 /* over baseline: palette[3] */
405 *(bitBP + i*font.w + j) = 3;
406 }else{
407 /* under baseline: palette[4] */
408 *(bitBP + i*font.w + j) = 4;
409 }
410 }else{
411 /* in dwidth: palette[0] */
412 *(bitBP + i*font.w + j) = 0;
413 }
414 }
415 }
416 }
417
418 /*
419 * 2.3) copy bitA inside BBX (smaller) to bitB (bigger)
420 * with offset-shifting;
421 * a scope beyond bitA is already filled with palette[0or3]
422 */
423 offleft = (-1)*font.offx + glyph.offx;
424 /* offright = font.w - glyph.w - offleft; */
425
426 offbottom = (-1)*font.offy + glyph.offy;
427 offtop = font.h - glyph.h - offbottom;
428
429 for(i=0; i<font.h; i++){
430 if( i<offtop || i>=offtop+glyph.h )
431 ; /* do nothing */
432 else
433 for(j=0; j<font.w; j++)
434 if( j<offleft || j>=offleft+glyph.w )
435 ; /* do nothing */
436 else
437 *(bitBP + i*font.w + j) = *(bitAP + (i-offtop)*bitAw + (j-offleft));
438 }
439
440 /*
441 * 2.4) copy bitB to bitmapAREA
442 */
443 for(i=0; i<font.h; i++)
444 for(j=0; j<font.w; j++)
445 *(bitmapP + (nowchar*font.w*font.h) + (i*font.w) + j) = *(bitBP + i*font.w + j);
446
447 nowchar++;
448 free(bitAP);
449 free(bitBP);
450}
451
452
453/*
454 * read oneline from textfile
455 */
456int getline(char* lineP, int max, FILE* inputP){
457 if (fgets(lineP, max, inputP) == NULL)
458 return 0;
459 else
460 return strlen(lineP); /* fgets returns strings included '\n' */
461}
462
463
464/*
465 * 1. read BDF-file and transfer to assignBitmap()
466 */
467unsigned char *readBdfFile(unsigned char *bitmapP, FILE *readP){
468 int i;
469 int length;
470 char sP[LINE_CHARMAX]; /* one line(strings) from bdf-font-file */
471 static int cnt; /* only used in debugging: counter of appeared glyphs */
472 struct boundingbox glyph; /* an indivisual glyph width, height,offset x,y */
473 int flagBitmap = OFF; /* this line is bitmap-data?(ON) or no?(OFF) */
474 char *tokP; /* top address of a token from strings */
475 char *glyphP = NULL; /* bitmap-data(hexadecimal strings) */
476 char* nextP = NULL; /* address of writing next in glyphP */
477 int dw = 0; /* dwidth */
478 static int bdfflag = OFF; /* the given bdf-file is valid or not */
479
480 while(1){
481 length = getline(sP, LINE_CHARMAX, readP);
482 if((bdfflag == OFF) && (length == 0)){
483 /* given input-file is not a bdf-file */
484 printf("error: input-file is not a bdf file\n");
485 exit(EXIT_FAILURE);
486 }
487 if(length == 0)
488 break; /* escape from while-loop */
489
490 /* remove carriage-return(CR) */
491 for(i=0; i<length; i++){
492 if(sP[i] == '\r'){
493 sP[i] = '\n';
494 length--;
495 }
496 }
497
498 /* classify from the top character of sP */
499 switch(sP[0]){
500 case 'S':
501 if(bdfflag == OFF){
502 /* top of the bdf-file */
503 if(strncmp(sP, "STARTFONT ", 10) == 0){
504 bdfflag = ON;
505 d_printf("startfont exists %d\n", bdfflag);
506 }else{
507 /* given input-file is not a bdf-file */
508 printf("error: input-file is not a bdf file\n");
509 exit(EXIT_FAILURE);
510 }
511 }
512 break;
513 case 'F':
514 if(strncmp(sP, "FONTBOUNDINGBOX ", 16) == 0){
515 /* 16 means no comparing '\0' */
516
517 /* get font.w, font.h, font.offx, and font.offy */
518 tokP = strtok(sP, " ");/* tokP addresses next space of FONTBOUNDINGBOX */
519 tokP += (strlen(tokP)+1);/* tokP addresses top character of width in FONTBOUNDINGBOX */
520 tokP = strtok(tokP, " ");/* set NUL on space after width */
521 font.w = atoi(tokP);
522 tokP += (strlen(tokP)+1);/* height in FONTBOUNDINGBOX */
523 tokP = strtok(tokP, " ");
524 font.h = atoi(tokP);
525 tokP += (strlen(tokP)+1);
526 tokP = strtok(tokP, " ");
527 font.offx = atoi(tokP);
528 tokP += (strlen(tokP)+1);
529 tokP = strtok(tokP, "\n");
530 font.offy = atoi(tokP);
531 d_printf("global glyph width=%dpixels ",font.w);
532 d_printf("height=%dpixels\n",font.h);
533 d_printf("global glyph offset x=%dpixels ",font.offx);
534 d_printf("y=%dpixels\n",font.offy);
535 }else
536 STOREBITMAP();
537 break;
538 case 'C':
539 if(strncmp(sP, "CHARS ", 6) == 0){
540 /* get chars */
541 tokP = strtok(sP, " ");
542 tokP += (strlen(tokP)+1);
543 tokP = strtok(tokP, "\n");
544 chars = atoi(tokP);
545 v_printf(" Total glyphs = %d\n",chars);
546 cnt=0;
547
548 /* allocate bitmapAREA */
549 bitmapP = (unsigned char*)malloc(chars * font.h * font.w );
550 if(bitmapP == NULL){
551 printf("error malloc\n");
552 exit(EXIT_FAILURE);
553 }
554 }else
555 STOREBITMAP();
556 break;
557 case 'D':
558 if(strncmp(sP, "DWIDTH ", 7) == 0){
559 /* get dw */
560 tokP = strtok(sP, " ");
561 tokP += (strlen(tokP)+1);
562 tokP = strtok(tokP, " ");
563 dw = atoi(tokP);
564 }else
565 STOREBITMAP();
566 break;
567 case 'B':
568 if(strncmp(sP, "BITMAP", 6) == 0){
569 /* allocate glyphP */
570 glyphP = (char*)malloc(font.w*font.h); /* allocate more room */
571 if(glyphP == NULL){
572 printf("error malloc bdf\n");
573 exit(EXIT_FAILURE);
574 }
575 memset(glyphP, 0, font.w*font.h); /* zero clear */
576 nextP = glyphP;
577 flagBitmap = ON;
578 }else if(strncmp(sP, "BBX ", 4) == 0){
579 /* get glyph.offx, glyph.offy, glyph.w, and glyph.h */
580 tokP = strtok(sP, " ");/* space after 'BBX' */
581 tokP += (strlen(tokP)+1);/* top of width */
582 tokP = strtok(tokP, " ");/* set NUL on space after width */
583 glyph.w = atoi(tokP);
584 tokP += (strlen(tokP)+1);/* height */
585 tokP = strtok(tokP, " ");
586 glyph.h = atoi(tokP);
587 tokP += (strlen(tokP)+1);/* offx */
588 tokP = strtok(tokP, " ");
589 glyph.offx = atoi(tokP);
590 tokP += (strlen(tokP)+1);/* offy */
591 tokP = strtok(tokP, "\n");
592 glyph.offy = atoi(tokP);
593 /* d_printf("glyph width=%dpixels ",glyph.w); */
594 /* d_printf("height=%dpixels\n",glyph.h); */
595 /* d_printf("glyph offset x=%dpixels ",glyph.offx); */
596 /* d_printf("y=%dpixels\n",glyph.offy); */
597 }else
598 STOREBITMAP();
599 break;
600 case 'E':
601 if(strncmp(sP, "ENDCHAR", 7) == 0){
602 d_printf("\nglyph %d\n", cnt);
603 d_printf("%s\n",glyphP);
604 assignBitmap(bitmapP, glyphP, nextP - glyphP, glyph, dw);
605 flagBitmap = OFF;
606 free(glyphP);
607 cnt++;
608 }else
609 STOREBITMAP();
610 break;
611 default:
612 STOREBITMAP();
613 break;
614 }/* switch */
615 }/* while */
616 /* 'break' goto here */
617 return bitmapP;
618}
619
620
621/*
622 *
623 */
624void printhelp(void){
625 printf("bdf2bmp version 0.6\n");
626 printf("Usage: bdf2bmp [-option] input-bdf-file output-bmp-file\n");
627 printf("Option:\n");
628 printf(" -sN spacing N pixels (default N=2)\n");
629 printf(" N value can range from 0 to 32\n");
630 printf(" -cN specifying N colomns in grid (default N=32)\n");
631 printf(" N value can range from 1 to 1024\n");
632 printf(" -w showing the baseline and the widths of glyphs\n");
633 printf(" with gray colors\n");
634 printf(" -i prompting whether to overwrite an existing file\n");
635 printf(" -h print help\n");
636 exit(EXIT_FAILURE);
637}
638
639
640
641/*
642 *
643 */
644int main(int argc, char *argv[]){
645 FILE *readP;
646 FILE *writeP;
647 char readFilename[FILENAME_CHARMAX] = "input.bdf";
648 char writeFilename[FILENAME_CHARMAX] = "output.bmp";
649 int i, j, tmp, n, dst, c;
650 char *sP;
651 unsigned char *bitmapP = NULL; /* address of bitmapAREA */
652 int spacing = 2; /* breadth of spacing (default 2) */
653 int flag;
654 int colchar = 32; /* number of columns(horizontal) (default 32) */
655 char paramP[PARAM_MAX][LINE_CHARMAX]; /* parameter strings */
656 int iflag = OFF;
657 struct stat fileinfo;
658
659 /*
660 * deal with arguments
661 */
662 if(argc < 2){
663 /* printf("error: not enough arguments\n"); */
664 printhelp();
665 }
666
667 /* formatting arguments */
668 sP = calloc(LINE_CHARMAX, sizeof(char));
669 if(sP == NULL){
670 printf("error\n");
671 exit(1);
672 }
673 for(i=1,dst=0,n=0; i<argc; i++){
674 if(argv[i][0] == '-'){
675 /* command-line options */
676 for(j=1; j<(int)strlen(argv[i]); j++){
677 if(argv[i][j]=='w' ||
678 argv[i][j]=='i' ||
679 argv[i][j]=='h' ||
680 argv[i][j]=='v')
681 {
682 *(sP+dst) = '-'; dst++;
683 *(sP+dst) = argv[i][j]; dst++;
684 *(sP+dst) = '\0';
685 strcpy(paramP[n], sP); dst=0; n++;
686 memset(sP,0,LINE_CHARMAX);
687 if(n >= PARAM_MAX){
688 printf("error: too many arguments\n");
689 exit(EXIT_FAILURE);
690 }
691
692 }else if( (argv[i][j]=='s') ||
693 (argv[i][j]=='c'))
694 {
695 *(sP+dst) = '-'; dst++;
696 *(sP+dst) = argv[i][j]; dst++;
697 }else if( isdigit(argv[i][j]) == 0 ){
698 /* not [0-9] */
699 printf("error: invalid option -- '%c'\n", argv[i][j]);
700 exit(EXIT_FAILURE);
701 }else if( argv[i][j+1] == '\0' ){
702 *(sP+dst) = argv[i][j]; dst++;
703 *(sP+dst) = '\0';
704 strcpy(paramP[n], sP); dst=0; n++;
705 if(n >= PARAM_MAX){
706 printf("error: too many arguments\n");
707 exit(EXIT_FAILURE);
708 }
709 }else{
710 *(sP+dst) = argv[i][j]; dst++;
711 }
712 }
713 }else{
714 /* not command-line options */
715 for(j=0; j<(int)strlen(argv[i]); j++){
716 *(sP+dst) = argv[i][j]; dst++;
717 }
718 *(sP+dst) = '\0';
719 strcpy(paramP[n], sP); dst=0; n++;
720 memset(sP,0,LINE_CHARMAX);
721 if(n >= PARAM_MAX){
722 printf("error: too many arguments\n");
723 exit(EXIT_FAILURE);
724 }
725 }
726 }
727 free(sP);
728
729 /* interpretting arguments */
730 for(i=0, flag=0; i<n; i++){
731 switch( paramP[i][0] ){
732 case '-':
733 if(paramP[i][1] == 's')
734 spacing = atoi(&paramP[i][2]);
735 else if(paramP[i][1] == 'c')
736 colchar = atoi(&paramP[i][2]);
737 else if(paramP[i][1] == 'w')
738 dwflag = ON;
739 else if(paramP[i][1] == 'i')
740 iflag = ON;
741 else if( (paramP[i][1]=='v') || (paramP[i][1]=='h'))
742 printhelp();
743 break;
744 default:
745 if(flag == 0){
746 strcpy(readFilename, paramP[i]);
747 flag ++;
748 }else{
749 strcpy(writeFilename, paramP[i]);
750 if(strcmp(readFilename, writeFilename) == 0){
751 printf("error: input-filename and output-filename are same\n");
752 exit(EXIT_FAILURE);
753 }
754 flag ++;
755 }
756 break;
757 }
758 }
759
760 if(flag < 2){
761 printf("error: not enough arguments\n");
762 printf("Usage: bdf2bmp [-option] input-bdf-file output-bmp-file\n");
763 exit(EXIT_FAILURE);
764 }
765
766 /* colchar is limited from 1 to 1024 */
767 if(colchar < 1)
768 colchar = 1;
769 else if(colchar > 1024)
770 colchar = 1024;
771
772 /* spacing is limited from 0 to 32 */
773 if(spacing < 0)
774 spacing = 0;
775 else if(spacing > 32)
776 spacing = 32;
777
778 /* checkEndian */
779 checkEndian();
780
781 /*
782 * prepare to read&write files
783 */
784 readP = fopen(readFilename, "r");
785 if(readP == NULL){
786 printf("bdf2bmp: '%s' does not exist\n", readFilename);
787 exit(EXIT_FAILURE);
788 }
789 /* Does writeFilename already exist? */
790 if((iflag==ON) && (stat(writeFilename, &fileinfo)==0)){
791 fprintf(stderr, "bdf2bmp: overwrite '%s'? ", writeFilename);
792 c = fgetc(stdin);
793 if((c=='y') || (c=='Y'))
794 ; /* go next */
795 else
796 /* printf("not overwrite\n"); */
797 exit(EXIT_FAILURE);
798 }
799 writeP=fopen(writeFilename, "wb");
800 if(writeP == NULL){
801 printf("error: cannot write '%s'\n", writeFilename);
802 exit(EXIT_FAILURE);
803 }
804
805
806 /* read bdf-font-file */
807 bitmapP = readBdfFile(bitmapP, readP);
808 fclose(readP);
809
810 /* write bmp-image-file */
811 writeBmpFile(bitmapP, spacing, colchar, writeP);
812 tmp = fclose(writeP);
813 if(tmp == EOF){
814 printf("error: cannot write '%s'\n", writeFilename);
815 free(bitmapP);
816 exit(EXIT_FAILURE);
817 }
818
819 free(bitmapP);
820 return EXIT_SUCCESS;
821}