2 * Convert BDF files to C source and/or Rockbox .fnt file format
4 * Copyright (c) 2002 by Greg Haerr <greg@censoft.com>
6 * What fun it is converting font data...
15 #define ROTATE /* define this for the new, rotated format */
18 /* loadable font magic and version #*/
20 #define VERSION "RB12" /* newer version */
22 #define VERSION "RB11"
25 /* bitmap_t helper macros*/
26 #define BITMAP_WORDS(x) (((x)+15)/16) /* image size in words*/
27 #define BITMAP_BYTES(x) (BITMAP_WORDS(x)*sizeof(bitmap_t))
28 #define BITMAP_BITSPERIMAGE (sizeof(bitmap_t) * 8)
29 #define BITMAP_BITVALUE(n) ((bitmap_t) (((bitmap_t) 1) << (n)))
30 #define BITMAP_FIRSTBIT (BITMAP_BITVALUE(BITMAP_BITSPERIMAGE - 1))
31 #define BITMAP_TESTBIT(m) ((m) & BITMAP_FIRSTBIT)
32 #define BITMAP_SHIFTBIT(m) ((bitmap_t) ((m) << 1))
34 typedef unsigned short bitmap_t
; /* bitmap image unit size*/
36 /* builtin C-based proportional/fixed font structure */
37 /* based on The Microwindows Project http://microwindows.org */
39 int maxwidth
; /* max width in pixels*/
40 int height
; /* height in pixels*/
41 int ascent
; /* ascent (baseline) height*/
42 int firstchar
; /* first character in bitmap*/
43 int size
; /* font size in glyphs*/
44 bitmap_t
* bits
; /* 16-bit right-padded bitmap data*/
45 unsigned long* offset
; /* offsets into bitmap data*/
46 unsigned char* width
; /* character widths or NULL if fixed*/
47 int defaultchar
; /* default char (not glyph index)*/
48 long bits_size
; /* # words of bitmap_t bits*/
50 /* unused by runtime system, read in by convbdf*/
51 unsigned long* offrot
; /* offsets into rotated bitmap data*/
52 char * name
; /* font name*/
53 char * facename
; /* facename of font*/
54 char * copyright
; /* copyright info for loadable fonts*/
57 int fbbw
, fbbh
, fbbx
, fbby
;
61 #define isprefix(buf,str) (!strncmp(buf, str, strlen(str)))
62 #define strequal(s1,s2) (!strcmp(s1, s2))
64 #define EXTRA 300 /* # bytes extra allocation for buggy .bdf files*/
70 int limit_char
= 65535;
75 void getopts(int *pac
, char ***pav
);
76 int convbdf(char *path
);
78 void free_font(struct font
* pf
);
79 struct font
* bdf_read_font(char *path
);
80 int bdf_read_header(FILE *fp
, struct font
* pf
);
81 int bdf_read_bitmaps(FILE *fp
, struct font
* pf
);
82 char * bdf_getline(FILE *fp
, char *buf
, int len
);
83 bitmap_t
bdf_hexval(unsigned char *buf
, int ndx1
, int ndx2
);
85 int gen_c_source(struct font
* pf
, char *path
);
86 int gen_fnt_file(struct font
* pf
, char *path
);
92 "Usage: convbdf [options] [input-files]\n"
93 " convbdf [options] [-o output-file] [single-input-file]\n"
95 " -c Convert .bdf to .c source file\n"
96 " -f Convert .bdf to .fnt font file\n"
97 " -s N Start output at character encodings >= N\n"
98 " -l N Limit output to character encodings <= N\n"
99 " -n Don't generate bitmaps as comments in .c file\n"
102 fprintf(stderr
, help
);
105 /* parse command line options*/
106 void getopts(int *pac
, char ***pav
)
114 while (ac
> 0 && av
[0][0] == '-') {
118 case ' ': /* multiple -args on av[]*/
119 while( *p
&& *p
== ' ')
121 if( *p
++ != '-') /* next option must have dash*/
123 break; /* proceed to next option*/
124 case 'c': /* generate .c output*/
127 case 'f': /* generate .fnt output*/
130 case 'n': /* don't gen bitmap comments*/
133 case 'o': /* set output file*/
137 while (*p
&& *p
!= ' ')
143 strcpy(outfile
, av
[0]);
146 case 'l': /* set encoding limit*/
148 limit_char
= atoi(p
);
149 while (*p
&& *p
!= ' ')
155 limit_char
= atoi(av
[0]);
158 case 's': /* set encoding start*/
160 start_char
= atoi(p
);
161 while (*p
&& *p
!= ' ')
167 start_char
= atoi(av
[0]);
171 fprintf(stderr
, "Unknown option ignored: %c\r\n", *(p
-1));
179 /* remove directory prefix and file suffix from full path*/
180 char *basename(char *path
)
183 static char base
[256];
185 /* remove prepended path and extension*/
187 for (p
=path
; *p
; ++p
) {
192 for (p
=base
; *p
; ++p
) {
201 int convbdf(char *path
)
206 pf
= bdf_read_font(path
);
212 strcpy(outfile
, basename(path
));
213 strcat(outfile
, ".c");
215 ret
|= gen_c_source(pf
, outfile
);
220 strcpy(outfile
, basename(path
));
221 strcat(outfile
, ".fnt");
223 ret
|= gen_fnt_file(pf
, outfile
);
230 int main(int ac
, char **av
)
234 ++av
; --ac
; /* skip av[0]*/
235 getopts(&ac
, &av
); /* read command line options*/
237 if (ac
< 1 || (!gen_c
&& !gen_fnt
)) {
242 if (ac
> 1 || (gen_c
&& gen_fnt
)) {
249 ret
|= convbdf(av
[0]);
256 /* free font structure*/
257 void free_font(struct font
* pf
)
276 /* build incore structure from .bdf file*/
277 struct font
* bdf_read_font(char *path
)
282 fp
= fopen(path
, "rb");
284 fprintf(stderr
, "Error opening file: %s\n", path
);
288 pf
= (struct font
*)calloc(1, sizeof(struct font
));
292 pf
->name
= strdup(basename(path
));
294 if (!bdf_read_header(fp
, pf
)) {
295 fprintf(stderr
, "Error reading font header\n");
299 if (!bdf_read_bitmaps(fp
, pf
)) {
300 fprintf(stderr
, "Error reading font bitmaps\n");
313 /* read bdf font header information, return 0 on error*/
314 int bdf_read_header(FILE *fp
, struct font
* pf
)
317 int nchars
, maxwidth
;
318 int firstchar
= 65535;
324 /* set certain values to errors for later error checking*/
325 pf
->defaultchar
= -1;
330 if (!bdf_getline(fp
, buf
, sizeof(buf
))) {
331 fprintf(stderr
, "Error: EOF on file\n");
334 if (isprefix(buf
, "FONT ")) { /* not required*/
335 if (sscanf(buf
, "FONT %[^\n]", facename
) != 1) {
336 fprintf(stderr
, "Error: bad 'FONT'\n");
339 pf
->facename
= strdup(facename
);
342 if (isprefix(buf
, "COPYRIGHT ")) { /* not required*/
343 if (sscanf(buf
, "COPYRIGHT \"%[^\"]", copyright
) != 1) {
344 fprintf(stderr
, "Error: bad 'COPYRIGHT'\n");
347 pf
->copyright
= strdup(copyright
);
350 if (isprefix(buf
, "DEFAULT_CHAR ")) { /* not required*/
351 if (sscanf(buf
, "DEFAULT_CHAR %d", &pf
->defaultchar
) != 1) {
352 fprintf(stderr
, "Error: bad 'DEFAULT_CHAR'\n");
356 if (isprefix(buf
, "FONT_DESCENT ")) {
357 if (sscanf(buf
, "FONT_DESCENT %d", &pf
->descent
) != 1) {
358 fprintf(stderr
, "Error: bad 'FONT_DESCENT'\n");
363 if (isprefix(buf
, "FONT_ASCENT ")) {
364 if (sscanf(buf
, "FONT_ASCENT %d", &pf
->ascent
) != 1) {
365 fprintf(stderr
, "Error: bad 'FONT_ASCENT'\n");
370 if (isprefix(buf
, "FONTBOUNDINGBOX ")) {
371 if (sscanf(buf
, "FONTBOUNDINGBOX %d %d %d %d",
372 &pf
->fbbw
, &pf
->fbbh
, &pf
->fbbx
, &pf
->fbby
) != 4) {
373 fprintf(stderr
, "Error: bad 'FONTBOUNDINGBOX'\n");
378 if (isprefix(buf
, "CHARS ")) {
379 if (sscanf(buf
, "CHARS %d", &nchars
) != 1) {
380 fprintf(stderr
, "Error: bad 'CHARS'\n");
387 * Reading ENCODING is necessary to get firstchar/lastchar
388 * which is needed to pre-calculate our offset and widths
391 if (isprefix(buf
, "ENCODING ")) {
392 if (sscanf(buf
, "ENCODING %d", &encoding
) != 1) {
393 fprintf(stderr
, "Error: bad 'ENCODING'\n");
397 encoding
<= limit_char
&&
398 encoding
>= start_char
) {
400 if (firstchar
> encoding
)
401 firstchar
= encoding
;
402 if (lastchar
< encoding
)
407 if (strequal(buf
, "ENDFONT"))
411 /* calc font height*/
412 if (pf
->ascent
< 0 || pf
->descent
< 0 || firstchar
< 0) {
413 fprintf(stderr
, "Error: Invalid BDF file, requires FONT_ASCENT/FONT_DESCENT/ENCODING\n");
416 pf
->height
= pf
->ascent
+ pf
->descent
;
418 /* calc default char*/
419 if (pf
->defaultchar
< 0 ||
420 pf
->defaultchar
< firstchar
||
421 pf
->defaultchar
> limit_char
)
422 pf
->defaultchar
= firstchar
;
424 /* calc font size (offset/width entries)*/
425 pf
->firstchar
= firstchar
;
426 pf
->size
= lastchar
- firstchar
+ 1;
428 /* use the font boundingbox to get initial maxwidth*/
429 /*maxwidth = pf->fbbw - pf->fbbx;*/
432 /* initially use font maxwidth * height for bits allocation*/
433 pf
->bits_size
= nchars
* BITMAP_WORDS(maxwidth
) * pf
->height
;
435 /* allocate bits, offset, and width arrays*/
436 pf
->bits
= (bitmap_t
*)malloc(pf
->bits_size
* sizeof(bitmap_t
) + EXTRA
);
437 pf
->offset
= (unsigned long *)malloc(pf
->size
* sizeof(unsigned long));
438 pf
->offrot
= (unsigned long *)malloc(pf
->size
* sizeof(unsigned long));
439 pf
->width
= (unsigned char *)malloc(pf
->size
* sizeof(unsigned char));
441 if (!pf
->bits
|| !pf
->offset
|| !pf
->offrot
|| !pf
->width
) {
442 fprintf(stderr
, "Error: no memory for font load\n");
449 /* read bdf font bitmaps, return 0 on error*/
450 int bdf_read_bitmaps(FILE *fp
, struct font
* pf
)
455 int i
, k
, encoding
, width
;
456 int bbw
, bbh
, bbx
, bby
;
457 int proportional
= 0;
462 /* reset file pointer*/
463 fseek(fp
, 0L, SEEK_SET
);
465 /* initially mark offsets as not used*/
466 for (i
=0; i
<pf
->size
; ++i
)
470 if (!bdf_getline(fp
, buf
, sizeof(buf
))) {
471 fprintf(stderr
, "Error: EOF on file\n");
474 if (isprefix(buf
, "STARTCHAR")) {
475 encoding
= width
= bbw
= bbh
= bbx
= bby
= -1;
478 if (isprefix(buf
, "ENCODING ")) {
479 if (sscanf(buf
, "ENCODING %d", &encoding
) != 1) {
480 fprintf(stderr
, "Error: bad 'ENCODING'\n");
483 if (encoding
< start_char
|| encoding
> limit_char
)
487 if (isprefix(buf
, "DWIDTH ")) {
488 if (sscanf(buf
, "DWIDTH %d", &width
) != 1) {
489 fprintf(stderr
, "Error: bad 'DWIDTH'\n");
492 /* use font boundingbox width if DWIDTH <= 0*/
494 width
= pf
->fbbw
- pf
->fbbx
;
497 if (isprefix(buf
, "BBX ")) {
498 if (sscanf(buf
, "BBX %d %d %d %d", &bbw
, &bbh
, &bbx
, &bby
) != 4) {
499 fprintf(stderr
, "Error: bad 'BBX'\n");
504 if (strequal(buf
, "BITMAP")) {
505 bitmap_t
*ch_bitmap
= pf
->bits
+ ofs
;
511 /* set bits offset in encode map*/
512 if (pf
->offset
[encoding
-pf
->firstchar
] != (unsigned long)-1) {
513 fprintf(stderr
, "Error: duplicate encoding for character %d (0x%02x), ignoring duplicate\n",
517 pf
->offset
[encoding
-pf
->firstchar
] = ofs
;
518 pf
->offrot
[encoding
-pf
->firstchar
] = ofr
;
523 /*if (width > maxwidth)
527 if (width
> maxwidth
)
529 pf
->width
[encoding
-pf
->firstchar
] = width
;
532 memset(ch_bitmap
, 0, BITMAP_BYTES(width
) * pf
->height
);
534 ch_words
= BITMAP_WORDS(width
);
535 #define BM(row,col) (*(ch_bitmap + ((row)*ch_words) + (col)))
536 #define BITMAP_NIBBLES (BITMAP_BITSPERIMAGE/4)
542 if (!bdf_getline(fp
, buf
, sizeof(buf
))) {
543 fprintf(stderr
, "Error: EOF reading BITMAP data\n");
546 if (isprefix(buf
, "ENDCHAR"))
549 hexnibbles
= strlen(buf
);
550 for (k
=0; k
<ch_words
; ++k
) {
551 int ndx
= k
* BITMAP_NIBBLES
;
552 int padnibbles
= hexnibbles
- ndx
;
557 if (padnibbles
>= BITMAP_NIBBLES
)
560 value
= bdf_hexval((unsigned char *)buf
,
561 ndx
, ndx
+BITMAP_NIBBLES
-1-padnibbles
);
562 value
<<= padnibbles
* BITMAP_NIBBLES
;
564 BM(pf
->height
- pf
->descent
- bby
- bbh
+ i
, k
) |=
566 /* handle overflow into next image word*/
568 BM(pf
->height
- pf
->descent
- bby
- bbh
+ i
, k
+1) =
569 value
<< (BITMAP_BITSPERIMAGE
- bbx
);
574 ofs
+= BITMAP_WORDS(width
) * pf
->height
;
575 ofr
+= pf
->width
[encoding
-pf
->firstchar
] * ((pf
->height
+7)/8);
579 if (strequal(buf
, "ENDFONT"))
584 pf
->maxwidth
= maxwidth
;
586 /* change unused offset/width values to default char values*/
587 for (i
=0; i
<pf
->size
; ++i
) {
588 int defchar
= pf
->defaultchar
- pf
->firstchar
;
590 if (pf
->offset
[i
] == (unsigned long)-1) {
591 pf
->offset
[i
] = pf
->offset
[defchar
];
592 pf
->offrot
[i
] = pf
->offrot
[defchar
];
593 pf
->width
[i
] = pf
->width
[defchar
];
597 /* determine whether font doesn't require encode table*/
600 for (i
=0; i
<pf
->size
; ++i
) {
601 if (pf
->offrot
[i
] != l
) {
605 l
+= pf
->maxwidth
* (pf
->height
+ 7) / 8;
609 for (i
=0; i
<pf
->size
; ++i
) {
610 if (pf
->offset
[i
] != l
) {
614 l
+= BITMAP_WORDS(pf
->width
[i
]) * pf
->height
;
622 /* determine whether font is fixed-width*/
623 for (i
=0; i
<pf
->size
; ++i
) {
624 if (pf
->width
[i
] != maxwidth
) {
634 /* reallocate bits array to actual bits used*/
635 if (ofs
< pf
->bits_size
) {
636 pf
->bits
= realloc(pf
->bits
, ofs
* sizeof(bitmap_t
));
640 if (ofs
> pf
->bits_size
) {
641 fprintf(stderr
, "Warning: DWIDTH spec > max FONTBOUNDINGBOX\n");
642 if (ofs
> pf
->bits_size
+EXTRA
) {
643 fprintf(stderr
, "Error: Not enough bits initially allocated\n");
651 pf
->bits_size
= ofr
; /* always update, rotated is smaller */
657 /* read the next non-comment line, returns buf or NULL if EOF*/
658 char *bdf_getline(FILE *fp
, char *buf
, int len
)
665 while ((c
= getc(fp
)) != EOF
) {
670 if (b
- buf
>= (len
- 1))
675 if (c
== EOF
&& b
== buf
)
677 if (b
!= buf
&& !isprefix(buf
, "COMMENT"))
683 /* return hex value of portion of buffer*/
684 bitmap_t
bdf_hexval(unsigned char *buf
, int ndx1
, int ndx2
)
689 for (i
=ndx1
; i
<=ndx2
; ++i
) {
691 if (c
>= '0' && c
<= '9')
694 if (c
>= 'A' && c
<= 'F')
697 if (c
>= 'a' && c
<= 'f')
701 val
= (val
<< 4) | c
;
707 * Take an bitmap_t bitmap and convert to Rockbox format.
708 * Used for converting font glyphs for the time being.
709 * Can use for standard X11 and Win32 images as well.
710 * See format description in lcd-recorder.c
712 * Doing it this way keeps fonts in standard formats,
713 * as well as keeping Rockbox hw bitmap format.
715 int rotleft(unsigned char *dst
, bitmap_t
*src
, unsigned int width
,
719 unsigned int src_words
; /* # words of input image*/
720 unsigned int dst_mask
; /* bit mask for destination */
721 bitmap_t src_mask
; /* bit mask for source */
723 /* calc words of input image*/
724 src_words
= BITMAP_WORDS(width
) * height
;
726 /* clear background*/
727 memset(dst
, 0, ((height
+ 7) / 8) * width
);
731 for (i
=0; i
< src_words
; i
++) {
733 /* calc src input bit*/
734 src_mask
= 1 << (sizeof (bitmap_t
) * 8 - 1);
736 /* for each input column...*/
737 for(j
=0; j
< width
; j
++) {
739 /* if set in input, set in rotated output */
740 if (src
[i
] & src_mask
)
743 src_mask
>>= 1; /* next input bit */
744 if (src_mask
== 0) /* input word done? */
746 src_mask
= 1 << (sizeof (bitmap_t
) * 8 - 1);
747 i
++; /* next input word */
751 dst_mask
<<= 1; /* next output bit (row) */
752 if (dst_mask
> (1 << 7)) /* output bit > 7? */
755 dst
+= width
; /* next output byte row */
758 return ((height
+ 7) / 8) * width
; /* return result size in bytes */
762 /* generate C source from in-core font*/
763 int gen_c_source(struct font
* pf
, char *path
)
767 int did_defaultchar
= 0;
770 bitmap_t
*ofs
= pf
->bits
;
774 "/* Generated by convbdf on %s. */\n"
775 "#include \"font.h\"\n"
776 "#ifdef HAVE_LCD_BITMAP\n"
778 "/* Font information:\n"
785 " first char: %d (0x%02x)\n"
786 " last char: %d (0x%02x)\n"
787 " default char: %d (0x%02x)\n"
788 " proportional: %s\n"
792 "/* Font character bitmap data. */\n"
793 "static const unsigned char _font_bits[] = {\n"
796 ofp
= fopen(path
, "w");
798 fprintf(stderr
, "Can't create %s\n", path
);
802 strcpy(buf
, ctime(&t
));
803 buf
[strlen(buf
)-1] = 0;
805 fprintf(ofp
, hdr1
, buf
,
807 pf
->facename
? pf
->facename
: "",
808 pf
->maxwidth
, pf
->height
,
810 pf
->ascent
, pf
->descent
,
811 pf
->firstchar
, pf
->firstchar
,
812 pf
->firstchar
+pf
->size
-1, pf
->firstchar
+pf
->size
-1,
813 pf
->defaultchar
, pf
->defaultchar
,
814 pf
->width
? "yes": "no",
815 pf
->copyright
? pf
->copyright
: "");
817 /* generate bitmaps*/
818 for (i
=0; i
<pf
->size
; ++i
) {
821 int width
= pf
->width
? pf
->width
[i
] : pf
->maxwidth
;
822 int height
= pf
->height
;
823 bitmap_t
*bits
= pf
->bits
+ (pf
->offset
? pf
->offset
[i
]: (height
* i
));
827 * Generate bitmap bits only if not this index isn't
828 * the default character in encode map, or the default
829 * character hasn't been generated yet.
832 (pf
->offset
[i
] == pf
->offset
[pf
->defaultchar
-pf
->firstchar
])) {
838 fprintf(ofp
, "\n/* Character %d (0x%02x):\n width %d",
839 i
+pf
->firstchar
, i
+pf
->firstchar
, width
);
842 fprintf(ofp
, "\n +");
843 for (x
=0; x
<width
; ++x
) fprintf(ofp
, "-");
848 if (x
== 0) fprintf(ofp
, " |");
851 bitcount
= BITMAP_BITSPERIMAGE
;
855 fprintf(ofp
, BITMAP_TESTBIT(bitvalue
)? "*": " ");
857 bitvalue
= BITMAP_SHIFTBIT(bitvalue
);
867 for (x
=0; x
<width
; ++x
)
869 fprintf(ofp
, "+ */\n");
872 fprintf(ofp
, " */\n");
874 bits
= pf
->bits
+ (pf
->offset
? pf
->offset
[i
]: (pf
->height
* i
));
875 #ifdef ROTATE /* pre-rotated into Rockbox bitmap format */
877 unsigned char bytemap
[256];
880 rotleft(bytemap
, bits
, width
, pf
->height
);
881 for (y8
=0; y8
<pf
->height
; y8
+=8) /* column rows */
883 for (x
=0; x
<width
; x
++) {
884 fprintf(ofp
, "0x%02x, ", bytemap
[ix
]);
891 for (x
=BITMAP_WORDS(width
)*pf
->height
; x
>0; --x
) {
892 fprintf(ofp
, "0x%04x,\n", *bits
);
893 if (!did_syncmsg
&& *bits
++ != *ofs
++) {
894 fprintf(stderr
, "Warning: found encoding values in non-sorted order (not an error).\n");
900 fprintf(ofp
, "};\n\n");
903 /* output offset table*/
904 fprintf(ofp
, "/* Character->glyph mapping. */\n"
905 "static const unsigned short _sysfont_offset[] = {\n");
907 for (i
=0; i
<pf
->size
; ++i
)
908 fprintf(ofp
, " %ld,\t/* (0x%02x) */\n",
910 pf
->offrot
[i
], i
+pf
->firstchar
);
912 pf
->offset
[i
], i
+pf
->firstchar
);
914 fprintf(ofp
, "};\n\n");
917 /* output width table for proportional fonts*/
919 fprintf(ofp
, "/* Character width data. */\n"
920 "static const unsigned char _sysfont_width[] = {\n");
922 for (i
=0; i
<pf
->size
; ++i
)
923 fprintf(ofp
, " %d,\t/* (0x%02x) */\n",
924 pf
->width
[i
], i
+pf
->firstchar
);
925 fprintf(ofp
, "};\n\n");
928 /* output struct font struct*/
930 sprintf(obuf
, "_sysfont_offset,");
932 sprintf(obuf
, "0, /* no encode table */");
935 sprintf(buf
, "_sysfont_width, /* width */");
937 sprintf(buf
, "0, /* fixed width */");
939 fprintf(ofp
, "/* Exported structure definition. */\n"
940 "const struct font sysfont = {\n"
941 " %d, /* maxwidth */\n"
942 " %d, /* height */\n"
943 " %d, /* ascent */\n"
944 " %d, /* firstchar */\n"
946 " _font_bits, /* bits */\n"
949 " %d, /* defaultchar */\n"
951 "#endif /* HAVE_LCD_BITMAP */\n",
952 pf
->maxwidth
, pf
->height
,
963 static int writebyte(FILE *fp
, unsigned char c
)
965 return putc(c
, fp
) != EOF
;
968 static int writeshort(FILE *fp
, unsigned short s
)
971 return putc(s
>>8, fp
) != EOF
;
974 static int writelong(FILE *fp
, unsigned long l
)
979 return putc(l
>>24, fp
) != EOF
;
982 static int writestr(FILE *fp
, char *str
, int count
)
984 return fwrite(str
, 1, count
, fp
) == count
;
987 static int writestrpad(FILE *fp
, char *str
, int totlen
)
991 while (str
&& *str
&& totlen
> 0) {
993 ret
= putc(*str
++, fp
);
997 while (--totlen
>= 0)
1002 /* generate .fnt format file from in-core font*/
1003 int gen_fnt_file(struct font
* pf
, char *path
)
1007 int did_defaultchar
= 0;
1009 ofp
= fopen(path
, "wb");
1011 fprintf(stderr
, "Can't create %s\n", path
);
1015 /* write magic and version #*/
1016 writestr(ofp
, VERSION
, 4);
1018 /* internal font name*/
1019 writestrpad(ofp
, pf
->name
, 64);
1022 writestrpad(ofp
, pf
->copyright
, 256);
1025 writeshort(ofp
, pf
->maxwidth
);
1026 writeshort(ofp
, pf
->height
);
1027 writeshort(ofp
, pf
->ascent
);
1029 writelong(ofp
, pf
->firstchar
);
1030 writelong(ofp
, pf
->defaultchar
);
1031 writelong(ofp
, pf
->size
);
1033 /* variable font data sizes*/
1034 writelong(ofp
, pf
->bits_size
); /* # words of bitmap_t*/
1035 writelong(ofp
, pf
->offset
? pf
->size
: 0); /* # longs of offset*/
1036 writelong(ofp
, pf
->width
? pf
->size
: 0); /* # bytes of width*/
1037 /* variable font data*/
1039 for (i
=0; i
<pf
->size
; ++i
)
1041 bitmap_t
* bits
= pf
->bits
+ (pf
->offset
? pf
->offset
[i
]: (pf
->height
* i
));
1042 int width
= pf
->width
? pf
->width
[i
] : pf
->maxwidth
;
1044 unsigned char bytemap
[256];
1047 (pf
->offset
[i
] == pf
->offset
[pf
->defaultchar
-pf
->firstchar
])) {
1048 if (did_defaultchar
)
1050 did_defaultchar
= 1;
1053 size
= rotleft(bytemap
, bits
, width
, pf
->height
);
1054 writestr(ofp
, bytemap
, size
);
1058 writebyte(ofp
, 0); /* pad to 16-bit boundary*/
1061 for (i
=0; i
<pf
->size
; ++i
)
1062 writeshort(ofp
, pf
->offrot
[i
]);
1065 for (i
=0; i
<pf
->size
; ++i
)
1066 writebyte(ofp
, pf
->width
[i
]);
1068 for (i
=0; i
<pf
->bits_size
; ++i
)
1069 writeshort(ofp
, pf
->bits
[i
]);
1071 writeshort(ofp
, 0); /* pad to 32-bit boundary*/
1074 for (i
=0; i
<pf
->size
; ++i
)
1075 writelong(ofp
, pf
->offset
[i
]);
1078 for (i
=0; i
<pf
->size
; ++i
)
1079 writebyte(ofp
, pf
->width
[i
]);