1 /*-
2 * Copyright (c) 2009, 2014 The FreeBSD Foundation
3 * All rights reserved.
4 *
5 * This software was developed by Ed Schouten under sponsorship from the
6 * FreeBSD Foundation.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 */
29
30 #include <sys/cdefs.h>
31 __FBSDID("$FreeBSD$");
32
33 #include <sys/types.h>
34 #include <sys/fnv_hash.h>
35 #include <sys/endian.h>
36 #include <sys/param.h>
37 #include <sys/queue.h>
38
39 #include <assert.h>
40 #include <err.h>
41 #include <stdint.h>
42 #include <stdio.h>
43 #include <stdlib.h>
44 #include <string.h>
45 #include <unistd.h>
46
47 #define VFNT_MAPS 4
48 #define VFNT_MAP_NORMAL 0
49 #define VFNT_MAP_NORMAL_RH 1
50 #define VFNT_MAP_BOLD 2
51 #define VFNT_MAP_BOLD_RH 3
52
53 static unsigned int width = 8, wbytes, height = 16;
54
55 struct glyph {
56 TAILQ_ENTRY(glyph) g_list;
57 SLIST_ENTRY(glyph) g_hash;
58 uint8_t *g_data;
59 unsigned int g_index;
60 };
61
62 #define FONTCVT_NHASH 4096
63 TAILQ_HEAD(glyph_list, glyph);
64 static SLIST_HEAD(, glyph) glyph_hash[FONTCVT_NHASH];
65 static struct glyph_list glyphs[VFNT_MAPS] = {
66 TAILQ_HEAD_INITIALIZER(glyphs[0]),
67 TAILQ_HEAD_INITIALIZER(glyphs[1]),
68 TAILQ_HEAD_INITIALIZER(glyphs[2]),
69 TAILQ_HEAD_INITIALIZER(glyphs[3]),
70 };
71 static unsigned int glyph_total, glyph_count[4], glyph_unique, glyph_dupe;
72
73 struct mapping {
74 TAILQ_ENTRY(mapping) m_list;
75 unsigned int m_char;
76 unsigned int m_length;
77 struct glyph *m_glyph;
78 };
79
80 TAILQ_HEAD(mapping_list, mapping);
81 static struct mapping_list maps[VFNT_MAPS] = {
82 TAILQ_HEAD_INITIALIZER(maps[0]),
83 TAILQ_HEAD_INITIALIZER(maps[1]),
84 TAILQ_HEAD_INITIALIZER(maps[2]),
85 TAILQ_HEAD_INITIALIZER(maps[3]),
86 };
87 static unsigned int mapping_total, map_count[4], map_folded_count[4],
88 mapping_unique, mapping_dupe;
89
90 static void
usage(void)91 usage(void)
92 {
93
94 (void)fprintf(stderr,
95 "usage: vtfontcvt [-w width] [-h height] [-v] normal.bdf [bold.bdf] out.fnt\n");
96 exit(1);
97 }
98
99 static void *
xmalloc(size_t size)100 xmalloc(size_t size)
101 {
102 void *m;
103
104 if ((m = malloc(size)) == NULL)
105 errx(1, "memory allocation failure");
106 return (m);
107 }
108
109 static int
add_mapping(struct glyph * gl,unsigned int c,unsigned int map_idx)110 add_mapping(struct glyph *gl, unsigned int c, unsigned int map_idx)
111 {
112 struct mapping *mp;
113 struct mapping_list *ml;
114
115 mapping_total++;
116
117 mp = xmalloc(sizeof *mp);
118 mp->m_char = c;
119 mp->m_glyph = gl;
120 mp->m_length = 0;
121
122 ml = &maps[map_idx];
123 if (TAILQ_LAST(ml, mapping_list) != NULL &&
124 TAILQ_LAST(ml, mapping_list)->m_char >= c)
125 errx(1, "Bad ordering at character %u\n", c);
126 TAILQ_INSERT_TAIL(ml, mp, m_list);
127
128 map_count[map_idx]++;
129 mapping_unique++;
130
131 return (0);
132 }
133
134 static int
dedup_mapping(unsigned int map_idx)135 dedup_mapping(unsigned int map_idx)
136 {
137 struct mapping *mp_bold, *mp_normal, *mp_temp;
138 unsigned normal_map_idx = map_idx - VFNT_MAP_BOLD;
139
140 assert(map_idx == VFNT_MAP_BOLD || map_idx == VFNT_MAP_BOLD_RH);
141 mp_normal = TAILQ_FIRST(&maps[normal_map_idx]);
142 TAILQ_FOREACH_SAFE(mp_bold, &maps[map_idx], m_list, mp_temp) {
143 while (mp_normal->m_char < mp_bold->m_char)
144 mp_normal = TAILQ_NEXT(mp_normal, m_list);
145 if (mp_bold->m_char != mp_normal->m_char)
146 errx(1, "Character %u not in normal font!\n",
147 mp_bold->m_char);
148 if (mp_bold->m_glyph != mp_normal->m_glyph)
149 continue;
150
151 /* No mapping is needed if it's equal to the normal mapping. */
152 TAILQ_REMOVE(&maps[map_idx], mp_bold, m_list);
153 free(mp_bold);
154 mapping_dupe++;
155 }
156 return (0);
157 }
158
159 static struct glyph *
add_glyph(const uint8_t * bytes,unsigned int map_idx,int fallback)160 add_glyph(const uint8_t *bytes, unsigned int map_idx, int fallback)
161 {
162 struct glyph *gl;
163 int hash;
164
165 glyph_total++;
166 glyph_count[map_idx]++;
167
168 hash = fnv_32_buf(bytes, wbytes * height, FNV1_32_INIT) % FONTCVT_NHASH;
169 SLIST_FOREACH(gl, &glyph_hash[hash], g_hash) {
170 if (memcmp(gl->g_data, bytes, wbytes * height) == 0) {
171 glyph_dupe++;
172 return (gl);
173 }
174 }
175
176 gl = xmalloc(sizeof *gl);
177 gl->g_data = xmalloc(wbytes * height);
178 memcpy(gl->g_data, bytes, wbytes * height);
179 if (fallback)
180 TAILQ_INSERT_HEAD(&glyphs[map_idx], gl, g_list);
181 else
182 TAILQ_INSERT_TAIL(&glyphs[map_idx], gl, g_list);
183 SLIST_INSERT_HEAD(&glyph_hash[hash], gl, g_hash);
184
185 glyph_unique++;
186 return (gl);
187 }
188
189 static int
add_char(unsigned curchar,unsigned map_idx,uint8_t * bytes,uint8_t * bytes_r)190 add_char(unsigned curchar, unsigned map_idx, uint8_t *bytes, uint8_t *bytes_r)
191 {
192 struct glyph *gl;
193
194 /* Prevent adding two glyphs for 0xFFFD */
195 if (curchar == 0xFFFD) {
196 if (map_idx < VFNT_MAP_BOLD)
197 gl = add_glyph(bytes, 0, 1);
198 } else if (curchar >= 0x20) {
199 gl = add_glyph(bytes, map_idx, 0);
200 if (add_mapping(gl, curchar, map_idx) != 0)
201 return (1);
202 if (bytes_r != NULL) {
203 gl = add_glyph(bytes_r, map_idx + 1, 0);
204 if (add_mapping(gl, curchar,
205 map_idx + 1) != 0)
206 return (1);
207 }
208 }
209 return (0);
210 }
211
212
213 static int
parse_bitmap_line(uint8_t * left,uint8_t * right,unsigned int line,unsigned int dwidth)214 parse_bitmap_line(uint8_t *left, uint8_t *right, unsigned int line,
215 unsigned int dwidth)
216 {
217 uint8_t *p;
218 unsigned int i, subline;
219
220 if (dwidth != width && dwidth != width * 2)
221 errx(1, "Bitmap with unsupported width %u!\n", dwidth);
222
223 /* Move pixel data right to simplify splitting double characters. */
224 line >>= (howmany(dwidth, 8) * 8) - dwidth;
225
226 for (i = dwidth / width; i > 0; i--) {
227 p = (i == 2) ? right : left;
228
229 subline = line & ((1 << width) - 1);
230 subline <<= (howmany(width, 8) * 8) - width;
231
232 if (wbytes == 1) {
233 *p = subline;
234 } else if (wbytes == 2) {
235 *p++ = subline >> 8;
236 *p = subline;
237 } else {
238 errx(1, "Unsupported wbytes %u!\n", wbytes);
239 }
240
241 line >>= width;
242 }
243
244 return (0);
245 }
246
247 static int
parse_bdf(FILE * fp,unsigned int map_idx)248 parse_bdf(FILE *fp, unsigned int map_idx)
249 {
250 char *ln;
251 size_t length;
252 uint8_t bytes[wbytes * height], bytes_r[wbytes * height];
253 unsigned int curchar = 0, dwidth = 0, i, line;
254
255 while ((ln = fgetln(fp, &length)) != NULL) {
256 ln[length - 1] = '\0';
257
258 if (strncmp(ln, "ENCODING ", 9) == 0) {
259 curchar = atoi(ln + 9);
260 }
261
262 if (strncmp(ln, "DWIDTH ", 7) == 0) {
263 dwidth = atoi(ln + 7);
264 }
265
266 if (strncmp(ln, "BITMAP", 6) == 0 &&
267 (ln[6] == ' ' || ln[6] == '\0')) {
268 for (i = 0; i < height; i++) {
269 if ((ln = fgetln(fp, &length)) == NULL)
270 errx(1, "Unexpected EOF!\n");
271 ln[length - 1] = '\0';
272 sscanf(ln, "%x", &line);
273 if (parse_bitmap_line(bytes + i * wbytes,
274 bytes_r + i * wbytes, line, dwidth) != 0)
275 return (1);
276 }
277
278 if (add_char(curchar, map_idx, bytes,
279 dwidth == width * 2 ? bytes_r : NULL) != 0)
280 return (1);
281 }
282 }
283
284 return (0);
285 }
286
287 static void
set_width(int w)288 set_width(int w)
289 {
290
291 if (w <= 0 || w > 128)
292 errx(1, "invalid width %d", w);
293 width = w;
294 wbytes = howmany(width, 8);
295 }
296
297 static int
parse_hex(FILE * fp,unsigned int map_idx)298 parse_hex(FILE *fp, unsigned int map_idx)
299 {
300 char *ln, *p;
301 char fmt_str[8];
302 size_t length;
303 uint8_t *bytes = NULL, *bytes_r = NULL;
304 unsigned curchar = 0, i, line, chars_per_row, dwidth;
305 int rv = 0;
306
307 while ((ln = fgetln(fp, &length)) != NULL) {
308 ln[length - 1] = '\0';
309
310 if (strncmp(ln, "# Height: ", 10) == 0) {
311 if (bytes != NULL)
312 errx(1, "malformed input: Height tag after font data");
313 height = atoi(ln + 10);
314 } else if (strncmp(ln, "# Width: ", 9) == 0) {
315 if (bytes != NULL)
316 errx(1, "malformed input: Width tag after font data");
317 set_width(atoi(ln + 9));
318 } else if (sscanf(ln, "%4x:", &curchar)) {
319 if (bytes == NULL) {
320 bytes = xmalloc(wbytes * height);
321 bytes_r = xmalloc(wbytes * height);
322 }
323 p = ln + 5;
324 chars_per_row = strlen(p) / height;
325 dwidth = width;
326 if (chars_per_row / 2 > (width + 7) / 8)
327 dwidth *= 2; /* Double-width character. */
328 snprintf(fmt_str, sizeof(fmt_str), "%%%ux",
329 chars_per_row);
330
331 for (i = 0; i < height; i++) {
332 sscanf(p, fmt_str, &line);
333 p += chars_per_row;
334 if (parse_bitmap_line(bytes + i * wbytes,
335 bytes_r + i * wbytes, line, dwidth) != 0) {
336 rv = 1;
337 goto out;
338 }
339 }
340
341 if (add_char(curchar, map_idx, bytes,
342 dwidth == width * 2 ? bytes_r : NULL) != 0) {
343 rv = 1;
344 goto out;
345 }
346 }
347 }
348 out:
349 free(bytes);
350 free(bytes_r);
351 return (rv);
352 }
353
354 static int
parse_file(const char * filename,unsigned int map_idx)355 parse_file(const char *filename, unsigned int map_idx)
356 {
357 FILE *fp;
358 size_t len;
359 int rv;
360
361 fp = fopen(filename, "r");
362 if (fp == NULL) {
363 perror(filename);
364 return (1);
365 }
366 len = strlen(filename);
367 if (len > 4 && strcasecmp(filename + len - 4, ".hex") == 0)
368 rv = parse_hex(fp, map_idx);
369 else
370 rv = parse_bdf(fp, map_idx);
371 fclose(fp);
372 return (rv);
373 }
374
375 static void
number_glyphs(void)376 number_glyphs(void)
377 {
378 struct glyph *gl;
379 unsigned int i, idx = 0;
380
381 for (i = 0; i < VFNT_MAPS; i++)
382 TAILQ_FOREACH(gl, &glyphs[i], g_list)
383 gl->g_index = idx++;
384 }
385
386 static int
write_glyphs(FILE * fp)387 write_glyphs(FILE *fp)
388 {
389 struct glyph *gl;
390 unsigned int i;
391
392 for (i = 0; i < VFNT_MAPS; i++) {
393 TAILQ_FOREACH(gl, &glyphs[i], g_list)
394 if (fwrite(gl->g_data, wbytes * height, 1, fp) != 1)
395 return (1);
396 }
397 return (0);
398 }
399
400 static void
fold_mappings(unsigned int map_idx)401 fold_mappings(unsigned int map_idx)
402 {
403 struct mapping_list *ml = &maps[map_idx];
404 struct mapping *mn, *mp, *mbase;
405
406 mp = mbase = TAILQ_FIRST(ml);
407 for (mp = mbase = TAILQ_FIRST(ml); mp != NULL; mp = mn) {
408 mn = TAILQ_NEXT(mp, m_list);
409 if (mn != NULL && mn->m_char == mp->m_char + 1 &&
410 mn->m_glyph->g_index == mp->m_glyph->g_index + 1)
411 continue;
412 mbase->m_length = mp->m_char - mbase->m_char + 1;
413 mbase = mp = mn;
414 map_folded_count[map_idx]++;
415 }
416 }
417
418 struct file_mapping {
419 uint32_t source;
420 uint16_t destination;
421 uint16_t length;
422 } __packed;
423
424 static int
write_mappings(FILE * fp,unsigned int map_idx)425 write_mappings(FILE *fp, unsigned int map_idx)
426 {
427 struct mapping_list *ml = &maps[map_idx];
428 struct mapping *mp;
429 struct file_mapping fm;
430 unsigned int i = 0, j = 0;
431
432 TAILQ_FOREACH(mp, ml, m_list) {
433 j++;
434 if (mp->m_length > 0) {
435 i += mp->m_length;
436 fm.source = htobe32(mp->m_char);
437 fm.destination = htobe16(mp->m_glyph->g_index);
438 fm.length = htobe16(mp->m_length - 1);
439 if (fwrite(&fm, sizeof fm, 1, fp) != 1)
440 return (1);
441 }
442 }
443 assert(i == j);
444 return (0);
445 }
446
447 struct file_header {
448 uint8_t magic[8];
449 uint8_t width;
450 uint8_t height;
451 uint16_t pad;
452 uint32_t glyph_count;
453 uint32_t map_count[4];
454 } __packed;
455
456 static int
write_fnt(const char * filename)457 write_fnt(const char *filename)
458 {
459 FILE *fp;
460 struct file_header fh = {
461 .magic = "VFNT0002",
462 };
463
464 fp = fopen(filename, "wb");
465 if (fp == NULL) {
466 perror(filename);
467 return (1);
468 }
469
470 fh.width = width;
471 fh.height = height;
472 fh.glyph_count = htobe32(glyph_unique);
473 fh.map_count[0] = htobe32(map_folded_count[0]);
474 fh.map_count[1] = htobe32(map_folded_count[1]);
475 fh.map_count[2] = htobe32(map_folded_count[2]);
476 fh.map_count[3] = htobe32(map_folded_count[3]);
477 if (fwrite(&fh, sizeof fh, 1, fp) != 1) {
478 perror(filename);
479 fclose(fp);
480 return (1);
481 }
482
483 if (write_glyphs(fp) != 0 ||
484 write_mappings(fp, VFNT_MAP_NORMAL) != 0 ||
485 write_mappings(fp, 1) != 0 ||
486 write_mappings(fp, VFNT_MAP_BOLD) != 0 ||
487 write_mappings(fp, 3) != 0) {
488 perror(filename);
489 fclose(fp);
490 return (1);
491 }
492
493 fclose(fp);
494 return (0);
495 }
496
497 static void
print_font_info(void)498 print_font_info(void)
499 {
500 printf(
501 "Statistics:\n"
502 "- glyph_total: %6u\n"
503 "- glyph_normal: %6u\n"
504 "- glyph_normal_right: %6u\n"
505 "- glyph_bold: %6u\n"
506 "- glyph_bold_right: %6u\n"
507 "- glyph_unique: %6u\n"
508 "- glyph_dupe: %6u\n"
509 "- mapping_total: %6u\n"
510 "- mapping_normal: %6u\n"
511 "- mapping_normal_folded: %6u\n"
512 "- mapping_normal_right: %6u\n"
513 "- mapping_normal_right_folded: %6u\n"
514 "- mapping_bold: %6u\n"
515 "- mapping_bold_folded: %6u\n"
516 "- mapping_bold_right: %6u\n"
517 "- mapping_bold_right_folded: %6u\n"
518 "- mapping_unique: %6u\n"
519 "- mapping_dupe: %6u\n",
520 glyph_total,
521 glyph_count[0],
522 glyph_count[1],
523 glyph_count[2],
524 glyph_count[3],
525 glyph_unique, glyph_dupe,
526 mapping_total,
527 map_count[0], map_folded_count[0],
528 map_count[1], map_folded_count[1],
529 map_count[2], map_folded_count[2],
530 map_count[3], map_folded_count[3],
531 mapping_unique, mapping_dupe);
532 }
533
534 int
main(int argc,char * argv[])535 main(int argc, char *argv[])
536 {
537 int ch, val, verbose = 0;
538
539 assert(sizeof(struct file_header) == 32);
540 assert(sizeof(struct file_mapping) == 8);
541
542 while ((ch = getopt(argc, argv, "h:vw:")) != -1) {
543 switch (ch) {
544 case 'h':
545 val = atoi(optarg);
546 if (val <= 0 || val > 128)
547 errx(1, "Invalid height %d", val);
548 height = val;
549 break;
550 case 'v':
551 verbose = 1;
552 break;
553 case 'w':
554 set_width(atoi(optarg));
555 break;
556 case '?':
557 default:
558 usage();
559 }
560 }
561 argc -= optind;
562 argv += optind;
563
564 if (argc < 2 || argc > 3)
565 usage();
566
567 wbytes = howmany(width, 8);
568
569 if (parse_file(argv[0], VFNT_MAP_NORMAL) != 0)
570 return (1);
571 argc--;
572 argv++;
573 if (argc == 2) {
574 if (parse_file(argv[0], VFNT_MAP_BOLD) != 0)
575 return (1);
576 argc--;
577 argv++;
578 }
579 number_glyphs();
580 dedup_mapping(VFNT_MAP_BOLD);
581 dedup_mapping(VFNT_MAP_BOLD_RH);
582 fold_mappings(0);
583 fold_mappings(1);
584 fold_mappings(2);
585 fold_mappings(3);
586 if (write_fnt(argv[0]) != 0)
587 return (1);
588
589 if (verbose)
590 print_font_info();
591
592 return (0);
593 }
594