1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright 2020 Toomas Soome
5 * Copyright 2019 OmniOS Community Edition (OmniOSce) Association.
6 * Copyright 2020 RackTop Systems, Inc.
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 /*
31 * The workhorse here is gfxfb_blt(). It is implemented to mimic UEFI
32 * GOP Blt, and allows us to fill the rectangle on screen, copy
33 * rectangle from video to buffer and buffer to video and video to video.
34 * Such implementation does allow us to have almost identical implementation
35 * for both BIOS VBE and UEFI.
36 *
37 * ALL pixel data is assumed to be 32-bit BGRA (byte order Blue, Green, Red,
38 * Alpha) format, this allows us to only handle RGB data and not to worry
39 * about mixing RGB with indexed colors.
40 * Data exchange between memory buffer and video will translate BGRA
41 * and native format as following:
42 *
43 * 32-bit to/from 32-bit is trivial case.
44 * 32-bit to/from 24-bit is also simple - we just drop the alpha channel.
45 * 32-bit to/from 16-bit is more complicated, because we nee to handle
46 * data loss from 32-bit to 16-bit. While reading/writing from/to video, we
47 * need to apply masks of 16-bit color components. This will preserve
48 * colors for terminal text. For 32-bit truecolor PMG images, we need to
49 * translate 32-bit colors to 15/16 bit colors and this means data loss.
50 * There are different algorithms how to perform such color space reduction,
51 * we are currently using bitwise right shift to reduce color space and so far
52 * this technique seems to be sufficient (see also gfx_fb_putimage(), the
53 * end of for loop).
54 * 32-bit to/from 8-bit is the most troublesome because 8-bit colors are
55 * indexed. From video, we do get color indexes, and we do translate
56 * color index values to RGB. To write to video, we again need to translate
57 * RGB to color index. Additionally, we need to translate between VGA and
58 * console colors.
59 *
60 * Our internal color data is represented using BGRA format. But the hardware
61 * used indexed colors for 8-bit colors (0-255) and for this mode we do
62 * need to perform translation to/from BGRA and index values.
63 *
64 * - paletteentry RGB <-> index -
65 * BGRA BUFFER <----/ \ - VIDEO
66 * \ /
67 * - RGB (16/24/32) -
68 *
69 * To perform index to RGB translation, we use palette table generated
70 * from when we set up 8-bit mode video. We cannot read palette data from
71 * the hardware, because not all hardware supports reading it.
72 *
73 * BGRA to index is implemented in rgb_to_color_index() by searching
74 * palette array for closest match of RBG values.
75 *
76 * Note: In 8-bit mode, We do store first 16 colors to palette registers
77 * in VGA color order, this serves two purposes; firstly,
78 * if palette update is not supported, we still have correct 16 colors.
79 * Secondly, the kernel does get correct 16 colors when some other boot
80 * loader is used. However, the palette map for 8-bit colors is using
81 * console color ordering - this does allow us to skip translation
82 * from VGA colors to console colors, while we are reading RGB data.
83 */
84
85 #include <sys/param.h>
86 #include <stand.h>
87 #include <teken.h>
88 #include <gfx_fb.h>
89 #include <sys/font.h>
90 #include <sys/linker.h>
91 #include <sys/module.h>
92 #include <sys/stdint.h>
93 #include <sys/endian.h>
94 #include <pnglite.h>
95 #include <bootstrap.h>
96 #include <lz4.h>
97 #if defined(EFI)
98 #include <efi.h>
99 #include <efilib.h>
100 #else
101 #include <vbe.h>
102 #endif
103
104 /* VGA text mode does use bold font. */
105 #if !defined(VGA_8X16_FONT)
106 #define VGA_8X16_FONT "/boot/fonts/8x16b.fnt"
107 #endif
108 #if !defined(DEFAULT_8X16_FONT)
109 #define DEFAULT_8X16_FONT "/boot/fonts/8x16.fnt"
110 #endif
111
112 /*
113 * Must be sorted by font size in descending order
114 */
115 font_list_t fonts = STAILQ_HEAD_INITIALIZER(fonts);
116
117 #define DEFAULT_FONT_DATA font_data_8x16
118 extern vt_font_bitmap_data_t font_data_8x16;
119 teken_gfx_t gfx_state = { 0 };
120
121 static struct {
122 unsigned char r; /* Red percentage value. */
123 unsigned char g; /* Green percentage value. */
124 unsigned char b; /* Blue percentage value. */
125 } color_def[NCOLORS] = {
126 {0, 0, 0}, /* black */
127 {50, 0, 0}, /* dark red */
128 {0, 50, 0}, /* dark green */
129 {77, 63, 0}, /* dark yellow */
130 {20, 40, 64}, /* dark blue */
131 {50, 0, 50}, /* dark magenta */
132 {0, 50, 50}, /* dark cyan */
133 {75, 75, 75}, /* light gray */
134
135 {18, 20, 21}, /* dark gray */
136 {100, 0, 0}, /* light red */
137 {0, 100, 0}, /* light green */
138 {100, 100, 0}, /* light yellow */
139 {45, 62, 81}, /* light blue */
140 {100, 0, 100}, /* light magenta */
141 {0, 100, 100}, /* light cyan */
142 {100, 100, 100}, /* white */
143 };
144 uint32_t cmap[NCMAP];
145
146 /*
147 * Between console's palette and VGA's one:
148 * - blue and red are swapped (1 <-> 4)
149 * - yellow and cyan are swapped (3 <-> 6)
150 */
151 const int cons_to_vga_colors[NCOLORS] = {
152 0, 4, 2, 6, 1, 5, 3, 7,
153 8, 12, 10, 14, 9, 13, 11, 15
154 };
155
156 static const int vga_to_cons_colors[NCOLORS] = {
157 0, 1, 2, 3, 4, 5, 6, 7,
158 8, 9, 10, 11, 12, 13, 14, 15
159 };
160
161 struct text_pixel *screen_buffer;
162 #if defined(EFI)
163 static EFI_GRAPHICS_OUTPUT_BLT_PIXEL *GlyphBuffer;
164 #else
165 static struct paletteentry *GlyphBuffer;
166 #endif
167 static size_t GlyphBufferSize;
168
169 static bool insert_font(char *, FONT_FLAGS);
170 static int font_set(struct env_var *, int, const void *);
171 static void * allocate_glyphbuffer(uint32_t, uint32_t);
172 static void gfx_fb_cursor_draw(teken_gfx_t *, const teken_pos_t *, bool);
173
174 /*
175 * Initialize gfx framework.
176 */
177 void
gfx_framework_init(void)178 gfx_framework_init(void)
179 {
180 /*
181 * Setup font list to have builtin font.
182 */
183 (void) insert_font(NULL, FONT_BUILTIN);
184 gfx_interp_ref(); /* Draw in the gfx interpreter for this thing */
185 }
186
187 static uint8_t *
gfx_get_fb_address(void)188 gfx_get_fb_address(void)
189 {
190 return (ptov((uint32_t)gfx_state.tg_fb.fb_addr));
191 }
192
193 /*
194 * Utility function to parse gfx mode line strings.
195 */
196 bool
gfx_parse_mode_str(char * str,int * x,int * y,int * depth)197 gfx_parse_mode_str(char *str, int *x, int *y, int *depth)
198 {
199 char *p, *end;
200
201 errno = 0;
202 p = str;
203 *x = strtoul(p, &end, 0);
204 if (*x == 0 || errno != 0)
205 return (false);
206 if (*end != 'x')
207 return (false);
208 p = end + 1;
209 *y = strtoul(p, &end, 0);
210 if (*y == 0 || errno != 0)
211 return (false);
212 if (*end != 'x') {
213 *depth = -1; /* auto select */
214 } else {
215 p = end + 1;
216 *depth = strtoul(p, &end, 0);
217 if (*depth == 0 || errno != 0 || *end != '\0')
218 return (false);
219 }
220
221 return (true);
222 }
223
224 static uint32_t
rgb_color_map(uint8_t index,uint32_t rmax,int roffset,uint32_t gmax,int goffset,uint32_t bmax,int boffset)225 rgb_color_map(uint8_t index, uint32_t rmax, int roffset,
226 uint32_t gmax, int goffset, uint32_t bmax, int boffset)
227 {
228 uint32_t color, code, gray, level;
229
230 if (index < NCOLORS) {
231 #define CF(_f, _i) ((_f ## max * color_def[(_i)]._f / 100) << _f ## offset)
232 return (CF(r, index) | CF(g, index) | CF(b, index));
233 #undef CF
234 }
235
236 #define CF(_f, _c) ((_f ## max & _c) << _f ## offset)
237 /* 6x6x6 color cube */
238 if (index > 15 && index < 232) {
239 uint32_t red, green, blue;
240
241 for (red = 0; red < 6; red++) {
242 for (green = 0; green < 6; green++) {
243 for (blue = 0; blue < 6; blue++) {
244 code = 16 + (red * 36) +
245 (green * 6) + blue;
246 if (code != index)
247 continue;
248 red = red ? (red * 40 + 55) : 0;
249 green = green ? (green * 40 + 55) : 0;
250 blue = blue ? (blue * 40 + 55) : 0;
251 color = CF(r, red);
252 color |= CF(g, green);
253 color |= CF(b, blue);
254 return (color);
255 }
256 }
257 }
258 }
259
260 /* colors 232-255 are a grayscale ramp */
261 for (gray = 0; gray < 24; gray++) {
262 level = (gray * 10) + 8;
263 code = 232 + gray;
264 if (code == index)
265 break;
266 }
267 return (CF(r, level) | CF(g, level) | CF(b, level));
268 #undef CF
269 }
270
271 /*
272 * Support for color mapping.
273 * For 8, 24 and 32 bit depth, use mask size 8.
274 * 15/16 bit depth needs to use mask size from mode,
275 * or we will lose color information from 32-bit to 15/16 bit translation.
276 */
277 uint32_t
gfx_fb_color_map(uint8_t index)278 gfx_fb_color_map(uint8_t index)
279 {
280 int rmask, gmask, bmask;
281 int roff, goff, boff, bpp;
282
283 roff = ffs(gfx_state.tg_fb.fb_mask_red) - 1;
284 goff = ffs(gfx_state.tg_fb.fb_mask_green) - 1;
285 boff = ffs(gfx_state.tg_fb.fb_mask_blue) - 1;
286 bpp = roundup2(gfx_state.tg_fb.fb_bpp, 8) >> 3;
287
288 if (bpp == 2)
289 rmask = gfx_state.tg_fb.fb_mask_red >> roff;
290 else
291 rmask = 0xff;
292
293 if (bpp == 2)
294 gmask = gfx_state.tg_fb.fb_mask_green >> goff;
295 else
296 gmask = 0xff;
297
298 if (bpp == 2)
299 bmask = gfx_state.tg_fb.fb_mask_blue >> boff;
300 else
301 bmask = 0xff;
302
303 return (rgb_color_map(index, rmask, 16, gmask, 8, bmask, 0));
304 }
305
306 /*
307 * Get indexed color from RGB. This function is used to write data to video
308 * memory when the adapter is set to use indexed colors.
309 * Since UEFI does only support 32-bit colors, we do not implement it for
310 * UEFI because there is no need for it and we do not have palette array
311 * for UEFI.
312 */
313 static uint8_t
rgb_to_color_index(uint8_t r,uint8_t g,uint8_t b)314 rgb_to_color_index(uint8_t r, uint8_t g, uint8_t b)
315 {
316 #if !defined(EFI)
317 uint32_t color, best, dist, k;
318 int diff;
319
320 color = 0;
321 best = 255 * 255 * 255;
322 for (k = 0; k < NCMAP; k++) {
323 diff = r - pe8[k].Red;
324 dist = diff * diff;
325 diff = g - pe8[k].Green;
326 dist += diff * diff;
327 diff = b - pe8[k].Blue;
328 dist += diff * diff;
329
330 /* Exact match, exit the loop */
331 if (dist == 0)
332 break;
333
334 if (dist < best) {
335 color = k;
336 best = dist;
337 }
338 }
339 if (k == NCMAP)
340 k = color;
341 return (k);
342 #else
343 (void) r;
344 (void) g;
345 (void) b;
346 return (0);
347 #endif
348 }
349
350 int
generate_cons_palette(uint32_t * palette,int format,uint32_t rmax,int roffset,uint32_t gmax,int goffset,uint32_t bmax,int boffset)351 generate_cons_palette(uint32_t *palette, int format,
352 uint32_t rmax, int roffset, uint32_t gmax, int goffset,
353 uint32_t bmax, int boffset)
354 {
355 int i;
356
357 switch (format) {
358 case COLOR_FORMAT_VGA:
359 for (i = 0; i < NCOLORS; i++)
360 palette[i] = cons_to_vga_colors[i];
361 for (; i < NCMAP; i++)
362 palette[i] = i;
363 break;
364 case COLOR_FORMAT_RGB:
365 for (i = 0; i < NCMAP; i++)
366 palette[i] = rgb_color_map(i, rmax, roffset,
367 gmax, goffset, bmax, boffset);
368 break;
369 default:
370 return (ENODEV);
371 }
372
373 return (0);
374 }
375
376 static void
gfx_mem_wr1(uint8_t * base,size_t size,uint32_t o,uint8_t v)377 gfx_mem_wr1(uint8_t *base, size_t size, uint32_t o, uint8_t v)
378 {
379
380 if (o >= size)
381 return;
382 *(uint8_t *)(base + o) = v;
383 }
384
385 static void
gfx_mem_wr2(uint8_t * base,size_t size,uint32_t o,uint16_t v)386 gfx_mem_wr2(uint8_t *base, size_t size, uint32_t o, uint16_t v)
387 {
388
389 if (o >= size)
390 return;
391 *(uint16_t *)(base + o) = v;
392 }
393
394 static void
gfx_mem_wr4(uint8_t * base,size_t size,uint32_t o,uint32_t v)395 gfx_mem_wr4(uint8_t *base, size_t size, uint32_t o, uint32_t v)
396 {
397
398 if (o >= size)
399 return;
400 *(uint32_t *)(base + o) = v;
401 }
402
gfxfb_blt_fill(void * BltBuffer,uint32_t DestinationX,uint32_t DestinationY,uint32_t Width,uint32_t Height)403 static int gfxfb_blt_fill(void *BltBuffer,
404 uint32_t DestinationX, uint32_t DestinationY,
405 uint32_t Width, uint32_t Height)
406 {
407 #if defined(EFI)
408 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *p;
409 #else
410 struct paletteentry *p;
411 #endif
412 uint32_t data, bpp, pitch, y, x;
413 int roff, goff, boff;
414 size_t size;
415 off_t off;
416 uint8_t *destination;
417
418 if (BltBuffer == NULL)
419 return (EINVAL);
420
421 if (DestinationY + Height > gfx_state.tg_fb.fb_height)
422 return (EINVAL);
423
424 if (DestinationX + Width > gfx_state.tg_fb.fb_width)
425 return (EINVAL);
426
427 if (Width == 0 || Height == 0)
428 return (EINVAL);
429
430 p = BltBuffer;
431 roff = ffs(gfx_state.tg_fb.fb_mask_red) - 1;
432 goff = ffs(gfx_state.tg_fb.fb_mask_green) - 1;
433 boff = ffs(gfx_state.tg_fb.fb_mask_blue) - 1;
434
435 if (gfx_state.tg_fb.fb_bpp == 8) {
436 data = rgb_to_color_index(p->Red, p->Green, p->Blue);
437 } else {
438 data = (p->Red &
439 (gfx_state.tg_fb.fb_mask_red >> roff)) << roff;
440 data |= (p->Green &
441 (gfx_state.tg_fb.fb_mask_green >> goff)) << goff;
442 data |= (p->Blue &
443 (gfx_state.tg_fb.fb_mask_blue >> boff)) << boff;
444 }
445
446 bpp = roundup2(gfx_state.tg_fb.fb_bpp, 8) >> 3;
447 pitch = gfx_state.tg_fb.fb_stride * bpp;
448 destination = gfx_get_fb_address();
449 size = gfx_state.tg_fb.fb_size;
450
451 for (y = DestinationY; y < Height + DestinationY; y++) {
452 off = y * pitch + DestinationX * bpp;
453 for (x = 0; x < Width; x++) {
454 switch (bpp) {
455 case 1:
456 gfx_mem_wr1(destination, size, off,
457 (data < NCOLORS) ?
458 cons_to_vga_colors[data] : data);
459 break;
460 case 2:
461 gfx_mem_wr2(destination, size, off, data);
462 break;
463 case 3:
464 gfx_mem_wr1(destination, size, off,
465 (data >> 16) & 0xff);
466 gfx_mem_wr1(destination, size, off + 1,
467 (data >> 8) & 0xff);
468 gfx_mem_wr1(destination, size, off + 2,
469 data & 0xff);
470 break;
471 case 4:
472 gfx_mem_wr4(destination, size, off, data);
473 break;
474 default:
475 return (EINVAL);
476 }
477 off += bpp;
478 }
479 }
480
481 return (0);
482 }
483
484 static int
gfxfb_blt_video_to_buffer(void * BltBuffer,uint32_t SourceX,uint32_t SourceY,uint32_t DestinationX,uint32_t DestinationY,uint32_t Width,uint32_t Height,uint32_t Delta)485 gfxfb_blt_video_to_buffer(void *BltBuffer, uint32_t SourceX, uint32_t SourceY,
486 uint32_t DestinationX, uint32_t DestinationY,
487 uint32_t Width, uint32_t Height, uint32_t Delta)
488 {
489 #if defined(EFI)
490 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *p;
491 #else
492 struct paletteentry *p;
493 #endif
494 uint32_t x, sy, dy;
495 uint32_t bpp, pitch, copybytes;
496 off_t off;
497 uint8_t *source, *destination, *sb;
498 uint8_t rm, rp, gm, gp, bm, bp;
499 bool bgra;
500
501 if (BltBuffer == NULL)
502 return (EINVAL);
503
504 if (SourceY + Height >
505 gfx_state.tg_fb.fb_height)
506 return (EINVAL);
507
508 if (SourceX + Width > gfx_state.tg_fb.fb_width)
509 return (EINVAL);
510
511 if (Width == 0 || Height == 0)
512 return (EINVAL);
513
514 if (Delta == 0)
515 Delta = Width * sizeof (*p);
516
517 bpp = roundup2(gfx_state.tg_fb.fb_bpp, 8) >> 3;
518 pitch = gfx_state.tg_fb.fb_stride * bpp;
519
520 copybytes = Width * bpp;
521
522 rp = ffs(gfx_state.tg_fb.fb_mask_red) - 1;
523 gp = ffs(gfx_state.tg_fb.fb_mask_green) - 1;
524 bp = ffs(gfx_state.tg_fb.fb_mask_blue) - 1;
525 rm = gfx_state.tg_fb.fb_mask_red >> rp;
526 gm = gfx_state.tg_fb.fb_mask_green >> gp;
527 bm = gfx_state.tg_fb.fb_mask_blue >> bp;
528
529 /* If FB pixel format is BGRA, we can use direct copy. */
530 bgra = bpp == 4 &&
531 ffs(rm) - 1 == 8 && rp == 16 &&
532 ffs(gm) - 1 == 8 && gp == 8 &&
533 ffs(bm) - 1 == 8 && bp == 0;
534
535 for (sy = SourceY, dy = DestinationY; dy < Height + DestinationY;
536 sy++, dy++) {
537 off = sy * pitch + SourceX * bpp;
538 source = gfx_get_fb_address() + off;
539 destination = (uint8_t *)BltBuffer + dy * Delta +
540 DestinationX * sizeof (*p);
541
542 if (bgra) {
543 bcopy(source, destination, copybytes);
544 } else {
545 for (x = 0; x < Width; x++) {
546 uint32_t c = 0;
547
548 p = (void *)(destination + x * sizeof (*p));
549 sb = source + x * bpp;
550 switch (bpp) {
551 case 1:
552 c = *sb;
553 break;
554 case 2:
555 c = *(uint16_t *)sb;
556 break;
557 case 3:
558 c = sb[0] << 16 | sb[1] << 8 | sb[2];
559 break;
560 case 4:
561 c = *(uint32_t *)sb;
562 break;
563 default:
564 return (EINVAL);
565 }
566
567 if (bpp == 1) {
568 *(uint32_t *)p = gfx_fb_color_map(
569 (c < 16) ?
570 vga_to_cons_colors[c] : c);
571 } else {
572 p->Red = (c >> rp) & rm;
573 p->Green = (c >> gp) & gm;
574 p->Blue = (c >> bp) & bm;
575 p->Reserved = 0;
576 }
577 }
578 }
579 }
580
581 return (0);
582 }
583
584 static int
gfxfb_blt_buffer_to_video(void * BltBuffer,uint32_t SourceX,uint32_t SourceY,uint32_t DestinationX,uint32_t DestinationY,uint32_t Width,uint32_t Height,uint32_t Delta)585 gfxfb_blt_buffer_to_video(void *BltBuffer, uint32_t SourceX, uint32_t SourceY,
586 uint32_t DestinationX, uint32_t DestinationY,
587 uint32_t Width, uint32_t Height, uint32_t Delta)
588 {
589 #if defined(EFI)
590 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *p;
591 #else
592 struct paletteentry *p;
593 #endif
594 uint32_t x, sy, dy;
595 uint32_t bpp, pitch, copybytes;
596 off_t off;
597 uint8_t *source, *destination;
598 uint8_t rm, rp, gm, gp, bm, bp;
599 bool bgra;
600
601 if (BltBuffer == NULL)
602 return (EINVAL);
603
604 if (DestinationY + Height >
605 gfx_state.tg_fb.fb_height)
606 return (EINVAL);
607
608 if (DestinationX + Width > gfx_state.tg_fb.fb_width)
609 return (EINVAL);
610
611 if (Width == 0 || Height == 0)
612 return (EINVAL);
613
614 if (Delta == 0)
615 Delta = Width * sizeof (*p);
616
617 bpp = roundup2(gfx_state.tg_fb.fb_bpp, 8) >> 3;
618 pitch = gfx_state.tg_fb.fb_stride * bpp;
619
620 copybytes = Width * bpp;
621
622 rp = ffs(gfx_state.tg_fb.fb_mask_red) - 1;
623 gp = ffs(gfx_state.tg_fb.fb_mask_green) - 1;
624 bp = ffs(gfx_state.tg_fb.fb_mask_blue) - 1;
625 rm = gfx_state.tg_fb.fb_mask_red >> rp;
626 gm = gfx_state.tg_fb.fb_mask_green >> gp;
627 bm = gfx_state.tg_fb.fb_mask_blue >> bp;
628
629 /* If FB pixel format is BGRA, we can use direct copy. */
630 bgra = bpp == 4 &&
631 ffs(rm) - 1 == 8 && rp == 16 &&
632 ffs(gm) - 1 == 8 && gp == 8 &&
633 ffs(bm) - 1 == 8 && bp == 0;
634
635 for (sy = SourceY, dy = DestinationY; sy < Height + SourceY;
636 sy++, dy++) {
637 off = dy * pitch + DestinationX * bpp;
638 destination = gfx_get_fb_address() + off;
639
640 if (bgra) {
641 source = (uint8_t *)BltBuffer + sy * Delta +
642 SourceX * sizeof (*p);
643 bcopy(source, destination, copybytes);
644 } else {
645 for (x = 0; x < Width; x++) {
646 uint32_t c;
647
648 p = (void *)((uint8_t *)BltBuffer +
649 sy * Delta +
650 (SourceX + x) * sizeof (*p));
651 if (bpp == 1) {
652 c = rgb_to_color_index(p->Red,
653 p->Green, p->Blue);
654 } else {
655 c = (p->Red & rm) << rp |
656 (p->Green & gm) << gp |
657 (p->Blue & bm) << bp;
658 }
659 off = x * bpp;
660 switch (bpp) {
661 case 1:
662 gfx_mem_wr1(destination, copybytes,
663 off, (c < 16) ?
664 cons_to_vga_colors[c] : c);
665 break;
666 case 2:
667 gfx_mem_wr2(destination, copybytes,
668 off, c);
669 break;
670 case 3:
671 gfx_mem_wr1(destination, copybytes,
672 off, (c >> 16) & 0xff);
673 gfx_mem_wr1(destination, copybytes,
674 off + 1, (c >> 8) & 0xff);
675 gfx_mem_wr1(destination, copybytes,
676 off + 2, c & 0xff);
677 break;
678 case 4:
679 gfx_mem_wr4(destination, copybytes,
680 x * bpp, c);
681 break;
682 default:
683 return (EINVAL);
684 }
685 }
686 }
687 }
688
689 return (0);
690 }
691
692 static int
gfxfb_blt_video_to_video(uint32_t SourceX,uint32_t SourceY,uint32_t DestinationX,uint32_t DestinationY,uint32_t Width,uint32_t Height)693 gfxfb_blt_video_to_video(uint32_t SourceX, uint32_t SourceY,
694 uint32_t DestinationX, uint32_t DestinationY,
695 uint32_t Width, uint32_t Height)
696 {
697 uint32_t bpp, copybytes;
698 int pitch;
699 uint8_t *source, *destination;
700 off_t off;
701
702 if (SourceY + Height >
703 gfx_state.tg_fb.fb_height)
704 return (EINVAL);
705
706 if (SourceX + Width > gfx_state.tg_fb.fb_width)
707 return (EINVAL);
708
709 if (DestinationY + Height >
710 gfx_state.tg_fb.fb_height)
711 return (EINVAL);
712
713 if (DestinationX + Width > gfx_state.tg_fb.fb_width)
714 return (EINVAL);
715
716 if (Width == 0 || Height == 0)
717 return (EINVAL);
718
719 bpp = roundup2(gfx_state.tg_fb.fb_bpp, 8) >> 3;
720 pitch = gfx_state.tg_fb.fb_stride * bpp;
721
722 copybytes = Width * bpp;
723
724 off = SourceY * pitch + SourceX * bpp;
725 source = gfx_get_fb_address() + off;
726 off = DestinationY * pitch + DestinationX * bpp;
727 destination = gfx_get_fb_address() + off;
728
729 if ((uintptr_t)destination > (uintptr_t)source) {
730 source += Height * pitch;
731 destination += Height * pitch;
732 pitch = -pitch;
733 }
734
735 while (Height-- > 0) {
736 bcopy(source, destination, copybytes);
737 source += pitch;
738 destination += pitch;
739 }
740
741 return (0);
742 }
743
744 static void
gfxfb_shadow_fill(uint32_t * BltBuffer,uint32_t DestinationX,uint32_t DestinationY,uint32_t Width,uint32_t Height)745 gfxfb_shadow_fill(uint32_t *BltBuffer,
746 uint32_t DestinationX, uint32_t DestinationY,
747 uint32_t Width, uint32_t Height)
748 {
749 uint32_t fbX, fbY;
750
751 if (gfx_state.tg_shadow_fb == NULL)
752 return;
753
754 fbX = gfx_state.tg_fb.fb_width;
755 fbY = gfx_state.tg_fb.fb_height;
756
757 if (BltBuffer == NULL)
758 return;
759
760 if (DestinationX + Width > fbX)
761 Width = fbX - DestinationX;
762
763 if (DestinationY + Height > fbY)
764 Height = fbY - DestinationY;
765
766 uint32_t y2 = Height + DestinationY;
767 for (uint32_t y1 = DestinationY; y1 < y2; y1++) {
768 uint32_t off = y1 * fbX + DestinationX;
769
770 for (uint32_t x = 0; x < Width; x++) {
771 gfx_state.tg_shadow_fb[off + x] = *BltBuffer;
772 }
773 }
774 }
775
776 int
gfxfb_blt(void * BltBuffer,GFXFB_BLT_OPERATION BltOperation,uint32_t SourceX,uint32_t SourceY,uint32_t DestinationX,uint32_t DestinationY,uint32_t Width,uint32_t Height,uint32_t Delta)777 gfxfb_blt(void *BltBuffer, GFXFB_BLT_OPERATION BltOperation,
778 uint32_t SourceX, uint32_t SourceY,
779 uint32_t DestinationX, uint32_t DestinationY,
780 uint32_t Width, uint32_t Height, uint32_t Delta)
781 {
782 int rv;
783 #if defined(EFI)
784 EFI_STATUS status;
785 EFI_GRAPHICS_OUTPUT *gop = gfx_state.tg_private;
786 EFI_TPL tpl;
787
788 /*
789 * We assume Blt() does work, if not, we will need to build exception
790 * list case by case. We only have boot services during part of our
791 * exectution. Once terminate boot services, these operations cannot be
792 * done as they are provided by protocols that disappear when exit
793 * boot services.
794 */
795 if (gop != NULL && boot_services_active) {
796 tpl = BS->RaiseTPL(TPL_NOTIFY);
797 switch (BltOperation) {
798 case GfxFbBltVideoFill:
799 gfxfb_shadow_fill(BltBuffer, DestinationX,
800 DestinationY, Width, Height);
801 status = gop->Blt(gop, BltBuffer, EfiBltVideoFill,
802 SourceX, SourceY, DestinationX, DestinationY,
803 Width, Height, Delta);
804 break;
805
806 case GfxFbBltVideoToBltBuffer:
807 status = gop->Blt(gop, BltBuffer,
808 EfiBltVideoToBltBuffer,
809 SourceX, SourceY, DestinationX, DestinationY,
810 Width, Height, Delta);
811 break;
812
813 case GfxFbBltBufferToVideo:
814 status = gop->Blt(gop, BltBuffer, EfiBltBufferToVideo,
815 SourceX, SourceY, DestinationX, DestinationY,
816 Width, Height, Delta);
817 break;
818
819 case GfxFbBltVideoToVideo:
820 status = gop->Blt(gop, BltBuffer, EfiBltVideoToVideo,
821 SourceX, SourceY, DestinationX, DestinationY,
822 Width, Height, Delta);
823 break;
824
825 default:
826 status = EFI_INVALID_PARAMETER;
827 break;
828 }
829
830 switch (status) {
831 case EFI_SUCCESS:
832 rv = 0;
833 break;
834
835 case EFI_INVALID_PARAMETER:
836 rv = EINVAL;
837 break;
838
839 case EFI_DEVICE_ERROR:
840 default:
841 rv = EIO;
842 break;
843 }
844
845 BS->RestoreTPL(tpl);
846 return (rv);
847 }
848 #endif
849
850 switch (BltOperation) {
851 case GfxFbBltVideoFill:
852 gfxfb_shadow_fill(BltBuffer, DestinationX, DestinationY,
853 Width, Height);
854 rv = gfxfb_blt_fill(BltBuffer, DestinationX, DestinationY,
855 Width, Height);
856 break;
857
858 case GfxFbBltVideoToBltBuffer:
859 rv = gfxfb_blt_video_to_buffer(BltBuffer, SourceX, SourceY,
860 DestinationX, DestinationY, Width, Height, Delta);
861 break;
862
863 case GfxFbBltBufferToVideo:
864 rv = gfxfb_blt_buffer_to_video(BltBuffer, SourceX, SourceY,
865 DestinationX, DestinationY, Width, Height, Delta);
866 break;
867
868 case GfxFbBltVideoToVideo:
869 rv = gfxfb_blt_video_to_video(SourceX, SourceY,
870 DestinationX, DestinationY, Width, Height);
871 break;
872
873 default:
874 rv = EINVAL;
875 break;
876 }
877 return (rv);
878 }
879
880 void
gfx_bitblt_bitmap(teken_gfx_t * state,const uint8_t * glyph,const teken_attr_t * a,uint32_t alpha,bool cursor)881 gfx_bitblt_bitmap(teken_gfx_t *state, const uint8_t *glyph,
882 const teken_attr_t *a, uint32_t alpha, bool cursor)
883 {
884 uint32_t width, height;
885 uint32_t fgc, bgc, bpl, cc, o;
886 int bpp, bit, byte;
887 bool invert = false;
888
889 bpp = 4; /* We only generate BGRA */
890 width = state->tg_font.vf_width;
891 height = state->tg_font.vf_height;
892 bpl = (width + 7) / 8; /* Bytes per source line. */
893
894 fgc = a->ta_fgcolor;
895 bgc = a->ta_bgcolor;
896 if (a->ta_format & TF_BOLD)
897 fgc |= TC_LIGHT;
898 if (a->ta_format & TF_BLINK)
899 bgc |= TC_LIGHT;
900
901 fgc = gfx_fb_color_map(fgc);
902 bgc = gfx_fb_color_map(bgc);
903
904 if (a->ta_format & TF_REVERSE)
905 invert = !invert;
906 if (cursor)
907 invert = !invert;
908 if (invert) {
909 uint32_t tmp;
910
911 tmp = fgc;
912 fgc = bgc;
913 bgc = tmp;
914 }
915
916 alpha = alpha << 24;
917 fgc |= alpha;
918 bgc |= alpha;
919
920 for (uint32_t y = 0; y < height; y++) {
921 for (uint32_t x = 0; x < width; x++) {
922 byte = y * bpl + x / 8;
923 bit = 0x80 >> (x % 8);
924 o = y * width * bpp + x * bpp;
925 cc = glyph[byte] & bit ? fgc : bgc;
926
927 gfx_mem_wr4(state->tg_glyph,
928 state->tg_glyph_size, o, cc);
929 }
930 }
931 }
932
933 /*
934 * Draw prepared glyph on terminal point p.
935 */
936 static void
gfx_fb_printchar(teken_gfx_t * state,const teken_pos_t * p)937 gfx_fb_printchar(teken_gfx_t *state, const teken_pos_t *p)
938 {
939 unsigned x, y, width, height;
940
941 width = state->tg_font.vf_width;
942 height = state->tg_font.vf_height;
943 x = state->tg_origin.tp_col + p->tp_col * width;
944 y = state->tg_origin.tp_row + p->tp_row * height;
945
946 gfx_fb_cons_display(x, y, width, height, state->tg_glyph);
947 }
948
949 /*
950 * Store char with its attribute to buffer and put it on screen.
951 */
952 void
gfx_fb_putchar(void * arg,const teken_pos_t * p,teken_char_t c,const teken_attr_t * a)953 gfx_fb_putchar(void *arg, const teken_pos_t *p, teken_char_t c,
954 const teken_attr_t *a)
955 {
956 teken_gfx_t *state = arg;
957 const uint8_t *glyph;
958 int idx;
959
960 idx = p->tp_col + p->tp_row * state->tg_tp.tp_col;
961 if (idx >= state->tg_tp.tp_col * state->tg_tp.tp_row)
962 return;
963
964 /* remove the cursor */
965 if (state->tg_cursor_visible)
966 gfx_fb_cursor_draw(state, &state->tg_cursor, false);
967
968 screen_buffer[idx].c = c;
969 screen_buffer[idx].a = *a;
970
971 glyph = font_lookup(&state->tg_font, c, a);
972 gfx_bitblt_bitmap(state, glyph, a, 0xff, false);
973 gfx_fb_printchar(state, p);
974
975 /* display the cursor */
976 if (state->tg_cursor_visible) {
977 const teken_pos_t *c;
978
979 c = teken_get_cursor(&state->tg_teken);
980 gfx_fb_cursor_draw(state, c, true);
981 }
982 }
983
984 void
gfx_fb_fill(void * arg,const teken_rect_t * r,teken_char_t c,const teken_attr_t * a)985 gfx_fb_fill(void *arg, const teken_rect_t *r, teken_char_t c,
986 const teken_attr_t *a)
987 {
988 teken_gfx_t *state = arg;
989 const uint8_t *glyph;
990 teken_pos_t p;
991 struct text_pixel *row;
992
993 /* remove the cursor */
994 if (state->tg_cursor_visible)
995 gfx_fb_cursor_draw(state, &state->tg_cursor, false);
996
997 glyph = font_lookup(&state->tg_font, c, a);
998 gfx_bitblt_bitmap(state, glyph, a, 0xff, false);
999
1000 for (p.tp_row = r->tr_begin.tp_row; p.tp_row < r->tr_end.tp_row;
1001 p.tp_row++) {
1002 row = &screen_buffer[p.tp_row * state->tg_tp.tp_col];
1003 for (p.tp_col = r->tr_begin.tp_col;
1004 p.tp_col < r->tr_end.tp_col; p.tp_col++) {
1005 row[p.tp_col].c = c;
1006 row[p.tp_col].a = *a;
1007 gfx_fb_printchar(state, &p);
1008 }
1009 }
1010
1011 /* display the cursor */
1012 if (state->tg_cursor_visible) {
1013 const teken_pos_t *c;
1014
1015 c = teken_get_cursor(&state->tg_teken);
1016 gfx_fb_cursor_draw(state, c, true);
1017 }
1018 }
1019
1020 static void
gfx_fb_cursor_draw(teken_gfx_t * state,const teken_pos_t * pos,bool on)1021 gfx_fb_cursor_draw(teken_gfx_t *state, const teken_pos_t *pos, bool on)
1022 {
1023 const uint8_t *glyph;
1024 teken_pos_t p;
1025 int idx;
1026
1027 p = *pos;
1028 if (p.tp_col >= state->tg_tp.tp_col)
1029 p.tp_col = state->tg_tp.tp_col - 1;
1030 if (p.tp_row >= state->tg_tp.tp_row)
1031 p.tp_row = state->tg_tp.tp_row - 1;
1032 idx = p.tp_col + p.tp_row * state->tg_tp.tp_col;
1033 if (idx >= state->tg_tp.tp_col * state->tg_tp.tp_row)
1034 return;
1035
1036 glyph = font_lookup(&state->tg_font, screen_buffer[idx].c,
1037 &screen_buffer[idx].a);
1038 gfx_bitblt_bitmap(state, glyph, &screen_buffer[idx].a, 0xff, on);
1039 gfx_fb_printchar(state, &p);
1040
1041 state->tg_cursor = p;
1042 }
1043
1044 void
gfx_fb_cursor(void * arg,const teken_pos_t * p)1045 gfx_fb_cursor(void *arg, const teken_pos_t *p)
1046 {
1047 teken_gfx_t *state = arg;
1048
1049 /* Switch cursor off in old location and back on in new. */
1050 if (state->tg_cursor_visible) {
1051 gfx_fb_cursor_draw(state, &state->tg_cursor, false);
1052 gfx_fb_cursor_draw(state, p, true);
1053 }
1054 }
1055
1056 void
gfx_fb_param(void * arg,int cmd,unsigned int value)1057 gfx_fb_param(void *arg, int cmd, unsigned int value)
1058 {
1059 teken_gfx_t *state = arg;
1060 const teken_pos_t *c;
1061
1062 switch (cmd) {
1063 case TP_SETLOCALCURSOR:
1064 /*
1065 * 0 means normal (usually block), 1 means hidden, and
1066 * 2 means blinking (always block) for compatibility with
1067 * syscons. We don't support any changes except hiding,
1068 * so must map 2 to 0.
1069 */
1070 value = (value == 1) ? 0 : 1;
1071 /* FALLTHROUGH */
1072 case TP_SHOWCURSOR:
1073 c = teken_get_cursor(&state->tg_teken);
1074 gfx_fb_cursor_draw(state, c, true);
1075 if (value != 0)
1076 state->tg_cursor_visible = true;
1077 else
1078 state->tg_cursor_visible = false;
1079 break;
1080 default:
1081 /* Not yet implemented */
1082 break;
1083 }
1084 }
1085
1086 bool
is_same_pixel(struct text_pixel * px1,struct text_pixel * px2)1087 is_same_pixel(struct text_pixel *px1, struct text_pixel *px2)
1088 {
1089 if (px1->c != px2->c)
1090 return (false);
1091
1092 /* Is there image stored? */
1093 if ((px1->a.ta_format & TF_IMAGE) ||
1094 (px2->a.ta_format & TF_IMAGE))
1095 return (false);
1096
1097 if (px1->a.ta_format != px2->a.ta_format)
1098 return (false);
1099 if (px1->a.ta_fgcolor != px2->a.ta_fgcolor)
1100 return (false);
1101 if (px1->a.ta_bgcolor != px2->a.ta_bgcolor)
1102 return (false);
1103
1104 return (true);
1105 }
1106
1107 static void
gfx_fb_copy_area(teken_gfx_t * state,const teken_rect_t * s,const teken_pos_t * d)1108 gfx_fb_copy_area(teken_gfx_t *state, const teken_rect_t *s,
1109 const teken_pos_t *d)
1110 {
1111 uint32_t sx, sy, dx, dy, width, height;
1112 uint32_t pitch, bytes;
1113 int step;
1114
1115 width = state->tg_font.vf_width;
1116 height = state->tg_font.vf_height;
1117
1118 sx = s->tr_begin.tp_col * width;
1119 sy = s->tr_begin.tp_row * height;
1120 dx = d->tp_col * width;
1121 dy = d->tp_row * height;
1122
1123 width *= (s->tr_end.tp_col - s->tr_begin.tp_col + 1);
1124
1125 /*
1126 * With no shadow fb, use video to video copy.
1127 */
1128 if (state->tg_shadow_fb == NULL) {
1129 (void) gfxfb_blt(NULL, GfxFbBltVideoToVideo,
1130 sx + state->tg_origin.tp_col,
1131 sy + state->tg_origin.tp_row,
1132 dx + state->tg_origin.tp_col,
1133 dy + state->tg_origin.tp_row,
1134 width, height, 0);
1135 return;
1136 }
1137
1138 /*
1139 * With shadow fb, we need to copy data on both shadow and video,
1140 * to preserve the consistency. We only read data from shadow fb.
1141 */
1142
1143 step = 1;
1144 pitch = state->tg_fb.fb_width;
1145 bytes = width * sizeof (*state->tg_shadow_fb);
1146
1147 /*
1148 * To handle overlapping areas, set up reverse copy here.
1149 */
1150 if (dy * pitch + dx > sy * pitch + sx) {
1151 sy += height;
1152 dy += height;
1153 step = -step;
1154 }
1155
1156 while (height-- > 0) {
1157 uint32_t *source = &state->tg_shadow_fb[sy * pitch + sx];
1158 uint32_t *destination = &state->tg_shadow_fb[dy * pitch + dx];
1159
1160 bcopy(source, destination, bytes);
1161 (void) gfxfb_blt(destination, GfxFbBltBufferToVideo,
1162 0, 0, dx + state->tg_origin.tp_col,
1163 dy + state->tg_origin.tp_row, width, 1, 0);
1164
1165 sy += step;
1166 dy += step;
1167 }
1168 }
1169
1170 static void
gfx_fb_copy_line(teken_gfx_t * state,int ncol,teken_pos_t * s,teken_pos_t * d)1171 gfx_fb_copy_line(teken_gfx_t *state, int ncol, teken_pos_t *s, teken_pos_t *d)
1172 {
1173 teken_rect_t sr;
1174 teken_pos_t dp;
1175 unsigned soffset, doffset;
1176 bool mark = false;
1177 int x;
1178
1179 soffset = s->tp_col + s->tp_row * state->tg_tp.tp_col;
1180 doffset = d->tp_col + d->tp_row * state->tg_tp.tp_col;
1181
1182 for (x = 0; x < ncol; x++) {
1183 if (is_same_pixel(&screen_buffer[soffset + x],
1184 &screen_buffer[doffset + x])) {
1185 if (mark) {
1186 gfx_fb_copy_area(state, &sr, &dp);
1187 mark = false;
1188 }
1189 } else {
1190 screen_buffer[doffset + x] = screen_buffer[soffset + x];
1191 if (mark) {
1192 /* update end point */
1193 sr.tr_end.tp_col = s->tp_col + x;
1194 } else {
1195 /* set up new rectangle */
1196 mark = true;
1197 sr.tr_begin.tp_col = s->tp_col + x;
1198 sr.tr_begin.tp_row = s->tp_row;
1199 sr.tr_end.tp_col = s->tp_col + x;
1200 sr.tr_end.tp_row = s->tp_row;
1201 dp.tp_col = d->tp_col + x;
1202 dp.tp_row = d->tp_row;
1203 }
1204 }
1205 }
1206 if (mark) {
1207 gfx_fb_copy_area(state, &sr, &dp);
1208 }
1209 }
1210
1211 void
gfx_fb_copy(void * arg,const teken_rect_t * r,const teken_pos_t * p)1212 gfx_fb_copy(void *arg, const teken_rect_t *r, const teken_pos_t *p)
1213 {
1214 teken_gfx_t *state = arg;
1215 unsigned doffset, soffset;
1216 teken_pos_t d, s;
1217 int nrow, ncol, y; /* Has to be signed - >= 0 comparison */
1218
1219 /*
1220 * Copying is a little tricky. We must make sure we do it in
1221 * correct order, to make sure we don't overwrite our own data.
1222 */
1223
1224 nrow = r->tr_end.tp_row - r->tr_begin.tp_row;
1225 ncol = r->tr_end.tp_col - r->tr_begin.tp_col;
1226
1227 if (p->tp_row + nrow > state->tg_tp.tp_row ||
1228 p->tp_col + ncol > state->tg_tp.tp_col)
1229 return;
1230
1231 soffset = r->tr_begin.tp_col + r->tr_begin.tp_row * state->tg_tp.tp_col;
1232 doffset = p->tp_col + p->tp_row * state->tg_tp.tp_col;
1233
1234 /* remove the cursor */
1235 if (state->tg_cursor_visible)
1236 gfx_fb_cursor_draw(state, &state->tg_cursor, false);
1237
1238 /*
1239 * Copy line by line.
1240 */
1241 if (doffset <= soffset) {
1242 s = r->tr_begin;
1243 d = *p;
1244 for (y = 0; y < nrow; y++) {
1245 s.tp_row = r->tr_begin.tp_row + y;
1246 d.tp_row = p->tp_row + y;
1247
1248 gfx_fb_copy_line(state, ncol, &s, &d);
1249 }
1250 } else {
1251 for (y = nrow - 1; y >= 0; y--) {
1252 s.tp_row = r->tr_begin.tp_row + y;
1253 d.tp_row = p->tp_row + y;
1254
1255 gfx_fb_copy_line(state, ncol, &s, &d);
1256 }
1257 }
1258
1259 /* display the cursor */
1260 if (state->tg_cursor_visible) {
1261 const teken_pos_t *c;
1262
1263 c = teken_get_cursor(&state->tg_teken);
1264 gfx_fb_cursor_draw(state, c, true);
1265 }
1266 }
1267
1268 /*
1269 * Implements alpha blending for RGBA data, could use pixels for arguments,
1270 * but byte stream seems more generic.
1271 * The generic alpha blending is:
1272 * blend = alpha * fg + (1.0 - alpha) * bg.
1273 * Since our alpha is not from range [0..1], we scale appropriately.
1274 */
1275 static uint8_t
alpha_blend(uint8_t fg,uint8_t bg,uint8_t alpha)1276 alpha_blend(uint8_t fg, uint8_t bg, uint8_t alpha)
1277 {
1278 uint16_t blend, h, l;
1279
1280 /* trivial corner cases */
1281 if (alpha == 0)
1282 return (bg);
1283 if (alpha == 0xFF)
1284 return (fg);
1285 blend = (alpha * fg + (0xFF - alpha) * bg);
1286 /* Division by 0xFF */
1287 h = blend >> 8;
1288 l = blend & 0xFF;
1289 if (h + l >= 0xFF)
1290 h++;
1291 return (h);
1292 }
1293
1294 /*
1295 * Implements alpha blending for RGBA data, could use pixels for arguments,
1296 * but byte stream seems more generic.
1297 * The generic alpha blending is:
1298 * blend = alpha * fg + (1.0 - alpha) * bg.
1299 * Since our alpha is not from range [0..1], we scale appropriately.
1300 */
1301 static void
bitmap_cpy(void * dst,void * src,uint32_t size)1302 bitmap_cpy(void *dst, void *src, uint32_t size)
1303 {
1304 #if defined(EFI)
1305 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *ps, *pd;
1306 #else
1307 struct paletteentry *ps, *pd;
1308 #endif
1309 uint32_t i;
1310 uint8_t a;
1311
1312 ps = src;
1313 pd = dst;
1314
1315 /*
1316 * we only implement alpha blending for depth 32.
1317 */
1318 for (i = 0; i < size; i ++) {
1319 a = ps[i].Reserved;
1320 pd[i].Red = alpha_blend(ps[i].Red, pd[i].Red, a);
1321 pd[i].Green = alpha_blend(ps[i].Green, pd[i].Green, a);
1322 pd[i].Blue = alpha_blend(ps[i].Blue, pd[i].Blue, a);
1323 pd[i].Reserved = a;
1324 }
1325 }
1326
1327 static void *
allocate_glyphbuffer(uint32_t width,uint32_t height)1328 allocate_glyphbuffer(uint32_t width, uint32_t height)
1329 {
1330 size_t size;
1331
1332 size = sizeof (*GlyphBuffer) * width * height;
1333 if (size != GlyphBufferSize) {
1334 free(GlyphBuffer);
1335 GlyphBuffer = malloc(size);
1336 if (GlyphBuffer == NULL)
1337 return (NULL);
1338 GlyphBufferSize = size;
1339 }
1340 return (GlyphBuffer);
1341 }
1342
1343 void
gfx_fb_cons_display(uint32_t x,uint32_t y,uint32_t width,uint32_t height,void * data)1344 gfx_fb_cons_display(uint32_t x, uint32_t y, uint32_t width, uint32_t height,
1345 void *data)
1346 {
1347 #if defined(EFI)
1348 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *buf, *p;
1349 #else
1350 struct paletteentry *buf, *p;
1351 #endif
1352 size_t size;
1353
1354 /*
1355 * If we do have shadow fb, we will use shadow to render data,
1356 * and copy shadow to video.
1357 */
1358 if (gfx_state.tg_shadow_fb != NULL) {
1359 uint32_t pitch = gfx_state.tg_fb.fb_width;
1360
1361 /* Copy rectangle line by line. */
1362 p = data;
1363 for (uint32_t sy = 0; sy < height; sy++) {
1364 buf = (void *)(gfx_state.tg_shadow_fb +
1365 (y - gfx_state.tg_origin.tp_row) * pitch +
1366 x - gfx_state.tg_origin.tp_col);
1367 bitmap_cpy(buf, &p[sy * width], width);
1368 (void) gfxfb_blt(buf, GfxFbBltBufferToVideo,
1369 0, 0, x, y, width, 1, 0);
1370 y++;
1371 }
1372 return;
1373 }
1374
1375 /*
1376 * Common data to display is glyph, use preallocated
1377 * glyph buffer.
1378 */
1379 if (gfx_state.tg_glyph_size != GlyphBufferSize)
1380 (void) allocate_glyphbuffer(width, height);
1381
1382 size = width * height * sizeof(*buf);
1383 if (size == GlyphBufferSize)
1384 buf = GlyphBuffer;
1385 else
1386 buf = malloc(size);
1387 if (buf == NULL)
1388 return;
1389
1390 if (gfxfb_blt(buf, GfxFbBltVideoToBltBuffer, x, y, 0, 0,
1391 width, height, 0) == 0) {
1392 bitmap_cpy(buf, data, width * height);
1393 (void) gfxfb_blt(buf, GfxFbBltBufferToVideo, 0, 0, x, y,
1394 width, height, 0);
1395 }
1396 if (buf != GlyphBuffer)
1397 free(buf);
1398 }
1399
1400 /*
1401 * Public graphics primitives.
1402 */
1403
1404 static int
isqrt(int num)1405 isqrt(int num)
1406 {
1407 int res = 0;
1408 int bit = 1 << 30;
1409
1410 /* "bit" starts at the highest power of four <= the argument. */
1411 while (bit > num)
1412 bit >>= 2;
1413
1414 while (bit != 0) {
1415 if (num >= res + bit) {
1416 num -= res + bit;
1417 res = (res >> 1) + bit;
1418 } else {
1419 res >>= 1;
1420 }
1421 bit >>= 2;
1422 }
1423 return (res);
1424 }
1425
1426 static uint32_t
gfx_fb_getcolor(void)1427 gfx_fb_getcolor(void)
1428 {
1429 uint32_t c;
1430 const teken_attr_t *ap;
1431
1432 ap = teken_get_curattr(&gfx_state.tg_teken);
1433 if (ap->ta_format & TF_REVERSE) {
1434 c = ap->ta_bgcolor;
1435 if (ap->ta_format & TF_BLINK)
1436 c |= TC_LIGHT;
1437 } else {
1438 c = ap->ta_fgcolor;
1439 if (ap->ta_format & TF_BOLD)
1440 c |= TC_LIGHT;
1441 }
1442
1443 return (gfx_fb_color_map(c));
1444 }
1445
1446 /* set pixel in framebuffer using gfx coordinates */
1447 void
gfx_fb_setpixel(uint32_t x,uint32_t y)1448 gfx_fb_setpixel(uint32_t x, uint32_t y)
1449 {
1450 uint32_t c;
1451
1452 if (gfx_state.tg_fb_type == FB_TEXT)
1453 return;
1454
1455 c = gfx_fb_getcolor();
1456
1457 if (x >= gfx_state.tg_fb.fb_width ||
1458 y >= gfx_state.tg_fb.fb_height)
1459 return;
1460
1461 gfxfb_blt(&c, GfxFbBltVideoFill, 0, 0, x, y, 1, 1, 0);
1462 }
1463
1464 /*
1465 * draw rectangle in framebuffer using gfx coordinates.
1466 */
1467 void
gfx_fb_drawrect(uint32_t x1,uint32_t y1,uint32_t x2,uint32_t y2,uint32_t fill)1468 gfx_fb_drawrect(uint32_t x1, uint32_t y1, uint32_t x2, uint32_t y2,
1469 uint32_t fill)
1470 {
1471 uint32_t c;
1472
1473 if (gfx_state.tg_fb_type == FB_TEXT)
1474 return;
1475
1476 c = gfx_fb_getcolor();
1477
1478 if (fill != 0) {
1479 gfxfb_blt(&c, GfxFbBltVideoFill, 0, 0, x1, y1, x2 - x1,
1480 y2 - y1, 0);
1481 } else {
1482 gfxfb_blt(&c, GfxFbBltVideoFill, 0, 0, x1, y1, x2 - x1, 1, 0);
1483 gfxfb_blt(&c, GfxFbBltVideoFill, 0, 0, x1, y2, x2 - x1, 1, 0);
1484 gfxfb_blt(&c, GfxFbBltVideoFill, 0, 0, x1, y1, 1, y2 - y1, 0);
1485 gfxfb_blt(&c, GfxFbBltVideoFill, 0, 0, x2, y1, 1, y2 - y1, 0);
1486 }
1487 }
1488
1489 void
gfx_fb_line(uint32_t x0,uint32_t y0,uint32_t x1,uint32_t y1,uint32_t wd)1490 gfx_fb_line(uint32_t x0, uint32_t y0, uint32_t x1, uint32_t y1, uint32_t wd)
1491 {
1492 int dx, sx, dy, sy;
1493 int err, e2, x2, y2, ed, width;
1494
1495 if (gfx_state.tg_fb_type == FB_TEXT)
1496 return;
1497
1498 width = wd;
1499 sx = x0 < x1? 1 : -1;
1500 sy = y0 < y1? 1 : -1;
1501 dx = x1 > x0? x1 - x0 : x0 - x1;
1502 dy = y1 > y0? y1 - y0 : y0 - y1;
1503 err = dx + dy;
1504 ed = dx + dy == 0 ? 1: isqrt(dx * dx + dy * dy);
1505
1506 for (;;) {
1507 gfx_fb_setpixel(x0, y0);
1508 e2 = err;
1509 x2 = x0;
1510 if ((e2 << 1) >= -dx) { /* x step */
1511 e2 += dy;
1512 y2 = y0;
1513 while (e2 < ed * width &&
1514 (y1 != (uint32_t)y2 || dx > dy)) {
1515 y2 += sy;
1516 gfx_fb_setpixel(x0, y2);
1517 e2 += dx;
1518 }
1519 if (x0 == x1)
1520 break;
1521 e2 = err;
1522 err -= dy;
1523 x0 += sx;
1524 }
1525 if ((e2 << 1) <= dy) { /* y step */
1526 e2 = dx-e2;
1527 while (e2 < ed * width &&
1528 (x1 != (uint32_t)x2 || dx < dy)) {
1529 x2 += sx;
1530 gfx_fb_setpixel(x2, y0);
1531 e2 += dy;
1532 }
1533 if (y0 == y1)
1534 break;
1535 err += dx;
1536 y0 += sy;
1537 }
1538 }
1539 }
1540
1541 /*
1542 * quadratic Bézier curve limited to gradients without sign change.
1543 */
1544 void
gfx_fb_bezier(uint32_t x0,uint32_t y0,uint32_t x1,uint32_t y1,uint32_t x2,uint32_t y2,uint32_t wd)1545 gfx_fb_bezier(uint32_t x0, uint32_t y0, uint32_t x1, uint32_t y1, uint32_t x2,
1546 uint32_t y2, uint32_t wd)
1547 {
1548 int sx, sy, xx, yy, xy, width;
1549 int dx, dy, err, curvature;
1550 int i;
1551
1552 if (gfx_state.tg_fb_type == FB_TEXT)
1553 return;
1554
1555 width = wd;
1556 sx = x2 - x1;
1557 sy = y2 - y1;
1558 xx = x0 - x1;
1559 yy = y0 - y1;
1560 curvature = xx*sy - yy*sx;
1561
1562 if (sx*sx + sy*sy > xx*xx+yy*yy) {
1563 x2 = x0;
1564 x0 = sx + x1;
1565 y2 = y0;
1566 y0 = sy + y1;
1567 curvature = -curvature;
1568 }
1569 if (curvature != 0) {
1570 xx += sx;
1571 sx = x0 < x2? 1 : -1;
1572 xx *= sx;
1573 yy += sy;
1574 sy = y0 < y2? 1 : -1;
1575 yy *= sy;
1576 xy = (xx*yy) << 1;
1577 xx *= xx;
1578 yy *= yy;
1579 if (curvature * sx * sy < 0) {
1580 xx = -xx;
1581 yy = -yy;
1582 xy = -xy;
1583 curvature = -curvature;
1584 }
1585 dx = 4 * sy * curvature * (x1 - x0) + xx - xy;
1586 dy = 4 * sx * curvature * (y0 - y1) + yy - xy;
1587 xx += xx;
1588 yy += yy;
1589 err = dx + dy + xy;
1590 do {
1591 for (i = 0; i <= width; i++)
1592 gfx_fb_setpixel(x0 + i, y0);
1593 if (x0 == x2 && y0 == y2)
1594 return; /* last pixel -> curve finished */
1595 y1 = 2 * err < dx;
1596 if (2 * err > dy) {
1597 x0 += sx;
1598 dx -= xy;
1599 dy += yy;
1600 err += dy;
1601 }
1602 if (y1 != 0) {
1603 y0 += sy;
1604 dy -= xy;
1605 dx += xx;
1606 err += dx;
1607 }
1608 } while (dy < dx); /* gradient negates -> algorithm fails */
1609 }
1610 gfx_fb_line(x0, y0, x2, y2, width);
1611 }
1612
1613 /*
1614 * draw rectangle using terminal coordinates and current foreground color.
1615 */
1616 void
gfx_term_drawrect(uint32_t ux1,uint32_t uy1,uint32_t ux2,uint32_t uy2)1617 gfx_term_drawrect(uint32_t ux1, uint32_t uy1, uint32_t ux2, uint32_t uy2)
1618 {
1619 int x1, y1, x2, y2;
1620 int xshift, yshift;
1621 int width, i;
1622 uint32_t vf_width, vf_height;
1623 teken_rect_t r;
1624
1625 if (gfx_state.tg_fb_type == FB_TEXT)
1626 return;
1627
1628 vf_width = gfx_state.tg_font.vf_width;
1629 vf_height = gfx_state.tg_font.vf_height;
1630 width = vf_width / 4; /* line width */
1631 xshift = (vf_width - width) / 2;
1632 yshift = (vf_height - width) / 2;
1633
1634 /* Shift coordinates */
1635 if (ux1 != 0)
1636 ux1--;
1637 if (uy1 != 0)
1638 uy1--;
1639 ux2--;
1640 uy2--;
1641
1642 /* mark area used in terminal */
1643 r.tr_begin.tp_col = ux1;
1644 r.tr_begin.tp_row = uy1;
1645 r.tr_end.tp_col = ux2 + 1;
1646 r.tr_end.tp_row = uy2 + 1;
1647
1648 term_image_display(&gfx_state, &r);
1649
1650 /*
1651 * Draw horizontal lines width points thick, shifted from outer edge.
1652 */
1653 x1 = (ux1 + 1) * vf_width + gfx_state.tg_origin.tp_col;
1654 y1 = uy1 * vf_height + gfx_state.tg_origin.tp_row + yshift;
1655 x2 = ux2 * vf_width + gfx_state.tg_origin.tp_col;
1656 gfx_fb_drawrect(x1, y1, x2, y1 + width, 1);
1657 y2 = uy2 * vf_height + gfx_state.tg_origin.tp_row;
1658 y2 += vf_height - yshift - width;
1659 gfx_fb_drawrect(x1, y2, x2, y2 + width, 1);
1660
1661 /*
1662 * Draw vertical lines width points thick, shifted from outer edge.
1663 */
1664 x1 = ux1 * vf_width + gfx_state.tg_origin.tp_col + xshift;
1665 y1 = uy1 * vf_height + gfx_state.tg_origin.tp_row;
1666 y1 += vf_height;
1667 y2 = uy2 * vf_height + gfx_state.tg_origin.tp_row;
1668 gfx_fb_drawrect(x1, y1, x1 + width, y2, 1);
1669 x1 = ux2 * vf_width + gfx_state.tg_origin.tp_col;
1670 x1 += vf_width - xshift - width;
1671 gfx_fb_drawrect(x1, y1, x1 + width, y2, 1);
1672
1673 /* Draw upper left corner. */
1674 x1 = ux1 * vf_width + gfx_state.tg_origin.tp_col + xshift;
1675 y1 = uy1 * vf_height + gfx_state.tg_origin.tp_row;
1676 y1 += vf_height;
1677
1678 x2 = ux1 * vf_width + gfx_state.tg_origin.tp_col;
1679 x2 += vf_width;
1680 y2 = uy1 * vf_height + gfx_state.tg_origin.tp_row + yshift;
1681 for (i = 0; i <= width; i++)
1682 gfx_fb_bezier(x1 + i, y1, x1 + i, y2 + i, x2, y2 + i, width-i);
1683
1684 /* Draw lower left corner. */
1685 x1 = ux1 * vf_width + gfx_state.tg_origin.tp_col;
1686 x1 += vf_width;
1687 y1 = uy2 * vf_height + gfx_state.tg_origin.tp_row;
1688 y1 += vf_height - yshift;
1689 x2 = ux1 * vf_width + gfx_state.tg_origin.tp_col + xshift;
1690 y2 = uy2 * vf_height + gfx_state.tg_origin.tp_row;
1691 for (i = 0; i <= width; i++)
1692 gfx_fb_bezier(x1, y1 - i, x2 + i, y1 - i, x2 + i, y2, width-i);
1693
1694 /* Draw upper right corner. */
1695 x1 = ux2 * vf_width + gfx_state.tg_origin.tp_col;
1696 y1 = uy1 * vf_height + gfx_state.tg_origin.tp_row + yshift;
1697 x2 = ux2 * vf_width + gfx_state.tg_origin.tp_col;
1698 x2 += vf_width - xshift - width;
1699 y2 = uy1 * vf_height + gfx_state.tg_origin.tp_row;
1700 y2 += vf_height;
1701 for (i = 0; i <= width; i++)
1702 gfx_fb_bezier(x1, y1 + i, x2 + i, y1 + i, x2 + i, y2, width-i);
1703
1704 /* Draw lower right corner. */
1705 x1 = ux2 * vf_width + gfx_state.tg_origin.tp_col;
1706 y1 = uy2 * vf_height + gfx_state.tg_origin.tp_row;
1707 y1 += vf_height - yshift;
1708 x2 = ux2 * vf_width + gfx_state.tg_origin.tp_col;
1709 x2 += vf_width - xshift - width;
1710 y2 = uy2 * vf_height + gfx_state.tg_origin.tp_row;
1711 for (i = 0; i <= width; i++)
1712 gfx_fb_bezier(x1, y1 - i, x2 + i, y1 - i, x2 + i, y2, width-i);
1713 }
1714
1715 int
gfx_fb_putimage(png_t * png,uint32_t ux1,uint32_t uy1,uint32_t ux2,uint32_t uy2,uint32_t flags)1716 gfx_fb_putimage(png_t *png, uint32_t ux1, uint32_t uy1, uint32_t ux2,
1717 uint32_t uy2, uint32_t flags)
1718 {
1719 #if defined(EFI)
1720 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *p;
1721 #else
1722 struct paletteentry *p;
1723 #endif
1724 uint8_t *data;
1725 uint32_t i, j, x, y, fheight, fwidth;
1726 int rs, gs, bs;
1727 uint8_t r, g, b, a;
1728 bool scale = false;
1729 bool trace = false;
1730 teken_rect_t rect;
1731
1732 trace = (flags & FL_PUTIMAGE_DEBUG) != 0;
1733
1734 if (gfx_state.tg_fb_type == FB_TEXT) {
1735 if (trace)
1736 printf("Framebuffer not active.\n");
1737 return (1);
1738 }
1739
1740 if (png->color_type != PNG_TRUECOLOR_ALPHA) {
1741 if (trace)
1742 printf("Not truecolor image.\n");
1743 return (1);
1744 }
1745
1746 if (ux1 > gfx_state.tg_fb.fb_width ||
1747 uy1 > gfx_state.tg_fb.fb_height) {
1748 if (trace)
1749 printf("Top left coordinate off screen.\n");
1750 return (1);
1751 }
1752
1753 if (png->width > UINT16_MAX || png->height > UINT16_MAX) {
1754 if (trace)
1755 printf("Image too large.\n");
1756 return (1);
1757 }
1758
1759 if (png->width < 1 || png->height < 1) {
1760 if (trace)
1761 printf("Image too small.\n");
1762 return (1);
1763 }
1764
1765 /*
1766 * If 0 was passed for either ux2 or uy2, then calculate the missing
1767 * part of the bottom right coordinate.
1768 */
1769 scale = true;
1770 if (ux2 == 0 && uy2 == 0) {
1771 /* Both 0, use the native resolution of the image */
1772 ux2 = ux1 + png->width;
1773 uy2 = uy1 + png->height;
1774 scale = false;
1775 } else if (ux2 == 0) {
1776 /* Set ux2 from uy2/uy1 to maintain aspect ratio */
1777 ux2 = ux1 + (png->width * (uy2 - uy1)) / png->height;
1778 } else if (uy2 == 0) {
1779 /* Set uy2 from ux2/ux1 to maintain aspect ratio */
1780 uy2 = uy1 + (png->height * (ux2 - ux1)) / png->width;
1781 }
1782
1783 if (ux2 > gfx_state.tg_fb.fb_width ||
1784 uy2 > gfx_state.tg_fb.fb_height) {
1785 if (trace)
1786 printf("Bottom right coordinate off screen.\n");
1787 return (1);
1788 }
1789
1790 fwidth = ux2 - ux1;
1791 fheight = uy2 - uy1;
1792
1793 /*
1794 * If the original image dimensions have been passed explicitly,
1795 * disable scaling.
1796 */
1797 if (fwidth == png->width && fheight == png->height)
1798 scale = false;
1799
1800 if (ux1 == 0) {
1801 /*
1802 * No top left X co-ordinate (real coordinates start at 1),
1803 * place as far right as it will fit.
1804 */
1805 ux2 = gfx_state.tg_fb.fb_width - gfx_state.tg_origin.tp_col;
1806 ux1 = ux2 - fwidth;
1807 }
1808
1809 if (uy1 == 0) {
1810 /*
1811 * No top left Y co-ordinate (real coordinates start at 1),
1812 * place as far down as it will fit.
1813 */
1814 uy2 = gfx_state.tg_fb.fb_height - gfx_state.tg_origin.tp_row;
1815 uy1 = uy2 - fheight;
1816 }
1817
1818 if (ux1 >= ux2 || uy1 >= uy2) {
1819 if (trace)
1820 printf("Image dimensions reversed.\n");
1821 return (1);
1822 }
1823
1824 if (fwidth < 2 || fheight < 2) {
1825 if (trace)
1826 printf("Target area too small\n");
1827 return (1);
1828 }
1829
1830 if (trace)
1831 printf("Image %ux%u -> %ux%u @%ux%u\n",
1832 png->width, png->height, fwidth, fheight, ux1, uy1);
1833
1834 rect.tr_begin.tp_col = ux1 / gfx_state.tg_font.vf_width;
1835 rect.tr_begin.tp_row = uy1 / gfx_state.tg_font.vf_height;
1836 rect.tr_end.tp_col = (ux1 + fwidth) / gfx_state.tg_font.vf_width;
1837 rect.tr_end.tp_row = (uy1 + fheight) / gfx_state.tg_font.vf_height;
1838
1839 /*
1840 * mark area used in terminal
1841 */
1842 if (!(flags & FL_PUTIMAGE_NOSCROLL))
1843 term_image_display(&gfx_state, &rect);
1844
1845 if ((flags & FL_PUTIMAGE_BORDER))
1846 gfx_fb_drawrect(ux1, uy1, ux2, uy2, 0);
1847
1848 data = malloc(fwidth * fheight * sizeof(*p));
1849 p = (void *)data;
1850 if (data == NULL) {
1851 if (trace)
1852 printf("Out of memory.\n");
1853 return (1);
1854 }
1855
1856 /*
1857 * Build image for our framebuffer.
1858 */
1859
1860 /* Helper to calculate the pixel index from the source png */
1861 #define GETPIXEL(xx, yy) (((yy) * png->width + (xx)) * png->bpp)
1862
1863 /*
1864 * For each of the x and y directions, calculate the number of pixels
1865 * in the source image that correspond to a single pixel in the target.
1866 * Use fixed-point arithmetic with 16-bits for each of the integer and
1867 * fractional parts.
1868 */
1869 const uint32_t wcstep = ((png->width - 1) << 16) / (fwidth - 1);
1870 const uint32_t hcstep = ((png->height - 1) << 16) / (fheight - 1);
1871
1872 rs = 8 - (fls(gfx_state.tg_fb.fb_mask_red) -
1873 ffs(gfx_state.tg_fb.fb_mask_red) + 1);
1874 gs = 8 - (fls(gfx_state.tg_fb.fb_mask_green) -
1875 ffs(gfx_state.tg_fb.fb_mask_green) + 1);
1876 bs = 8 - (fls(gfx_state.tg_fb.fb_mask_blue) -
1877 ffs(gfx_state.tg_fb.fb_mask_blue) + 1);
1878
1879 uint32_t hc = 0;
1880 for (y = 0; y < fheight; y++) {
1881 uint32_t hc2 = (hc >> 9) & 0x7f;
1882 uint32_t hc1 = 0x80 - hc2;
1883
1884 uint32_t offset_y = hc >> 16;
1885 uint32_t offset_y1 = offset_y + 1;
1886
1887 uint32_t wc = 0;
1888 for (x = 0; x < fwidth; x++) {
1889 uint32_t wc2 = (wc >> 9) & 0x7f;
1890 uint32_t wc1 = 0x80 - wc2;
1891
1892 uint32_t offset_x = wc >> 16;
1893 uint32_t offset_x1 = offset_x + 1;
1894
1895 /* Target pixel index */
1896 j = y * fwidth + x;
1897
1898 if (!scale) {
1899 i = GETPIXEL(x, y);
1900 r = png->image[i];
1901 g = png->image[i + 1];
1902 b = png->image[i + 2];
1903 a = png->image[i + 3];
1904 } else {
1905 uint8_t pixel[4];
1906
1907 uint32_t p00 = GETPIXEL(offset_x, offset_y);
1908 uint32_t p01 = GETPIXEL(offset_x, offset_y1);
1909 uint32_t p10 = GETPIXEL(offset_x1, offset_y);
1910 uint32_t p11 = GETPIXEL(offset_x1, offset_y1);
1911
1912 /*
1913 * Given a 2x2 array of pixels in the source
1914 * image, combine them to produce a single
1915 * value for the pixel in the target image.
1916 * Each column of pixels is combined using
1917 * a weighted average where the top and bottom
1918 * pixels contribute hc1 and hc2 respectively.
1919 * The calculation for bottom pixel pB and
1920 * top pixel pT is:
1921 * (pT * hc1 + pB * hc2) / (hc1 + hc2)
1922 * Once the values are determined for the two
1923 * columns of pixels, then the columns are
1924 * averaged together in the same way but using
1925 * wc1 and wc2 for the weightings.
1926 *
1927 * Since hc1 and hc2 are chosen so that
1928 * hc1 + hc2 == 128 (and same for wc1 + wc2),
1929 * the >> 14 below is a quick way to divide by
1930 * (hc1 + hc2) * (wc1 + wc2)
1931 */
1932 for (i = 0; i < 4; i++)
1933 pixel[i] = (
1934 (png->image[p00 + i] * hc1 +
1935 png->image[p01 + i] * hc2) * wc1 +
1936 (png->image[p10 + i] * hc1 +
1937 png->image[p11 + i] * hc2) * wc2)
1938 >> 14;
1939
1940 r = pixel[0];
1941 g = pixel[1];
1942 b = pixel[2];
1943 a = pixel[3];
1944 }
1945
1946 if (trace)
1947 printf("r/g/b: %x/%x/%x\n", r, g, b);
1948 /*
1949 * Rough colorspace reduction for 15/16 bit colors.
1950 */
1951 p[j].Red = r >> rs;
1952 p[j].Green = g >> gs;
1953 p[j].Blue = b >> bs;
1954 p[j].Reserved = a;
1955
1956 wc += wcstep;
1957 }
1958 hc += hcstep;
1959 }
1960
1961 gfx_fb_cons_display(ux1, uy1, fwidth, fheight, data);
1962 free(data);
1963 return (0);
1964 }
1965
1966 /*
1967 * Reset font flags to FONT_AUTO.
1968 */
1969 void
reset_font_flags(void)1970 reset_font_flags(void)
1971 {
1972 struct fontlist *fl;
1973
1974 STAILQ_FOREACH(fl, &fonts, font_next) {
1975 fl->font_flags = FONT_AUTO;
1976 }
1977 }
1978
1979 /* Return w^2 + h^2 or 0, if the dimensions are unknown */
1980 static unsigned
edid_diagonal_squared(void)1981 edid_diagonal_squared(void)
1982 {
1983 unsigned w, h;
1984
1985 if (edid_info == NULL)
1986 return (0);
1987
1988 w = edid_info->display.max_horizontal_image_size;
1989 h = edid_info->display.max_vertical_image_size;
1990
1991 /* If either one is 0, we have aspect ratio, not size */
1992 if (w == 0 || h == 0)
1993 return (0);
1994
1995 /*
1996 * some monitors encode the aspect ratio instead of the physical size.
1997 */
1998 if ((w == 16 && h == 9) || (w == 16 && h == 10) ||
1999 (w == 4 && h == 3) || (w == 5 && h == 4))
2000 return (0);
2001
2002 /*
2003 * translate cm to inch, note we scale by 100 here.
2004 */
2005 w = w * 100 / 254;
2006 h = h * 100 / 254;
2007
2008 /* Return w^2 + h^2 */
2009 return (w * w + h * h);
2010 }
2011
2012 /*
2013 * calculate pixels per inch.
2014 */
2015 static unsigned
gfx_get_ppi(void)2016 gfx_get_ppi(void)
2017 {
2018 unsigned dp, di;
2019
2020 di = edid_diagonal_squared();
2021 if (di == 0)
2022 return (0);
2023
2024 dp = gfx_state.tg_fb.fb_width *
2025 gfx_state.tg_fb.fb_width +
2026 gfx_state.tg_fb.fb_height *
2027 gfx_state.tg_fb.fb_height;
2028
2029 return (isqrt(dp / di));
2030 }
2031
2032 /*
2033 * Calculate font size from density independent pixels (dp):
2034 * ((16dp * ppi) / 160) * display_factor.
2035 * Here we are using fixed constants: 1dp == 160 ppi and
2036 * display_factor 2.
2037 *
2038 * We are rounding font size up and are searching for font which is
2039 * not smaller than calculated size value.
2040 */
2041 static vt_font_bitmap_data_t *
gfx_get_font(void)2042 gfx_get_font(void)
2043 {
2044 unsigned ppi, size;
2045 vt_font_bitmap_data_t *font = NULL;
2046 struct fontlist *fl, *next;
2047
2048 /* Text mode is not supported here. */
2049 if (gfx_state.tg_fb_type == FB_TEXT)
2050 return (NULL);
2051
2052 ppi = gfx_get_ppi();
2053 if (ppi == 0)
2054 return (NULL);
2055
2056 /*
2057 * We will search for 16dp font.
2058 * We are using scale up by 10 for roundup.
2059 */
2060 size = (16 * ppi * 10) / 160;
2061 /* Apply display factor 2. */
2062 size = roundup(size * 2, 10) / 10;
2063
2064 STAILQ_FOREACH(fl, &fonts, font_next) {
2065 next = STAILQ_NEXT(fl, font_next);
2066
2067 /*
2068 * If this is last font or, if next font is smaller,
2069 * we have our font. Make sure, it actually is loaded.
2070 */
2071 if (next == NULL || next->font_data->vfbd_height < size) {
2072 font = fl->font_data;
2073 if (font->vfbd_font == NULL ||
2074 fl->font_flags == FONT_RELOAD) {
2075 if (fl->font_load != NULL &&
2076 fl->font_name != NULL)
2077 font = fl->font_load(fl->font_name);
2078 }
2079 break;
2080 }
2081 }
2082
2083 return (font);
2084 }
2085
2086 static vt_font_bitmap_data_t *
set_font(teken_unit_t * rows,teken_unit_t * cols,teken_unit_t h,teken_unit_t w)2087 set_font(teken_unit_t *rows, teken_unit_t *cols, teken_unit_t h, teken_unit_t w)
2088 {
2089 vt_font_bitmap_data_t *font = NULL;
2090 struct fontlist *fl;
2091 unsigned height = h;
2092 unsigned width = w;
2093
2094 /*
2095 * First check for manually loaded font.
2096 */
2097 STAILQ_FOREACH(fl, &fonts, font_next) {
2098 if (fl->font_flags == FONT_MANUAL) {
2099 font = fl->font_data;
2100 if (font->vfbd_font == NULL && fl->font_load != NULL &&
2101 fl->font_name != NULL) {
2102 font = fl->font_load(fl->font_name);
2103 }
2104 if (font == NULL || font->vfbd_font == NULL)
2105 font = NULL;
2106 break;
2107 }
2108 }
2109
2110 if (font == NULL)
2111 font = gfx_get_font();
2112
2113 if (font != NULL) {
2114 *rows = height / font->vfbd_height;
2115 *cols = width / font->vfbd_width;
2116 return (font);
2117 }
2118
2119 /*
2120 * Find best font for these dimensions, or use default.
2121 * If height >= VT_FB_MAX_HEIGHT and width >= VT_FB_MAX_WIDTH,
2122 * do not use smaller font than our DEFAULT_FONT_DATA.
2123 */
2124 STAILQ_FOREACH(fl, &fonts, font_next) {
2125 font = fl->font_data;
2126 if ((*rows * font->vfbd_height <= height &&
2127 *cols * font->vfbd_width <= width) ||
2128 (height >= VT_FB_MAX_HEIGHT &&
2129 width >= VT_FB_MAX_WIDTH &&
2130 font->vfbd_height == DEFAULT_FONT_DATA.vfbd_height &&
2131 font->vfbd_width == DEFAULT_FONT_DATA.vfbd_width)) {
2132 if (font->vfbd_font == NULL ||
2133 fl->font_flags == FONT_RELOAD) {
2134 if (fl->font_load != NULL &&
2135 fl->font_name != NULL) {
2136 font = fl->font_load(fl->font_name);
2137 }
2138 if (font == NULL)
2139 continue;
2140 }
2141 *rows = height / font->vfbd_height;
2142 *cols = width / font->vfbd_width;
2143 break;
2144 }
2145 font = NULL;
2146 }
2147
2148 if (font == NULL) {
2149 /*
2150 * We have fonts sorted smallest last, try it before
2151 * falling back to builtin.
2152 */
2153 fl = STAILQ_LAST(&fonts, fontlist, font_next);
2154 if (fl != NULL && fl->font_load != NULL &&
2155 fl->font_name != NULL) {
2156 font = fl->font_load(fl->font_name);
2157 }
2158 if (font == NULL)
2159 font = &DEFAULT_FONT_DATA;
2160
2161 *rows = height / font->vfbd_height;
2162 *cols = width / font->vfbd_width;
2163 }
2164
2165 return (font);
2166 }
2167
2168 static void
cons_clear(void)2169 cons_clear(void)
2170 {
2171 char clear[] = { '\033', 'c' };
2172
2173 /* Reset terminal */
2174 teken_input(&gfx_state.tg_teken, clear, sizeof(clear));
2175 gfx_state.tg_functions->tf_param(&gfx_state, TP_SHOWCURSOR, 0);
2176 }
2177
2178 void
setup_font(teken_gfx_t * state,teken_unit_t height,teken_unit_t width)2179 setup_font(teken_gfx_t *state, teken_unit_t height, teken_unit_t width)
2180 {
2181 vt_font_bitmap_data_t *font_data;
2182 teken_pos_t *tp = &state->tg_tp;
2183 char env[8];
2184 int i;
2185
2186 /*
2187 * set_font() will select a appropriate sized font for
2188 * the number of rows and columns selected. If we don't
2189 * have a font that will fit, then it will use the
2190 * default builtin font and adjust the rows and columns
2191 * to fit on the screen.
2192 */
2193 font_data = set_font(&tp->tp_row, &tp->tp_col, height, width);
2194
2195 if (font_data == NULL)
2196 panic("out of memory");
2197
2198 for (i = 0; i < VFNT_MAPS; i++) {
2199 state->tg_font.vf_map[i] =
2200 font_data->vfbd_font->vf_map[i];
2201 state->tg_font.vf_map_count[i] =
2202 font_data->vfbd_font->vf_map_count[i];
2203 }
2204
2205 state->tg_font.vf_bytes = font_data->vfbd_font->vf_bytes;
2206 state->tg_font.vf_height = font_data->vfbd_font->vf_height;
2207 state->tg_font.vf_width = font_data->vfbd_font->vf_width;
2208
2209 snprintf(env, sizeof (env), "%ux%u",
2210 state->tg_font.vf_width, state->tg_font.vf_height);
2211 env_setenv("screen.font", EV_VOLATILE | EV_NOHOOK,
2212 env, font_set, env_nounset);
2213 }
2214
2215 /* Binary search for the glyph. Return 0 if not found. */
2216 static uint16_t
font_bisearch(const vfnt_map_t * map,uint32_t len,teken_char_t src)2217 font_bisearch(const vfnt_map_t *map, uint32_t len, teken_char_t src)
2218 {
2219 unsigned min, mid, max;
2220
2221 min = 0;
2222 max = len - 1;
2223
2224 /* Empty font map. */
2225 if (len == 0)
2226 return (0);
2227 /* Character below minimal entry. */
2228 if (src < map[0].vfm_src)
2229 return (0);
2230 /* Optimization: ASCII characters occur very often. */
2231 if (src <= map[0].vfm_src + map[0].vfm_len)
2232 return (src - map[0].vfm_src + map[0].vfm_dst);
2233 /* Character above maximum entry. */
2234 if (src > map[max].vfm_src + map[max].vfm_len)
2235 return (0);
2236
2237 /* Binary search. */
2238 while (max >= min) {
2239 mid = (min + max) / 2;
2240 if (src < map[mid].vfm_src)
2241 max = mid - 1;
2242 else if (src > map[mid].vfm_src + map[mid].vfm_len)
2243 min = mid + 1;
2244 else
2245 return (src - map[mid].vfm_src + map[mid].vfm_dst);
2246 }
2247
2248 return (0);
2249 }
2250
2251 /*
2252 * Return glyph bitmap. If glyph is not found, we will return bitmap
2253 * for the first (offset 0) glyph.
2254 */
2255 uint8_t *
font_lookup(const struct vt_font * vf,teken_char_t c,const teken_attr_t * a)2256 font_lookup(const struct vt_font *vf, teken_char_t c, const teken_attr_t *a)
2257 {
2258 uint16_t dst;
2259 size_t stride;
2260
2261 /* Substitute bold with normal if not found. */
2262 if (a->ta_format & TF_BOLD) {
2263 dst = font_bisearch(vf->vf_map[VFNT_MAP_BOLD],
2264 vf->vf_map_count[VFNT_MAP_BOLD], c);
2265 if (dst != 0)
2266 goto found;
2267 }
2268 dst = font_bisearch(vf->vf_map[VFNT_MAP_NORMAL],
2269 vf->vf_map_count[VFNT_MAP_NORMAL], c);
2270
2271 found:
2272 stride = howmany(vf->vf_width, 8) * vf->vf_height;
2273 return (&vf->vf_bytes[dst * stride]);
2274 }
2275
2276 static int
load_mapping(int fd,struct vt_font * fp,int n)2277 load_mapping(int fd, struct vt_font *fp, int n)
2278 {
2279 size_t i, size;
2280 ssize_t rv;
2281 vfnt_map_t *mp;
2282
2283 if (fp->vf_map_count[n] == 0)
2284 return (0);
2285
2286 size = fp->vf_map_count[n] * sizeof(*mp);
2287 mp = malloc(size);
2288 if (mp == NULL)
2289 return (ENOMEM);
2290 fp->vf_map[n] = mp;
2291
2292 rv = read(fd, mp, size);
2293 if (rv < 0 || (size_t)rv != size) {
2294 free(fp->vf_map[n]);
2295 fp->vf_map[n] = NULL;
2296 return (EIO);
2297 }
2298
2299 for (i = 0; i < fp->vf_map_count[n]; i++) {
2300 mp[i].vfm_src = be32toh(mp[i].vfm_src);
2301 mp[i].vfm_dst = be16toh(mp[i].vfm_dst);
2302 mp[i].vfm_len = be16toh(mp[i].vfm_len);
2303 }
2304 return (0);
2305 }
2306
2307 static int
builtin_mapping(struct vt_font * fp,int n)2308 builtin_mapping(struct vt_font *fp, int n)
2309 {
2310 size_t size;
2311 struct vfnt_map *mp;
2312
2313 if (n >= VFNT_MAPS)
2314 return (EINVAL);
2315
2316 if (fp->vf_map_count[n] == 0)
2317 return (0);
2318
2319 size = fp->vf_map_count[n] * sizeof(*mp);
2320 mp = malloc(size);
2321 if (mp == NULL)
2322 return (ENOMEM);
2323 fp->vf_map[n] = mp;
2324
2325 memcpy(mp, DEFAULT_FONT_DATA.vfbd_font->vf_map[n], size);
2326 return (0);
2327 }
2328
2329 /*
2330 * Load font from builtin or from file.
2331 * We do need special case for builtin because the builtin font glyphs
2332 * are compressed and we do need to uncompress them.
2333 * Having single load_font() for both cases will help us to simplify
2334 * font switch handling.
2335 */
2336 static vt_font_bitmap_data_t *
load_font(char * path)2337 load_font(char *path)
2338 {
2339 int fd, i;
2340 uint32_t glyphs;
2341 struct font_header fh;
2342 struct fontlist *fl;
2343 vt_font_bitmap_data_t *bp;
2344 struct vt_font *fp;
2345 size_t size;
2346 ssize_t rv;
2347
2348 /* Get our entry from the font list. */
2349 STAILQ_FOREACH(fl, &fonts, font_next) {
2350 if (strcmp(fl->font_name, path) == 0)
2351 break;
2352 }
2353 if (fl == NULL)
2354 return (NULL); /* Should not happen. */
2355
2356 bp = fl->font_data;
2357 if (bp->vfbd_font != NULL && fl->font_flags != FONT_RELOAD)
2358 return (bp);
2359
2360 fd = -1;
2361 /*
2362 * Special case for builtin font.
2363 * Builtin font is the very first font we load, we do not have
2364 * previous loads to be released.
2365 */
2366 if (fl->font_flags == FONT_BUILTIN) {
2367 if ((fp = calloc(1, sizeof(struct vt_font))) == NULL)
2368 return (NULL);
2369
2370 fp->vf_width = DEFAULT_FONT_DATA.vfbd_width;
2371 fp->vf_height = DEFAULT_FONT_DATA.vfbd_height;
2372
2373 fp->vf_bytes = malloc(DEFAULT_FONT_DATA.vfbd_uncompressed_size);
2374 if (fp->vf_bytes == NULL) {
2375 free(fp);
2376 return (NULL);
2377 }
2378
2379 bp->vfbd_uncompressed_size =
2380 DEFAULT_FONT_DATA.vfbd_uncompressed_size;
2381 bp->vfbd_compressed_size =
2382 DEFAULT_FONT_DATA.vfbd_compressed_size;
2383
2384 if (lz4_decompress(DEFAULT_FONT_DATA.vfbd_compressed_data,
2385 fp->vf_bytes,
2386 DEFAULT_FONT_DATA.vfbd_compressed_size,
2387 DEFAULT_FONT_DATA.vfbd_uncompressed_size, 0) != 0) {
2388 free(fp->vf_bytes);
2389 free(fp);
2390 return (NULL);
2391 }
2392
2393 for (i = 0; i < VFNT_MAPS; i++) {
2394 fp->vf_map_count[i] =
2395 DEFAULT_FONT_DATA.vfbd_font->vf_map_count[i];
2396 if (builtin_mapping(fp, i) != 0)
2397 goto free_done;
2398 }
2399
2400 bp->vfbd_font = fp;
2401 return (bp);
2402 }
2403
2404 fd = open(path, O_RDONLY);
2405 if (fd < 0)
2406 return (NULL);
2407
2408 size = sizeof(fh);
2409 rv = read(fd, &fh, size);
2410 if (rv < 0 || (size_t)rv != size) {
2411 bp = NULL;
2412 goto done;
2413 }
2414 if (memcmp(fh.fh_magic, FONT_HEADER_MAGIC, sizeof(fh.fh_magic)) != 0) {
2415 bp = NULL;
2416 goto done;
2417 }
2418 if ((fp = calloc(1, sizeof(struct vt_font))) == NULL) {
2419 bp = NULL;
2420 goto done;
2421 }
2422 for (i = 0; i < VFNT_MAPS; i++)
2423 fp->vf_map_count[i] = be32toh(fh.fh_map_count[i]);
2424
2425 glyphs = be32toh(fh.fh_glyph_count);
2426 fp->vf_width = fh.fh_width;
2427 fp->vf_height = fh.fh_height;
2428
2429 size = howmany(fp->vf_width, 8) * fp->vf_height * glyphs;
2430 bp->vfbd_uncompressed_size = size;
2431 if ((fp->vf_bytes = malloc(size)) == NULL)
2432 goto free_done;
2433
2434 rv = read(fd, fp->vf_bytes, size);
2435 if (rv < 0 || (size_t)rv != size)
2436 goto free_done;
2437 for (i = 0; i < VFNT_MAPS; i++) {
2438 if (load_mapping(fd, fp, i) != 0)
2439 goto free_done;
2440 }
2441
2442 /*
2443 * Reset builtin flag now as we have full font loaded.
2444 */
2445 if (fl->font_flags == FONT_BUILTIN)
2446 fl->font_flags = FONT_AUTO;
2447
2448 /*
2449 * Release previously loaded entries. We can do this now, as
2450 * the new font is loaded. Note, there can be no console
2451 * output till the new font is in place and teken is notified.
2452 * We do need to keep fl->font_data for glyph dimensions.
2453 */
2454 STAILQ_FOREACH(fl, &fonts, font_next) {
2455 if (fl->font_data->vfbd_font == NULL)
2456 continue;
2457
2458 for (i = 0; i < VFNT_MAPS; i++)
2459 free(fl->font_data->vfbd_font->vf_map[i]);
2460 free(fl->font_data->vfbd_font->vf_bytes);
2461 free(fl->font_data->vfbd_font);
2462 fl->font_data->vfbd_font = NULL;
2463 }
2464
2465 bp->vfbd_font = fp;
2466 bp->vfbd_compressed_size = 0;
2467
2468 done:
2469 if (fd != -1)
2470 close(fd);
2471 return (bp);
2472
2473 free_done:
2474 for (i = 0; i < VFNT_MAPS; i++)
2475 free(fp->vf_map[i]);
2476 free(fp->vf_bytes);
2477 free(fp);
2478 bp = NULL;
2479 goto done;
2480 }
2481
2482 struct name_entry {
2483 char *n_name;
2484 SLIST_ENTRY(name_entry) n_entry;
2485 };
2486
2487 SLIST_HEAD(name_list, name_entry);
2488
2489 /* Read font names from index file. */
2490 static struct name_list *
read_list(char * fonts)2491 read_list(char *fonts)
2492 {
2493 struct name_list *nl;
2494 struct name_entry *np;
2495 char *dir, *ptr;
2496 char buf[PATH_MAX];
2497 int fd, len;
2498
2499 TSENTER();
2500
2501 dir = strdup(fonts);
2502 if (dir == NULL)
2503 return (NULL);
2504
2505 ptr = strrchr(dir, '/');
2506 *ptr = '\0';
2507
2508 fd = open(fonts, O_RDONLY);
2509 if (fd < 0)
2510 return (NULL);
2511
2512 nl = malloc(sizeof(*nl));
2513 if (nl == NULL) {
2514 close(fd);
2515 return (nl);
2516 }
2517
2518 SLIST_INIT(nl);
2519 while ((len = fgetstr(buf, sizeof (buf), fd)) >= 0) {
2520 if (*buf == '#' || *buf == '\0')
2521 continue;
2522
2523 if (bcmp(buf, "MENU", 4) == 0)
2524 continue;
2525
2526 if (bcmp(buf, "FONT", 4) == 0)
2527 continue;
2528
2529 ptr = strchr(buf, ':');
2530 if (ptr == NULL)
2531 continue;
2532 else
2533 *ptr = '\0';
2534
2535 np = malloc(sizeof(*np));
2536 if (np == NULL) {
2537 close(fd);
2538 return (nl); /* return what we have */
2539 }
2540 if (asprintf(&np->n_name, "%s/%s", dir, buf) < 0) {
2541 free(np);
2542 close(fd);
2543 return (nl); /* return what we have */
2544 }
2545 SLIST_INSERT_HEAD(nl, np, n_entry);
2546 }
2547 close(fd);
2548 TSEXIT();
2549 return (nl);
2550 }
2551
2552 /*
2553 * Read the font properties and insert new entry into the list.
2554 * The font list is built in descending order.
2555 */
2556 static bool
insert_font(char * name,FONT_FLAGS flags)2557 insert_font(char *name, FONT_FLAGS flags)
2558 {
2559 struct font_header fh;
2560 struct fontlist *fp, *previous, *entry, *next;
2561 size_t size;
2562 ssize_t rv;
2563 int fd;
2564 char *font_name;
2565
2566 TSENTER();
2567
2568 font_name = NULL;
2569 if (flags == FONT_BUILTIN) {
2570 /*
2571 * We only install builtin font once, while setting up
2572 * initial console. Since this will happen very early,
2573 * we assume asprintf will not fail. Once we have access to
2574 * files, the builtin font will be replaced by font loaded
2575 * from file.
2576 */
2577 if (!STAILQ_EMPTY(&fonts))
2578 return (false);
2579
2580 fh.fh_width = DEFAULT_FONT_DATA.vfbd_width;
2581 fh.fh_height = DEFAULT_FONT_DATA.vfbd_height;
2582
2583 (void) asprintf(&font_name, "%dx%d",
2584 DEFAULT_FONT_DATA.vfbd_width,
2585 DEFAULT_FONT_DATA.vfbd_height);
2586 } else {
2587 fd = open(name, O_RDONLY);
2588 if (fd < 0)
2589 return (false);
2590 rv = read(fd, &fh, sizeof(fh));
2591 close(fd);
2592 if (rv < 0 || (size_t)rv != sizeof(fh))
2593 return (false);
2594
2595 if (memcmp(fh.fh_magic, FONT_HEADER_MAGIC,
2596 sizeof(fh.fh_magic)) != 0)
2597 return (false);
2598 font_name = strdup(name);
2599 }
2600
2601 if (font_name == NULL)
2602 return (false);
2603
2604 /*
2605 * If we have an entry with the same glyph dimensions, replace
2606 * the file name and mark us. We only support unique dimensions.
2607 */
2608 STAILQ_FOREACH(entry, &fonts, font_next) {
2609 if (fh.fh_width == entry->font_data->vfbd_width &&
2610 fh.fh_height == entry->font_data->vfbd_height) {
2611 free(entry->font_name);
2612 entry->font_name = font_name;
2613 entry->font_flags = FONT_RELOAD;
2614 TSEXIT();
2615 return (true);
2616 }
2617 }
2618
2619 fp = calloc(sizeof(*fp), 1);
2620 if (fp == NULL) {
2621 free(font_name);
2622 return (false);
2623 }
2624 fp->font_data = calloc(sizeof(*fp->font_data), 1);
2625 if (fp->font_data == NULL) {
2626 free(font_name);
2627 free(fp);
2628 return (false);
2629 }
2630 fp->font_name = font_name;
2631 fp->font_flags = flags;
2632 fp->font_load = load_font;
2633 fp->font_data->vfbd_width = fh.fh_width;
2634 fp->font_data->vfbd_height = fh.fh_height;
2635
2636 if (STAILQ_EMPTY(&fonts)) {
2637 STAILQ_INSERT_HEAD(&fonts, fp, font_next);
2638 TSEXIT();
2639 return (true);
2640 }
2641
2642 previous = NULL;
2643 size = fp->font_data->vfbd_width * fp->font_data->vfbd_height;
2644
2645 STAILQ_FOREACH(entry, &fonts, font_next) {
2646 vt_font_bitmap_data_t *bd;
2647
2648 bd = entry->font_data;
2649 /* Should fp be inserted before the entry? */
2650 if (size > bd->vfbd_width * bd->vfbd_height) {
2651 if (previous == NULL) {
2652 STAILQ_INSERT_HEAD(&fonts, fp, font_next);
2653 } else {
2654 STAILQ_INSERT_AFTER(&fonts, previous, fp,
2655 font_next);
2656 }
2657 TSEXIT();
2658 return (true);
2659 }
2660 next = STAILQ_NEXT(entry, font_next);
2661 if (next == NULL ||
2662 size > next->font_data->vfbd_width *
2663 next->font_data->vfbd_height) {
2664 STAILQ_INSERT_AFTER(&fonts, entry, fp, font_next);
2665 TSEXIT();
2666 return (true);
2667 }
2668 previous = entry;
2669 }
2670 TSEXIT();
2671 return (true);
2672 }
2673
2674 static int
font_set(struct env_var * ev __unused,int flags __unused,const void * value)2675 font_set(struct env_var *ev __unused, int flags __unused, const void *value)
2676 {
2677 struct fontlist *fl;
2678 char *eptr;
2679 unsigned long x = 0, y = 0;
2680
2681 /*
2682 * Attempt to extract values from "XxY" string. In case of error,
2683 * we have unmaching glyph dimensions and will just output the
2684 * available values.
2685 */
2686 if (value != NULL) {
2687 x = strtoul(value, &eptr, 10);
2688 if (*eptr == 'x')
2689 y = strtoul(eptr + 1, &eptr, 10);
2690 }
2691 STAILQ_FOREACH(fl, &fonts, font_next) {
2692 if (fl->font_data->vfbd_width == x &&
2693 fl->font_data->vfbd_height == y)
2694 break;
2695 }
2696 if (fl != NULL) {
2697 /* Reset any FONT_MANUAL flag. */
2698 reset_font_flags();
2699
2700 /* Mark this font manually loaded */
2701 fl->font_flags = FONT_MANUAL;
2702 cons_update_mode(gfx_state.tg_fb_type != FB_TEXT);
2703 return (CMD_OK);
2704 }
2705
2706 printf("Available fonts:\n");
2707 STAILQ_FOREACH(fl, &fonts, font_next) {
2708 printf(" %dx%d\n", fl->font_data->vfbd_width,
2709 fl->font_data->vfbd_height);
2710 }
2711 return (CMD_OK);
2712 }
2713
2714 void
bios_text_font(bool use_vga_font)2715 bios_text_font(bool use_vga_font)
2716 {
2717 if (use_vga_font)
2718 (void) insert_font(VGA_8X16_FONT, FONT_MANUAL);
2719 else
2720 (void) insert_font(DEFAULT_8X16_FONT, FONT_MANUAL);
2721 }
2722
2723 void
autoload_font(bool bios)2724 autoload_font(bool bios)
2725 {
2726 struct name_list *nl;
2727 struct name_entry *np;
2728
2729 TSENTER();
2730
2731 nl = read_list("/boot/fonts/INDEX.fonts");
2732 if (nl == NULL)
2733 return;
2734
2735 while (!SLIST_EMPTY(nl)) {
2736 np = SLIST_FIRST(nl);
2737 SLIST_REMOVE_HEAD(nl, n_entry);
2738 if (insert_font(np->n_name, FONT_AUTO) == false)
2739 printf("failed to add font: %s\n", np->n_name);
2740 free(np->n_name);
2741 free(np);
2742 }
2743
2744 /*
2745 * If vga text mode was requested, load vga.font (8x16 bold) font.
2746 */
2747 if (bios) {
2748 bios_text_font(true);
2749 }
2750
2751 (void) cons_update_mode(gfx_state.tg_fb_type != FB_TEXT);
2752
2753 TSEXIT();
2754 }
2755
2756 COMMAND_SET(load_font, "loadfont", "load console font from file", command_font);
2757
2758 static int
command_font(int argc,char * argv[])2759 command_font(int argc, char *argv[])
2760 {
2761 int i, c, rc;
2762 struct fontlist *fl;
2763 vt_font_bitmap_data_t *bd;
2764 bool list;
2765
2766 list = false;
2767 optind = 1;
2768 optreset = 1;
2769 rc = CMD_OK;
2770
2771 while ((c = getopt(argc, argv, "l")) != -1) {
2772 switch (c) {
2773 case 'l':
2774 list = true;
2775 break;
2776 case '?':
2777 default:
2778 return (CMD_ERROR);
2779 }
2780 }
2781
2782 argc -= optind;
2783 argv += optind;
2784
2785 if (argc > 1 || (list && argc != 0)) {
2786 printf("Usage: loadfont [-l] | [file.fnt]\n");
2787 return (CMD_ERROR);
2788 }
2789
2790 if (list) {
2791 STAILQ_FOREACH(fl, &fonts, font_next) {
2792 printf("font %s: %dx%d%s\n", fl->font_name,
2793 fl->font_data->vfbd_width,
2794 fl->font_data->vfbd_height,
2795 fl->font_data->vfbd_font == NULL? "" : " loaded");
2796 }
2797 return (CMD_OK);
2798 }
2799
2800 /* Clear scren */
2801 cons_clear();
2802
2803 if (argc == 1) {
2804 char *name = argv[0];
2805
2806 if (insert_font(name, FONT_MANUAL) == false) {
2807 printf("loadfont error: failed to load: %s\n", name);
2808 return (CMD_ERROR);
2809 }
2810
2811 (void) cons_update_mode(gfx_state.tg_fb_type != FB_TEXT);
2812 return (CMD_OK);
2813 }
2814
2815 if (argc == 0) {
2816 /*
2817 * Walk entire font list, release any loaded font, and set
2818 * autoload flag. The font list does have at least the builtin
2819 * default font.
2820 */
2821 STAILQ_FOREACH(fl, &fonts, font_next) {
2822 if (fl->font_data->vfbd_font != NULL) {
2823
2824 bd = fl->font_data;
2825 /*
2826 * Note the setup_font() is releasing
2827 * font bytes.
2828 */
2829 for (i = 0; i < VFNT_MAPS; i++)
2830 free(bd->vfbd_font->vf_map[i]);
2831 free(fl->font_data->vfbd_font);
2832 fl->font_data->vfbd_font = NULL;
2833 fl->font_data->vfbd_uncompressed_size = 0;
2834 fl->font_flags = FONT_AUTO;
2835 }
2836 }
2837 (void) cons_update_mode(gfx_state.tg_fb_type != FB_TEXT);
2838 }
2839 return (rc);
2840 }
2841
2842 bool
gfx_get_edid_resolution(struct vesa_edid_info * edid,edid_res_list_t * res)2843 gfx_get_edid_resolution(struct vesa_edid_info *edid, edid_res_list_t *res)
2844 {
2845 struct resolution *rp, *p;
2846
2847 /*
2848 * Walk detailed timings tables (4).
2849 */
2850 if ((edid->display.supported_features
2851 & EDID_FEATURE_PREFERRED_TIMING_MODE) != 0) {
2852 /* Walk detailed timing descriptors (4) */
2853 for (int i = 0; i < DET_TIMINGS; i++) {
2854 /*
2855 * Reserved value 0 is not used for display descriptor.
2856 */
2857 if (edid->detailed_timings[i].pixel_clock == 0)
2858 continue;
2859 if ((rp = malloc(sizeof(*rp))) == NULL)
2860 continue;
2861 rp->width = GET_EDID_INFO_WIDTH(edid, i);
2862 rp->height = GET_EDID_INFO_HEIGHT(edid, i);
2863 if (rp->width > 0 && rp->width <= EDID_MAX_PIXELS &&
2864 rp->height > 0 && rp->height <= EDID_MAX_LINES)
2865 TAILQ_INSERT_TAIL(res, rp, next);
2866 else
2867 free(rp);
2868 }
2869 }
2870
2871 /*
2872 * Walk standard timings list (8).
2873 */
2874 for (int i = 0; i < STD_TIMINGS; i++) {
2875 /* Is this field unused? */
2876 if (edid->standard_timings[i] == 0x0101)
2877 continue;
2878
2879 if ((rp = malloc(sizeof(*rp))) == NULL)
2880 continue;
2881
2882 rp->width = HSIZE(edid->standard_timings[i]);
2883 switch (RATIO(edid->standard_timings[i])) {
2884 case RATIO1_1:
2885 rp->height = HSIZE(edid->standard_timings[i]);
2886 if (edid->header.version > 1 ||
2887 edid->header.revision > 2) {
2888 rp->height = rp->height * 10 / 16;
2889 }
2890 break;
2891 case RATIO4_3:
2892 rp->height = HSIZE(edid->standard_timings[i]) * 3 / 4;
2893 break;
2894 case RATIO5_4:
2895 rp->height = HSIZE(edid->standard_timings[i]) * 4 / 5;
2896 break;
2897 case RATIO16_9:
2898 rp->height = HSIZE(edid->standard_timings[i]) * 9 / 16;
2899 break;
2900 }
2901
2902 /*
2903 * Create resolution list in decreasing order, except keep
2904 * first entry (preferred timing mode).
2905 */
2906 TAILQ_FOREACH(p, res, next) {
2907 if (p->width * p->height < rp->width * rp->height) {
2908 /* Keep preferred mode first */
2909 if (TAILQ_FIRST(res) == p)
2910 TAILQ_INSERT_AFTER(res, p, rp, next);
2911 else
2912 TAILQ_INSERT_BEFORE(p, rp, next);
2913 break;
2914 }
2915 if (TAILQ_NEXT(p, next) == NULL) {
2916 TAILQ_INSERT_TAIL(res, rp, next);
2917 break;
2918 }
2919 }
2920 }
2921 return (!TAILQ_EMPTY(res));
2922 }
2923
2924 vm_offset_t
build_font_module(vm_offset_t addr)2925 build_font_module(vm_offset_t addr)
2926 {
2927 vt_font_bitmap_data_t *bd;
2928 struct vt_font *fd;
2929 struct preloaded_file *fp;
2930 size_t size;
2931 uint32_t checksum;
2932 int i;
2933 struct font_info fi;
2934 struct fontlist *fl;
2935 uint64_t fontp;
2936
2937 if (STAILQ_EMPTY(&fonts))
2938 return (addr);
2939
2940 /* We can't load first */
2941 if ((file_findfile(NULL, NULL)) == NULL) {
2942 printf("Can not load font module: %s\n",
2943 "the kernel is not loaded");
2944 return (addr);
2945 }
2946
2947 /* helper pointers */
2948 bd = NULL;
2949 STAILQ_FOREACH(fl, &fonts, font_next) {
2950 if (gfx_state.tg_font.vf_width == fl->font_data->vfbd_width &&
2951 gfx_state.tg_font.vf_height == fl->font_data->vfbd_height) {
2952 /*
2953 * Kernel does have better built in font.
2954 */
2955 if (fl->font_flags == FONT_BUILTIN)
2956 return (addr);
2957
2958 bd = fl->font_data;
2959 break;
2960 }
2961 }
2962 if (bd == NULL)
2963 return (addr);
2964 fd = bd->vfbd_font;
2965
2966 fi.fi_width = fd->vf_width;
2967 checksum = fi.fi_width;
2968 fi.fi_height = fd->vf_height;
2969 checksum += fi.fi_height;
2970 fi.fi_bitmap_size = bd->vfbd_uncompressed_size;
2971 checksum += fi.fi_bitmap_size;
2972
2973 size = roundup2(sizeof (struct font_info), 8);
2974 for (i = 0; i < VFNT_MAPS; i++) {
2975 fi.fi_map_count[i] = fd->vf_map_count[i];
2976 checksum += fi.fi_map_count[i];
2977 size += fd->vf_map_count[i] * sizeof (struct vfnt_map);
2978 size += roundup2(size, 8);
2979 }
2980 size += bd->vfbd_uncompressed_size;
2981
2982 fi.fi_checksum = -checksum;
2983
2984 fp = file_findfile(NULL, "elf kernel");
2985 if (fp == NULL)
2986 fp = file_findfile(NULL, "elf64 kernel");
2987 if (fp == NULL)
2988 panic("can't find kernel file");
2989
2990 fontp = addr;
2991 addr += archsw.arch_copyin(&fi, addr, sizeof (struct font_info));
2992 addr = roundup2(addr, 8);
2993
2994 /* Copy maps. */
2995 for (i = 0; i < VFNT_MAPS; i++) {
2996 if (fd->vf_map_count[i] != 0) {
2997 addr += archsw.arch_copyin(fd->vf_map[i], addr,
2998 fd->vf_map_count[i] * sizeof (struct vfnt_map));
2999 addr = roundup2(addr, 8);
3000 }
3001 }
3002
3003 /* Copy the bitmap. */
3004 addr += archsw.arch_copyin(fd->vf_bytes, addr, fi.fi_bitmap_size);
3005
3006 /* Looks OK so far; populate control structure */
3007 file_addmetadata(fp, MODINFOMD_FONT, sizeof(fontp), &fontp);
3008 return (addr);
3009 }
3010