Annotation of /trunk/mkinitrd-magellan/busybox/console-tools/loadfont.c
Parent Directory | Revision Log
Revision 1123 -
(hide annotations)
(download)
Wed Aug 18 21:56:57 2010 UTC (13 years, 9 months ago) by niro
File MIME type: text/plain
File size: 12614 byte(s)
Wed Aug 18 21:56:57 2010 UTC (13 years, 9 months ago) by niro
File MIME type: text/plain
File size: 12614 byte(s)
-updated to busybox-1.17.1
1 | niro | 532 | /* vi: set sw=4 ts=4: */ |
2 | /* | ||
3 | * loadfont.c - Eugene Crosser & Andries Brouwer | ||
4 | * | ||
5 | * Version 0.96bb | ||
6 | * | ||
7 | * Loads the console font, and possibly the corresponding screen map(s). | ||
8 | * (Adapted for busybox by Matej Vela.) | ||
9 | niro | 984 | * |
10 | * Licensed under GPLv2, see file LICENSE in this tarball for details. | ||
11 | niro | 532 | */ |
12 | niro | 816 | #include "libbb.h" |
13 | niro | 532 | #include <sys/kd.h> |
14 | |||
15 | niro | 816 | #ifndef KDFONTOP |
16 | niro | 1123 | # define KDFONTOP 0x4B72 |
17 | niro | 816 | struct console_font_op { |
18 | unsigned op; /* KD_FONT_OP_* */ | ||
19 | unsigned flags; /* KD_FONT_FLAG_* */ | ||
20 | unsigned width, height; | ||
21 | unsigned charcount; | ||
22 | unsigned char *data; /* font data with height fixed to 32 */ | ||
23 | }; | ||
24 | niro | 1123 | # define KD_FONT_OP_SET 0 /* Set font */ |
25 | # define KD_FONT_OP_GET 1 /* Get font */ | ||
26 | # define KD_FONT_OP_SET_DEFAULT 2 /* Set font to default, data points to name / NULL */ | ||
27 | # define KD_FONT_OP_COPY 3 /* Copy from another console */ | ||
28 | # define KD_FONT_FLAG_OLD 0x80000000 /* Invoked via old interface */ | ||
29 | # define KD_FONT_FLAG_DONT_RECALC 1 /* Don't call adjust_height() */ | ||
30 | niro | 816 | /* (Used internally for PIO_FONT support) */ |
31 | #endif /* KDFONTOP */ | ||
32 | |||
33 | |||
34 | niro | 532 | enum { |
35 | niro | 1123 | PSF1_MAGIC0 = 0x36, |
36 | PSF1_MAGIC1 = 0x04, | ||
37 | PSF1_MODE512 = 0x01, | ||
38 | PSF1_MODEHASTAB = 0x02, | ||
39 | PSF1_MODEHASSEQ = 0x04, | ||
40 | PSF1_MAXMODE = 0x05, | ||
41 | PSF1_STARTSEQ = 0xfffe, | ||
42 | PSF1_SEPARATOR = 0xffff, | ||
43 | niro | 532 | }; |
44 | |||
45 | niro | 1123 | struct psf1_header { |
46 | unsigned char magic[2]; /* Magic number */ | ||
47 | niro | 816 | unsigned char mode; /* PSF font mode */ |
48 | unsigned char charsize; /* Character size */ | ||
49 | niro | 532 | }; |
50 | |||
51 | niro | 1123 | #define psf1h(x) ((struct psf1_header*)(x)) |
52 | niro | 532 | |
53 | niro | 1123 | #define PSF1_MAGIC_OK(x) ( \ |
54 | (x)->magic[0] == PSF1_MAGIC0 \ | ||
55 | && (x)->magic[1] == PSF1_MAGIC1 \ | ||
56 | ) | ||
57 | |||
58 | #if ENABLE_FEATURE_LOADFONT_PSF2 | ||
59 | enum { | ||
60 | PSF2_MAGIC0 = 0x72, | ||
61 | PSF2_MAGIC1 = 0xb5, | ||
62 | PSF2_MAGIC2 = 0x4a, | ||
63 | PSF2_MAGIC3 = 0x86, | ||
64 | PSF2_HAS_UNICODE_TABLE = 0x01, | ||
65 | PSF2_MAXVERSION = 0, | ||
66 | PSF2_STARTSEQ = 0xfe, | ||
67 | PSF2_SEPARATOR = 0xff | ||
68 | }; | ||
69 | |||
70 | struct psf2_header { | ||
71 | unsigned char magic[4]; | ||
72 | unsigned int version; | ||
73 | unsigned int headersize; /* offset of bitmaps in file */ | ||
74 | unsigned int flags; | ||
75 | unsigned int length; /* number of glyphs */ | ||
76 | unsigned int charsize; /* number of bytes for each character */ | ||
77 | unsigned int height; /* max dimensions of glyphs */ | ||
78 | unsigned int width; /* charsize = height * ((width + 7) / 8) */ | ||
79 | }; | ||
80 | |||
81 | #define psf2h(x) ((struct psf2_header*)(x)) | ||
82 | |||
83 | #define PSF2_MAGIC_OK(x) ( \ | ||
84 | (x)->magic[0] == PSF2_MAGIC0 \ | ||
85 | && (x)->magic[1] == PSF2_MAGIC1 \ | ||
86 | && (x)->magic[2] == PSF2_MAGIC2 \ | ||
87 | && (x)->magic[3] == PSF2_MAGIC3 \ | ||
88 | ) | ||
89 | #endif /* ENABLE_FEATURE_LOADFONT_PSF2 */ | ||
90 | |||
91 | |||
92 | static void do_loadfont(int fd, unsigned char *inbuf, int height, int width, int charsize, int fontsize) | ||
93 | niro | 532 | { |
94 | niro | 1123 | unsigned char *buf; |
95 | int charwidth = 32 * ((width+7)/8); | ||
96 | niro | 532 | int i; |
97 | |||
98 | niro | 1123 | if (height < 1 || height > 32 || width < 1 || width > 32) |
99 | bb_error_msg_and_die("bad character size %dx%d", height, width); | ||
100 | niro | 532 | |
101 | niro | 1123 | buf = xzalloc(charwidth * ((fontsize < 128) ? 128 : fontsize)); |
102 | niro | 532 | for (i = 0; i < fontsize; i++) |
103 | niro | 1123 | memcpy(buf + (i*charwidth), inbuf + (i*charsize), charsize); |
104 | niro | 532 | |
105 | niro | 816 | { /* KDFONTOP */ |
106 | struct console_font_op cfo; | ||
107 | cfo.op = KD_FONT_OP_SET; | ||
108 | cfo.flags = 0; | ||
109 | niro | 1123 | cfo.width = width; |
110 | cfo.height = height; | ||
111 | niro | 816 | cfo.charcount = fontsize; |
112 | niro | 1123 | cfo.data = buf; |
113 | niro | 816 | xioctl(fd, KDFONTOP, &cfo); |
114 | } | ||
115 | |||
116 | free(buf); | ||
117 | niro | 532 | } |
118 | |||
119 | niro | 1123 | /* |
120 | * Format of the Unicode information: | ||
121 | * | ||
122 | * For each font position <uc>*<seq>*<term> | ||
123 | * where <uc> is a 2-byte little endian Unicode value (PSF1) | ||
124 | * or an UTF-8 coded value (PSF2), | ||
125 | * <seq> = <ss><uc><uc>*, <ss> = psf1 ? 0xFFFE : 0xFE, | ||
126 | * <term> = psf1 ? 0xFFFF : 0xFF. | ||
127 | * and * denotes zero or more occurrences of the preceding item. | ||
128 | * | ||
129 | * Semantics: | ||
130 | * The leading <uc>* part gives Unicode symbols that are all | ||
131 | * represented by this font position. The following sequences | ||
132 | * are sequences of Unicode symbols - probably a symbol | ||
133 | * together with combining accents - also represented by | ||
134 | * this font position. | ||
135 | * | ||
136 | * Example: | ||
137 | * At the font position for a capital A-ring glyph, we | ||
138 | * may have: | ||
139 | * 00C5,212B,FFFE,0041,030A,FFFF | ||
140 | * Some font positions may be described by sequences only, | ||
141 | * namely when there is no precomposed Unicode value for the glyph. | ||
142 | */ | ||
143 | #if !ENABLE_FEATURE_LOADFONT_PSF2 | ||
144 | #define do_loadtable(fd, inbuf, tailsz, fontsize, psf2) \ | ||
145 | do_loadtable(fd, inbuf, tailsz, fontsize) | ||
146 | #endif | ||
147 | static void do_loadtable(int fd, unsigned char *inbuf, int tailsz, int fontsize, int psf2) | ||
148 | niro | 532 | { |
149 | niro | 1123 | #if !ENABLE_FEATURE_LOADFONT_PSF2 |
150 | /* gcc 4.3.1 code size: */ | ||
151 | # define psf2 0 /* +0 bytes */ | ||
152 | // const int psf2 = 0; /* +8 bytes */ | ||
153 | // enum { psf2 = 0 }; /* +13 bytes */ | ||
154 | #endif | ||
155 | niro | 532 | struct unimapinit advice; |
156 | struct unimapdesc ud; | ||
157 | struct unipair *up; | ||
158 | int ct = 0, maxct; | ||
159 | int glyph; | ||
160 | uint16_t unicode; | ||
161 | |||
162 | niro | 816 | maxct = tailsz; /* more than enough */ |
163 | niro | 1123 | up = xmalloc(maxct * sizeof(*up)); |
164 | niro | 532 | |
165 | for (glyph = 0; glyph < fontsize; glyph++) { | ||
166 | niro | 1123 | while (tailsz > 0) { |
167 | if (!psf2) { /* PSF1 */ | ||
168 | unicode = (((uint16_t) inbuf[1]) << 8) + inbuf[0]; | ||
169 | tailsz -= 2; | ||
170 | inbuf += 2; | ||
171 | if (unicode == PSF1_SEPARATOR) | ||
172 | break; | ||
173 | } else { /* PSF2 */ | ||
174 | #if ENABLE_FEATURE_LOADFONT_PSF2 | ||
175 | --tailsz; | ||
176 | unicode = *inbuf++; | ||
177 | if (unicode == PSF2_SEPARATOR) { | ||
178 | break; | ||
179 | } else if (unicode == PSF2_STARTSEQ) { | ||
180 | bb_error_msg_and_die("unicode sequences not implemented"); | ||
181 | } else if (unicode >= 0xC0) { | ||
182 | if (unicode >= 0xFC) | ||
183 | unicode &= 0x01, maxct = 5; | ||
184 | else if (unicode >= 0xF8) | ||
185 | unicode &= 0x03, maxct = 4; | ||
186 | else if (unicode >= 0xF0) | ||
187 | unicode &= 0x07, maxct = 3; | ||
188 | else if (unicode >= 0xE0) | ||
189 | unicode &= 0x0F, maxct = 2; | ||
190 | else | ||
191 | unicode &= 0x1F, maxct = 1; | ||
192 | do { | ||
193 | if (tailsz <= 0 || *inbuf < 0x80 || *inbuf > 0xBF) | ||
194 | bb_error_msg_and_die("illegal UTF-8 character"); | ||
195 | --tailsz; | ||
196 | unicode = (unicode << 6) + (*inbuf++ & 0x3F); | ||
197 | } while (--maxct > 0); | ||
198 | } else if (unicode >= 0x80) { | ||
199 | bb_error_msg_and_die("illegal UTF-8 character"); | ||
200 | } | ||
201 | #else | ||
202 | return; | ||
203 | #endif | ||
204 | } | ||
205 | niro | 532 | up[ct].unicode = unicode; |
206 | up[ct].fontpos = glyph; | ||
207 | ct++; | ||
208 | } | ||
209 | } | ||
210 | |||
211 | /* Note: after PIO_UNIMAPCLR and before PIO_UNIMAP | ||
212 | this printf did not work on many kernels */ | ||
213 | |||
214 | advice.advised_hashsize = 0; | ||
215 | advice.advised_hashstep = 0; | ||
216 | advice.advised_hashlevel = 0; | ||
217 | niro | 816 | xioctl(fd, PIO_UNIMAPCLR, &advice); |
218 | niro | 532 | ud.entry_ct = ct; |
219 | ud.entries = up; | ||
220 | niro | 816 | xioctl(fd, PIO_UNIMAP, &ud); |
221 | niro | 1123 | #undef psf2 |
222 | niro | 532 | } |
223 | |||
224 | niro | 1123 | static void do_load(int fd, unsigned char *buffer, size_t len) |
225 | niro | 532 | { |
226 | niro | 1123 | int height; |
227 | int width = 8; | ||
228 | int charsize; | ||
229 | int fontsize = 256; | ||
230 | int has_table = 0; | ||
231 | unsigned char *font = buffer; | ||
232 | unsigned char *table; | ||
233 | niro | 532 | |
234 | niro | 1123 | if (len >= sizeof(struct psf1_header) && PSF1_MAGIC_OK(psf1h(buffer))) { |
235 | if (psf1h(buffer)->mode > PSF1_MAXMODE) | ||
236 | niro | 816 | bb_error_msg_and_die("unsupported psf file mode"); |
237 | niro | 1123 | if (psf1h(buffer)->mode & PSF1_MODE512) |
238 | fontsize = 512; | ||
239 | if (psf1h(buffer)->mode & PSF1_MODEHASTAB) | ||
240 | has_table = 1; | ||
241 | height = charsize = psf1h(buffer)->charsize; | ||
242 | font += sizeof(struct psf1_header); | ||
243 | } else | ||
244 | #if ENABLE_FEATURE_LOADFONT_PSF2 | ||
245 | if (len >= sizeof(struct psf2_header) && PSF2_MAGIC_OK(psf2h(buffer))) { | ||
246 | if (psf2h(buffer)->version > PSF2_MAXVERSION) | ||
247 | bb_error_msg_and_die("unsupported psf file version"); | ||
248 | fontsize = psf2h(buffer)->length; | ||
249 | if (psf2h(buffer)->flags & PSF2_HAS_UNICODE_TABLE) | ||
250 | has_table = 2; | ||
251 | charsize = psf2h(buffer)->charsize; | ||
252 | height = psf2h(buffer)->height; | ||
253 | width = psf2h(buffer)->width; | ||
254 | font += psf2h(buffer)->headersize; | ||
255 | } else | ||
256 | #endif | ||
257 | #if ENABLE_FEATURE_LOADFONT_RAW | ||
258 | if (len == 9780) { /* file with three code pages? */ | ||
259 | charsize = height = 16; | ||
260 | font += 40; | ||
261 | } else if ((len & 0377) == 0) { /* bare font */ | ||
262 | charsize = height = len / 256; | ||
263 | } else | ||
264 | #endif | ||
265 | { | ||
266 | bb_error_msg_and_die("input file: bad length or unsupported font type"); | ||
267 | } | ||
268 | |||
269 | niro | 816 | #if !defined(PIO_FONTX) || defined(__sparc__) |
270 | niro | 1123 | if (fontsize != 256) |
271 | bb_error_msg_and_die("only fontsize 256 supported"); | ||
272 | niro | 816 | #endif |
273 | |||
274 | niro | 1123 | table = font + fontsize * charsize; |
275 | buffer += len; | ||
276 | niro | 816 | |
277 | niro | 1123 | if (table > buffer || (!has_table && table != buffer)) |
278 | bb_error_msg_and_die("input file: bad length"); | ||
279 | |||
280 | do_loadfont(fd, font, height, width, charsize, fontsize); | ||
281 | |||
282 | if (has_table) | ||
283 | do_loadtable(fd, table, buffer - table, fontsize, has_table - 1); | ||
284 | niro | 816 | } |
285 | |||
286 | niro | 1123 | |
287 | niro | 816 | #if ENABLE_LOADFONT |
288 | int loadfont_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; | ||
289 | int loadfont_main(int argc UNUSED_PARAM, char **argv) | ||
290 | { | ||
291 | size_t len; | ||
292 | niro | 1123 | unsigned char *buffer; |
293 | niro | 816 | |
294 | // no arguments allowed! | ||
295 | opt_complementary = "=0"; | ||
296 | getopt32(argv, ""); | ||
297 | |||
298 | niro | 532 | /* |
299 | * We used to look at the length of the input file | ||
300 | * with stat(); now that we accept compressed files, | ||
301 | * just read the entire file. | ||
302 | */ | ||
303 | niro | 816 | len = 32*1024; // can't be larger |
304 | niro | 1123 | buffer = xmalloc_read(STDIN_FILENO, &len); |
305 | niro | 816 | // xmalloc_open_zipped_read_close(filename, &len); |
306 | niro | 1123 | if (!buffer) |
307 | niro | 532 | bb_perror_msg_and_die("error reading input font"); |
308 | niro | 1123 | do_load(get_console_fd_or_die(), buffer, len); |
309 | niro | 532 | |
310 | niro | 816 | return EXIT_SUCCESS; |
311 | } | ||
312 | #endif | ||
313 | niro | 532 | |
314 | niro | 816 | #if ENABLE_SETFONT |
315 | niro | 532 | |
316 | niro | 816 | /* |
317 | kbd-1.12: | ||
318 | niro | 532 | |
319 | niro | 816 | setfont [-O font+umap.orig] [-o font.orig] [-om cmap.orig] |
320 | [-ou umap.orig] [-N] [font.new ...] [-m cmap] [-u umap] [-C console] | ||
321 | [-hNN] [-v] [-V] | ||
322 | niro | 532 | |
323 | niro | 816 | -h NN Override font height |
324 | -o file | ||
325 | Save previous font in file | ||
326 | -O file | ||
327 | Save previous font and Unicode map in file | ||
328 | -om file | ||
329 | Store console map in file | ||
330 | -ou file | ||
331 | Save previous Unicode map in file | ||
332 | -m file | ||
333 | Load console map or Unicode console map from file | ||
334 | -u file | ||
335 | Load Unicode table describing the font from file | ||
336 | Example: | ||
337 | # cp866 | ||
338 | 0x00-0x7f idem | ||
339 | # | ||
340 | 0x80 U+0410 # CYRILLIC CAPITAL LETTER A | ||
341 | 0x81 U+0411 # CYRILLIC CAPITAL LETTER BE | ||
342 | 0x82 U+0412 # CYRILLIC CAPITAL LETTER VE | ||
343 | -C console | ||
344 | Set the font for the indicated console | ||
345 | -v Verbose | ||
346 | -V Version | ||
347 | */ | ||
348 | |||
349 | #if ENABLE_FEATURE_SETFONT_TEXTUAL_MAP | ||
350 | static int ctoi(char *s) | ||
351 | { | ||
352 | if (s[0] == '\'' && s[1] != '\0' && s[2] == '\'' && s[3] == '\0') | ||
353 | return s[1]; | ||
354 | // U+ means 0x | ||
355 | if (s[0] == 'U' && s[1] == '+') { | ||
356 | s[0] = '0'; | ||
357 | s[1] = 'x'; | ||
358 | } | ||
359 | if (!isdigit(s[0])) | ||
360 | return -1; | ||
361 | return xstrtoul(s, 0); | ||
362 | } | ||
363 | niro | 532 | #endif |
364 | |||
365 | niro | 816 | int setfont_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; |
366 | int setfont_main(int argc UNUSED_PARAM, char **argv) | ||
367 | { | ||
368 | size_t len; | ||
369 | unsigned opts; | ||
370 | int fd; | ||
371 | niro | 1123 | unsigned char *buffer; |
372 | niro | 816 | char *mapfilename; |
373 | const char *tty_name = CURRENT_TTY; | ||
374 | |||
375 | opt_complementary = "=1"; | ||
376 | opts = getopt32(argv, "m:C:", &mapfilename, &tty_name); | ||
377 | argv += optind; | ||
378 | |||
379 | niro | 984 | fd = xopen_nonblocking(tty_name); |
380 | niro | 816 | |
381 | if (sizeof(CONFIG_DEFAULT_SETFONT_DIR) > 1) { // if not "" | ||
382 | if (*argv[0] != '/') { | ||
383 | // goto default fonts location. don't die if doesn't exist | ||
384 | chdir(CONFIG_DEFAULT_SETFONT_DIR "/consolefonts"); | ||
385 | } | ||
386 | niro | 532 | } |
387 | niro | 816 | // load font |
388 | len = 32*1024; // can't be larger | ||
389 | niro | 1123 | buffer = xmalloc_open_zipped_read_close(*argv, &len); |
390 | if (!buffer) | ||
391 | niro | 816 | bb_simple_perror_msg_and_die(*argv); |
392 | niro | 1123 | do_load(fd, buffer, len); |
393 | niro | 532 | |
394 | niro | 816 | // load the screen map, if any |
395 | if (opts & 1) { // -m | ||
396 | unsigned mode = PIO_SCRNMAP; | ||
397 | void *map; | ||
398 | |||
399 | if (sizeof(CONFIG_DEFAULT_SETFONT_DIR) > 1) { // if not "" | ||
400 | if (mapfilename[0] != '/') { | ||
401 | // goto default keymaps location | ||
402 | chdir(CONFIG_DEFAULT_SETFONT_DIR "/consoletrans"); | ||
403 | } | ||
404 | } | ||
405 | // fetch keymap | ||
406 | map = xmalloc_open_zipped_read_close(mapfilename, &len); | ||
407 | if (!map) | ||
408 | bb_simple_perror_msg_and_die(mapfilename); | ||
409 | // file size is 256 or 512 bytes? -> assume binary map | ||
410 | if (len == E_TABSZ || len == 2*E_TABSZ) { | ||
411 | if (len == 2*E_TABSZ) | ||
412 | mode = PIO_UNISCRNMAP; | ||
413 | } | ||
414 | #if ENABLE_FEATURE_SETFONT_TEXTUAL_MAP | ||
415 | // assume textual Unicode console maps: | ||
416 | // 0x00 U+0000 # NULL (NUL) | ||
417 | // 0x01 U+0001 # START OF HEADING (SOH) | ||
418 | // 0x02 U+0002 # START OF TEXT (STX) | ||
419 | // 0x03 U+0003 # END OF TEXT (ETX) | ||
420 | else { | ||
421 | int i; | ||
422 | char *token[2]; | ||
423 | parser_t *parser; | ||
424 | |||
425 | if (ENABLE_FEATURE_CLEAN_UP) | ||
426 | free(map); | ||
427 | map = xmalloc(E_TABSZ * sizeof(unsigned short)); | ||
428 | |||
429 | #define unicodes ((unsigned short *)map) | ||
430 | // fill vanilla map | ||
431 | for (i = 0; i < E_TABSZ; i++) | ||
432 | unicodes[i] = 0xf000 + i; | ||
433 | |||
434 | parser = config_open(mapfilename); | ||
435 | while (config_read(parser, token, 2, 2, "# \t", PARSE_NORMAL | PARSE_MIN_DIE)) { | ||
436 | // parse code/value pair | ||
437 | int a = ctoi(token[0]); | ||
438 | int b = ctoi(token[1]); | ||
439 | if (a < 0 || a >= E_TABSZ | ||
440 | || b < 0 || b > 65535 | ||
441 | ) { | ||
442 | bb_error_msg_and_die("map format"); | ||
443 | } | ||
444 | // patch map | ||
445 | unicodes[a] = b; | ||
446 | // unicode character is met? | ||
447 | if (b > 255) | ||
448 | mode = PIO_UNISCRNMAP; | ||
449 | } | ||
450 | if (ENABLE_FEATURE_CLEAN_UP) | ||
451 | config_close(parser); | ||
452 | |||
453 | if (mode != PIO_UNISCRNMAP) { | ||
454 | #define asciis ((unsigned char *)map) | ||
455 | for (i = 0; i < E_TABSZ; i++) | ||
456 | asciis[i] = unicodes[i]; | ||
457 | #undef asciis | ||
458 | } | ||
459 | #undef unicodes | ||
460 | } | ||
461 | #endif // ENABLE_FEATURE_SETFONT_TEXTUAL_MAP | ||
462 | |||
463 | // do set screen map | ||
464 | xioctl(fd, mode, map); | ||
465 | |||
466 | if (ENABLE_FEATURE_CLEAN_UP) | ||
467 | free(map); | ||
468 | niro | 532 | } |
469 | niro | 816 | |
470 | return EXIT_SUCCESS; | ||
471 | niro | 532 | } |
472 | niro | 816 | #endif |